client/stt_dbus.c

   1 /*
   2 *  Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
   3 *  Licensed under the Apache License, Version 2.0 (the "License");
   4 *  you may not use this file except in compliance with the License.
   5 *  You may obtain a copy of the License at
   6 *  http://www.apache.org/licenses/LICENSE-2.0
   7 *  Unless required by applicable law or agreed to in writing, software
   8 *  distributed under the License is distributed on an "AS IS" BASIS,
   9 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  10 *  See the License for the specific language governing permissions and
  11 *  limitations under the License.
  12 */
  13
  14
  15 #include "stt_main.h"
  16 #include "stt_dbus.h"
  17 #include "stt_defs.h"
  18
  19 #include "stt_client.h"
  20
  21 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         if (NULL == g_conn_sender) {
 297                 g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 298                 if (dbus_error_is_set(&err)) {
 299                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Dbus Connection Error (%s)", err.message);
 300                         dbus_error_free(&err);
 301                 }
 302         }
 303
 304         if (NULL == g_conn_sender) {
 305                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to get dbus connection");
 306                 return STT_ERROR_OPERATION_FAILED;
 307         }
 308
 309         dbus_connection_set_exit_on_disconnect(g_conn_sender, false);
 310
 311         /* connect to the DBUS system bus, and check for errors */
 312         if (NULL == g_conn_listener) {
 313                 g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 314                 if (dbus_error_is_set(&err)) {
 315                         SLOG(LOG_ERROR, TAG_STTC, "Dbus Connection Error (%s)", err.message);
 316                         dbus_error_free(&err);
 317                 }
 318         }
 319
 320         if (NULL == g_conn_listener) {
 321                 SLOG(LOG_ERROR, TAG_STTC, "Fail to get dbus connection");
 322                 return STT_ERROR_OPERATION_FAILED;
 323         }
 324
 325         int pid = getpid();
 326
 327         char service_name[64];
 328         memset(service_name, '\0', 64);
 329         snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
 330
 331         SLOG(LOG_DEBUG, TAG_STTC, "service name is %s", service_name);
 332
 333         /* register our name on the bus, and check for errors */
 334         dbus_bus_request_name(g_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
 335
 336         if (dbus_error_is_set(&err)) {
 337                 SLOG(LOG_ERROR, TAG_STTC, "Name Error (%s)", err.message);
 338                 dbus_error_free(&err);
 339         }
 340
 341         char rule[128] = {0, };
 342         snprintf(rule, 128, "type='signal',interface='%s%d'", STT_CLIENT_SERVICE_INTERFACE, pid);
 343
 344         /* add a rule for which messages we want to see */
 345         dbus_bus_add_match(g_conn_listener, rule, &err);
 346         dbus_connection_flush(g_conn_listener);
 347
 348         if (dbus_error_is_set(&err)) {
 349                 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)", err.message);
 350                 dbus_error_free(&err);
 351                 return STT_ERROR_OPERATION_FAILED;
 352         }
 353
 354         int fd = 0;
 355         if (true != dbus_connection_get_unix_fd(g_conn_listener, &fd)) {
 356                 SLOG(LOG_ERROR, TAG_STTC, "Fail to get fd from dbus");
 357                 return STT_ERROR_OPERATION_FAILED;
 358         } else {
 359                 SLOG(LOG_DEBUG, TAG_STTC, "Get fd from dbus : %d", fd);
 360         }
 361
 362         g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
 363         if (NULL == g_fd_handler) {
 364                 SLOG(LOG_ERROR, TAG_STTC, "fail to get fd handler from ecore");
 365                 return STT_ERROR_OPERATION_FAILED;
 366         }
 367
 368         return 0;
 369 }
 370
 371 int stt_dbus_close_connection()
 372 {
 373         DBusError err;
 374         dbus_error_init(&err);
 375
 376         if (NULL != g_fd_handler) {
 377                 ecore_main_fd_handler_del(g_fd_handler);
 378                 g_fd_handler = NULL;
 379         }
 380
 381         int pid = getpid();
 382
 383         char service_name[64];
 384         memset(service_name, '\0', 64);
 385         snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
 386
 387         dbus_bus_release_name(g_conn_listener, service_name, &err);
 388         if (dbus_error_is_set(&err)) {
 389                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Release name Error (%s)", err.message);
 390                 dbus_error_free(&err);
 391         }
 392
 393         dbus_connection_close(g_conn_sender);
 394         dbus_connection_close(g_conn_listener);
 395
 396         dbus_connection_unref(g_conn_sender);
 397         dbus_connection_unref(g_conn_listener);
 398
 399         g_conn_sender = NULL;
 400         g_conn_listener = NULL;
 401
 402         return 0;
 403 }
 404
 405 int stt_dbus_reconnect()
 406 {
 407         bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
 408         bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
 409         SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Sender(%s) Listener(%s)",
 410                 sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
 411
 412         if (false == sender_connected || false == listener_connected) {
 413                 stt_dbus_close_connection();
 414
 415                 if (0 != stt_dbus_open_connection()) {
 416                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to reconnect");
 417                         return -1;
 418                 }
 419
 420                 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Reconnect");
 421         }
 422
 423         return 0;
 424 }
 425
 426 int stt_dbus_request_hello()
 427 {
 428         DBusMessage* msg;
 429
 430         msg = dbus_message_new_method_call(
 431                 STT_SERVER_SERVICE_NAME,
 432                 STT_SERVER_SERVICE_OBJECT_PATH,
 433                 STT_SERVER_SERVICE_INTERFACE,
 434                 STT_METHOD_HELLO);
 435
 436         if (NULL == msg) {
 437                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request stt hello : Fail to make message");
 438                 return STT_ERROR_OPERATION_FAILED;
 439         }
 440
 441         DBusError err;
 442         dbus_error_init(&err);
 443
 444         DBusMessage* result_msg = NULL;
 445         int result = 0;
 446
 447         if (g_conn_sender) {
 448                 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
 449                 dbus_message_unref(msg);
 450                 if (dbus_error_is_set(&err)) {
 451                         dbus_error_free(&err);
 452                 }
 453
 454                 if (NULL != result_msg) {
 455                         dbus_message_unref(result_msg);
 456
 457                         if (dbus_error_is_set(&err)) {
 458                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 459                                 dbus_error_free(&err);
 460                         }
 461
 462                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt hello");
 463                 } else {
 464                         if (dbus_error_is_set(&err)) {
 465                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 466                                 dbus_error_free(&err);
 467                         }
 468
 469                         SLOG(LOG_ERROR, TAG_STTC, "STT_ERROR_TIME_OUT");
 470                         result = STT_ERROR_TIMED_OUT;
 471                 }
 472         } else {
 473                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
 474                 result = STT_ERROR_OPERATION_FAILED;
 475         }
 476
 477         return result;
 478 }
 479
 480
 481 int stt_dbus_request_initialize(int uid, bool* silence_supported, bool* credential_needed)
 482 {
 483         DBusMessage* msg;
 484
 485         msg = dbus_message_new_method_call(
 486                 STT_SERVER_SERVICE_NAME,
 487                 STT_SERVER_SERVICE_OBJECT_PATH,
 488                 STT_SERVER_SERVICE_INTERFACE,
 489                 STT_METHOD_INITIALIZE);
 490
 491         if (NULL == msg) {
 492                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt initialize : Fail to make message");
 493                 return STT_ERROR_OPERATION_FAILED;
 494         } else {
 495                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt initialize : uid(%d)", uid);
 496         }
 497
 498         int pid = getpid();
 499         dbus_message_append_args(msg,
 500                 DBUS_TYPE_INT32, &pid,
 501                 DBUS_TYPE_INT32, &uid,
 502                 DBUS_TYPE_INVALID);
 503
 504         DBusError err;
 505         dbus_error_init(&err);
 506
 507         DBusMessage* result_msg;
 508         int result = STT_ERROR_OPERATION_FAILED;
 509
 510         if (g_conn_sender) {
 511                 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 512                 dbus_message_unref(msg);
 513                 if (dbus_error_is_set(&err)) {
 514                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 515                         dbus_error_free(&err);
 516                 }
 517
 518                 if (NULL != result_msg) {
 519                         dbus_message_get_args(result_msg, &err,
 520                                 DBUS_TYPE_INT32, &result,
 521                                 DBUS_TYPE_INT32, silence_supported,
 522                                 DBUS_TYPE_INT32, credential_needed,
 523                                 DBUS_TYPE_INVALID);
 524
 525                         if (dbus_error_is_set(&err)) {
 526                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 527                                 dbus_error_free(&err);
 528                                 result = STT_ERROR_OPERATION_FAILED;
 529                         }
 530
 531                         if (0 == result) {
 532                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt initialize : result = %d, silence(%d), credential(%d)",
 533                                         result, *silence_supported, *credential_needed);
 534                         } else {
 535                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt initialize : result = %d", result);
 536                         }
 537
 538                         dbus_message_unref(result_msg);
 539                 } else {
 540                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 541                         stt_dbus_reconnect();
 542                         result = STT_ERROR_TIMED_OUT;
 543                 }
 544         } else {
 545                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
 546                 result = STT_ERROR_OPERATION_FAILED;
 547         }
 548
 549         return result;
 550 }
 551
 552 int stt_dbus_request_finalize(int uid)
 553 {
 554         DBusMessage* msg;
 555
 556         msg = dbus_message_new_method_call(
 557                 STT_SERVER_SERVICE_NAME,
 558                 STT_SERVER_SERVICE_OBJECT_PATH,
 559                 STT_SERVER_SERVICE_INTERFACE,
 560                 STT_METHOD_FINALIZE);
 561
 562         if (NULL == msg) {
 563                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt finalize : Fail to make message");
 564                 return STT_ERROR_OPERATION_FAILED;
 565         } else {
 566                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt finalize : uid(%d)", uid);
 567         }
 568
 569         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 570
 571         DBusError err;
 572         dbus_error_init(&err);
 573
 574         DBusMessage* result_msg;
 575         int result = STT_ERROR_OPERATION_FAILED;
 576
 577         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
 578         dbus_message_unref(msg);
 579         if (dbus_error_is_set(&err)) {
 580                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 581                 dbus_error_free(&err);
 582         }
 583
 584         if (NULL != result_msg) {
 585                 dbus_message_get_args(result_msg, &err,
 586                                 DBUS_TYPE_INT32, &result,
 587                                 DBUS_TYPE_INVALID);
 588
 589                 if (dbus_error_is_set(&err)) {
 590                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 591                         dbus_error_free(&err);
 592                         result = STT_ERROR_OPERATION_FAILED;
 593                 }
 594
 595                 dbus_message_unref(result_msg);
 596
 597                 if (0 == result) {
 598                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt finalize : result = %d", result);
 599                 } else {
 600                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt finalize : result = %d", result);
 601                 }
 602         } else {
 603                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 604                 stt_dbus_reconnect();
 605                 result = STT_ERROR_TIMED_OUT;
 606         }
 607
 608         return result;
 609 }
 610
 611 int stt_dbus_request_set_current_engine(int uid, const char* engine_id, bool* silence_supported, bool* credential_needed)
 612 {
 613         DBusMessage* msg;
 614
 615         msg = dbus_message_new_method_call(
 616                 STT_SERVER_SERVICE_NAME,
 617                 STT_SERVER_SERVICE_OBJECT_PATH,
 618                 STT_SERVER_SERVICE_INTERFACE,
 619                 STT_METHOD_SET_CURRENT_ENGINE);
 620
 621         if (NULL == msg) {
 622                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set engine : Fail to make message");
 623                 return STT_ERROR_OPERATION_FAILED;
 624         } else {
 625                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set engine : uid(%d), engine_id(%s)", uid, (NULL == engine_id) ? "NULL" : engine_id);
 626         }
 627
 628         dbus_message_append_args(msg,
 629                 DBUS_TYPE_INT32, &uid,
 630                 DBUS_TYPE_STRING, &engine_id,
 631                 DBUS_TYPE_INVALID);
 632
 633         DBusError err;
 634         dbus_error_init(&err);
 635
 636         DBusMessage* result_msg;
 637         int result = STT_ERROR_OPERATION_FAILED;
 638
 639         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 640         dbus_message_unref(msg);
 641         if (dbus_error_is_set(&err)) {
 642                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 643                 dbus_error_free(&err);
 644         }
 645
 646         if (NULL != result_msg) {
 647                 dbus_message_get_args(result_msg, &err,
 648                         DBUS_TYPE_INT32, &result,
 649                         DBUS_TYPE_INT32, silence_supported,
 650                         DBUS_TYPE_INT32, credential_needed,
 651                         DBUS_TYPE_INVALID);
 652
 653                 if (dbus_error_is_set(&err)) {
 654                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 655                         dbus_error_free(&err);
 656                         result = STT_ERROR_OPERATION_FAILED;
 657                 }
 658
 659                 dbus_message_unref(result_msg);
 660
 661                 if (0 == result) {
 662                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set engine : result = %d , silence(%d), credential(%d)",
 663                                 result, *silence_supported, *credential_needed);
 664                 } else {
 665                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set engine : result = %d", result);
 666                 }
 667         } else {
 668                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 669                 stt_dbus_reconnect();
 670                 result = STT_ERROR_TIMED_OUT;
 671         }
 672
 673         return result;
 674 }
 675
 676 int stt_dbus_request_check_app_agreed(int uid, const char* appid, bool* value)
 677 {
 678         if (NULL == appid || NULL == value) {
 679                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 680                 return STT_ERROR_INVALID_PARAMETER;
 681         }
 682
 683         DBusMessage* msg;
 684
 685         msg = dbus_message_new_method_call(
 686                 STT_SERVER_SERVICE_NAME,
 687                 STT_SERVER_SERVICE_OBJECT_PATH,
 688                 STT_SERVER_SERVICE_INTERFACE,
 689                 STT_METHOD_CHECK_APP_AGREED);
 690
 691         if (NULL == msg) {
 692                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt check app agreed : Fail to make message");
 693                 return STT_ERROR_OPERATION_FAILED;
 694         } else {
 695                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt check app agreed : uid(%d) appid(%s)", uid, appid);
 696         }
 697
 698         dbus_message_append_args(msg,
 699                 DBUS_TYPE_INT32, &uid,
 700                 DBUS_TYPE_STRING, &appid,
 701                 DBUS_TYPE_INVALID);
 702
 703         DBusError err;
 704         dbus_error_init(&err);
 705
 706         DBusMessage* result_msg;
 707         int result = STT_ERROR_OPERATION_FAILED;
 708         int available = -1;
 709
 710         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 711         dbus_message_unref(msg);
 712         if (dbus_error_is_set(&err)) {
 713                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 714                 dbus_error_free(&err);
 715         }
 716
 717         if (NULL != result_msg) {
 718                 dbus_message_get_args(result_msg, &err,
 719                         DBUS_TYPE_INT32, &result,
 720                         DBUS_TYPE_INT32, &available,
 721                         DBUS_TYPE_INVALID);
 722
 723                 if (dbus_error_is_set(&err)) {
 724                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 725                         dbus_error_free(&err);
 726                         result = STT_ERROR_OPERATION_FAILED;
 727                 }
 728                 dbus_message_unref(result_msg);
 729
 730                 if (0 == result) {
 731                         *value = (bool)available;
 732                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt check app agreed : result = %d, available = %d", result, *value);
 733                 } else {
 734                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt check app agreed : result = %d", result);
 735                 }
 736         } else {
 737                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 738                 stt_dbus_reconnect();
 739                 result = STT_ERROR_TIMED_OUT;
 740         }
 741
 742         return result;
 743 }
 744
 745 int stt_dbus_request_get_support_langs(int uid, stt_h stt, stt_supported_language_cb callback, void* user_data)
 746 {
 747         if (NULL == stt || NULL == callback) {
 748                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 749                 return STT_ERROR_INVALID_PARAMETER;
 750         }
 751
 752         DBusMessage* msg;
 753
 754         msg = dbus_message_new_method_call(
 755                 STT_SERVER_SERVICE_NAME,
 756                 STT_SERVER_SERVICE_OBJECT_PATH,
 757                 STT_SERVER_SERVICE_INTERFACE,
 758                 STT_METHOD_GET_SUPPORT_LANGS);
 759
 760         if (NULL == msg) {
 761                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get supported languages : Fail to make message");
 762                 return STT_ERROR_OPERATION_FAILED;
 763         } else {
 764                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get supported languages : uid(%d)", uid);
 765         }
 766
 767         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 768
 769         DBusError err;
 770         dbus_error_init(&err);
 771
 772         DBusMessage* result_msg;
 773         DBusMessageIter args;
 774         int result = STT_ERROR_OPERATION_FAILED;
 775
 776         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 777         dbus_message_unref(msg);
 778         if (dbus_error_is_set(&err)) {
 779                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 780                 dbus_error_free(&err);
 781         }
 782
 783         if (NULL != result_msg) {
 784                 if (dbus_message_iter_init(result_msg, &args)) {
 785                         /* Get result */
 786                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 787                                 dbus_message_iter_get_basic(&args, &result);
 788                                 dbus_message_iter_next(&args);
 789                         }
 790
 791                         if (0 == result) {
 792                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get support languages : result = %d", result);
 793
 794                                 /* Get voice size */
 795                                 int size = 0;
 796                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 797                                         dbus_message_iter_get_basic(&args, &size);
 798                                         dbus_message_iter_next(&args);
 799                                 }
 800
 801                                 if (0 >= size) {
 802                                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt size of language error : size = %d", size);
 803                                 } else {
 804                                         int i = 0;
 805                                         char* temp_lang;
 806
 807                                         for (i = 0; i < size; i++) {
 808                                                 dbus_message_iter_get_basic(&args, &(temp_lang));
 809                                                 dbus_message_iter_next(&args);
 810
 811                                                 if (true != callback(stt, temp_lang, user_data)) {
 812                                                         break;
 813                                                 }
 814                                         }
 815                                 }
 816                         } else {
 817                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result = %d", result);
 818                         }
 819                 }
 820                 dbus_message_unref(result_msg);
 821         } else {
 822                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result message is NULL");
 823                 stt_dbus_reconnect();
 824                 result = STT_ERROR_TIMED_OUT;
 825         }
 826
 827         return result;
 828 }
 829
 830 int stt_dbus_request_get_default_lang(int uid, char** language)
 831 {
 832         if (NULL == language) {
 833                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 834                 return STT_ERROR_INVALID_PARAMETER;
 835         }
 836
 837         DBusMessage* msg;
 838
 839         msg = dbus_message_new_method_call(
 840                 STT_SERVER_SERVICE_NAME,
 841                 STT_SERVER_SERVICE_OBJECT_PATH,
 842                 STT_SERVER_SERVICE_INTERFACE,
 843                 STT_METHOD_GET_CURRENT_LANG);
 844
 845         if (NULL == msg) {
 846                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get default language : Fail to make message");
 847                 return STT_ERROR_OPERATION_FAILED;
 848         } else {
 849                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get default language  : uid(%d)", uid);
 850         }
 851
 852         dbus_message_append_args(msg,
 853                 DBUS_TYPE_INT32, &uid,
 854                 DBUS_TYPE_INVALID);
 855
 856         DBusError err;
 857         dbus_error_init(&err);
 858
 859         DBusMessage* result_msg;
 860         int result = STT_ERROR_OPERATION_FAILED;
 861         char* temp_lang = NULL;
 862
 863         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 864         dbus_message_unref(msg);
 865         if (dbus_error_is_set(&err)) {
 866                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 867                 dbus_error_free(&err);
 868         }
 869
 870         if (NULL != result_msg) {
 871                 dbus_message_get_args(result_msg, &err,
 872                         DBUS_TYPE_INT32, &result,
 873                         DBUS_TYPE_STRING, &temp_lang,
 874                         DBUS_TYPE_INVALID);
 875
 876                 if (dbus_error_is_set(&err)) {
 877                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 878                         dbus_error_free(&err);
 879                         result = STT_ERROR_OPERATION_FAILED;
 880                 }
 881                 dbus_message_unref(result_msg);
 882
 883                 if (0 == result) {
 884                         *language = strdup(temp_lang);
 885                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get default language : result = %d, language = %s", result, *language);
 886                 } else {
 887                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get default language : result = %d", result);
 888                 }
 889         } else {
 890                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 891                 stt_dbus_reconnect();
 892                 result = STT_ERROR_TIMED_OUT;
 893         }
 894
 895         return result;
 896 }
 897
 898 int stt_dbus_request_set_private_data(int uid, const char* key, const char* data)
 899 {
 900         if (NULL == key || NULL == data) {
 901                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 902                 return STT_ERROR_INVALID_PARAMETER;
 903         }
 904
 905         DBusMessage* msg;
 906
 907         msg = dbus_message_new_method_call(
 908                 STT_SERVER_SERVICE_NAME,
 909                 STT_SERVER_SERVICE_OBJECT_PATH,
 910                 STT_SERVER_SERVICE_INTERFACE,
 911                 STT_METHOD_SET_PRIVATE_DATA);
 912
 913         if (NULL == msg) {
 914                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set private data : Fail to make message");
 915                 return STT_ERROR_OPERATION_FAILED;
 916         } else {
 917                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set private data : uid(%d)", uid);
 918         }
 919
 920         if (true != dbus_message_append_args(msg,
 921                         DBUS_TYPE_INT32, &uid,
 922                         DBUS_TYPE_STRING, &key,
 923                         DBUS_TYPE_STRING, &data,
 924                         DBUS_TYPE_INVALID)) {
 925                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to append args");
 926                 return STT_ERROR_OPERATION_FAILED;
 927         }
 928
 929         DBusError err;
 930         dbus_error_init(&err);
 931
 932         DBusMessage* result_msg;
 933         int result = STT_ERROR_OPERATION_FAILED;
 934
 935         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 936         dbus_message_unref(msg);
 937         if (dbus_error_is_set(&err)) {
 938                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 939                 dbus_error_free(&err);
 940         }
 941
 942         if (NULL != result_msg) {
 943                 dbus_message_get_args(result_msg, &err,
 944                         DBUS_TYPE_INT32, &result,
 945                         DBUS_TYPE_INVALID);
 946
 947                 if (dbus_error_is_set(&err)) {
 948                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 949                         dbus_error_free(&err);
 950                         result = STT_ERROR_OPERATION_FAILED;
 951                 }
 952                 dbus_message_unref(result_msg);
 953
 954                 if (0 == result) {
 955                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set private data : result = %d", result);
 956                 } else {
 957                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set private data : result = %d", result);
 958                 }
 959         } else {
 960                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 961                 stt_dbus_reconnect();
 962                 result = STT_ERROR_TIMED_OUT;
 963         }
 964
 965         return result;
 966 }
 967
 968 int stt_dbus_request_get_private_data(int uid, const char* key, char** data)
 969 {
 970         if (NULL == key || NULL == data) {
 971                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 972                 return STT_ERROR_INVALID_PARAMETER;
 973         }
 974
 975         DBusMessage* msg;
 976
 977         msg = dbus_message_new_method_call(
 978                 STT_SERVER_SERVICE_NAME,
 979                 STT_SERVER_SERVICE_OBJECT_PATH,
 980                 STT_SERVER_SERVICE_INTERFACE,
 981                 STT_METHOD_GET_PRIVATE_DATA);
 982
 983         if (NULL == msg) {
 984                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get private data : Fail to make message");
 985                 return STT_ERROR_OPERATION_FAILED;
 986         } else {
 987                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get private data : uid(%d)", uid);
 988         }
 989
 990         if (true != dbus_message_append_args(msg,
 991                         DBUS_TYPE_INT32, &uid,
 992                         DBUS_TYPE_STRING, &key,
 993                         DBUS_TYPE_INVALID)) {
 994                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to append args");
 995                 return STT_ERROR_OPERATION_FAILED;
 996         }
 997
 998         DBusError err;
 999         dbus_error_init(&err);
1000
1001         DBusMessage* result_msg;
1002         int result = STT_ERROR_OPERATION_FAILED;
1003
1004         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1005         dbus_message_unref(msg);
1006         if (dbus_error_is_set(&err)) {
1007                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1008                 dbus_error_free(&err);
1009         }
1010
1011         char* temp = NULL;
1012         if (NULL != result_msg) {
1013                 dbus_message_get_args(result_msg, &err,
1014                         DBUS_TYPE_INT32, &result,
1015                         DBUS_TYPE_STRING, &temp,
1016                         DBUS_TYPE_INVALID);
1017
1018                 if (dbus_error_is_set(&err)) {
1019                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1020                         dbus_error_free(&err);
1021                         result = STT_ERROR_OPERATION_FAILED;
1022                 }
1023                 dbus_message_unref(result_msg);
1024
1025                 if (0 == result) {
1026                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get private data : result = %d", result);
1027                         if (NULL != temp) {
1028                                 *data = strdup(temp);
1029                         }
1030                 } else {
1031                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get private data : result = %d", result);
1032                 }
1033         } else {
1034                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1035                 stt_dbus_reconnect();
1036                 result = STT_ERROR_TIMED_OUT;
1037         }
1038
1039         return result;
1040 }
1041
1042
1043
1044 int stt_dbus_request_is_recognition_type_supported(int uid, const char* type, bool* support)
1045 {
1046         if (NULL == support || NULL == type) {
1047                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1048                 return STT_ERROR_INVALID_PARAMETER;
1049         }
1050
1051         DBusMessage* msg;
1052
1053         msg = dbus_message_new_method_call(
1054                    STT_SERVER_SERVICE_NAME,
1055                    STT_SERVER_SERVICE_OBJECT_PATH,
1056                    STT_SERVER_SERVICE_INTERFACE,
1057                    STT_METHOD_IS_TYPE_SUPPORTED);
1058
1059         if (NULL == msg) {
1060                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt is partial result supported : Fail to make message");
1061                 return STT_ERROR_OPERATION_FAILED;
1062         } else {
1063                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt is recognition type supported : uid(%d) type(%s)", uid, type);
1064         }
1065
1066         dbus_message_append_args(msg,
1067                 DBUS_TYPE_INT32, &uid,
1068                 DBUS_TYPE_STRING, &type,
1069                 DBUS_TYPE_INVALID);
1070
1071         DBusError err;
1072         dbus_error_init(&err);
1073
1074         DBusMessage* result_msg;
1075         int result = STT_ERROR_OPERATION_FAILED;
1076         int result_support = -1;
1077
1078         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1079         dbus_message_unref(msg);
1080         if (dbus_error_is_set(&err)) {
1081                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1082                 dbus_error_free(&err);
1083         }
1084
1085         if (NULL != result_msg) {
1086                 dbus_message_get_args(result_msg, &err,
1087                         DBUS_TYPE_INT32, &result,
1088                         DBUS_TYPE_INT32, &result_support,
1089                         DBUS_TYPE_INVALID);
1090
1091                 if (dbus_error_is_set(&err)) {
1092                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1093                         dbus_error_free(&err);
1094                         result = STT_ERROR_OPERATION_FAILED;
1095                 }
1096                 dbus_message_unref(result_msg);
1097
1098                 if (0 == result) {
1099                         *support = (bool)result_support;
1100                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt is recognition type supported : result = %d, support = %s", result, *support ? "true" : "false");
1101                 } else {
1102                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt is recognition type supported : result = %d", result);
1103                 }
1104         } else {
1105                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1106                 stt_dbus_reconnect();
1107                 result = STT_ERROR_TIMED_OUT;
1108         }
1109
1110         return result;
1111 }
1112
1113 int stt_dbus_request_set_start_sound(int uid, const char* file)
1114 {
1115         if (NULL == file) {
1116                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1117                 return STT_ERROR_INVALID_PARAMETER;
1118         }
1119
1120         DBusMessage* msg;
1121
1122         msg = dbus_message_new_method_call(
1123                    STT_SERVER_SERVICE_NAME,
1124                    STT_SERVER_SERVICE_OBJECT_PATH,
1125                    STT_SERVER_SERVICE_INTERFACE,
1126                    STT_METHOD_SET_START_SOUND);
1127
1128         if (NULL == msg) {
1129                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set start sound : Fail to make message");
1130                 return STT_ERROR_OPERATION_FAILED;
1131         } else {
1132                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set start sound : uid(%d) file(%s)", uid, file);
1133         }
1134
1135         dbus_message_append_args(msg,
1136                 DBUS_TYPE_INT32, &uid,
1137                 DBUS_TYPE_STRING, &file,
1138                 DBUS_TYPE_INVALID);
1139
1140         DBusError err;
1141         dbus_error_init(&err);
1142
1143         DBusMessage* result_msg;
1144         int result = STT_ERROR_OPERATION_FAILED;
1145
1146         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1147         dbus_message_unref(msg);
1148         if (dbus_error_is_set(&err)) {
1149                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1150                 dbus_error_free(&err);
1151         }
1152
1153         if (NULL != result_msg) {
1154                 dbus_message_get_args(result_msg, &err,
1155                         DBUS_TYPE_INT32, &result,
1156                         DBUS_TYPE_INVALID);
1157
1158                 if (dbus_error_is_set(&err)) {
1159                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1160                         dbus_error_free(&err);
1161                         result = STT_ERROR_OPERATION_FAILED;
1162                 }
1163                 dbus_message_unref(result_msg);
1164
1165                 if (0 == result) {
1166                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1167                 } else {
1168                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1169                 }
1170         } else {
1171                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1172                 stt_dbus_reconnect();
1173                 result = STT_ERROR_TIMED_OUT;
1174         }
1175
1176         return result;
1177 }
1178
1179 int stt_dbus_request_unset_start_sound(int uid)
1180 {
1181         DBusMessage* msg;
1182
1183         msg = dbus_message_new_method_call(
1184                    STT_SERVER_SERVICE_NAME,
1185                    STT_SERVER_SERVICE_OBJECT_PATH,
1186                    STT_SERVER_SERVICE_INTERFACE,
1187                    STT_METHOD_UNSET_START_SOUND);
1188
1189         if (NULL == msg) {
1190                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset start sound : Fail to make message");
1191                 return STT_ERROR_OPERATION_FAILED;
1192         } else {
1193                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset start sound : uid(%d)", uid);
1194         }
1195
1196         dbus_message_append_args(msg,
1197                 DBUS_TYPE_INT32, &uid,
1198                 DBUS_TYPE_INVALID);
1199
1200         DBusError err;
1201         dbus_error_init(&err);
1202
1203         DBusMessage* result_msg;
1204         int result = STT_ERROR_OPERATION_FAILED;
1205
1206         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1207         dbus_message_unref(msg);
1208         if (dbus_error_is_set(&err)) {
1209                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1210                 dbus_error_free(&err);
1211         }
1212
1213         if (NULL != result_msg) {
1214                 dbus_message_get_args(result_msg, &err,
1215                         DBUS_TYPE_INT32, &result,
1216                         DBUS_TYPE_INVALID);
1217
1218                 if (dbus_error_is_set(&err)) {
1219                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1220                         dbus_error_free(&err);
1221                         result = STT_ERROR_OPERATION_FAILED;
1222                 }
1223                 dbus_message_unref(result_msg);
1224
1225                 if (0 == result) {
1226                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1227                 } else {
1228                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1229                 }
1230         } else {
1231                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1232                 stt_dbus_reconnect();
1233                 result = STT_ERROR_TIMED_OUT;
1234         }
1235
1236         return result;
1237 }
1238
1239 int stt_dbus_request_set_stop_sound(int uid, const char* file)
1240 {
1241         if (NULL == file) {
1242                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1243                 return STT_ERROR_INVALID_PARAMETER;
1244         }
1245
1246         DBusMessage* msg;
1247
1248         msg = dbus_message_new_method_call(
1249                    STT_SERVER_SERVICE_NAME,
1250                    STT_SERVER_SERVICE_OBJECT_PATH,
1251                    STT_SERVER_SERVICE_INTERFACE,
1252                    STT_METHOD_SET_STOP_SOUND);
1253
1254         if (NULL == msg) {
1255                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set stop sound : Fail to make message");
1256                 return STT_ERROR_OPERATION_FAILED;
1257         } else {
1258                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set stop sound : uid(%d) file(%s)", uid, file);
1259         }
1260
1261         dbus_message_append_args(msg,
1262                 DBUS_TYPE_INT32, &uid,
1263                 DBUS_TYPE_STRING, &file,
1264                 DBUS_TYPE_INVALID);
1265
1266         DBusError err;
1267         dbus_error_init(&err);
1268
1269         DBusMessage* result_msg;
1270         int result = STT_ERROR_OPERATION_FAILED;
1271
1272         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1273         dbus_message_unref(msg);
1274         if (dbus_error_is_set(&err)) {
1275                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1276                 dbus_error_free(&err);
1277         }
1278
1279         if (NULL != result_msg) {
1280                 dbus_message_get_args(result_msg, &err,
1281                         DBUS_TYPE_INT32, &result,
1282                         DBUS_TYPE_INVALID);
1283
1284                 if (dbus_error_is_set(&err)) {
1285                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1286                         dbus_error_free(&err);
1287                         result = STT_ERROR_OPERATION_FAILED;
1288                 }
1289                 dbus_message_unref(result_msg);
1290
1291                 if (0 == result) {
1292                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1293                 } else {
1294                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1295                 }
1296         } else {
1297                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1298                 stt_dbus_reconnect();
1299                 result = STT_ERROR_TIMED_OUT;
1300         }
1301
1302         return result;
1303 }
1304
1305 int stt_dbus_request_unset_stop_sound(int uid)
1306 {
1307         DBusMessage* msg;
1308
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_UNSET_STOP_SOUND);
1314
1315         if (NULL == msg) {
1316                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset stop sound : Fail to make message");
1317                 return STT_ERROR_OPERATION_FAILED;
1318         } else {
1319                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset stop sound : uid(%d)", uid);
1320         }
1321
1322         dbus_message_append_args(msg,
1323                 DBUS_TYPE_INT32, &uid,
1324                 DBUS_TYPE_INVALID);
1325
1326         DBusError err;
1327         dbus_error_init(&err);
1328
1329         DBusMessage* result_msg;
1330         int result = STT_ERROR_OPERATION_FAILED;
1331
1332         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1333         dbus_message_unref(msg);
1334         if (dbus_error_is_set(&err)) {
1335                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1336                 dbus_error_free(&err);
1337         }
1338
1339         if (NULL != result_msg) {
1340                 dbus_message_get_args(result_msg, &err,
1341                         DBUS_TYPE_INT32, &result,
1342                         DBUS_TYPE_INVALID);
1343
1344                 if (dbus_error_is_set(&err)) {
1345                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1346                         dbus_error_free(&err);
1347                         result = STT_ERROR_OPERATION_FAILED;
1348                 }
1349                 dbus_message_unref(result_msg);
1350
1351                 if (0 == result) {
1352                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1353                 } else {
1354                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1355                 }
1356         } else {
1357                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1358                 stt_dbus_reconnect();
1359                 result = STT_ERROR_TIMED_OUT;
1360         }
1361
1362         return result;
1363 }
1364
1365 int stt_dbus_request_start(int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential)
1366 {
1367         if (NULL == lang || NULL == type || NULL == appid) {
1368                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1369                 return STT_ERROR_INVALID_PARAMETER;
1370         }
1371
1372         DBusMessage* msg;
1373
1374         /* create a signal & check for errors */
1375         msg = dbus_message_new_method_call(
1376                 STT_SERVER_SERVICE_NAME,
1377                 STT_SERVER_SERVICE_OBJECT_PATH,
1378                 STT_SERVER_SERVICE_INTERFACE,
1379                 STT_METHOD_START);
1380
1381         if (NULL == msg) {
1382                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start : Fail to make message");
1383                 return STT_ERROR_OPERATION_FAILED;
1384         } else {
1385                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start : uid(%d), language(%s), type(%s)", uid, lang, type);
1386         }
1387
1388         char *temp = NULL;
1389         if (NULL == credential) {
1390                 temp = strdup("NULL");
1391         } else {
1392                 temp = strdup(credential);
1393         }
1394
1395         dbus_message_append_args(msg,
1396                 DBUS_TYPE_INT32, &uid,
1397                 DBUS_TYPE_STRING, &lang,
1398                 DBUS_TYPE_STRING, &type,
1399                 DBUS_TYPE_INT32, &silence,
1400                 DBUS_TYPE_STRING, &appid,
1401                 DBUS_TYPE_STRING, &temp,
1402                 DBUS_TYPE_INVALID);
1403 #if 1
1404         if (g_conn_sender) {
1405                 dbus_message_set_no_reply(msg, TRUE);
1406
1407                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1408                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt start message : Out Of Memory !");
1409                         if (NULL != temp) {
1410                                         free(temp);
1411                                         temp = NULL;
1412                         }
1413                         return STT_ERROR_OUT_OF_MEMORY;
1414                 } else {
1415                         dbus_connection_flush(g_conn_sender);
1416                 }
1417
1418                 dbus_message_unref(msg);
1419
1420         } else {
1421                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1422                 if (NULL != temp) {
1423                                 free(temp);
1424                                 temp = NULL;
1425                 }
1426                 return STT_ERROR_OPERATION_FAILED;
1427         }
1428
1429         if (NULL != temp) {
1430                         free(temp);
1431                         temp = NULL;
1432         }
1433         return 0;
1434 #else
1435         DBusError err;
1436         dbus_error_init(&err);
1437
1438         DBusMessage* result_msg;
1439         int result = STT_ERROR_OPERATION_FAILED;
1440
1441         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1442         dbus_message_unref(msg);
1443         if (dbus_error_is_set(&err)) {
1444                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1445                 dbus_error_free(&err);
1446         }
1447
1448         if (NULL != result_msg) {
1449                 dbus_message_get_args(result_msg, &err,
1450                         DBUS_TYPE_INT32, &result,
1451                         DBUS_TYPE_INVALID);
1452
1453                 if (dbus_error_is_set(&err)) {
1454                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1455                         dbus_error_free(&err);
1456                         result = STT_ERROR_OPERATION_FAILED;
1457                 }
1458                 dbus_message_unref(result_msg);
1459
1460                 if (0 == result) {
1461                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt start : result = %d ", result);
1462                 } else {
1463                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt start : result = %d ", result);
1464                 }
1465         } else {
1466                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1467                 stt_dbus_reconnect();
1468                 result = STT_ERROR_TIMED_OUT;
1469         }
1470
1471         return result;
1472 #endif
1473 }
1474
1475 int stt_dbus_request_stop(int uid)
1476 {
1477         DBusMessage* msg;
1478
1479         /* create a signal & check for errors */
1480         msg = dbus_message_new_method_call(
1481                 STT_SERVER_SERVICE_NAME,
1482                 STT_SERVER_SERVICE_OBJECT_PATH,
1483                 STT_SERVER_SERVICE_INTERFACE,
1484                 STT_METHOD_STOP);
1485
1486         if (NULL == msg) {
1487                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt stop : Fail to make message");
1488                 return STT_ERROR_OPERATION_FAILED;
1489         } else {
1490                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt stop : uid(%d)", uid);
1491         }
1492
1493         dbus_message_append_args(msg,
1494                 DBUS_TYPE_INT32, &uid,
1495                 DBUS_TYPE_INVALID);
1496 #if 1
1497         if (g_conn_sender) {
1498                 dbus_message_set_no_reply(msg, TRUE);
1499
1500                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1501                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
1502                         return STT_ERROR_OUT_OF_MEMORY;
1503                 } else {
1504                         dbus_connection_flush(g_conn_sender);
1505                 }
1506
1507                 dbus_message_unref(msg);
1508         } else {
1509                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1510                 return STT_ERROR_OPERATION_FAILED;
1511         }
1512
1513         return 0;
1514 #else
1515         DBusError err;
1516         dbus_error_init(&err);
1517
1518         DBusMessage* result_msg;
1519         int result = STT_ERROR_OPERATION_FAILED;
1520
1521         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1522         dbus_message_unref(msg);
1523         if (dbus_error_is_set(&err)) {
1524                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1525                 dbus_error_free(&err);
1526         }
1527
1528         if (NULL != result_msg) {
1529                 dbus_message_get_args(result_msg, &err,
1530                         DBUS_TYPE_INT32, &result,
1531                         DBUS_TYPE_INVALID);
1532
1533                 if (dbus_error_is_set(&err)) {
1534                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1535                         dbus_error_free(&err);
1536                         result = STT_ERROR_OPERATION_FAILED;
1537                 }
1538                 dbus_message_unref(result_msg);
1539
1540                 if (0 == result) {
1541                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt stop : result = %d ", result);
1542                 } else {
1543                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt stop : result = %d ", result);
1544                 }
1545         } else {
1546                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1547                 stt_dbus_reconnect();
1548                 result = STT_ERROR_TIMED_OUT;
1549         }
1550
1551         return result;
1552 #endif
1553 }
1554
1555 int stt_dbus_request_cancel(int uid)
1556 {
1557         DBusMessage* msg;
1558
1559         /* create a signal & check for errors */
1560         msg = dbus_message_new_method_call(
1561                 STT_SERVER_SERVICE_NAME,
1562                 STT_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
1563                 STT_SERVER_SERVICE_INTERFACE,   /* interface name of the signal */
1564                 STT_METHOD_CANCEL);     /* name of the signal */
1565
1566         if (NULL == msg) {
1567                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel : Fail to make message");
1568                 return STT_ERROR_OPERATION_FAILED;
1569         } else {
1570                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel : uid(%d)", uid);
1571         }
1572
1573         dbus_message_append_args(msg,
1574                 DBUS_TYPE_INT32, &uid,
1575                 DBUS_TYPE_INVALID);
1576 #if 1
1577         if (g_conn_sender) {
1578                 dbus_message_set_no_reply(msg, TRUE);
1579
1580                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1581                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
1582                         return STT_ERROR_OUT_OF_MEMORY;
1583                 } else {
1584                         dbus_connection_flush(g_conn_sender);
1585                 }
1586
1587                 dbus_message_unref(msg);
1588         } else {
1589                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1590                 return STT_ERROR_OPERATION_FAILED;
1591         }
1592
1593         return 0;
1594 #else
1595         DBusError err;
1596         dbus_error_init(&err);
1597
1598         DBusMessage* result_msg;
1599         int result = STT_ERROR_OPERATION_FAILED;
1600
1601         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1602         dbus_message_unref(msg);
1603         if (dbus_error_is_set(&err)) {
1604                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1605                 dbus_error_free(&err);
1606         }
1607
1608         if (NULL != result_msg) {
1609                 dbus_message_get_args(result_msg, &err,
1610                         DBUS_TYPE_INT32, &result,
1611                         DBUS_TYPE_INVALID);
1612
1613                 if (dbus_error_is_set(&err)) {
1614                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1615                         dbus_error_free(&err);
1616                         result = STT_ERROR_OPERATION_FAILED;
1617                 }
1618                 dbus_message_unref(result_msg);
1619
1620                 if (0 == result) {
1621                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt cancel : result = %d ", result);
1622                 } else {
1623                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt cancel : result = %d ", result);
1624                 }
1625         } else {
1626                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1627                 stt_dbus_reconnect();
1628                 result = STT_ERROR_TIMED_OUT;
1629         }
1630
1631         return result;
1632 #endif
1633 }