client/stt_dbus.c

   1 /*
   2 *  Copyright (c) 2012, 2013 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 <Ecore.h>
  20 #include "stt_client.h"
  21
  22 static int g_waiting_time = 1500;
  23 static int g_waiting_start_time = 2000;
  24
  25 static Ecore_Fd_Handler* g_fd_handler = NULL;
  26
  27 static DBusConnection* g_conn = NULL;
  28
  29
  30 extern int __stt_cb_error(int uid, int reason);
  31
  32 extern int __stt_cb_result(int uid, const char* type, const char** data, int data_count, const char* msg);
  33
  34 extern int __stt_cb_partial_result(int uid, const char* data);
  35
  36 extern int __stt_cb_set_state(int uid, int state);
  37
  38 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
  39 {
  40         DBusConnection* conn = (DBusConnection*)data;
  41         DBusMessage* msg = NULL;
  42         DBusMessage *reply = NULL;
  43
  44         if (NULL == conn)
  45                 return ECORE_CALLBACK_RENEW;
  46
  47         dbus_connection_read_write_dispatch(conn, 50);
  48
  49         msg = dbus_connection_pop_message(conn);
  50
  51         /* loop again if we haven't read a message */
  52         if (NULL == msg) {
  53                 return ECORE_CALLBACK_RENEW;
  54         }
  55
  56         DBusError err;
  57         dbus_error_init(&err);
  58
  59         char if_name[64];
  60         snprintf(if_name, 64, "%s%d", STT_CLIENT_SERVICE_INTERFACE, getpid());
  61
  62         if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_HELLO)) {
  63                 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Hello");
  64                 int uid = 0;
  65                 int response = -1;
  66
  67                 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
  68
  69                 if (uid > 0) {
  70                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get hello : uid(%d) \n", uid);
  71
  72                         /* check uid */
  73                         stt_client_s* client = stt_client_get_by_uid(uid);
  74                         if( NULL != client )
  75                                 response = 1;
  76                         else
  77                                 response = 0;
  78                 } else {
  79                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get hello : invalid uid \n");
  80                 }
  81
  82                 reply = dbus_message_new_method_return(msg);
  83
  84                 if (NULL != reply) {
  85                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
  86
  87                         if (!dbus_connection_send(conn, reply, NULL))
  88                                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to send reply");
  89                         else
  90                                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get hello : result(%d)", response);
  91
  92                         dbus_connection_flush(conn);
  93                         dbus_message_unref(reply);
  94                 } else {
  95                         SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to create reply message");
  96                 }
  97
  98                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
  99                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 100         } /* STTD_METHOD_HELLO */
 101
 102         else if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_SET_STATE)) {
 103                 SLOG(LOG_DEBUG, TAG_STTC, "===== Set State");
 104                 int uid = 0;
 105                 int response = -1;
 106                 int state = -1;
 107
 108                 dbus_message_get_args(msg, &err,
 109                         DBUS_TYPE_INT32, &uid,
 110                         DBUS_TYPE_INT32, &state,
 111                         DBUS_TYPE_INVALID);
 112
 113                 if (uid > 0 && state >= 0) {
 114                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set state : uid(%d), state(%d)", uid, state);
 115
 116                         response = __stt_cb_set_state(uid, state);
 117                 } else {
 118                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set state : invalid uid or state");
 119                 }
 120
 121                 reply = dbus_message_new_method_return(msg);
 122
 123                 if (NULL != reply) {
 124                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
 125
 126                         if (!dbus_connection_send(conn, reply, NULL))
 127                                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set state : fail to send reply");
 128                         else
 129                                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set state : result(%d)", response);
 130
 131                         dbus_connection_flush(conn);
 132                         dbus_message_unref(reply);
 133                 } else {
 134                         SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set state : fail to create reply message");
 135                 }
 136
 137                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 138                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 139         } /* STTD_METHOD_SET_STATE */
 140
 141         else if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_GET_STATE)) {
 142                 SLOG(LOG_DEBUG, TAG_STTC, "===== Get state");
 143                 int uid = 0;
 144                 int response = -1;
 145
 146                 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 147
 148                 if (uid > 0) {
 149                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get state : uid(%d) \n", uid);
 150
 151                         /* check state */
 152                         stt_client_s* client = stt_client_get_by_uid(uid);
 153                         if( NULL != client )
 154                                 response = client->current_state;
 155                         else
 156                                 SLOG(LOG_ERROR, TAG_STTC, "invalid uid \n");
 157
 158                 } else {
 159                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get state : invalid uid \n");
 160                 }
 161
 162                 reply = dbus_message_new_method_return(msg);
 163
 164                 if (NULL != reply) {
 165                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
 166
 167                         if (!dbus_connection_send(conn, reply, NULL))
 168                                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get state : fail to send reply");
 169                         else
 170                                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get state : result(%d)", response);
 171
 172                         dbus_connection_flush(conn);
 173                         dbus_message_unref(reply);
 174                 } else {
 175                         SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to create reply message");
 176                 }
 177
 178                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 179                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 180         } /* STTD_METHOD_GET_STATE */
 181
 182         else if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_RESULT)) {
 183                 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Result");
 184                 int uid = 0;
 185                 DBusMessageIter args;
 186
 187                 dbus_message_iter_init(msg, &args);
 188
 189                 /* Get result */
 190                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 191                         dbus_message_iter_get_basic(&args, &uid);
 192                         dbus_message_iter_next(&args);
 193                 }
 194
 195                 if (uid > 0) {
 196                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get result : uid(%d) \n", uid);
 197                         char** temp_result;
 198                         char* temp_msg = NULL;
 199                         char* temp_char = NULL;
 200                         char* temp_type = 0;
 201                         int temp_count = 0;
 202
 203                         /* Get recognition type */
 204                         if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&args)) {
 205                                 dbus_message_iter_get_basic(&args, &temp_type);
 206                                 dbus_message_iter_next(&args);
 207                         }
 208
 209                         if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&args)) {
 210                                 dbus_message_iter_get_basic(&args, &(temp_msg) );
 211                                 dbus_message_iter_next(&args);
 212                         }
 213
 214                         /* Get voice size */
 215                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 216                                 dbus_message_iter_get_basic(&args, &temp_count);
 217                                 dbus_message_iter_next(&args);
 218                         }
 219
 220                         if (temp_count <= 0) {
 221                                 SLOG(LOG_WARN, TAG_STTC, "Result count is 0");
 222                                 __stt_cb_result(uid, temp_type, NULL, 0, temp_msg);
 223                         } else {
 224                                 temp_result = g_malloc0(temp_count * sizeof(char*));
 225
 226                                 if (NULL == temp_result)        {
 227                                         SLOG(LOG_ERROR, TAG_STTC, "Fail : memory allocation error \n");
 228                                 } else {
 229                                         int i = 0;
 230                                         for (i = 0;i < temp_count;i++) {
 231                                                 dbus_message_iter_get_basic(&args, &(temp_char) );
 232                                                 dbus_message_iter_next(&args);
 233
 234                                                 if (NULL != temp_char)
 235                                                         temp_result[i] = strdup(temp_char);
 236                                         }
 237
 238                                         __stt_cb_result(uid, temp_type, (const char**)temp_result, temp_count, temp_msg);
 239
 240                                         for (i = 0;i < temp_count;i++) {
 241                                                 if (NULL != temp_result[i])
 242                                                         free(temp_result[i]);
 243                                         }
 244
 245                                         g_free(temp_result);
 246                                 }
 247                         }
 248                 } else {
 249                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get result : invalid uid \n");
 250                 }
 251
 252                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 253                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 254         }/* STTD_METHOD_RESULT */
 255
 256         else if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_PARTIAL_RESULT)) {
 257                 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Partial Result");
 258                 int uid = 0;
 259                 DBusMessageIter args;
 260
 261                 dbus_message_iter_init(msg, &args);
 262
 263                 /* Get result */
 264                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 265                         dbus_message_iter_get_basic(&args, &uid);
 266                         dbus_message_iter_next(&args);
 267                 }
 268
 269                 if (uid > 0) {
 270                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get partial result : uid(%d) \n", uid);
 271                         char* temp_char = NULL;
 272
 273                         if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&args)) {
 274                                 dbus_message_iter_get_basic(&args, &(temp_char) );
 275                                 dbus_message_iter_next(&args);
 276                         }
 277
 278                         __stt_cb_partial_result(uid, temp_char);
 279                 } else {
 280                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get partial result : invalid uid \n");
 281                 }
 282
 283                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 284                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 285         }/* STTD_METHOD_PARTIAL_RESULT */
 286
 287         else if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_ERROR)) {
 288                 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Error");
 289                 int uid;
 290                 int reason;
 291                 char* err_msg;
 292
 293                 dbus_message_get_args(msg, &err,
 294                         DBUS_TYPE_INT32, &uid,
 295                         DBUS_TYPE_INT32, &reason,
 296                         DBUS_TYPE_STRING, &err_msg,
 297                         DBUS_TYPE_INVALID);
 298
 299                 if (dbus_error_is_set(&err)) {
 300                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt Get Error message : Get arguments error (%s)\n", err.message);
 301                         dbus_error_free(&err);
 302                 } else {
 303                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt Get Error message : uid(%d), reason(%d), msg(%s)\n", uid, reason, err_msg);
 304                         __stt_cb_error(uid, reason);
 305                 }
 306
 307                 reply = dbus_message_new_method_return(msg);
 308
 309                 if (NULL != reply) {
 310                         if (!dbus_connection_send(conn, reply, NULL))
 311                                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt Error message : fail to send reply");
 312                         else
 313                                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt Error message");
 314
 315                         dbus_connection_flush(conn);
 316                         dbus_message_unref(reply);
 317                 } else {
 318                         SLOG(LOG_ERROR, TAG_STTC, ">>>> stt Error message : fail to create reply message");
 319                 }
 320
 321                 SLOG(LOG_DEBUG, TAG_STTC, "=====");
 322                 SLOG(LOG_DEBUG, TAG_STTC, " ");
 323         }/* STTD_METHOD_ERROR */
 324
 325         /* free the message */
 326         dbus_message_unref(msg);
 327
 328         return ECORE_CALLBACK_PASS_ON;
 329 }
 330
 331 int stt_dbus_open_connection()
 332 {
 333         if (NULL != g_conn) {
 334                 SLOG(LOG_WARN, TAG_STTC, "already existed connection ");
 335                 return 0;
 336         }
 337
 338         DBusError err;
 339         int ret;
 340
 341         /* initialise the error value */
 342         dbus_error_init(&err);
 343
 344         /* connect to the DBUS system bus, and check for errors */
 345         g_conn = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
 346
 347         if (dbus_error_is_set(&err)) {
 348                 SLOG(LOG_ERROR, TAG_STTC, "Dbus Connection Error (%s)\n", err.message);
 349                 dbus_error_free(&err);
 350         }
 351
 352         if (NULL == g_conn) {
 353                 SLOG(LOG_ERROR, TAG_STTC, "Fail to get dbus connection \n");
 354                 return STT_ERROR_OPERATION_FAILED;
 355         }
 356
 357         int pid = getpid();
 358
 359         char service_name[64];
 360         memset(service_name, '\0', 64);
 361         snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
 362
 363         SLOG(LOG_DEBUG, TAG_STTC, "service name is %s\n", service_name);
 364
 365         /* register our name on the bus, and check for errors */
 366         ret = dbus_bus_request_name(g_conn, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
 367
 368         if (dbus_error_is_set(&err)) {
 369                 SLOG(LOG_ERROR, TAG_STTC, "Name Error (%s)\n", err.message);
 370                 dbus_error_free(&err);
 371         }
 372
 373         if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
 374                 printf("fail dbus_bus_request_name()\n");
 375                 return -2;
 376         }
 377
 378         if( NULL != g_fd_handler ) {
 379                 SLOG(LOG_WARN, TAG_STTC, "The handler already exists.");
 380                 return 0;
 381         }
 382
 383         char rule[128];
 384         snprintf(rule, 128, "type='signal',interface='%s%d'", STT_CLIENT_SERVICE_INTERFACE, pid);
 385
 386         /* add a rule for which messages we want to see */
 387         dbus_bus_add_match(g_conn, rule, &err);
 388         dbus_connection_flush(g_conn);
 389
 390         if (dbus_error_is_set(&err))
 391         {
 392                 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)\n", err.message);
 393                 return STT_ERROR_OPERATION_FAILED;
 394         }
 395
 396         int fd = 0;
 397         if (1 != dbus_connection_get_unix_fd(g_conn, &fd)) {
 398                 SLOG(LOG_ERROR, TAG_STTC, "fail to get fd from dbus \n");
 399                 return STT_ERROR_OPERATION_FAILED;
 400         } else {
 401                 SLOG(LOG_DEBUG, TAG_STTC, "Get fd from dbus : %d\n", fd);
 402         }
 403
 404         g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn, NULL, NULL);
 405
 406         if (NULL == g_fd_handler) {
 407                 SLOG(LOG_ERROR, TAG_STTC, "fail to get fd handler from ecore \n");
 408                 return STT_ERROR_OPERATION_FAILED;
 409         }
 410
 411         return 0;
 412 }
 413
 414 int stt_dbus_close_connection()
 415 {
 416         DBusError err;
 417         dbus_error_init(&err);
 418
 419         int pid = getpid();
 420
 421         char service_name[64];
 422         memset(service_name, '\0', 64);
 423         snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
 424
 425         dbus_bus_release_name (g_conn, service_name, &err);
 426
 427         dbus_connection_close(g_conn);
 428
 429         g_fd_handler = NULL;
 430         g_conn = NULL;
 431
 432         return 0;
 433 }
 434
 435 int stt_dbus_request_hello()
 436 {
 437         DBusMessage* msg;
 438
 439         msg = dbus_message_new_method_call(
 440                 STT_SERVER_SERVICE_NAME,
 441                 STT_SERVER_SERVICE_OBJECT_PATH,
 442                 STT_SERVER_SERVICE_INTERFACE,
 443                 STT_METHOD_HELLO);
 444
 445         if (NULL == msg) {
 446                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request stt hello : Fail to make message \n");
 447                 return STT_ERROR_OPERATION_FAILED;
 448         }
 449
 450         DBusError err;
 451         dbus_error_init(&err);
 452
 453         DBusMessage* result_msg = NULL;
 454         int result = 0;
 455
 456         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 500, &err);
 457
 458         dbus_message_unref(msg);
 459
 460         if (NULL != result_msg) {
 461                 dbus_message_unref(result_msg);
 462
 463                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt hello");
 464                 result = 0;
 465         } else {
 466                 result = STT_ERROR_OPERATION_FAILED;
 467         }
 468
 469         return result;
 470 }
 471
 472
 473 int stt_dbus_request_initialize(int uid, bool* silence_supported, bool* profanity_supported, bool* punctuation_supported)
 474 {
 475         DBusMessage* msg;
 476
 477         msg = dbus_message_new_method_call(
 478                 STT_SERVER_SERVICE_NAME,
 479                 STT_SERVER_SERVICE_OBJECT_PATH,
 480                 STT_SERVER_SERVICE_INTERFACE,
 481                 STT_METHOD_INITIALIZE);
 482
 483         if (NULL == msg) {
 484                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt initialize : Fail to make message \n");
 485                 return STT_ERROR_OPERATION_FAILED;
 486         } else {
 487                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt initialize : uid(%d)", uid);
 488         }
 489
 490         int pid = getpid();
 491         dbus_message_append_args( msg,
 492                 DBUS_TYPE_INT32, &pid,
 493                 DBUS_TYPE_INT32, &uid,
 494                 DBUS_TYPE_INVALID);
 495
 496         DBusError err;
 497         dbus_error_init(&err);
 498
 499         DBusMessage* result_msg;
 500         int result = STT_ERROR_OPERATION_FAILED;
 501
 502         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 503
 504         if (NULL != result_msg) {
 505                 dbus_message_get_args(result_msg, &err,
 506                         DBUS_TYPE_INT32, &result,
 507                         DBUS_TYPE_INT32, silence_supported,
 508                         DBUS_TYPE_INT32, profanity_supported,
 509                         DBUS_TYPE_INT32, punctuation_supported,
 510                         DBUS_TYPE_INVALID);
 511
 512                 if (dbus_error_is_set(&err)) {
 513                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)\n", err.message);
 514                         dbus_error_free(&err);
 515                         result = STT_ERROR_OPERATION_FAILED;
 516                 }
 517
 518                 dbus_message_unref(result_msg);
 519         } else {
 520                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL \n");
 521         }
 522
 523         if (0 == result) {
 524                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt initialize : result = %d , silence(%d), profanity(%d), punctuation(%d)",
 525                         result, *silence_supported, *profanity_supported, *punctuation_supported);
 526         } else {
 527                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt initialize : result = %d \n", result);
 528         }
 529
 530         dbus_message_unref(msg);
 531
 532         return result;
 533 }
 534
 535 int stt_dbus_request_finalize(int uid)
 536 {
 537         DBusMessage* msg;
 538
 539         msg = dbus_message_new_method_call(
 540                 STT_SERVER_SERVICE_NAME,
 541                 STT_SERVER_SERVICE_OBJECT_PATH,
 542                 STT_SERVER_SERVICE_INTERFACE,
 543                 STT_METHOD_FINALIZE);
 544
 545         if (NULL == msg) {
 546                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt finalize : Fail to make message \n");
 547                 return STT_ERROR_OPERATION_FAILED;
 548         } else {
 549                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt finalize : uid(%d)", uid);
 550         }
 551
 552         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 553
 554         DBusError err;
 555         dbus_error_init(&err);
 556
 557         DBusMessage* result_msg;
 558         int result = STT_ERROR_OPERATION_FAILED;
 559
 560         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 561
 562         if (NULL != result_msg) {
 563                 dbus_message_get_args(result_msg, &err,
 564                                 DBUS_TYPE_INT32, &result,
 565                                 DBUS_TYPE_INVALID);
 566
 567                 if (dbus_error_is_set(&err)) {
 568                         printf("<<<< Get arguments error (%s)\n", err.message);
 569                         dbus_error_free(&err);
 570                         result = STT_ERROR_OPERATION_FAILED;
 571                 }
 572
 573                 dbus_message_unref(result_msg);
 574         } else {
 575                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL \n");
 576         }
 577
 578         if (0 == result) {
 579                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt finalize : result = %d \n", result);
 580         } else {
 581                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt finalize : result = %d \n", result);
 582         }
 583
 584         dbus_message_unref(msg);
 585
 586         return result;
 587 }
 588
 589 int stt_dbus_request_get_support_langs(int uid, stt_h stt, stt_supported_language_cb callback, void* user_data)
 590 {
 591         if (NULL == stt || NULL == callback) {
 592                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 593                 return STT_ERROR_INVALID_PARAMETER;
 594         }
 595
 596         DBusMessage* msg;
 597
 598         msg = dbus_message_new_method_call(
 599                 STT_SERVER_SERVICE_NAME,
 600                 STT_SERVER_SERVICE_OBJECT_PATH,
 601                 STT_SERVER_SERVICE_INTERFACE,
 602                 STT_METHOD_GET_SUPPORT_LANGS);
 603
 604         if (NULL == msg) {
 605                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get supported languages : Fail to make message \n");
 606                 return STT_ERROR_OPERATION_FAILED;
 607         } else {
 608                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get supported languages : uid(%d)", uid);
 609         }
 610
 611         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 612
 613         DBusError err;
 614         dbus_error_init(&err);
 615
 616         DBusMessage* result_msg;
 617         DBusMessageIter args;
 618         int result = STT_ERROR_OPERATION_FAILED;
 619
 620         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err );
 621
 622         if (NULL != result_msg) {
 623                 if (dbus_message_iter_init(result_msg, &args)) {
 624                         /* Get result */
 625                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 626                                 dbus_message_iter_get_basic(&args, &result);
 627                                 dbus_message_iter_next(&args);
 628                         }
 629
 630                         if (0 == result) {
 631                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get support languages : result = %d \n", result);
 632
 633                                 /* Get voice size */
 634                                 int size ;
 635                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 636                                         dbus_message_iter_get_basic(&args, &size);
 637                                         dbus_message_iter_next(&args);
 638                                 }
 639
 640                                 if (0 >= size) {
 641                                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt size of language error : size = %d \n", size);
 642                                 } else {
 643                                         int i=0;
 644                                         char* temp_lang;
 645
 646                                         for (i=0 ; i<size ; i++) {
 647                                                 dbus_message_iter_get_basic(&args, &(temp_lang));
 648                                                 dbus_message_iter_next(&args);
 649
 650                                                 if (true != callback(stt, temp_lang, user_data)) {
 651                                                         break;
 652                                                 }
 653                                         }
 654                                 }
 655                         } else {
 656                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result = %d \n", result);
 657                         }
 658                 }
 659                 dbus_message_unref(result_msg);
 660         } else {
 661                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result message is NULL \n");
 662         }
 663
 664         dbus_message_unref(msg);
 665
 666         return result;
 667 }
 668
 669 int stt_dbus_request_get_default_lang(int uid, char** language)
 670 {
 671         if (NULL == language) {
 672                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 673                 return STT_ERROR_INVALID_PARAMETER;
 674         }
 675
 676
 677         DBusMessage* msg;
 678
 679         msg = dbus_message_new_method_call(
 680                 STT_SERVER_SERVICE_NAME,
 681                 STT_SERVER_SERVICE_OBJECT_PATH,
 682                 STT_SERVER_SERVICE_INTERFACE,
 683                 STT_METHOD_GET_CURRENT_LANG);
 684
 685         if (NULL == msg) {
 686                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get default language : Fail to make message \n");
 687                 return STT_ERROR_OPERATION_FAILED;
 688         } else {
 689                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get default language  : uid(%d)", uid);
 690         }
 691
 692         dbus_message_append_args( msg,
 693                 DBUS_TYPE_INT32, &uid,
 694                 DBUS_TYPE_INVALID);
 695
 696         DBusError err;
 697         dbus_error_init(&err);
 698
 699         DBusMessage* result_msg;
 700         int result = STT_ERROR_OPERATION_FAILED;
 701         char* temp_lang = NULL;
 702
 703         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 704
 705         if (NULL != result_msg) {
 706                 dbus_message_get_args(result_msg, &err,
 707                         DBUS_TYPE_INT32, &result,
 708                         DBUS_TYPE_STRING, &temp_lang,
 709                         DBUS_TYPE_INVALID);
 710
 711                 if (dbus_error_is_set(&err)) {
 712                         printf("<<<< Get arguments error (%s)\n", err.message);
 713                         dbus_error_free(&err);
 714                         result = STT_ERROR_OPERATION_FAILED;
 715                 }
 716                 dbus_message_unref(result_msg);
 717         } else {
 718                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL \n");
 719         }
 720
 721         if (0 == result) {
 722                 *language = strdup(temp_lang);
 723                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get default language : result = %d, language = %s \n", result, *language);
 724         } else {
 725                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get default language : result = %d \n", result);
 726         }
 727
 728         dbus_message_unref(msg);
 729
 730         return result;
 731 }
 732
 733 int stt_dbus_request_is_partial_result_supported(int uid, bool* partial_result)
 734 {
 735         if (NULL == partial_result) {
 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_IS_PARTIAL_SUPPORTED);
 747
 748         if (NULL == msg) {
 749                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt is partial result supported : Fail to make message \n");
 750                 return STT_ERROR_OPERATION_FAILED;
 751         } else {
 752                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt is partial result supported : uid(%d)", uid);
 753         }
 754
 755         dbus_message_append_args( msg,
 756                 DBUS_TYPE_INT32, &uid,
 757                 DBUS_TYPE_INVALID);
 758
 759         DBusError err;
 760         dbus_error_init(&err);
 761
 762         DBusMessage* result_msg;
 763         int result = STT_ERROR_OPERATION_FAILED;
 764         int support = -1;
 765
 766         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 767
 768         if (NULL != result_msg) {
 769                 dbus_message_get_args(result_msg, &err,
 770                         DBUS_TYPE_INT32, &result,
 771                         DBUS_TYPE_INT32, &support,
 772                         DBUS_TYPE_INVALID);
 773
 774                 if (dbus_error_is_set(&err)) {
 775                         printf("<<<< Get arguments error (%s)\n", err.message);
 776                         dbus_error_free(&err);
 777                         result = STT_ERROR_OPERATION_FAILED;
 778                 }
 779                 dbus_message_unref(result_msg);
 780         } else {
 781                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL \n");
 782         }
 783
 784         if (0 == result) {
 785                 *partial_result = (bool)support;
 786                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt is partial result supported : result = %d, support = %s \n", result, *partial_result ? "true" : "false");
 787         } else {
 788                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt is partial result supported : result = %d \n", result);
 789         }
 790
 791         dbus_message_unref(msg);
 792
 793         return result;
 794 }
 795
 796 int stt_dbus_request_start(int uid, const char* lang, const char* type, int profanity, int punctuation, int silence)
 797 {
 798         if (NULL == lang || NULL == type) {
 799                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 800                 return STT_ERROR_INVALID_PARAMETER;
 801         }
 802
 803         DBusMessage* msg;
 804
 805         /* create a signal & check for errors */
 806         msg = dbus_message_new_method_call(
 807                 STT_SERVER_SERVICE_NAME,
 808                 STT_SERVER_SERVICE_OBJECT_PATH,
 809                 STT_SERVER_SERVICE_INTERFACE,
 810                 STT_METHOD_START);
 811
 812         if (NULL == msg) {
 813                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start : Fail to make message \n");
 814                 return STT_ERROR_OPERATION_FAILED;
 815         } else {
 816                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start : uid(%d), language(%s), type(%s)", uid, lang, type);
 817         }
 818
 819         dbus_message_append_args( msg,
 820                 DBUS_TYPE_INT32, &uid,
 821                 DBUS_TYPE_STRING, &lang,
 822                 DBUS_TYPE_STRING, &type,
 823                 DBUS_TYPE_INT32, &profanity,
 824                 DBUS_TYPE_INT32, &punctuation,
 825                 DBUS_TYPE_INT32, &silence,
 826                 DBUS_TYPE_INVALID);
 827
 828         DBusError err;
 829         dbus_error_init(&err);
 830
 831         DBusMessage* result_msg;
 832         int result = STT_ERROR_OPERATION_FAILED;
 833
 834         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_start_time, &err);
 835
 836         if (NULL != result_msg) {
 837                 dbus_message_get_args(result_msg, &err,
 838                         DBUS_TYPE_INT32, &result,
 839                         DBUS_TYPE_INVALID);
 840
 841                 if (dbus_error_is_set(&err)) {
 842                         printf("<<<< Get arguments error (%s)\n", err.message);
 843                         dbus_error_free(&err);
 844                         result = STT_ERROR_OPERATION_FAILED;
 845                 }
 846                 dbus_message_unref(result_msg);
 847         } else {
 848                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
 849         }
 850
 851         if (0 == result) {
 852                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt start : result = %d ", result);
 853         } else {
 854                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt start : result = %d ", result);
 855         }
 856
 857         dbus_message_unref(msg);
 858
 859         return result;
 860 }
 861
 862 int stt_dbus_request_stop(int uid)
 863 {
 864         DBusMessage* msg;
 865
 866         /* create a signal & check for errors */
 867         msg = dbus_message_new_method_call(
 868                 STT_SERVER_SERVICE_NAME,
 869                 STT_SERVER_SERVICE_OBJECT_PATH,
 870                 STT_SERVER_SERVICE_INTERFACE,
 871                 STT_METHOD_STOP);
 872
 873         if (NULL == msg) {
 874                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt stop : Fail to make message \n");
 875                 return STT_ERROR_OPERATION_FAILED;
 876         } else {
 877                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt stop : uid(%d)", uid);
 878         }
 879
 880         dbus_message_append_args(msg,
 881                 DBUS_TYPE_INT32, &uid,
 882                 DBUS_TYPE_INVALID);
 883
 884         DBusError err;
 885         dbus_error_init(&err);
 886
 887         DBusMessage* result_msg;
 888         int result = STT_ERROR_OPERATION_FAILED;
 889
 890         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 891
 892         if (NULL != result_msg) {
 893                 dbus_message_get_args(result_msg, &err,
 894                         DBUS_TYPE_INT32, &result,
 895                         DBUS_TYPE_INVALID);
 896
 897                 if (dbus_error_is_set(&err)) {
 898                         printf("<<<< Get arguments error (%s)\n", err.message);
 899                         dbus_error_free(&err);
 900                         result = STT_ERROR_OPERATION_FAILED;
 901                 }
 902                 dbus_message_unref(result_msg);
 903         } else {
 904                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
 905         }
 906
 907         if (0 == result) {
 908                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt stop : result = %d ", result);
 909         } else {
 910                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt stop : result = %d ", result);
 911         }
 912
 913         dbus_message_unref(msg);
 914
 915         return result;
 916 }
 917
 918 int stt_dbus_request_cancel(int uid)
 919 {
 920         DBusMessage* msg;
 921
 922         /* create a signal & check for errors */
 923         msg = dbus_message_new_method_call(
 924                 STT_SERVER_SERVICE_NAME,
 925                 STT_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
 926                 STT_SERVER_SERVICE_INTERFACE,   /* interface name of the signal */
 927                 STT_METHOD_CANCEL);     /* name of the signal */
 928
 929         if (NULL == msg) {
 930                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel : Fail to make message \n");
 931                 return STT_ERROR_OPERATION_FAILED;
 932         } else {
 933                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel : uid(%d)", uid);
 934         }
 935
 936         dbus_message_append_args(msg,
 937                 DBUS_TYPE_INT32, &uid,
 938                 DBUS_TYPE_INVALID);
 939
 940         DBusError err;
 941         dbus_error_init(&err);
 942
 943         DBusMessage* result_msg;
 944         int result = STT_ERROR_OPERATION_FAILED;
 945
 946         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 947
 948         if (NULL != result_msg) {
 949                 dbus_message_get_args(result_msg, &err,
 950                         DBUS_TYPE_INT32, &result,
 951                         DBUS_TYPE_INVALID);
 952
 953                 if (dbus_error_is_set(&err)) {
 954                         printf("<<<< Get arguments error (%s)\n", err.message);
 955                         dbus_error_free(&err);
 956                         result = STT_ERROR_OPERATION_FAILED;
 957                 }
 958                 dbus_message_unref(result_msg);
 959         } else {
 960                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
 961         }
 962
 963         if (0 == result) {
 964                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt cancel : result = %d ", result);
 965         } else {
 966                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt cancel : result = %d ", result);
 967         }
 968
 969         dbus_message_unref(msg);
 970
 971         return result;
 972 }