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