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