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 (NULL == g_conn_sender) {
 867                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender); //LCOV_EXCL_LINE
 868                 result = stt_dbus_reconnect();
 869                 if (0 != result)
 870                         return STT_ERROR_OPERATION_FAILED;
 871         }
 872
 873         if (NULL != client) {
 874                 __stt_dbus_service_free();
 875
 876                 if (NULL == client->current_engine_id) {
 877                         /* Default engine */
 878                         g_server_service_name = strdup(STT_SERVER_SERVICE_NAME);
 879                         if (NULL == g_server_service_name) {
 880                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory"); //LCOV_EXCL_LINE
 881                                 return STT_ERROR_OUT_OF_MEMORY;
 882                         }
 883                         g_server_service_object = strdup(STT_SERVER_SERVICE_OBJECT_PATH);
 884                         if (NULL == g_server_service_name) {
 885                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
 886                                 return STT_ERROR_OUT_OF_MEMORY;
 887                         }
 888                         g_server_service_interface = strdup(STT_SERVER_SERVICE_INTERFACE);
 889                         if (NULL == g_server_service_name) {
 890                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
 891                                 return STT_ERROR_OUT_OF_MEMORY;
 892                         }
 893
 894                         msg = dbus_message_new_method_call(
 895                                 STT_SERVER_SERVICE_NAME,
 896                                 STT_SERVER_SERVICE_OBJECT_PATH,
 897                                 STT_SERVER_SERVICE_INTERFACE,
 898                                 STT_METHOD_HELLO);
 899                 } else {
 900                         /* Get service name, object, interface */
 901                         SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] current_engine_id: %s", client->current_engine_id); //LCOV_EXCL_LINE
 902
 903                         g_server_service_name = __stt_get_service_name(client->current_engine_id);
 904                         g_server_service_object = __stt_get_service_object(client->current_engine_id);
 905                         g_server_service_interface = __stt_get_service_interface(client->current_engine_id);
 906
 907                         if (NULL == g_server_service_name || NULL == g_server_service_object || NULL == g_server_service_interface) {
 908                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] dbus service info invalid"); //LCOV_EXCL_LINE
 909                                 return STT_ERROR_OPERATION_FAILED;
 910                         }
 911
 912                         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
 913
 914                         /* Custom engine */
 915                         is_exist = dbus_bus_name_has_owner(g_conn_sender, g_server_service_name, &err);
 916                         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
 917
 918                         if (TRUE == is_exist) {
 919                                 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] dbus: is_exist: True"); //LCOV_EXCL_LINE
 920                                 msg = dbus_message_new_method_call(
 921                                         g_server_service_name,
 922                                         g_server_service_object,
 923                                         g_server_service_interface,
 924                                         STT_METHOD_HELLO);
 925                         } else {
 926                                 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] dbus: is_exist: False"); //LCOV_EXCL_LINE
 927                                 msg = dbus_message_new_method_call(
 928                                         STT_SERVER_CUSTOM_SERVICE_NAME,
 929                                         STT_SERVER_CUSTOM_SERVICE_OBJECT_PATH,
 930                                         STT_SERVER_CUSTOM_SERVICE_INTERFACE,
 931                                         STT_METHOD_HELLO);
 932                         }
 933                 }
 934         }
 935
 936         if (NULL == msg) {
 937                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request stt hello : Fail to make message");
 938                 return STT_ERROR_OPERATION_FAILED;
 939         } else {
 940                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> Request stt hello : uid(%d)", uid);
 941         }
 942
 943         if (g_conn_sender) {
 944                 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
 945                 dbus_message_unref(msg);
 946                 if (dbus_error_is_set(&err)) {
 947                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 948                         dbus_error_free(&err);
 949                 }
 950
 951                 if (NULL != result_msg) {
 952                         dbus_message_unref(result_msg);
 953
 954                         if (dbus_error_is_set(&err)) {
 955                                 //LCOV_EXCL_START
 956                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 957                                 dbus_error_free(&err);
 958                                 //LCOV_EXCL_STOP
 959                         }
 960
 961                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt hello");
 962                 } else {
 963                         if (dbus_error_is_set(&err)) {
 964                                 //LCOV_EXCL_START
 965                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 966                                 dbus_error_free(&err);
 967                                 //LCOV_EXCL_STOP
 968                         }
 969
 970                         result = STT_ERROR_TIMED_OUT;
 971                 }
 972         } else {
 973                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender); //LCOV_EXCL_LINE
 974                 stt_dbus_reconnect();
 975                 result = STT_ERROR_OPERATION_FAILED;
 976         }
 977
 978         return result;
 979 }
 980
 981
 982 int stt_dbus_request_initialize(int uid, bool* silence_supported, bool* credential_needed)
 983 {
 984         DBusMessage* msg;
 985
 986         msg = dbus_message_new_method_call(
 987                 g_server_service_name,
 988                 g_server_service_object,
 989                 g_server_service_interface,
 990                 STT_METHOD_INITIALIZE);
 991
 992         if (NULL == msg) {
 993                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt initialize : Fail to make message"); //LCOV_EXCL_LINE
 994                 return STT_ERROR_OPERATION_FAILED;
 995         } else {
 996                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt initialize : uid(%d)", uid);
 997         }
 998
 999         int pid = getpid();
1000         dbus_message_append_args(msg,
1001                 DBUS_TYPE_INT32, &pid,
1002                 DBUS_TYPE_INT32, &uid,
1003                 DBUS_TYPE_INVALID);
1004
1005         DBusError err;
1006         dbus_error_init(&err);
1007
1008         DBusMessage* result_msg;
1009         int result = STT_ERROR_OPERATION_FAILED;
1010
1011         if (g_conn_sender) {
1012                 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1013                 dbus_message_unref(msg);
1014                 if (dbus_error_is_set(&err)) {
1015                         //LCOV_EXCL_START
1016                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1017                         dbus_error_free(&err);
1018                         //LCOV_EXCL_STOP
1019                 }
1020
1021                 if (NULL != result_msg) {
1022                         int int_silence_supported = 0;
1023                         int int_credential_needed = 0;
1024                         dbus_message_get_args(result_msg, &err,
1025                                 DBUS_TYPE_INT32, &result,
1026                                 DBUS_TYPE_INT32, &int_silence_supported,
1027                                 DBUS_TYPE_INT32, &int_credential_needed,
1028                                 DBUS_TYPE_INVALID);
1029
1030                         *silence_supported = (bool)(int_silence_supported);
1031                         *credential_needed = (bool)(int_credential_needed);
1032
1033                         if (dbus_error_is_set(&err)) {
1034                                 //LCOV_EXCL_START
1035                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1036                                 dbus_error_free(&err);
1037                                 result = STT_ERROR_OPERATION_FAILED;
1038                                 //LCOV_EXCL_STOP
1039                         }
1040
1041                         if (0 == result) {
1042                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt initialize : result = %d, silence(%d), credential(%d)",
1043                                         result, *silence_supported, *credential_needed);
1044
1045                                 stt_client_s* client = stt_client_get_by_uid(uid);
1046                                 if (NULL == client) {
1047                                         SLOG(LOG_ERROR, TAG_STTC, "Fail to get STT client");
1048                                         return STT_ERROR_OPERATION_FAILED;
1049                                 }
1050
1051                                 if (STT_ERROR_SERVICE_RESET != client->reason) {
1052                                         /* add a rule for daemon error */
1053                                         char rule_err[256] = {0, };
1054
1055                                         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);
1056                                         dbus_bus_add_match(g_conn_listener, rule_err, &err);
1057                                         dbus_connection_flush(g_conn_listener);
1058
1059                                         if (dbus_error_is_set(&err)) {
1060                                                 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)", err.message);
1061                                                 dbus_error_free(&err);
1062                                                 return STT_ERROR_OPERATION_FAILED;
1063                                         }
1064                                 }
1065                         } else {
1066                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt initialize : result = %d", result); //LCOV_EXCL_LINE
1067                         }
1068
1069                         dbus_message_unref(result_msg);
1070                 } else {
1071                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL"); //LCOV_EXCL_LINE
1072                         stt_dbus_reconnect();
1073                         result = STT_ERROR_TIMED_OUT;
1074                 }
1075         } else {
1076                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender); //LCOV_EXCL_LINE
1077                 result = STT_ERROR_OPERATION_FAILED;
1078         }
1079
1080         return result;
1081 }
1082
1083 int stt_dbus_request_finalize(int uid)
1084 {
1085         DBusMessage* msg;
1086
1087         DBusError err;
1088         dbus_error_init(&err);
1089
1090         /* remove a rule for daemon error */
1091         char rule_err[256] = {0, };
1092         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);
1093         dbus_bus_remove_match(g_conn_listener, rule_err, &err);
1094         dbus_connection_flush(g_conn_listener);
1095         if (dbus_error_is_set(&err)) {
1096                 //LCOV_EXCL_START
1097                 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)", err.message);
1098                 dbus_error_free(&err);
1099                 //LCOV_EXCL_STOP
1100         }
1101
1102         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);
1103
1104         msg = dbus_message_new_method_call(
1105                 g_server_service_name,
1106                 g_server_service_object,
1107                 g_server_service_interface,
1108                 STT_METHOD_FINALIZE);
1109
1110         if (NULL == msg) {
1111                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt finalize : Fail to make message"); //LCOV_EXCL_LINE
1112                 return STT_ERROR_OPERATION_FAILED;
1113         } else {
1114                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt finalize : uid(%d)", uid);
1115         }
1116
1117         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
1118
1119         DBusMessage* result_msg;
1120         int result = STT_ERROR_OPERATION_FAILED;
1121
1122         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
1123         dbus_message_unref(msg);
1124         if (dbus_error_is_set(&err)) {
1125                 //LCOV_EXCL_START
1126                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1127                 dbus_error_free(&err);
1128                 //LCOV_EXCL_STOP
1129         }
1130
1131         if (NULL != result_msg) {
1132                 dbus_message_get_args(result_msg, &err,
1133                                 DBUS_TYPE_INT32, &result,
1134                                 DBUS_TYPE_INVALID);
1135
1136                 if (dbus_error_is_set(&err)) {
1137                         //LCOV_EXCL_START
1138                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1139                         dbus_error_free(&err);
1140                         result = STT_ERROR_OPERATION_FAILED;
1141                         //LCOV_EXCL_STOP
1142                 }
1143
1144                 dbus_message_unref(result_msg);
1145
1146                 if (0 == result) {
1147                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt finalize : result = %d", result);
1148                 } else {
1149                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt finalize : result = %d", result); //LCOV_EXCL_LINE
1150                 }
1151         } else {
1152                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL"); //LCOV_EXCL_LINE
1153                 stt_dbus_reconnect();
1154                 result = STT_ERROR_TIMED_OUT;
1155         }
1156
1157         return result;
1158 }
1159
1160 //LCOV_EXCL_START
1161 int stt_dbus_request_set_current_engine(int uid, const char* engine_id, bool* silence_supported, bool* credential_needed)
1162 {
1163         DBusMessage* msg;
1164
1165         msg = dbus_message_new_method_call(
1166                 g_server_service_name,
1167                 g_server_service_object,
1168                 g_server_service_interface,
1169                 STT_METHOD_SET_CURRENT_ENGINE);
1170
1171
1172         if (NULL == msg) {
1173                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set engine : Fail to make message");
1174                 return STT_ERROR_OPERATION_FAILED;
1175         } else {
1176                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set engine : uid(%d), engine_id(%s)", uid, (NULL == engine_id) ? "NULL" : engine_id);
1177         }
1178
1179         dbus_message_append_args(msg,
1180                 DBUS_TYPE_INT32, &uid,
1181                 DBUS_TYPE_STRING, &engine_id,
1182                 DBUS_TYPE_INVALID);
1183
1184         DBusError err;
1185         dbus_error_init(&err);
1186
1187         DBusMessage* result_msg;
1188         int result = STT_ERROR_OPERATION_FAILED;
1189
1190         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1191         dbus_message_unref(msg);
1192         if (dbus_error_is_set(&err)) {
1193                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1194                 dbus_error_free(&err);
1195         }
1196
1197         if (NULL != result_msg) {
1198                 int int_silence_supported = 0;
1199                 int int_credential_needed = 0;
1200
1201                 dbus_message_get_args(result_msg, &err,
1202                         DBUS_TYPE_INT32, &result,
1203                         DBUS_TYPE_INT32, &int_silence_supported,
1204                         DBUS_TYPE_INT32, &int_credential_needed,
1205                         DBUS_TYPE_INVALID);
1206
1207                 *silence_supported = (bool)(int_silence_supported);
1208                 *credential_needed = (bool)(int_credential_needed);
1209
1210                 if (dbus_error_is_set(&err)) {
1211                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1212                         dbus_error_free(&err);
1213                         result = STT_ERROR_OPERATION_FAILED;
1214                 }
1215
1216                 dbus_message_unref(result_msg);
1217
1218                 if (0 == result) {
1219                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set engine : result = %d , silence(%d), credential(%d)",
1220                                 result, *silence_supported, *credential_needed);
1221                 } else {
1222                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set engine : result = %d", result);
1223                 }
1224         } else {
1225                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1226                 stt_dbus_reconnect();
1227                 result = STT_ERROR_TIMED_OUT;
1228         }
1229
1230         return result;
1231 }
1232
1233 int stt_dbus_request_check_app_agreed(int uid, const char* appid, bool* value)
1234 {
1235         if (NULL == appid || NULL == value) {
1236                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1237                 return STT_ERROR_INVALID_PARAMETER;
1238         }
1239
1240         DBusMessage* msg;
1241
1242         msg = dbus_message_new_method_call(
1243                 g_server_service_name,
1244                 g_server_service_object,
1245                 g_server_service_interface,
1246                 STT_METHOD_CHECK_APP_AGREED);
1247
1248         if (NULL == msg) {
1249                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt check app agreed : Fail to make message");
1250                 return STT_ERROR_OPERATION_FAILED;
1251         } else {
1252                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt check app agreed : uid(%d) appid(%s)", uid, appid);
1253         }
1254
1255         dbus_message_append_args(msg,
1256                 DBUS_TYPE_INT32, &uid,
1257                 DBUS_TYPE_STRING, &appid,
1258                 DBUS_TYPE_INVALID);
1259
1260         DBusError err;
1261         dbus_error_init(&err);
1262
1263         DBusMessage* result_msg;
1264         int result = STT_ERROR_OPERATION_FAILED;
1265         int available = -1;
1266
1267         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1268         dbus_message_unref(msg);
1269         if (dbus_error_is_set(&err)) {
1270                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1271                 dbus_error_free(&err);
1272         }
1273
1274         if (NULL != result_msg) {
1275                 dbus_message_get_args(result_msg, &err,
1276                         DBUS_TYPE_INT32, &result,
1277                         DBUS_TYPE_INT32, &available,
1278                         DBUS_TYPE_INVALID);
1279
1280                 if (dbus_error_is_set(&err)) {
1281                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1282                         dbus_error_free(&err);
1283                         result = STT_ERROR_OPERATION_FAILED;
1284                 }
1285                 dbus_message_unref(result_msg);
1286
1287                 if (0 == result) {
1288                         *value = (bool)available;
1289                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt check app agreed : result = %d, available = %d", result, *value);
1290                 } else {
1291                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt check app agreed : result = %d", result);
1292                 }
1293         } else {
1294                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1295                 stt_dbus_reconnect();
1296                 result = STT_ERROR_TIMED_OUT;
1297         }
1298
1299         return result;
1300 }
1301
1302 int stt_dbus_request_get_support_langs(int uid, stt_h stt, stt_supported_language_cb callback, void* user_data)
1303 {
1304         if (NULL == stt || NULL == callback) {
1305                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1306                 return STT_ERROR_INVALID_PARAMETER;
1307         }
1308
1309         DBusMessage* msg;
1310
1311         msg = dbus_message_new_method_call(
1312                 g_server_service_name,
1313                 g_server_service_object,
1314                 g_server_service_interface,
1315                 STT_METHOD_GET_SUPPORT_LANGS);
1316
1317         if (NULL == msg) {
1318                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get supported languages : Fail to make message");
1319                 return STT_ERROR_OPERATION_FAILED;
1320         } else {
1321                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get supported languages : uid(%d)", uid);
1322         }
1323
1324         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
1325
1326         DBusError err;
1327         dbus_error_init(&err);
1328
1329         DBusMessage* result_msg;
1330         DBusMessageIter args;
1331         int result = STT_ERROR_OPERATION_FAILED;
1332
1333         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1334         dbus_message_unref(msg);
1335         if (dbus_error_is_set(&err)) {
1336                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1337                 dbus_error_free(&err);
1338         }
1339
1340         if (NULL != result_msg) {
1341                 if (dbus_message_iter_init(result_msg, &args)) {
1342                         /* Get result */
1343                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
1344                                 dbus_message_iter_get_basic(&args, &result);
1345                                 dbus_message_iter_next(&args);
1346                         }
1347
1348                         if (0 == result) {
1349                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get support languages : result = %d", result);
1350
1351                                 /* Get voice size */
1352                                 int size = 0;
1353                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
1354                                         dbus_message_iter_get_basic(&args, &size);
1355                                         dbus_message_iter_next(&args);
1356                                 }
1357
1358                                 if (0 >= size) {
1359                                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt size of language error : size = %d", size);
1360                                 } else {
1361                                         int i = 0;
1362                                         char* temp_lang;
1363
1364                                         for (i = 0; i < size; i++) {
1365                                                 dbus_message_iter_get_basic(&args, &(temp_lang));
1366                                                 dbus_message_iter_next(&args);
1367
1368                                                 if (true != callback(stt, temp_lang, user_data)) {
1369                                                         break;
1370                                                 }
1371                                         }
1372                                 }
1373                         } else {
1374                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result = %d", result);
1375                         }
1376                 }
1377                 dbus_message_unref(result_msg);
1378         } else {
1379                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result message is NULL");
1380                 stt_dbus_reconnect();
1381                 result = STT_ERROR_TIMED_OUT;
1382         }
1383
1384         return result;
1385 }
1386
1387 int stt_dbus_request_get_default_lang(int uid, char** language)
1388 {
1389         if (NULL == language) {
1390                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1391                 return STT_ERROR_INVALID_PARAMETER;
1392         }
1393
1394         DBusMessage* msg;
1395
1396         msg = dbus_message_new_method_call(
1397                 g_server_service_name,
1398                 g_server_service_object,
1399                 g_server_service_interface,
1400                 STT_METHOD_GET_CURRENT_LANG);
1401
1402         if (NULL == msg) {
1403                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get default language : Fail to make message");
1404                 return STT_ERROR_OPERATION_FAILED;
1405         } else {
1406                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get default language  : uid(%d)", uid);
1407         }
1408
1409         dbus_message_append_args(msg,
1410                 DBUS_TYPE_INT32, &uid,
1411                 DBUS_TYPE_INVALID);
1412
1413         DBusError err;
1414         dbus_error_init(&err);
1415
1416         DBusMessage* result_msg;
1417         int result = STT_ERROR_OPERATION_FAILED;
1418         char* temp_lang = NULL;
1419
1420         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1421         dbus_message_unref(msg);
1422         if (dbus_error_is_set(&err)) {
1423                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1424                 dbus_error_free(&err);
1425         }
1426
1427         if (NULL != result_msg) {
1428                 dbus_message_get_args(result_msg, &err,
1429                         DBUS_TYPE_INT32, &result,
1430                         DBUS_TYPE_STRING, &temp_lang,
1431                         DBUS_TYPE_INVALID);
1432
1433                 if (dbus_error_is_set(&err)) {
1434                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1435                         dbus_error_free(&err);
1436                         result = STT_ERROR_OPERATION_FAILED;
1437                 }
1438                 dbus_message_unref(result_msg);
1439
1440                 if (0 == result) {
1441                         *language = strdup(temp_lang);
1442                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get default language : result = %d, language = %s", result, *language);
1443                 } else {
1444                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get default language : result = %d", result);
1445                 }
1446         } else {
1447                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1448                 stt_dbus_reconnect();
1449                 result = STT_ERROR_TIMED_OUT;
1450         }
1451
1452         return result;
1453 }
1454 //LCOV_EXCL_STOP
1455
1456 int stt_dbus_request_set_private_data(int uid, const char* key, const char* data)
1457 {
1458         if (NULL == key || NULL == data) {
1459                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL"); //LCOV_EXCL_LINE
1460                 return STT_ERROR_INVALID_PARAMETER;
1461         }
1462
1463         DBusMessage* msg;
1464
1465         msg = dbus_message_new_method_call(
1466                 g_server_service_name,
1467                 g_server_service_object,
1468                 g_server_service_interface,
1469                 STT_METHOD_SET_PRIVATE_DATA);
1470
1471         if (NULL == msg) {
1472                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set private data : Fail to make message"); //LCOV_EXCL_LINE
1473                 return STT_ERROR_OPERATION_FAILED;
1474         } else {
1475                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set private data : uid(%d)", uid);
1476         }
1477
1478         if (true != dbus_message_append_args(msg,
1479                         DBUS_TYPE_INT32, &uid,
1480                         DBUS_TYPE_STRING, &key,
1481                         DBUS_TYPE_STRING, &data,
1482                         DBUS_TYPE_INVALID)) {
1483                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to append args"); //LCOV_EXCL_LINE
1484                 return STT_ERROR_OPERATION_FAILED;
1485         }
1486
1487         DBusError err;
1488         dbus_error_init(&err);
1489
1490         DBusMessage* result_msg;
1491         int result = STT_ERROR_OPERATION_FAILED;
1492
1493         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1494         dbus_message_unref(msg);
1495         if (dbus_error_is_set(&err)) {
1496                 //LCOV_EXCL_START
1497                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1498                 dbus_error_free(&err);
1499                 //LCOV_EXCL_STOP
1500         }
1501
1502         if (NULL != result_msg) {
1503                 dbus_message_get_args(result_msg, &err,
1504                         DBUS_TYPE_INT32, &result,
1505                         DBUS_TYPE_INVALID);
1506
1507                 if (dbus_error_is_set(&err)) {
1508                         //LCOV_EXCL_START
1509                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1510                         dbus_error_free(&err);
1511                         result = STT_ERROR_OPERATION_FAILED;
1512                         //LCOV_EXCL_STOP
1513                 }
1514                 dbus_message_unref(result_msg);
1515
1516                 if (0 == result) {
1517                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set private data : result = %d", result);
1518                 } else {
1519                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set private data : result = %d", result); //LCOV_EXCL_LINE
1520                 }
1521         } else {
1522                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL"); //LCOV_EXCL_LINE
1523                 stt_dbus_reconnect();
1524                 result = STT_ERROR_TIMED_OUT;
1525         }
1526
1527         return result;
1528 }
1529
1530 int stt_dbus_request_get_private_data(int uid, const char* key, char** data)
1531 {
1532         if (NULL == key || NULL == data) {
1533                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL"); //LCOV_EXCL_LINE
1534                 return STT_ERROR_INVALID_PARAMETER;
1535         }
1536
1537         DBusMessage* msg;
1538
1539         msg = dbus_message_new_method_call(
1540                 g_server_service_name,
1541                 g_server_service_object,
1542                 g_server_service_interface,
1543                 STT_METHOD_GET_PRIVATE_DATA);
1544
1545         if (NULL == msg) {
1546                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get private data : Fail to make message"); //LCOV_EXCL_LINE
1547                 return STT_ERROR_OPERATION_FAILED;
1548         } else {
1549                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get private data : uid(%d)", uid);
1550         }
1551
1552         if (true != dbus_message_append_args(msg,
1553                         DBUS_TYPE_INT32, &uid,
1554                         DBUS_TYPE_STRING, &key,
1555                         DBUS_TYPE_INVALID)) {
1556                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to append args"); //LCOV_EXCL_LINE
1557                 return STT_ERROR_OPERATION_FAILED;
1558         }
1559
1560         DBusError err;
1561         dbus_error_init(&err);
1562
1563         DBusMessage* result_msg;
1564         int result = STT_ERROR_OPERATION_FAILED;
1565
1566         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1567         dbus_message_unref(msg);
1568         if (dbus_error_is_set(&err)) {
1569                 //LCOV_EXCL_START
1570                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1571                 dbus_error_free(&err);
1572                 //LCOV_EXCL_STOP
1573         }
1574
1575         char* temp = NULL;
1576         if (NULL != result_msg) {
1577                 dbus_message_get_args(result_msg, &err,
1578                         DBUS_TYPE_INT32, &result,
1579                         DBUS_TYPE_STRING, &temp,
1580                         DBUS_TYPE_INVALID);
1581
1582                 if (dbus_error_is_set(&err)) {
1583                         //LCOV_EXCL_START
1584                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1585                         dbus_error_free(&err);
1586                         result = STT_ERROR_OPERATION_FAILED;
1587                         //LCOV_EXCL_STOP
1588                 }
1589                 dbus_message_unref(result_msg);
1590
1591                 if (0 == result) {
1592                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get private data : result = %d", result);
1593                         if (NULL != temp) {
1594                                 *data = strdup(temp);
1595                         }
1596                 } else {
1597                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get private data : result = %d", result); //LCOV_EXCL_LINE
1598                 }
1599         } else {
1600                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL"); //LCOV_EXCL_LINE
1601                 stt_dbus_reconnect();
1602                 result = STT_ERROR_TIMED_OUT;
1603         }
1604
1605         return result;
1606 }
1607
1608
1609
1610 int stt_dbus_request_is_recognition_type_supported(int uid, const char* type, bool* support)
1611 {
1612         if (NULL == support || NULL == type) {
1613                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL"); //LCOV_EXCL_LINE
1614                 return STT_ERROR_INVALID_PARAMETER;
1615         }
1616
1617         DBusMessage* msg;
1618
1619         msg = dbus_message_new_method_call(
1620                 g_server_service_name,
1621                 g_server_service_object,
1622                 g_server_service_interface,
1623                 STT_METHOD_IS_TYPE_SUPPORTED);
1624
1625         if (NULL == msg) {
1626                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt is partial result supported : Fail to make message"); //LCOV_EXCL_LINE
1627                 return STT_ERROR_OPERATION_FAILED;
1628         } else {
1629                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt is recognition type supported : uid(%d) type(%s)", uid, type);
1630         }
1631
1632         dbus_message_append_args(msg,
1633                 DBUS_TYPE_INT32, &uid,
1634                 DBUS_TYPE_STRING, &type,
1635                 DBUS_TYPE_INVALID);
1636
1637         DBusError err;
1638         dbus_error_init(&err);
1639
1640         DBusMessage* result_msg;
1641         int result = STT_ERROR_OPERATION_FAILED;
1642         int result_support = -1;
1643
1644         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1645         dbus_message_unref(msg);
1646         if (dbus_error_is_set(&err)) {
1647                 //LCOV_EXCL_START
1648                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1649                 dbus_error_free(&err);
1650                 //LCOV_EXCL_STOP
1651         }
1652
1653         if (NULL != result_msg) {
1654                 dbus_message_get_args(result_msg, &err,
1655                         DBUS_TYPE_INT32, &result,
1656                         DBUS_TYPE_INT32, &result_support,
1657                         DBUS_TYPE_INVALID);
1658
1659                 if (dbus_error_is_set(&err)) {
1660                         //LCOV_EXCL_START
1661                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1662                         dbus_error_free(&err);
1663                         result = STT_ERROR_OPERATION_FAILED;
1664                         //LCOV_EXCL_STOP
1665                 }
1666                 dbus_message_unref(result_msg);
1667
1668                 if (0 == result) {
1669                         *support = (bool)result_support;
1670                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt is recognition type supported : result = %d, support = %s", result, *support ? "true" : "false");
1671                 } else {
1672                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt is recognition type supported : result = %d", result); //LCOV_EXCL_LINE
1673                 }
1674         } else {
1675                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL"); //LCOV_EXCL_LINE
1676                 stt_dbus_reconnect();
1677                 result = STT_ERROR_TIMED_OUT;
1678         }
1679
1680         return result;
1681 }
1682
1683 int stt_dbus_request_set_start_sound(int uid, const char* file)
1684 {
1685         if (NULL == file) {
1686                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL"); //LCOV_EXCL_LINE
1687                 return STT_ERROR_INVALID_PARAMETER;
1688         }
1689
1690         DBusMessage* msg;
1691
1692         msg = dbus_message_new_method_call(
1693                 g_server_service_name,
1694                 g_server_service_object,
1695                 g_server_service_interface,
1696                 STT_METHOD_SET_START_SOUND);
1697
1698         if (NULL == msg) {
1699                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set start sound : Fail to make message"); //LCOV_EXCL_LINE
1700                 return STT_ERROR_OPERATION_FAILED;
1701         } else {
1702                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set start sound : uid(%d) file(%s)", uid, file);
1703         }
1704
1705         dbus_message_append_args(msg,
1706                 DBUS_TYPE_INT32, &uid,
1707                 DBUS_TYPE_STRING, &file,
1708                 DBUS_TYPE_INVALID);
1709
1710         DBusError err;
1711         dbus_error_init(&err);
1712
1713         DBusMessage* result_msg;
1714         int result = STT_ERROR_OPERATION_FAILED;
1715
1716         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1717         dbus_message_unref(msg);
1718         if (dbus_error_is_set(&err)) {
1719                 //LCOV_EXCL_START
1720                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1721                 dbus_error_free(&err);
1722                 //LCOV_EXCL_STOP
1723         }
1724
1725         if (NULL != result_msg) {
1726                 dbus_message_get_args(result_msg, &err,
1727                         DBUS_TYPE_INT32, &result,
1728                         DBUS_TYPE_INVALID);
1729
1730                 if (dbus_error_is_set(&err)) {
1731                         //LCOV_EXCL_START
1732                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1733                         dbus_error_free(&err);
1734                         result = STT_ERROR_OPERATION_FAILED;
1735                         //LCOV_EXCL_STOP
1736                 }
1737                 dbus_message_unref(result_msg);
1738
1739                 if (0 == result) {
1740                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1741                 } else {
1742                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set start sound : result = %d", result); //LCOV_EXCL_LINE
1743                 }
1744         } else {
1745                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL"); //LCOV_EXCL_LINE
1746                 stt_dbus_reconnect();
1747                 result = STT_ERROR_TIMED_OUT;
1748         }
1749
1750         return result;
1751 }
1752
1753 int stt_dbus_request_unset_start_sound(int uid)
1754 {
1755         DBusMessage* msg;
1756
1757         msg = dbus_message_new_method_call(
1758                 g_server_service_name,
1759                 g_server_service_object,
1760                 g_server_service_interface,
1761                 STT_METHOD_UNSET_START_SOUND);
1762
1763         if (NULL == msg) {
1764                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset start sound : Fail to make message"); //LCOV_EXCL_LINE
1765                 return STT_ERROR_OPERATION_FAILED;
1766         } else {
1767                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset start sound : uid(%d)", uid);
1768         }
1769
1770         dbus_message_append_args(msg,
1771                 DBUS_TYPE_INT32, &uid,
1772                 DBUS_TYPE_INVALID);
1773
1774         DBusError err;
1775         dbus_error_init(&err);
1776
1777         DBusMessage* result_msg;
1778         int result = STT_ERROR_OPERATION_FAILED;
1779
1780         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1781         dbus_message_unref(msg);
1782         if (dbus_error_is_set(&err)) {
1783                 //LCOV_EXCL_START
1784                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1785                 dbus_error_free(&err);
1786                 //LCOV_EXCL_STOP
1787         }
1788
1789         if (NULL != result_msg) {
1790                 dbus_message_get_args(result_msg, &err,
1791                         DBUS_TYPE_INT32, &result,
1792                         DBUS_TYPE_INVALID);
1793
1794                 if (dbus_error_is_set(&err)) {
1795                         //LCOV_EXCL_START
1796                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1797                         dbus_error_free(&err);
1798                         result = STT_ERROR_OPERATION_FAILED;
1799                         //LCOV_EXCL_STOP
1800                 }
1801                 dbus_message_unref(result_msg);
1802
1803                 if (0 == result) {
1804                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1805                 } else {
1806                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset start sound : result = %d", result); //LCOV_EXCL_LINE
1807                 }
1808         } else {
1809                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL"); //LCOV_EXCL_LINE
1810                 stt_dbus_reconnect();
1811                 result = STT_ERROR_TIMED_OUT;
1812         }
1813
1814         return result;
1815 }
1816
1817 int stt_dbus_request_set_stop_sound(int uid, const char* file)
1818 {
1819         if (NULL == file) {
1820                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL"); //LCOV_EXCL_LINE
1821                 return STT_ERROR_INVALID_PARAMETER;
1822         }
1823
1824         DBusMessage* msg;
1825
1826         msg = dbus_message_new_method_call(
1827                 g_server_service_name,
1828                 g_server_service_object,
1829                 g_server_service_interface,
1830                 STT_METHOD_SET_STOP_SOUND);
1831
1832         if (NULL == msg) {
1833                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set stop sound : Fail to make message"); //LCOV_EXCL_LINE
1834                 return STT_ERROR_OPERATION_FAILED;
1835         } else {
1836                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set stop sound : uid(%d) file(%s)", uid, file);
1837         }
1838
1839         dbus_message_append_args(msg,
1840                 DBUS_TYPE_INT32, &uid,
1841                 DBUS_TYPE_STRING, &file,
1842                 DBUS_TYPE_INVALID);
1843
1844         DBusError err;
1845         dbus_error_init(&err);
1846
1847         DBusMessage* result_msg;
1848         int result = STT_ERROR_OPERATION_FAILED;
1849
1850         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1851         dbus_message_unref(msg);
1852         if (dbus_error_is_set(&err)) {
1853                 //LCOV_EXCL_START
1854                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1855                 dbus_error_free(&err);
1856                 //LCOV_EXCL_STOP
1857         }
1858
1859         if (NULL != result_msg) {
1860                 dbus_message_get_args(result_msg, &err,
1861                         DBUS_TYPE_INT32, &result,
1862                         DBUS_TYPE_INVALID);
1863
1864                 if (dbus_error_is_set(&err)) {
1865                         //LCOV_EXCL_START
1866                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1867                         dbus_error_free(&err);
1868                         result = STT_ERROR_OPERATION_FAILED;
1869                         //LCOV_EXCL_STOP
1870                 }
1871                 dbus_message_unref(result_msg);
1872
1873                 if (0 == result) {
1874                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1875                 } else {
1876                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set stop sound : result = %d", result); //LCOV_EXCL_LINE
1877                 }
1878         } else {
1879                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL"); //LCOV_EXCL_LINE
1880                 stt_dbus_reconnect();
1881                 result = STT_ERROR_TIMED_OUT;
1882         }
1883
1884         return result;
1885 }
1886
1887 int stt_dbus_request_unset_stop_sound(int uid)
1888 {
1889         DBusMessage* msg;
1890
1891         msg = dbus_message_new_method_call(
1892                 g_server_service_name,
1893                 g_server_service_object,
1894                 g_server_service_interface,
1895                 STT_METHOD_UNSET_STOP_SOUND);
1896
1897         if (NULL == msg) {
1898                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset stop sound : Fail to make message"); //LCOV_EXCL_LINE
1899                 return STT_ERROR_OPERATION_FAILED;
1900         } else {
1901                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset stop sound : uid(%d)", uid);
1902         }
1903
1904         dbus_message_append_args(msg,
1905                 DBUS_TYPE_INT32, &uid,
1906                 DBUS_TYPE_INVALID);
1907
1908         DBusError err;
1909         dbus_error_init(&err);
1910
1911         DBusMessage* result_msg;
1912         int result = STT_ERROR_OPERATION_FAILED;
1913
1914         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1915         dbus_message_unref(msg);
1916         if (dbus_error_is_set(&err)) {
1917                 //LCOV_EXCL_START
1918                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1919                 dbus_error_free(&err);
1920                 //LCOV_EXCL_STOP
1921         }
1922
1923         if (NULL != result_msg) {
1924                 dbus_message_get_args(result_msg, &err,
1925                         DBUS_TYPE_INT32, &result,
1926                         DBUS_TYPE_INVALID);
1927
1928                 if (dbus_error_is_set(&err)) {
1929                         //LCOV_EXCL_START
1930                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1931                         dbus_error_free(&err);
1932                         result = STT_ERROR_OPERATION_FAILED;
1933                         //LCOV_EXCL_STOP
1934                 }
1935                 dbus_message_unref(result_msg);
1936
1937                 if (0 == result) {
1938                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1939                 } else {
1940                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset stop sound : result = %d", result); //LCOV_EXCL_LINE
1941                 }
1942         } else {
1943                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL"); //LCOV_EXCL_LINE
1944                 stt_dbus_reconnect();
1945                 result = STT_ERROR_TIMED_OUT;
1946         }
1947
1948         return result;
1949 }
1950
1951 int stt_dbus_request_start(int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential)
1952 {
1953         if (NULL == lang || NULL == type || NULL == appid) {
1954                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL"); //LCOV_EXCL_LINE
1955                 return STT_ERROR_INVALID_PARAMETER;
1956         }
1957
1958         DBusMessage* msg;
1959
1960         /* create a signal & check for errors */
1961         msg = dbus_message_new_method_call(
1962                 g_server_service_name,
1963                 g_server_service_object,
1964                 g_server_service_interface,
1965                 STT_METHOD_START);
1966
1967         if (NULL == msg) {
1968                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start : Fail to make message"); //LCOV_EXCL_LINE
1969                 return STT_ERROR_OPERATION_FAILED;
1970         } else {
1971                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start : uid(%d), language(%s), type(%s)", uid, lang, type);
1972         }
1973
1974         char *temp = NULL;
1975         if (NULL == credential) {
1976                 temp = strdup("NULL");
1977         } else {
1978                 temp = strdup(credential);
1979         }
1980
1981         dbus_message_append_args(msg,
1982                 DBUS_TYPE_INT32, &uid,
1983                 DBUS_TYPE_STRING, &lang,
1984                 DBUS_TYPE_STRING, &type,
1985                 DBUS_TYPE_INT32, &silence,
1986                 DBUS_TYPE_STRING, &appid,
1987                 DBUS_TYPE_STRING, &temp,
1988                 DBUS_TYPE_INVALID);
1989 #if 1
1990         if (g_conn_sender) {
1991                 dbus_message_set_no_reply(msg, TRUE);
1992
1993                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1994                         //LCOV_EXCL_START
1995                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt start message : Out Of Memory !");
1996                         if (NULL != temp) {
1997                                         free(temp);
1998                                         temp = NULL;
1999                         }
2000                         return STT_ERROR_OUT_OF_MEMORY;
2001                         //LCOV_EXCL_STOP
2002                 } else {
2003                         dbus_connection_flush(g_conn_sender);
2004                 }
2005
2006                 dbus_message_unref(msg);
2007
2008         } else {
2009                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender); //LCOV_EXCL_LINE
2010                 if (NULL != temp) {
2011                                 free(temp);
2012                                 temp = NULL;
2013                 }
2014                 return STT_ERROR_OPERATION_FAILED;
2015         }
2016
2017         if (NULL != temp) {
2018                         free(temp);
2019                         temp = NULL;
2020         }
2021         return 0;
2022 #else
2023         DBusError err;
2024         dbus_error_init(&err);
2025
2026         DBusMessage* result_msg;
2027         int result = STT_ERROR_OPERATION_FAILED;
2028
2029         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
2030         dbus_message_unref(msg);
2031         if (dbus_error_is_set(&err)) {
2032                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
2033                 dbus_error_free(&err);
2034         }
2035
2036         if (NULL != result_msg) {
2037                 dbus_message_get_args(result_msg, &err,
2038                         DBUS_TYPE_INT32, &result,
2039                         DBUS_TYPE_INVALID);
2040
2041                 if (dbus_error_is_set(&err)) {
2042                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
2043                         dbus_error_free(&err);
2044                         result = STT_ERROR_OPERATION_FAILED;
2045                 }
2046                 dbus_message_unref(result_msg);
2047
2048                 if (0 == result) {
2049                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt start : result = %d ", result);
2050                 } else {
2051                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt start : result = %d ", result);
2052                 }
2053         } else {
2054                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
2055                 stt_dbus_reconnect();
2056                 result = STT_ERROR_TIMED_OUT;
2057         }
2058
2059         return result;
2060 #endif
2061 }
2062
2063 int stt_dbus_request_stop(int uid)
2064 {
2065         DBusMessage* msg;
2066
2067         /* create a signal & check for errors */
2068         msg = dbus_message_new_method_call(
2069                 g_server_service_name,
2070                 g_server_service_object,
2071                 g_server_service_interface,
2072                 STT_METHOD_STOP);
2073
2074         if (NULL == msg) {
2075                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt stop : Fail to make message"); //LCOV_EXCL_LINE
2076                 return STT_ERROR_OPERATION_FAILED;
2077         } else {
2078                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt stop : uid(%d)", uid);
2079         }
2080
2081         dbus_message_append_args(msg,
2082                 DBUS_TYPE_INT32, &uid,
2083                 DBUS_TYPE_INVALID);
2084 #if 1
2085         if (g_conn_sender) {
2086                 dbus_message_set_no_reply(msg, TRUE);
2087
2088                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
2089                         //LCOV_EXCL_START
2090                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
2091                         return STT_ERROR_OUT_OF_MEMORY;
2092                         //LCOV_EXCL_STOP
2093                 } else {
2094                         dbus_connection_flush(g_conn_sender);
2095                 }
2096
2097                 dbus_message_unref(msg);
2098         } else {
2099                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
2100                 return STT_ERROR_OPERATION_FAILED;
2101         }
2102
2103         return 0;
2104 #else
2105         DBusError err;
2106         dbus_error_init(&err);
2107
2108         DBusMessage* result_msg;
2109         int result = STT_ERROR_OPERATION_FAILED;
2110
2111         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
2112         dbus_message_unref(msg);
2113         if (dbus_error_is_set(&err)) {
2114                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
2115                 dbus_error_free(&err);
2116         }
2117
2118         if (NULL != result_msg) {
2119                 dbus_message_get_args(result_msg, &err,
2120                         DBUS_TYPE_INT32, &result,
2121                         DBUS_TYPE_INVALID);
2122
2123                 if (dbus_error_is_set(&err)) {
2124                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
2125                         dbus_error_free(&err);
2126                         result = STT_ERROR_OPERATION_FAILED;
2127                 }
2128                 dbus_message_unref(result_msg);
2129
2130                 if (0 == result) {
2131                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt stop : result = %d ", result);
2132                 } else {
2133                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt stop : result = %d ", result);
2134                 }
2135         } else {
2136                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
2137                 stt_dbus_reconnect();
2138                 result = STT_ERROR_TIMED_OUT;
2139         }
2140
2141         return result;
2142 #endif
2143 }
2144
2145 int stt_dbus_request_cancel(int uid)
2146 {
2147         DBusMessage* msg;
2148
2149         /* create a signal & check for errors */
2150         msg = dbus_message_new_method_call(
2151                 g_server_service_name,
2152                 g_server_service_object,
2153                 g_server_service_interface,
2154                 STT_METHOD_CANCEL);
2155
2156         if (NULL == msg) {
2157                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel : Fail to make message"); //LCOV_EXCL_LINE
2158                 return STT_ERROR_OPERATION_FAILED;
2159         } else {
2160                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel : uid(%d)", uid);
2161         }
2162
2163         dbus_message_append_args(msg,
2164                 DBUS_TYPE_INT32, &uid,
2165                 DBUS_TYPE_INVALID);
2166 #if 1
2167         if (g_conn_sender) {
2168                 dbus_message_set_no_reply(msg, TRUE);
2169
2170                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
2171                         //LCOV_EXCL_START
2172                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
2173                         return STT_ERROR_OUT_OF_MEMORY;
2174                         //LCOV_EXCL_STOP
2175                 } else {
2176                         dbus_connection_flush(g_conn_sender);
2177                 }
2178
2179                 dbus_message_unref(msg);
2180         } else {
2181                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
2182                 return STT_ERROR_OPERATION_FAILED;
2183         }
2184
2185         return 0;
2186 #else
2187         DBusError err;
2188         dbus_error_init(&err);
2189
2190         DBusMessage* result_msg;
2191         int result = STT_ERROR_OPERATION_FAILED;
2192
2193         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
2194         dbus_message_unref(msg);
2195         if (dbus_error_is_set(&err)) {
2196                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
2197                 dbus_error_free(&err);
2198         }
2199
2200         if (NULL != result_msg) {
2201                 dbus_message_get_args(result_msg, &err,
2202                         DBUS_TYPE_INT32, &result,
2203                         DBUS_TYPE_INVALID);
2204
2205                 if (dbus_error_is_set(&err)) {
2206                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
2207                         dbus_error_free(&err);
2208                         result = STT_ERROR_OPERATION_FAILED;
2209                 }
2210                 dbus_message_unref(result_msg);
2211
2212                 if (0 == result) {
2213                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt cancel : result = %d ", result);
2214                 } else {
2215                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt cancel : result = %d ", result);
2216                 }
2217         } else {
2218                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
2219                 stt_dbus_reconnect();
2220                 result = STT_ERROR_TIMED_OUT;
2221         }
2222
2223         return result;
2224 #endif
2225 }
2226
2227 //LCOV_EXCL_START
2228 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)
2229 {
2230         if (NULL == lang || NULL == type || NULL == appid) {
2231                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
2232                 return STT_ERROR_INVALID_PARAMETER;
2233         }
2234
2235         DBusMessage* msg;
2236
2237         /* create a signal & check for errors */
2238         msg = dbus_message_new_method_call(
2239                 g_server_service_name,
2240                 g_server_service_object,
2241                 g_server_service_interface,
2242                 STT_METHOD_START_FILE);
2243
2244         if (NULL == msg) {
2245                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start file : Fail to make message");
2246                 return STT_ERROR_OPERATION_FAILED;
2247         } else {
2248                 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);
2249         }
2250
2251         char *temp = NULL;
2252         if (NULL == credential) {
2253                 temp = strdup("NULL");
2254         } else {
2255                 temp = strdup(credential);
2256         }
2257
2258         dbus_message_append_args(msg,
2259                 DBUS_TYPE_INT32, &uid,
2260                 DBUS_TYPE_STRING, &lang,
2261                 DBUS_TYPE_STRING, &type,
2262                 DBUS_TYPE_INT32, &silence,
2263                 DBUS_TYPE_STRING, &appid,
2264                 DBUS_TYPE_STRING, &temp,
2265                 DBUS_TYPE_STRING, &filepath,
2266                 DBUS_TYPE_INT32, &audio_type,
2267                 DBUS_TYPE_INT32, &sample_rate,
2268                 DBUS_TYPE_INVALID);
2269         if (g_conn_sender) {
2270                 dbus_message_set_no_reply(msg, TRUE);
2271
2272                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
2273                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt start message : Out Of Memory !");
2274                         if (NULL != temp) {
2275                                 free(temp);
2276                                 temp = NULL;
2277                         }
2278                         return STT_ERROR_OUT_OF_MEMORY;
2279                 } else {
2280                         dbus_connection_flush(g_conn_sender);
2281                 }
2282
2283                 dbus_message_unref(msg);
2284
2285         } else {
2286                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
2287                 if (NULL != temp) {
2288                                 free(temp);
2289                                 temp = NULL;
2290                 }
2291                 return STT_ERROR_OPERATION_FAILED;
2292         }
2293
2294         if (NULL != temp) {
2295                         free(temp);
2296                         temp = NULL;
2297         }
2298         return 0;
2299 }
2300
2301 int stt_dbus_request_cancel_file(int uid)
2302 {
2303         DBusMessage* msg;
2304
2305         /* create a signal & check for errors */
2306         msg = dbus_message_new_method_call(
2307                 g_server_service_name,
2308                 g_server_service_object,
2309                 g_server_service_interface,
2310                 STT_METHOD_CANCEL_FILE);
2311
2312         if (NULL == msg) {
2313                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel file : Fail to make message");
2314                 return STT_ERROR_OPERATION_FAILED;
2315         } else {
2316                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel file : uid(%d)", uid);
2317         }
2318
2319         dbus_message_append_args(msg,
2320                 DBUS_TYPE_INT32, &uid,
2321                 DBUS_TYPE_INVALID);
2322
2323         if (g_conn_sender) {
2324                 dbus_message_set_no_reply(msg, TRUE);
2325
2326                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
2327                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
2328                         return STT_ERROR_OUT_OF_MEMORY;
2329                 } else {
2330                         dbus_connection_flush(g_conn_sender);
2331                 }
2332
2333                 dbus_message_unref(msg);
2334         } else {
2335                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
2336                 return STT_ERROR_OPERATION_FAILED;
2337         }
2338
2339         return 0;
2340 }
2341 //LCOV_EXCL_STOP