client/stt_dbus.c

   1 /*
   2 *  Copyright (c) 2011-2014 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 static int g_waiting_time = 3000;
  22 static int g_waiting_short_time = 500;
  23
  24 static Ecore_Fd_Handler* g_fd_handler = NULL;
  25
  26 static DBusConnection* g_conn = NULL;
  27
  28
  29 extern int __stt_cb_error(int uid, int reason);
  30
  31 extern int __stt_cb_result(int uid, int event, char** data, int data_count, const char* msg);
  32
  33 extern int __stt_cb_set_state(int uid, int state);
  34
  35 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
  36 {
  37         DBusConnection* conn = (DBusConnection*)data;
  38         DBusMessage* msg = NULL;
  39         DBusMessage *reply = NULL;
  40
  41         if (NULL == conn)
  42                 return ECORE_CALLBACK_RENEW;
  43
  44         dbus_connection_read_write_dispatch(conn, 50);
  45
  46         msg = dbus_connection_pop_message(conn);
  47
  48         if (true != dbus_connection_get_is_connected(conn)) {
  49                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Conn is disconnected");
  50                 return ECORE_CALLBACK_RENEW;
  51         }
  52
  53         /* loop again if we haven't read a message */
  54         if (NULL == msg) {
  55                 return ECORE_CALLBACK_RENEW;
  56         }
  57
  58         DBusError err;
  59         dbus_error_init(&err);
  60
  61         char if_name[64];
  62         snprintf(if_name, 64, "%s%d", STT_CLIENT_SERVICE_INTERFACE, getpid());
  63
  64         if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_HELLO)) {
  65                 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Hello");
  66                 int uid = 0;
  67                 int response = -1;
  68
  69                 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
  70                 if (dbus_error_is_set(&err)) {
  71                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
  72                         dbus_error_free(&err);
  73                 }
  74
  75                 if (uid > 0) {
  76                         SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get hello : uid(%d)", uid);
  77
  78                         /* check uid */
  79                         stt_client_s* client = stt_client_get_by_uid(uid);
  80                         if( NULL != client )
  81                                 response = 1;
  82                         else
  83                                 response = 0;
  84                 } else {
  85                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get hello : invalid uid");
  86                 }
  87
  88                 reply = dbus_message_new_method_return(msg);
  89
  90                 if (NULL != reply) {
  91                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
  92
  93                         if (!dbus_connection_send(conn, reply, NULL))
  94                                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to send reply");
  95                         else
  96                                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get hello : result(%d)", response);
  97
  98                         dbus_connection_flush(conn);
  99                         dbus_message_unref(reply);
 100                 } else {
 101                         SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to create reply message");
 102                 }
 103
 104                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 105                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 106         } /* STTD_METHOD_HELLO */
 107
 108         else if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_SET_STATE)) {
 109                 SLOG(LOG_DEBUG, TAG_STTC, "===== Set State");
 110                 int uid = 0;
 111                 int response = -1;
 112                 int state = -1;
 113
 114                 dbus_message_get_args(msg, &err,
 115                         DBUS_TYPE_INT32, &uid,
 116                         DBUS_TYPE_INT32, &state,
 117                         DBUS_TYPE_INVALID);
 118
 119                 if (dbus_error_is_set(&err)) {
 120                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 121                         dbus_error_free(&err);
 122                 }
 123
 124                 if (uid > 0 && state >= 0) {
 125                         SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set state : uid(%d), state(%d)", uid, state);
 126
 127                         response = __stt_cb_set_state(uid, state);
 128                 } else {
 129                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set state : invalid uid or state");
 130                 }
 131
 132                 reply = dbus_message_new_method_return(msg);
 133
 134                 if (NULL != reply) {
 135                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
 136
 137                         if (!dbus_connection_send(conn, reply, NULL)) {
 138                                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set state : fail to send reply");
 139                         }
 140
 141                         dbus_connection_flush(conn);
 142                         dbus_message_unref(reply);
 143                 } else {
 144                         SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set state : fail to create reply message");
 145                 }
 146
 147                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 148                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 149         } /* STTD_METHOD_SET_STATE */
 150
 151         else if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_GET_STATE)) {
 152                 SLOG(LOG_DEBUG, TAG_STTC, "===== Get state");
 153                 int uid = 0;
 154                 int response = -1;
 155
 156                 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 157
 158                 if (dbus_error_is_set(&err)) {
 159                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 160                         dbus_error_free(&err);
 161                 }
 162
 163                 if (uid > 0) {
 164                         SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get state : uid(%d)", uid);
 165
 166                         /* check state */
 167                         stt_client_s* client = stt_client_get_by_uid(uid);
 168                         if( NULL != client )
 169                                 response = client->current_state;
 170                         else
 171                                 SLOG(LOG_ERROR, TAG_STTC, "invalid uid");
 172
 173                 } else {
 174                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get state : invalid uid");
 175                 }
 176
 177                 reply = dbus_message_new_method_return(msg);
 178
 179                 if (NULL != reply) {
 180                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
 181
 182                         if (!dbus_connection_send(conn, reply, NULL))
 183                                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get state : fail to send reply");
 184                         else
 185                                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get state : result(%d)", response);
 186
 187                         dbus_connection_flush(conn);
 188                         dbus_message_unref(reply);
 189                 } else {
 190                         SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to create reply message");
 191                 }
 192
 193                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 194                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 195         } /* STTD_METHOD_GET_STATE */
 196
 197         else if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_RESULT)) {
 198                 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Result");
 199                 int uid = 0;
 200                 DBusMessageIter args;
 201
 202                 dbus_message_iter_init(msg, &args);
 203
 204                 /* Get result */
 205                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 206                         dbus_message_iter_get_basic(&args, &uid);
 207                         dbus_message_iter_next(&args);
 208                 }
 209
 210                 if (uid > 0) {
 211                         char** temp_result = NULL;
 212                         char* temp_msg = NULL;
 213                         char* temp_char = NULL;
 214                         int temp_event = 0;
 215                         int temp_count = 0;
 216
 217                         /* Get recognition type */
 218                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 219                                 dbus_message_iter_get_basic(&args, &temp_event);
 220                                 dbus_message_iter_next(&args);
 221                         }
 222
 223                         if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&args)) {
 224                                 dbus_message_iter_get_basic(&args, &(temp_msg) );
 225                                 dbus_message_iter_next(&args);
 226                         }
 227
 228                         /* Get voice size */
 229                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 230                                 dbus_message_iter_get_basic(&args, &temp_count);
 231                                 dbus_message_iter_next(&args);
 232                         }
 233
 234                         SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get result : uid(%d) event(%d) message(%s) count(%d)",
 235                                 uid, temp_event, temp_msg, temp_count);
 236
 237                         if (temp_count <= 0) {
 238                                 __stt_cb_result(uid, temp_event, NULL, 0, temp_msg);
 239                         } else {
 240                                 temp_result = (char**)calloc(temp_count, sizeof(char*));
 241
 242                                 if (NULL == temp_result)        {
 243                                         SLOG(LOG_ERROR, TAG_STTC, "Fail : memory allocation error");
 244                                 } else {
 245                                         int i = 0;
 246                                         for (i = 0;i < temp_count;i++) {
 247                                                 dbus_message_iter_get_basic(&args, &(temp_char) );
 248                                                 dbus_message_iter_next(&args);
 249
 250                                                 if (NULL != temp_char) {
 251                                                         temp_result[i] = strdup(temp_char);
 252                                                         SLOG(LOG_DEBUG, TAG_STTC, "result[%d] : %s", i, temp_result[i]);
 253                                                 }
 254                                         }
 255
 256                                         __stt_cb_result(uid, temp_event, temp_result, temp_count, temp_msg);
 257
 258                                         for (i = 0;i < temp_count;i++) {
 259                                                 if (NULL != temp_result[i])
 260                                                         free(temp_result[i]);
 261                                         }
 262
 263                                         free(temp_result);
 264                                 }
 265                         }
 266                 } else {
 267                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get result : invalid uid");
 268                 }
 269
 270                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 271                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 272         }/* STTD_METHOD_RESULT */
 273
 274         else if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_ERROR)) {
 275                 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Error");
 276                 int uid;
 277                 int reason;
 278                 char* err_msg;
 279
 280                 dbus_message_get_args(msg, &err,
 281                         DBUS_TYPE_INT32, &uid,
 282                         DBUS_TYPE_INT32, &reason,
 283                         DBUS_TYPE_STRING, &err_msg,
 284                         DBUS_TYPE_INVALID);
 285
 286                 if (dbus_error_is_set(&err)) {
 287                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt Get Error message : Get arguments error (%s)\n", err.message);
 288                         dbus_error_free(&err);
 289                 } else {
 290                         SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt Get Error message : uid(%d), reason(%d), msg(%s)\n", uid, reason, err_msg);
 291                         __stt_cb_error(uid, reason);
 292                 }
 293
 294                 reply = dbus_message_new_method_return(msg);
 295
 296                 if (NULL != reply) {
 297                         if (!dbus_connection_send(conn, reply, NULL))
 298                                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt Error message : fail to send reply");
 299                         else
 300                                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt Error message");
 301
 302                         dbus_connection_flush(conn);
 303                         dbus_message_unref(reply);
 304                 } else {
 305                         SLOG(LOG_ERROR, TAG_STTC, ">>>> stt Error message : fail to create reply message");
 306                 }
 307
 308                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 309                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 310         }/* STTD_METHOD_ERROR */
 311
 312         /* free the message */
 313         dbus_message_unref(msg);
 314
 315         return ECORE_CALLBACK_PASS_ON;
 316 }
 317
 318 int stt_dbus_open_connection()
 319 {
 320         if (NULL != g_conn) {
 321                 SLOG(LOG_WARN, TAG_STTC, "already existed connection ");
 322                 return 0;
 323         }
 324
 325         DBusError err;
 326         int ret;
 327
 328         /* initialise the error value */
 329         dbus_error_init(&err);
 330
 331         /* connect to the DBUS system bus, and check for errors */
 332         g_conn = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
 333
 334         if (dbus_error_is_set(&err)) {
 335                 SLOG(LOG_ERROR, TAG_STTC, "Dbus Connection Error (%s)\n", err.message);
 336                 dbus_error_free(&err);
 337         }
 338
 339         if (NULL == g_conn) {
 340                 SLOG(LOG_ERROR, TAG_STTC, "Fail to get dbus connection");
 341                 return STT_ERROR_OPERATION_FAILED;
 342         }
 343
 344         int pid = getpid();
 345
 346         char service_name[64];
 347         memset(service_name, '\0', 64);
 348         snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
 349
 350         SECURE_SLOG(LOG_DEBUG, TAG_STTC, "service name is %s\n", service_name);
 351
 352         /* register our name on the bus, and check for errors */
 353         ret = dbus_bus_request_name(g_conn, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
 354
 355         if (dbus_error_is_set(&err)) {
 356                 SLOG(LOG_ERROR, TAG_STTC, "Name Error (%s)\n", err.message);
 357                 dbus_error_free(&err);
 358         }
 359
 360         if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
 361                 SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] Fail to be primary owner");
 362                 return -2;
 363         }
 364
 365         if( NULL != g_fd_handler ) {
 366                 SLOG(LOG_WARN, TAG_STTC, "The handler already exists.");
 367                 return 0;
 368         }
 369
 370         char rule[128];
 371         snprintf(rule, 128, "type='signal',interface='%s%d'", STT_CLIENT_SERVICE_INTERFACE, pid);
 372
 373         /* add a rule for which messages we want to see */
 374         dbus_bus_add_match(g_conn, rule, &err);
 375         dbus_connection_flush(g_conn);
 376
 377         if (dbus_error_is_set(&err)) {
 378                 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)\n", err.message);
 379                 dbus_error_free(&err);
 380                 return STT_ERROR_OPERATION_FAILED;
 381         }
 382
 383         int fd = 0;
 384         if (1 != dbus_connection_get_unix_fd(g_conn, &fd)) {
 385                 SLOG(LOG_ERROR, TAG_STTC, "fail to get fd from dbus");
 386                 return STT_ERROR_OPERATION_FAILED;
 387         } else {
 388                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "Get fd from dbus : %d\n", fd);
 389         }
 390
 391         g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn, NULL, NULL);
 392
 393         if (NULL == g_fd_handler) {
 394                 SLOG(LOG_ERROR, TAG_STTC, "fail to get fd handler from ecore");
 395                 return STT_ERROR_OPERATION_FAILED;
 396         }
 397
 398         return 0;
 399 }
 400
 401 int stt_dbus_close_connection()
 402 {
 403         DBusError err;
 404         dbus_error_init(&err);
 405
 406         int pid = getpid();
 407
 408         char service_name[64];
 409         memset(service_name, '\0', 64);
 410         snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
 411
 412         dbus_bus_release_name (g_conn, service_name, &err);
 413
 414         if (dbus_error_is_set(&err)) {
 415                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Release name Error (%s)", err.message);
 416                 dbus_error_free(&err);
 417         }
 418
 419         dbus_connection_close(g_conn);
 420
 421         g_fd_handler = NULL;
 422         g_conn = NULL;
 423
 424         return 0;
 425 }
 426
 427 int stt_dbus_reconnect()
 428 {
 429         bool connected = dbus_connection_get_is_connected(g_conn);
 430         SECURE_SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] %s", connected ? "Connected" : "Not connected");
 431
 432         if (false == connected) {
 433                 stt_dbus_close_connection();
 434
 435                 if(0 != stt_dbus_open_connection()) {
 436                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to reconnect");
 437                         return -1;
 438                 }
 439
 440                 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Reconnect");
 441         }
 442
 443         return 0;
 444 }
 445
 446 int stt_dbus_request_hello()
 447 {
 448         DBusMessage* msg;
 449
 450         msg = dbus_message_new_method_call(
 451                 STT_SERVER_SERVICE_NAME,
 452                 STT_SERVER_SERVICE_OBJECT_PATH,
 453                 STT_SERVER_SERVICE_INTERFACE,
 454                 STT_METHOD_HELLO);
 455
 456         if (NULL == msg) {
 457                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request stt hello : Fail to make message");
 458                 return STT_ERROR_OPERATION_FAILED;
 459         }
 460
 461         if (NULL == g_conn) {
 462                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
 463                 dbus_message_unref(msg);
 464                 return STT_ERROR_INVALID_STATE;
 465         }
 466
 467         DBusError err;
 468         dbus_error_init(&err);
 469
 470         DBusMessage* result_msg = NULL;
 471         int result = STT_DAEMON_NORMAL;
 472
 473         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_short_time, &err);
 474         dbus_message_unref(msg);
 475         if (dbus_error_is_set(&err)) {
 476                 dbus_error_free(&err);
 477         }
 478
 479         int status = 0;
 480         if (NULL != result_msg) {
 481                 dbus_message_get_args(result_msg, &err,
 482                                 DBUS_TYPE_INT32, &status,
 483                                 DBUS_TYPE_INVALID);
 484
 485                 dbus_message_unref(result_msg);
 486
 487                 if (dbus_error_is_set(&err)) {
 488                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 489                         dbus_error_free(&err);
 490                 }
 491
 492                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt hello - %d", status);
 493                 result = status;
 494         } else {
 495                 result = STT_ERROR_TIMED_OUT;
 496         }
 497
 498         return result;
 499 }
 500
 501
 502 int stt_dbus_request_initialize(int uid, bool* silence_supported)
 503 {
 504         DBusMessage* msg;
 505
 506         msg = dbus_message_new_method_call(
 507                 STT_SERVER_SERVICE_NAME,
 508                 STT_SERVER_SERVICE_OBJECT_PATH,
 509                 STT_SERVER_SERVICE_INTERFACE,
 510                 STT_METHOD_INITIALIZE);
 511
 512         if (NULL == msg) {
 513                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt initialize : Fail to make message");
 514                 return STT_ERROR_OPERATION_FAILED;
 515         } else {
 516                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt initialize : uid(%d)", uid);
 517         }
 518
 519         if (NULL == g_conn) {
 520                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
 521                 dbus_message_unref(msg);
 522                 return STT_ERROR_INVALID_STATE;
 523         }
 524
 525         int pid = getpid();
 526         dbus_message_append_args( msg,
 527                 DBUS_TYPE_INT32, &pid,
 528                 DBUS_TYPE_INT32, &uid,
 529                 DBUS_TYPE_INVALID);
 530
 531         DBusError err;
 532         dbus_error_init(&err);
 533
 534         DBusMessage* result_msg;
 535         int result = STT_ERROR_OPERATION_FAILED;
 536
 537         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 538         dbus_message_unref(msg);
 539         if (dbus_error_is_set(&err)) {
 540                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 541                 dbus_error_free(&err);
 542         }
 543
 544         if (NULL != result_msg) {
 545                 dbus_message_get_args(result_msg, &err,
 546                         DBUS_TYPE_INT32, &result,
 547                         DBUS_TYPE_INT32, silence_supported,
 548                         DBUS_TYPE_INVALID);
 549
 550                 if (dbus_error_is_set(&err)) {
 551                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)\n", err.message);
 552                         dbus_error_free(&err);
 553                         result = STT_ERROR_OPERATION_FAILED;
 554                 }
 555
 556                 if (0 == result) {
 557                         SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt initialize : result = %d, silence(%d)",
 558                                 result, *silence_supported);
 559                 } else {
 560                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt initialize : result = %d", result);
 561                 }
 562
 563                 dbus_message_unref(result_msg);
 564         } else {
 565                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 566                 stt_dbus_reconnect();
 567                 result = STT_ERROR_TIMED_OUT;
 568         }
 569
 570         return result;
 571 }
 572
 573 int stt_dbus_request_finalize(int uid)
 574 {
 575         DBusMessage* msg;
 576
 577         msg = dbus_message_new_method_call(
 578                 STT_SERVER_SERVICE_NAME,
 579                 STT_SERVER_SERVICE_OBJECT_PATH,
 580                 STT_SERVER_SERVICE_INTERFACE,
 581                 STT_METHOD_FINALIZE);
 582
 583         if (NULL == msg) {
 584                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt finalize : Fail to make message");
 585                 return STT_ERROR_OPERATION_FAILED;
 586         } else {
 587                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt finalize : uid(%d)", uid);
 588         }
 589
 590         if (NULL == g_conn) {
 591                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
 592                 dbus_message_unref(msg);
 593                 return STT_ERROR_INVALID_STATE;
 594         }
 595
 596         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 597
 598         DBusError err;
 599         dbus_error_init(&err);
 600
 601         DBusMessage* result_msg;
 602         int result = STT_ERROR_OPERATION_FAILED;
 603
 604         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_short_time, &err);
 605         dbus_message_unref(msg);
 606         if (dbus_error_is_set(&err)) {
 607                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 608                 dbus_error_free(&err);
 609         }
 610
 611         if (NULL != result_msg) {
 612                 dbus_message_get_args(result_msg, &err,
 613                                 DBUS_TYPE_INT32, &result,
 614                                 DBUS_TYPE_INVALID);
 615
 616                 if (dbus_error_is_set(&err)) {
 617                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 618                         dbus_error_free(&err);
 619                         result = STT_ERROR_OPERATION_FAILED;
 620                 }
 621
 622                 dbus_message_unref(result_msg);
 623
 624                 if (0 == result) {
 625                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt finalize : result = %d", result);
 626                 } else {
 627                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt finalize : result = %d", result);
 628                 }
 629         } else {
 630                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 631                 stt_dbus_reconnect();
 632                 result = STT_ERROR_TIMED_OUT;
 633         }
 634
 635         return result;
 636 }
 637
 638 int stt_dbus_request_set_current_engine(int uid, const char* engine_id, bool* silence_supported)
 639 {
 640         DBusMessage* msg;
 641
 642         msg = dbus_message_new_method_call(
 643                 STT_SERVER_SERVICE_NAME,
 644                 STT_SERVER_SERVICE_OBJECT_PATH,
 645                 STT_SERVER_SERVICE_INTERFACE,
 646                 STT_METHOD_SET_CURRENT_ENGINE);
 647
 648         if (NULL == msg) {
 649                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set engine : Fail to make message");
 650                 return STT_ERROR_OPERATION_FAILED;
 651         } else {
 652                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set engine : uid(%d)", uid);
 653         }
 654
 655         if (NULL == g_conn) {
 656                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
 657                 dbus_message_unref(msg);
 658                 return STT_ERROR_INVALID_STATE;
 659         }
 660
 661         dbus_message_append_args( msg,
 662                 DBUS_TYPE_INT32, &uid,
 663                 DBUS_TYPE_STRING, &engine_id,
 664                 DBUS_TYPE_INVALID);
 665
 666         DBusError err;
 667         dbus_error_init(&err);
 668
 669         DBusMessage* result_msg;
 670         int result = STT_ERROR_OPERATION_FAILED;
 671
 672         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 673         dbus_message_unref(msg);
 674         if (dbus_error_is_set(&err)) {
 675                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 676                 dbus_error_free(&err);
 677         }
 678
 679         if (NULL != result_msg) {
 680                 dbus_message_get_args(result_msg, &err,
 681                         DBUS_TYPE_INT32, &result,
 682                         DBUS_TYPE_INT32, silence_supported,
 683                         DBUS_TYPE_INVALID);
 684
 685                 if (dbus_error_is_set(&err)) {
 686                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)\n", err.message);
 687                         dbus_error_free(&err);
 688                         result = STT_ERROR_OPERATION_FAILED;
 689                 }
 690
 691                 dbus_message_unref(result_msg);
 692
 693                 if (0 == result) {
 694                         SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set engine : result = %d , silence(%d)",
 695                                 result, *silence_supported);
 696                 } else {
 697                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set engine : result = %d", result);
 698                 }
 699         } else {
 700                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 701                 stt_dbus_reconnect();
 702                 result = STT_ERROR_TIMED_OUT;
 703         }
 704
 705         return result;
 706 }
 707
 708 int stt_dbus_request_check_app_agreed(int uid, const char* appid, bool* value)
 709 {
 710         if (NULL == appid || NULL == value) {
 711                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 712                 return STT_ERROR_INVALID_PARAMETER;
 713         }
 714
 715         DBusMessage* msg;
 716
 717         msg = dbus_message_new_method_call(
 718                 STT_SERVER_SERVICE_NAME,
 719                 STT_SERVER_SERVICE_OBJECT_PATH,
 720                 STT_SERVER_SERVICE_INTERFACE,
 721                 STT_METHOD_CHECK_APP_AGREED);
 722
 723         if (NULL == msg) {
 724                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt check app agreed : Fail to make message");
 725                 return STT_ERROR_OPERATION_FAILED;
 726         } else {
 727                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt check app agreed : uid(%d) appid(%s)", uid, appid);
 728         }
 729
 730         if (NULL == g_conn) {
 731                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
 732                 dbus_message_unref(msg);
 733                 return STT_ERROR_INVALID_STATE;
 734         }
 735
 736         dbus_message_append_args(msg,
 737                 DBUS_TYPE_INT32, &uid,
 738                 DBUS_TYPE_STRING, &appid,
 739                 DBUS_TYPE_INVALID);
 740
 741         DBusError err;
 742         dbus_error_init(&err);
 743
 744         DBusMessage* result_msg;
 745         int result = STT_ERROR_OPERATION_FAILED;
 746         int available = -1;
 747
 748         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 749         dbus_message_unref(msg);
 750         if (dbus_error_is_set(&err)) {
 751                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 752                 dbus_error_free(&err);
 753         }
 754
 755         if (NULL != result_msg) {
 756                 dbus_message_get_args(result_msg, &err,
 757                         DBUS_TYPE_INT32, &result,
 758                         DBUS_TYPE_INT32, &available,
 759                         DBUS_TYPE_INVALID);
 760
 761                 if (dbus_error_is_set(&err)) {
 762                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 763                         dbus_error_free(&err);
 764                         result = STT_ERROR_OPERATION_FAILED;
 765                 }
 766                 dbus_message_unref(result_msg);
 767
 768                 if (0 == result) {
 769                         *value = (bool)available;
 770                         SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt check app agreed : result = %d, available = %d", result, *value);
 771                 } else {
 772                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt check app agreed : result = %d", result);
 773                 }
 774         } else {
 775                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 776                 stt_dbus_reconnect();
 777                 result = STT_ERROR_TIMED_OUT;
 778         }
 779
 780         return result;
 781 }
 782
 783 int stt_dbus_request_get_support_langs(int uid, stt_h stt, stt_supported_language_cb callback, void* user_data)
 784 {
 785         if (NULL == stt || NULL == callback) {
 786                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 787                 return STT_ERROR_INVALID_PARAMETER;
 788         }
 789
 790         DBusMessage* msg;
 791
 792         msg = dbus_message_new_method_call(
 793                 STT_SERVER_SERVICE_NAME,
 794                 STT_SERVER_SERVICE_OBJECT_PATH,
 795                 STT_SERVER_SERVICE_INTERFACE,
 796                 STT_METHOD_GET_SUPPORT_LANGS);
 797
 798         if (NULL == msg) {
 799                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get supported languages : Fail to make message");
 800                 return STT_ERROR_OPERATION_FAILED;
 801         } else {
 802                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get supported languages : uid(%d)", uid);
 803         }
 804
 805         if (NULL == g_conn) {
 806                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
 807                 dbus_message_unref(msg);
 808                 return STT_ERROR_INVALID_STATE;
 809         }
 810
 811         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 812
 813         DBusError err;
 814         dbus_error_init(&err);
 815
 816         DBusMessage* result_msg;
 817         DBusMessageIter args;
 818         int result = STT_ERROR_OPERATION_FAILED;
 819
 820         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err );
 821         dbus_message_unref(msg);
 822         if (dbus_error_is_set(&err)) {
 823                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 824                 dbus_error_free(&err);
 825         }
 826
 827         if (NULL != result_msg) {
 828                 if (dbus_message_iter_init(result_msg, &args)) {
 829                         /* Get result */
 830                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 831                                 dbus_message_iter_get_basic(&args, &result);
 832                                 dbus_message_iter_next(&args);
 833                         }
 834
 835                         if (0 == result) {
 836                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get support languages : result = %d", result);
 837
 838                                 /* Get voice size */
 839                                 int size = 0;
 840                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 841                                         dbus_message_iter_get_basic(&args, &size);
 842                                         dbus_message_iter_next(&args);
 843                                 }
 844
 845                                 if (0 >= size) {
 846                                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt size of language error : size = %d", size);
 847                                 } else {
 848                                         int i=0;
 849                                         char* temp_lang;
 850
 851                                         for (i=0 ; i<size ; i++) {
 852                                                 dbus_message_iter_get_basic(&args, &(temp_lang));
 853                                                 dbus_message_iter_next(&args);
 854
 855                                                 if (true != callback(stt, temp_lang, user_data)) {
 856                                                         break;
 857                                                 }
 858                                         }
 859                                 }
 860                         } else {
 861                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result = %d", result);
 862                         }
 863                 }
 864                 dbus_message_unref(result_msg);
 865         } else {
 866                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result message is NULL");
 867                 stt_dbus_reconnect();
 868                 result = STT_ERROR_TIMED_OUT;
 869         }
 870
 871         return result;
 872 }
 873
 874 int stt_dbus_request_get_default_lang(int uid, char** language)
 875 {
 876         if (NULL == language) {
 877                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 878                 return STT_ERROR_INVALID_PARAMETER;
 879         }
 880
 881         DBusMessage* msg;
 882
 883         msg = dbus_message_new_method_call(
 884                 STT_SERVER_SERVICE_NAME,
 885                 STT_SERVER_SERVICE_OBJECT_PATH,
 886                 STT_SERVER_SERVICE_INTERFACE,
 887                 STT_METHOD_GET_CURRENT_LANG);
 888
 889         if (NULL == msg) {
 890                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get default language : Fail to make message");
 891                 return STT_ERROR_OPERATION_FAILED;
 892         } else {
 893                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get default language  : uid(%d)", uid);
 894         }
 895
 896         if (NULL == g_conn) {
 897                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
 898                 dbus_message_unref(msg);
 899                 return STT_ERROR_INVALID_STATE;
 900         }
 901
 902         dbus_message_append_args( msg,
 903                 DBUS_TYPE_INT32, &uid,
 904                 DBUS_TYPE_INVALID);
 905
 906         DBusError err;
 907         dbus_error_init(&err);
 908
 909         DBusMessage* result_msg;
 910         int result = STT_ERROR_OPERATION_FAILED;
 911         char* temp_lang = NULL;
 912
 913         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 914         dbus_message_unref(msg);
 915         if (dbus_error_is_set(&err)) {
 916                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 917                 dbus_error_free(&err);
 918         }
 919
 920         if (NULL != result_msg) {
 921                 dbus_message_get_args(result_msg, &err,
 922                         DBUS_TYPE_INT32, &result,
 923                         DBUS_TYPE_STRING, &temp_lang,
 924                         DBUS_TYPE_INVALID);
 925
 926                 if (dbus_error_is_set(&err)) {
 927                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 928                         dbus_error_free(&err);
 929                         result = STT_ERROR_OPERATION_FAILED;
 930                 }
 931                 dbus_message_unref(result_msg);
 932
 933                 if (0 == result) {
 934                         *language = strdup(temp_lang);
 935                         SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get default language : result = %d, language = %s", result, *language);
 936                 } else {
 937                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get default language : result = %d", result);
 938                 }
 939         } else {
 940                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 941                 stt_dbus_reconnect();
 942                 result = STT_ERROR_TIMED_OUT;
 943         }
 944
 945         return result;
 946 }
 947
 948 int stt_dbus_request_is_recognition_type_supported(int uid, const char* type, bool* support)
 949 {
 950         if (NULL == support || NULL == type) {
 951                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 952                 return STT_ERROR_INVALID_PARAMETER;
 953         }
 954
 955         DBusMessage* msg;
 956
 957         msg = dbus_message_new_method_call(
 958                    STT_SERVER_SERVICE_NAME,
 959                    STT_SERVER_SERVICE_OBJECT_PATH,
 960                    STT_SERVER_SERVICE_INTERFACE,
 961                    STT_METHOD_IS_TYPE_SUPPORTED);
 962
 963         if (NULL == msg) {
 964                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt is partial result supported : Fail to make message");
 965                 return STT_ERROR_OPERATION_FAILED;
 966         } else {
 967                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt is recognition type supported : uid(%d) type(%s)", uid, type);
 968         }
 969
 970         if (NULL == g_conn) {
 971                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
 972                 dbus_message_unref(msg);
 973                 return STT_ERROR_INVALID_STATE;
 974         }
 975
 976         dbus_message_append_args( msg,
 977                 DBUS_TYPE_INT32, &uid,
 978                 DBUS_TYPE_STRING, &type,
 979                 DBUS_TYPE_INVALID);
 980
 981         DBusError err;
 982         dbus_error_init(&err);
 983
 984         DBusMessage* result_msg;
 985         int result = STT_ERROR_OPERATION_FAILED;
 986         int result_support = -1;
 987
 988         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 989         dbus_message_unref(msg);
 990         if (dbus_error_is_set(&err)) {
 991                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 992                 dbus_error_free(&err);
 993         }
 994
 995         if (NULL != result_msg) {
 996                 dbus_message_get_args(result_msg, &err,
 997                         DBUS_TYPE_INT32, &result,
 998                         DBUS_TYPE_INT32, &result_support,
 999                         DBUS_TYPE_INVALID);
1000
1001                 if (dbus_error_is_set(&err)) {
1002                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1003                         dbus_error_free(&err);
1004                         result = STT_ERROR_OPERATION_FAILED;
1005                 }
1006                 dbus_message_unref(result_msg);
1007
1008                 if (0 == result) {
1009                         *support = (bool)result_support;
1010                         SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt is recognition type supported : result = %d, support = %s", result, *support ? "true" : "false");
1011                 } else {
1012                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt is recognition type supported : result = %d", result);
1013                 }
1014         } else {
1015                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1016                 stt_dbus_reconnect();
1017                 result = STT_ERROR_TIMED_OUT;
1018         }
1019
1020         return result;
1021 }
1022
1023 int stt_dbus_request_set_start_sound(int uid, const char* file)
1024 {
1025         if (NULL == file) {
1026                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1027                 return STT_ERROR_INVALID_PARAMETER;
1028         }
1029
1030         DBusMessage* msg;
1031
1032         msg = dbus_message_new_method_call(
1033                    STT_SERVER_SERVICE_NAME,
1034                    STT_SERVER_SERVICE_OBJECT_PATH,
1035                    STT_SERVER_SERVICE_INTERFACE,
1036                    STT_METHOD_SET_START_SOUND);
1037
1038         if (NULL == msg) {
1039                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set start sound : Fail to make message");
1040                 return STT_ERROR_OPERATION_FAILED;
1041         } else {
1042                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set start sound : uid(%d) file(%s)", uid, file);
1043         }
1044
1045         if (NULL == g_conn) {
1046                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
1047                 dbus_message_unref(msg);
1048                 return STT_ERROR_INVALID_STATE;
1049         }
1050
1051         dbus_message_append_args( msg,
1052                 DBUS_TYPE_INT32, &uid,
1053                 DBUS_TYPE_STRING, &file,
1054                 DBUS_TYPE_INVALID);
1055
1056         DBusError err;
1057         dbus_error_init(&err);
1058
1059         DBusMessage* result_msg;
1060         int result = STT_ERROR_OPERATION_FAILED;
1061
1062         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
1063         dbus_message_unref(msg);
1064         if (dbus_error_is_set(&err)) {
1065                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1066                 dbus_error_free(&err);
1067         }
1068
1069         if (NULL != result_msg) {
1070                 dbus_message_get_args(result_msg, &err,
1071                         DBUS_TYPE_INT32, &result,
1072                         DBUS_TYPE_INVALID);
1073
1074                 if (dbus_error_is_set(&err)) {
1075                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1076                         dbus_error_free(&err);
1077                         result = STT_ERROR_OPERATION_FAILED;
1078                 }
1079                 dbus_message_unref(result_msg);
1080
1081                 if (0 == result) {
1082                         SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1083                 } else {
1084                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1085                 }
1086         } else {
1087                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1088                 stt_dbus_reconnect();
1089                 result = STT_ERROR_TIMED_OUT;
1090         }
1091
1092         return result;
1093 }
1094
1095 int stt_dbus_request_unset_start_sound(int uid)
1096 {
1097         DBusMessage* msg;
1098
1099         msg = dbus_message_new_method_call(
1100                    STT_SERVER_SERVICE_NAME,
1101                    STT_SERVER_SERVICE_OBJECT_PATH,
1102                    STT_SERVER_SERVICE_INTERFACE,
1103                    STT_METHOD_UNSET_START_SOUND);
1104
1105         if (NULL == msg) {
1106                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset start sound : Fail to make message");
1107                 return STT_ERROR_OPERATION_FAILED;
1108         } else {
1109                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset start sound : uid(%d)", uid);
1110         }
1111
1112         if (NULL == g_conn) {
1113                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
1114                 dbus_message_unref(msg);
1115                 return STT_ERROR_INVALID_STATE;
1116         }
1117
1118         dbus_message_append_args( msg,
1119                 DBUS_TYPE_INT32, &uid,
1120                 DBUS_TYPE_INVALID);
1121
1122         DBusError err;
1123         dbus_error_init(&err);
1124
1125         DBusMessage* result_msg;
1126         int result = STT_ERROR_OPERATION_FAILED;
1127
1128         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
1129         dbus_message_unref(msg);
1130         if (dbus_error_is_set(&err)) {
1131                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1132                 dbus_error_free(&err);
1133         }
1134
1135         if (NULL != result_msg) {
1136                 dbus_message_get_args(result_msg, &err,
1137                         DBUS_TYPE_INT32, &result,
1138                         DBUS_TYPE_INVALID);
1139
1140                 if (dbus_error_is_set(&err)) {
1141                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1142                         dbus_error_free(&err);
1143                         result = STT_ERROR_OPERATION_FAILED;
1144                 }
1145                 dbus_message_unref(result_msg);
1146
1147                 if (0 == result) {
1148                         SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1149                 } else {
1150                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1151                 }
1152         } else {
1153                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1154                 stt_dbus_reconnect();
1155                 result = STT_ERROR_TIMED_OUT;
1156         }
1157
1158         return result;
1159 }
1160
1161 int stt_dbus_request_set_stop_sound(int uid, const char* file)
1162 {
1163         if (NULL == file) {
1164                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1165                 return STT_ERROR_INVALID_PARAMETER;
1166         }
1167
1168         DBusMessage* msg;
1169
1170         msg = dbus_message_new_method_call(
1171                    STT_SERVER_SERVICE_NAME,
1172                    STT_SERVER_SERVICE_OBJECT_PATH,
1173                    STT_SERVER_SERVICE_INTERFACE,
1174                    STT_METHOD_SET_STOP_SOUND);
1175
1176         if (NULL == msg) {
1177                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set stop sound : Fail to make message");
1178                 return STT_ERROR_OPERATION_FAILED;
1179         } else {
1180                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set stop sound : uid(%d) file(%s)", uid, file);
1181         }
1182
1183         if (NULL == g_conn) {
1184                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
1185                 dbus_message_unref(msg);
1186                 return STT_ERROR_INVALID_STATE;
1187         }
1188
1189         dbus_message_append_args( msg,
1190                 DBUS_TYPE_INT32, &uid,
1191                 DBUS_TYPE_STRING, &file,
1192                 DBUS_TYPE_INVALID);
1193
1194         DBusError err;
1195         dbus_error_init(&err);
1196
1197         DBusMessage* result_msg;
1198         int result = STT_ERROR_OPERATION_FAILED;
1199
1200         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
1201         dbus_message_unref(msg);
1202         if (dbus_error_is_set(&err)) {
1203                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1204                 dbus_error_free(&err);
1205         }
1206
1207         if (NULL != result_msg) {
1208                 dbus_message_get_args(result_msg, &err,
1209                         DBUS_TYPE_INT32, &result,
1210                         DBUS_TYPE_INVALID);
1211
1212                 if (dbus_error_is_set(&err)) {
1213                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1214                         dbus_error_free(&err);
1215                         result = STT_ERROR_OPERATION_FAILED;
1216                 }
1217                 dbus_message_unref(result_msg);
1218
1219                 if (0 == result) {
1220                         SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1221                 } else {
1222                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set stop sound : 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_unset_stop_sound(int uid)
1234 {
1235         DBusMessage* msg;
1236
1237         msg = dbus_message_new_method_call(
1238                    STT_SERVER_SERVICE_NAME,
1239                    STT_SERVER_SERVICE_OBJECT_PATH,
1240                    STT_SERVER_SERVICE_INTERFACE,
1241                    STT_METHOD_UNSET_STOP_SOUND);
1242
1243         if (NULL == msg) {
1244                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset stop sound : Fail to make message");
1245                 return STT_ERROR_OPERATION_FAILED;
1246         } else {
1247                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset stop sound : uid(%d)", uid);
1248         }
1249
1250         if (NULL == g_conn) {
1251                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
1252                 dbus_message_unref(msg);
1253                 return STT_ERROR_INVALID_STATE;
1254         }
1255
1256         dbus_message_append_args( msg,
1257                 DBUS_TYPE_INT32, &uid,
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
1266         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
1267         dbus_message_unref(msg);
1268         if (dbus_error_is_set(&err)) {
1269                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1270                 dbus_error_free(&err);
1271         }
1272
1273         if (NULL != result_msg) {
1274                 dbus_message_get_args(result_msg, &err,
1275                         DBUS_TYPE_INT32, &result,
1276                         DBUS_TYPE_INVALID);
1277
1278                 if (dbus_error_is_set(&err)) {
1279                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1280                         dbus_error_free(&err);
1281                         result = STT_ERROR_OPERATION_FAILED;
1282                 }
1283                 dbus_message_unref(result_msg);
1284
1285                 if (0 == result) {
1286                         SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1287                 } else {
1288                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1289                 }
1290         } else {
1291                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1292                 stt_dbus_reconnect();
1293                 result = STT_ERROR_TIMED_OUT;
1294         }
1295
1296         return result;
1297 }
1298
1299 int stt_dbus_request_start(int uid, const char* lang, const char* type, int silence, const char* appid)
1300 {
1301         if (NULL == lang || NULL == type || NULL == appid) {
1302                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1303                 return STT_ERROR_INVALID_PARAMETER;
1304         }
1305
1306         DBusMessage* msg;
1307
1308         /* create a signal & check for errors */
1309         msg = dbus_message_new_method_call(
1310                 STT_SERVER_SERVICE_NAME,
1311                 STT_SERVER_SERVICE_OBJECT_PATH,
1312                 STT_SERVER_SERVICE_INTERFACE,
1313                 STT_METHOD_START);
1314
1315         if (NULL == msg) {
1316                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start : Fail to make message");
1317                 return STT_ERROR_OPERATION_FAILED;
1318         } else {
1319                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start : uid(%d), language(%s), type(%s)", uid, lang, type);
1320         }
1321
1322         if (NULL == g_conn) {
1323                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
1324                 dbus_message_unref(msg);
1325                 return STT_ERROR_INVALID_STATE;
1326         }
1327
1328         dbus_message_append_args( msg,
1329                 DBUS_TYPE_INT32, &uid,
1330                 DBUS_TYPE_STRING, &lang,
1331                 DBUS_TYPE_STRING, &type,
1332                 DBUS_TYPE_INT32, &silence,
1333                 DBUS_TYPE_STRING, &appid,
1334                 DBUS_TYPE_INVALID);
1335
1336         DBusError err;
1337         dbus_error_init(&err);
1338
1339         DBusMessage* result_msg;
1340         int result = STT_ERROR_OPERATION_FAILED;
1341
1342         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
1343         dbus_message_unref(msg);
1344         if (dbus_error_is_set(&err)) {
1345                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1346                 dbus_error_free(&err);
1347         }
1348
1349         if (NULL != result_msg) {
1350                 dbus_message_get_args(result_msg, &err,
1351                         DBUS_TYPE_INT32, &result,
1352                         DBUS_TYPE_INVALID);
1353
1354                 if (dbus_error_is_set(&err)) {
1355                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1356                         dbus_error_free(&err);
1357                         result = STT_ERROR_OPERATION_FAILED;
1358                 }
1359                 dbus_message_unref(result_msg);
1360
1361                 if (0 == result) {
1362                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt start : result = %d ", result);
1363                 } else {
1364                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt start : result = %d ", result);
1365                 }
1366         } else {
1367                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1368                 stt_dbus_reconnect();
1369                 result = STT_ERROR_TIMED_OUT;
1370         }
1371
1372         return result;
1373 }
1374
1375 int stt_dbus_request_stop(int uid)
1376 {
1377         DBusMessage* msg;
1378
1379         /* create a signal & check for errors */
1380         msg = dbus_message_new_method_call(
1381                 STT_SERVER_SERVICE_NAME,
1382                 STT_SERVER_SERVICE_OBJECT_PATH,
1383                 STT_SERVER_SERVICE_INTERFACE,
1384                 STT_METHOD_STOP);
1385
1386         if (NULL == msg) {
1387                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt stop : Fail to make message");
1388                 return STT_ERROR_OPERATION_FAILED;
1389         } else {
1390                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt stop : uid(%d)", uid);
1391         }
1392
1393         if (NULL == g_conn) {
1394                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
1395                 dbus_message_unref(msg);
1396                 return STT_ERROR_INVALID_STATE;
1397         }
1398
1399         dbus_message_append_args(msg,
1400                 DBUS_TYPE_INT32, &uid,
1401                 DBUS_TYPE_INVALID);
1402
1403         DBusError err;
1404         dbus_error_init(&err);
1405
1406         DBusMessage* result_msg;
1407         int result = STT_ERROR_OPERATION_FAILED;
1408
1409         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
1410         dbus_message_unref(msg);
1411         if (dbus_error_is_set(&err)) {
1412                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1413                 dbus_error_free(&err);
1414         }
1415
1416         if (NULL != result_msg) {
1417                 dbus_message_get_args(result_msg, &err,
1418                         DBUS_TYPE_INT32, &result,
1419                         DBUS_TYPE_INVALID);
1420
1421                 if (dbus_error_is_set(&err)) {
1422                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1423                         dbus_error_free(&err);
1424                         result = STT_ERROR_OPERATION_FAILED;
1425                 }
1426                 dbus_message_unref(result_msg);
1427
1428                 if (0 == result) {
1429                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt stop : result = %d ", result);
1430                 } else {
1431                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt stop : result = %d ", result);
1432                 }
1433         } else {
1434                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1435                 stt_dbus_reconnect();
1436                 result = STT_ERROR_TIMED_OUT;
1437         }
1438
1439         return result;
1440 }
1441
1442 int stt_dbus_request_cancel(int uid)
1443 {
1444         DBusMessage* msg;
1445
1446         /* create a signal & check for errors */
1447         msg = dbus_message_new_method_call(
1448                 STT_SERVER_SERVICE_NAME,
1449                 STT_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
1450                 STT_SERVER_SERVICE_INTERFACE,   /* interface name of the signal */
1451                 STT_METHOD_CANCEL);     /* name of the signal */
1452
1453         if (NULL == msg) {
1454                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel : Fail to make message");
1455                 return STT_ERROR_OPERATION_FAILED;
1456         } else {
1457                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel : uid(%d)", uid);
1458         }
1459
1460         if (NULL == g_conn) {
1461                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
1462                 dbus_message_unref(msg);
1463                 return STT_ERROR_INVALID_STATE;
1464         }
1465
1466         dbus_message_append_args(msg,
1467                 DBUS_TYPE_INT32, &uid,
1468                 DBUS_TYPE_INVALID);
1469
1470         DBusError err;
1471         dbus_error_init(&err);
1472
1473         DBusMessage* result_msg;
1474         int result = STT_ERROR_OPERATION_FAILED;
1475
1476         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
1477         dbus_message_unref(msg);
1478         if (dbus_error_is_set(&err)) {
1479                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1480                 dbus_error_free(&err);
1481         }
1482
1483         if (NULL != result_msg) {
1484                 dbus_message_get_args(result_msg, &err,
1485                         DBUS_TYPE_INT32, &result,
1486                         DBUS_TYPE_INVALID);
1487
1488                 if (dbus_error_is_set(&err)) {
1489                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1490                         dbus_error_free(&err);
1491                         result = STT_ERROR_OPERATION_FAILED;
1492                 }
1493                 dbus_message_unref(result_msg);
1494
1495                 if (0 == result) {
1496                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt cancel : result = %d ", result);
1497                 } else {
1498                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt cancel : result = %d ", result);
1499                 }
1500         } else {
1501                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1502                 stt_dbus_reconnect();
1503                 result = STT_ERROR_TIMED_OUT;
1504         }
1505
1506         return result;
1507 }