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         } else {
 449                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> Request stt hello");
 450         }
 451
 452         DBusError err;
 453         dbus_error_init(&err);
 454
 455         DBusMessage* result_msg = NULL;
 456         int result = 0;
 457
 458         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 500, &err);
 459
 460         dbus_message_unref(msg);
 461
 462         if (NULL != result_msg) {
 463                 dbus_message_unref(result_msg);
 464
 465                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt hello");
 466                 result = 0;
 467         } else {
 468                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt hello : no response");
 469                 result = STT_ERROR_OPERATION_FAILED;
 470         }
 471
 472         return result;
 473 }
 474
 475
 476 int stt_dbus_request_initialize(int uid, bool* silence_supported, bool* profanity_supported, bool* punctuation_supported)
 477 {
 478         DBusMessage* msg;
 479
 480         msg = dbus_message_new_method_call(
 481                 STT_SERVER_SERVICE_NAME,
 482                 STT_SERVER_SERVICE_OBJECT_PATH,
 483                 STT_SERVER_SERVICE_INTERFACE,
 484                 STT_METHOD_INITIALIZE);
 485
 486         if (NULL == msg) {
 487                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt initialize : Fail to make message \n");
 488                 return STT_ERROR_OPERATION_FAILED;
 489         } else {
 490                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt initialize : uid(%d)", uid);
 491         }
 492
 493         int pid = getpid();
 494         dbus_message_append_args( msg,
 495                 DBUS_TYPE_INT32, &pid,
 496                 DBUS_TYPE_INT32, &uid,
 497                 DBUS_TYPE_INVALID);
 498
 499         DBusError err;
 500         dbus_error_init(&err);
 501
 502         DBusMessage* result_msg;
 503         int result = STT_ERROR_OPERATION_FAILED;
 504
 505         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 506
 507         if (NULL != result_msg) {
 508                 dbus_message_get_args(result_msg, &err,
 509                         DBUS_TYPE_INT32, &result,
 510                         DBUS_TYPE_INT32, silence_supported,
 511                         DBUS_TYPE_INT32, profanity_supported,
 512                         DBUS_TYPE_INT32, punctuation_supported,
 513                         DBUS_TYPE_INVALID);
 514
 515                 if (dbus_error_is_set(&err)) {
 516                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)\n", err.message);
 517                         dbus_error_free(&err);
 518                         result = STT_ERROR_OPERATION_FAILED;
 519                 }
 520
 521                 dbus_message_unref(result_msg);
 522         } else {
 523                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL \n");
 524         }
 525
 526         if (0 == result) {
 527                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt initialize : result = %d , silence(%d), profanity(%d), punctuation(%d)",
 528                         result, *silence_supported, *profanity_supported, *punctuation_supported);
 529         } else {
 530                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt initialize : result = %d \n", result);
 531         }
 532
 533         dbus_message_unref(msg);
 534
 535         return result;
 536 }
 537
 538 int stt_dbus_request_finalize(int uid)
 539 {
 540         DBusMessage* msg;
 541
 542         msg = dbus_message_new_method_call(
 543                 STT_SERVER_SERVICE_NAME,
 544                 STT_SERVER_SERVICE_OBJECT_PATH,
 545                 STT_SERVER_SERVICE_INTERFACE,
 546                 STT_METHOD_FINALIZE);
 547
 548         if (NULL == msg) {
 549                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt finalize : Fail to make message \n");
 550                 return STT_ERROR_OPERATION_FAILED;
 551         } else {
 552                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt finalize : uid(%d)", uid);
 553         }
 554
 555         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 556
 557         DBusError err;
 558         dbus_error_init(&err);
 559
 560         DBusMessage* result_msg;
 561         int result = STT_ERROR_OPERATION_FAILED;
 562
 563         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 564
 565         if (NULL != result_msg) {
 566                 dbus_message_get_args(result_msg, &err,
 567                                 DBUS_TYPE_INT32, &result,
 568                                 DBUS_TYPE_INVALID);
 569
 570                 if (dbus_error_is_set(&err)) {
 571                         printf("<<<< Get arguments error (%s)\n", err.message);
 572                         dbus_error_free(&err);
 573                         result = STT_ERROR_OPERATION_FAILED;
 574                 }
 575
 576                 dbus_message_unref(result_msg);
 577         } else {
 578                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL \n");
 579         }
 580
 581         if (0 == result) {
 582                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt finalize : result = %d \n", result);
 583         } else {
 584                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt finalize : result = %d \n", result);
 585         }
 586
 587         dbus_message_unref(msg);
 588
 589         return result;
 590 }
 591
 592 int stt_dbus_request_get_support_langs(int uid, stt_h stt, stt_supported_language_cb callback, void* user_data)
 593 {
 594         if (NULL == stt || NULL == callback) {
 595                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 596                 return STT_ERROR_INVALID_PARAMETER;
 597         }
 598
 599         DBusMessage* msg;
 600
 601         msg = dbus_message_new_method_call(
 602                 STT_SERVER_SERVICE_NAME,
 603                 STT_SERVER_SERVICE_OBJECT_PATH,
 604                 STT_SERVER_SERVICE_INTERFACE,
 605                 STT_METHOD_GET_SUPPORT_LANGS);
 606
 607         if (NULL == msg) {
 608                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get supported languages : Fail to make message \n");
 609                 return STT_ERROR_OPERATION_FAILED;
 610         } else {
 611                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get supported languages : uid(%d)", uid);
 612         }
 613
 614         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 615
 616         DBusError err;
 617         dbus_error_init(&err);
 618
 619         DBusMessage* result_msg;
 620         DBusMessageIter args;
 621         int result = STT_ERROR_OPERATION_FAILED;
 622
 623         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err );
 624
 625         if (NULL != result_msg) {
 626                 if (dbus_message_iter_init(result_msg, &args)) {
 627                         /* Get result */
 628                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 629                                 dbus_message_iter_get_basic(&args, &result);
 630                                 dbus_message_iter_next(&args);
 631                         }
 632
 633                         if (0 == result) {
 634                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get support languages : result = %d \n", result);
 635
 636                                 /* Get voice size */
 637                                 int size ;
 638                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 639                                         dbus_message_iter_get_basic(&args, &size);
 640                                         dbus_message_iter_next(&args);
 641                                 }
 642
 643                                 if (0 >= size) {
 644                                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt size of language error : size = %d \n", size);
 645                                 } else {
 646                                         int i=0;
 647                                         char* temp_lang;
 648
 649                                         for (i=0 ; i<size ; i++) {
 650                                                 dbus_message_iter_get_basic(&args, &(temp_lang));
 651                                                 dbus_message_iter_next(&args);
 652
 653                                                 if (true != callback(stt, temp_lang, user_data)) {
 654                                                         break;
 655                                                 }
 656                                         }
 657                                 }
 658                         } else {
 659                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result = %d \n", result);
 660                         }
 661                 }
 662                 dbus_message_unref(result_msg);
 663         } else {
 664                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result message is NULL \n");
 665         }
 666
 667         dbus_message_unref(msg);
 668
 669         return result;
 670 }
 671
 672 int stt_dbus_request_get_default_lang(int uid, char** language)
 673 {
 674         if (NULL == language) {
 675                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 676                 return STT_ERROR_INVALID_PARAMETER;
 677         }
 678
 679
 680         DBusMessage* msg;
 681
 682         msg = dbus_message_new_method_call(
 683                 STT_SERVER_SERVICE_NAME,
 684                 STT_SERVER_SERVICE_OBJECT_PATH,
 685                 STT_SERVER_SERVICE_INTERFACE,
 686                 STT_METHOD_GET_CURRENT_LANG);
 687
 688         if (NULL == msg) {
 689                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get default language : Fail to make message \n");
 690                 return STT_ERROR_OPERATION_FAILED;
 691         } else {
 692                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get default language  : uid(%d)", uid);
 693         }
 694
 695         dbus_message_append_args( msg,
 696                 DBUS_TYPE_INT32, &uid,
 697                 DBUS_TYPE_INVALID);
 698
 699         DBusError err;
 700         dbus_error_init(&err);
 701
 702         DBusMessage* result_msg;
 703         int result = STT_ERROR_OPERATION_FAILED;
 704         char* temp_lang = NULL;
 705
 706         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 707
 708         if (NULL != result_msg) {
 709                 dbus_message_get_args(result_msg, &err,
 710                         DBUS_TYPE_INT32, &result,
 711                         DBUS_TYPE_STRING, &temp_lang,
 712                         DBUS_TYPE_INVALID);
 713
 714                 if (dbus_error_is_set(&err)) {
 715                         printf("<<<< Get arguments error (%s)\n", err.message);
 716                         dbus_error_free(&err);
 717                         result = STT_ERROR_OPERATION_FAILED;
 718                 }
 719                 dbus_message_unref(result_msg);
 720         } else {
 721                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL \n");
 722         }
 723
 724         if (0 == result) {
 725                 *language = strdup(temp_lang);
 726                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get default language : result = %d, language = %s \n", result, *language);
 727         } else {
 728                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get default language : result = %d \n", result);
 729         }
 730
 731         dbus_message_unref(msg);
 732
 733         return result;
 734 }
 735
 736 int stt_dbus_request_is_partial_result_supported(int uid, bool* partial_result)
 737 {
 738         if (NULL == partial_result) {
 739                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 740                 return STT_ERROR_INVALID_PARAMETER;
 741         }
 742
 743         DBusMessage* msg;
 744
 745         msg = dbus_message_new_method_call(
 746                    STT_SERVER_SERVICE_NAME,
 747                    STT_SERVER_SERVICE_OBJECT_PATH,
 748                    STT_SERVER_SERVICE_INTERFACE,
 749                    STT_METHOD_IS_PARTIAL_SUPPORTED);
 750
 751         if (NULL == msg) {
 752                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt is partial result supported : Fail to make message \n");
 753                 return STT_ERROR_OPERATION_FAILED;
 754         } else {
 755                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt is partial result supported : uid(%d)", uid);
 756         }
 757
 758         dbus_message_append_args( msg,
 759                 DBUS_TYPE_INT32, &uid,
 760                 DBUS_TYPE_INVALID);
 761
 762         DBusError err;
 763         dbus_error_init(&err);
 764
 765         DBusMessage* result_msg;
 766         int result = STT_ERROR_OPERATION_FAILED;
 767         int support = -1;
 768
 769         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 770
 771         if (NULL != result_msg) {
 772                 dbus_message_get_args(result_msg, &err,
 773                         DBUS_TYPE_INT32, &result,
 774                         DBUS_TYPE_INT32, &support,
 775                         DBUS_TYPE_INVALID);
 776
 777                 if (dbus_error_is_set(&err)) {
 778                         printf("<<<< Get arguments error (%s)\n", err.message);
 779                         dbus_error_free(&err);
 780                         result = STT_ERROR_OPERATION_FAILED;
 781                 }
 782                 dbus_message_unref(result_msg);
 783         } else {
 784                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL \n");
 785         }
 786
 787         if (0 == result) {
 788                 *partial_result = (bool)support;
 789                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt is partial result supported : result = %d, support = %s \n", result, *partial_result ? "true" : "false");
 790         } else {
 791                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt is partial result supported : result = %d \n", result);
 792         }
 793
 794         dbus_message_unref(msg);
 795
 796         return result;
 797 }
 798
 799 int stt_dbus_request_start(int uid, const char* lang, const char* type, int profanity, int punctuation, int silence)
 800 {
 801         if (NULL == lang || NULL == type) {
 802                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 803                 return STT_ERROR_INVALID_PARAMETER;
 804         }
 805
 806         DBusMessage* msg;
 807
 808         /* create a signal & check for errors */
 809         msg = dbus_message_new_method_call(
 810                 STT_SERVER_SERVICE_NAME,
 811                 STT_SERVER_SERVICE_OBJECT_PATH,
 812                 STT_SERVER_SERVICE_INTERFACE,
 813                 STT_METHOD_START);
 814
 815         if (NULL == msg) {
 816                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start : Fail to make message \n");
 817                 return STT_ERROR_OPERATION_FAILED;
 818         } else {
 819                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start : uid(%d), language(%s), type(%s)", uid, lang, type);
 820         }
 821
 822         dbus_message_append_args( msg,
 823                 DBUS_TYPE_INT32, &uid,
 824                 DBUS_TYPE_STRING, &lang,
 825                 DBUS_TYPE_STRING, &type,
 826                 DBUS_TYPE_INT32, &profanity,
 827                 DBUS_TYPE_INT32, &punctuation,
 828                 DBUS_TYPE_INT32, &silence,
 829                 DBUS_TYPE_INVALID);
 830
 831         DBusError err;
 832         dbus_error_init(&err);
 833
 834         DBusMessage* result_msg;
 835         int result = STT_ERROR_OPERATION_FAILED;
 836
 837         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_start_time, &err);
 838
 839         if (NULL != result_msg) {
 840                 dbus_message_get_args(result_msg, &err,
 841                         DBUS_TYPE_INT32, &result,
 842                         DBUS_TYPE_INVALID);
 843
 844                 if (dbus_error_is_set(&err)) {
 845                         printf("<<<< Get arguments error (%s)\n", err.message);
 846                         dbus_error_free(&err);
 847                         result = STT_ERROR_OPERATION_FAILED;
 848                 }
 849                 dbus_message_unref(result_msg);
 850         } else {
 851                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
 852         }
 853
 854         if (0 == result) {
 855                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt start : result = %d ", result);
 856         } else {
 857                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt start : result = %d ", result);
 858         }
 859
 860         dbus_message_unref(msg);
 861
 862         return result;
 863 }
 864
 865 int stt_dbus_request_stop(int uid)
 866 {
 867         DBusMessage* msg;
 868
 869         /* create a signal & check for errors */
 870         msg = dbus_message_new_method_call(
 871                 STT_SERVER_SERVICE_NAME,
 872                 STT_SERVER_SERVICE_OBJECT_PATH,
 873                 STT_SERVER_SERVICE_INTERFACE,
 874                 STT_METHOD_STOP);
 875
 876         if (NULL == msg) {
 877                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt stop : Fail to make message \n");
 878                 return STT_ERROR_OPERATION_FAILED;
 879         } else {
 880                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt stop : uid(%d)", uid);
 881         }
 882
 883         dbus_message_append_args(msg,
 884                 DBUS_TYPE_INT32, &uid,
 885                 DBUS_TYPE_INVALID);
 886
 887         DBusError err;
 888         dbus_error_init(&err);
 889
 890         DBusMessage* result_msg;
 891         int result = STT_ERROR_OPERATION_FAILED;
 892
 893         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 894
 895         if (NULL != result_msg) {
 896                 dbus_message_get_args(result_msg, &err,
 897                         DBUS_TYPE_INT32, &result,
 898                         DBUS_TYPE_INVALID);
 899
 900                 if (dbus_error_is_set(&err)) {
 901                         printf("<<<< Get arguments error (%s)\n", err.message);
 902                         dbus_error_free(&err);
 903                         result = STT_ERROR_OPERATION_FAILED;
 904                 }
 905                 dbus_message_unref(result_msg);
 906         } else {
 907                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
 908         }
 909
 910         if (0 == result) {
 911                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt stop : result = %d ", result);
 912         } else {
 913                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt stop : result = %d ", result);
 914         }
 915
 916         dbus_message_unref(msg);
 917
 918         return result;
 919 }
 920
 921 int stt_dbus_request_cancel(int uid)
 922 {
 923         DBusMessage* msg;
 924
 925         /* create a signal & check for errors */
 926         msg = dbus_message_new_method_call(
 927                 STT_SERVER_SERVICE_NAME,
 928                 STT_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
 929                 STT_SERVER_SERVICE_INTERFACE,   /* interface name of the signal */
 930                 STT_METHOD_CANCEL);     /* name of the signal */
 931
 932         if (NULL == msg) {
 933                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel : Fail to make message \n");
 934                 return STT_ERROR_OPERATION_FAILED;
 935         } else {
 936                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel : uid(%d)", uid);
 937         }
 938
 939         dbus_message_append_args(msg,
 940                 DBUS_TYPE_INT32, &uid,
 941                 DBUS_TYPE_INVALID);
 942
 943         DBusError err;
 944         dbus_error_init(&err);
 945
 946         DBusMessage* result_msg;
 947         int result = STT_ERROR_OPERATION_FAILED;
 948
 949         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 950
 951         if (NULL != result_msg) {
 952                 dbus_message_get_args(result_msg, &err,
 953                         DBUS_TYPE_INT32, &result,
 954                         DBUS_TYPE_INVALID);
 955
 956                 if (dbus_error_is_set(&err)) {
 957                         printf("<<<< Get arguments error (%s)\n", err.message);
 958                         dbus_error_free(&err);
 959                         result = STT_ERROR_OPERATION_FAILED;
 960                 }
 961                 dbus_message_unref(result_msg);
 962         } else {
 963                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
 964         }
 965
 966         if (0 == result) {
 967                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt cancel : result = %d ", result);
 968         } else {
 969                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt cancel : result = %d ", result);
 970         }
 971
 972         dbus_message_unref(msg);
 973
 974         return result;
 975 }
 976
 977
 978 int stt_dbus_request_get_audio_volume(int uid, float* volume)
 979 {
 980         if (NULL == volume) {
 981                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 982                 return STT_ERROR_INVALID_PARAMETER;
 983         }
 984
 985         DBusMessage* msg;
 986
 987         msg = dbus_message_new_method_call(
 988                 STT_SERVER_SERVICE_NAME,
 989                 STT_SERVER_SERVICE_OBJECT_PATH,
 990                 STT_SERVER_SERVICE_INTERFACE,
 991                 STT_METHOD_GET_AUDIO_VOLUME);
 992
 993         if (NULL == msg) {
 994                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get volume : Fail to make message \n");
 995                 return STT_ERROR_OPERATION_FAILED;
 996         } else {
 997                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get volume : uid(%d)", uid);
 998         }
 999
1000         dbus_message_append_args( msg,
1001                 DBUS_TYPE_INT32, &uid,
1002                 DBUS_TYPE_INVALID);
1003
1004         DBusError err;
1005         dbus_error_init(&err);
1006
1007         DBusMessage* result_msg;
1008         int result = STT_ERROR_OPERATION_FAILED;
1009         double vol = 0;
1010
1011         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
1012
1013         if (NULL != result_msg) {
1014                 dbus_message_get_args(result_msg, &err,
1015                         DBUS_TYPE_INT32, &result,
1016                         DBUS_TYPE_DOUBLE, &vol,
1017                         DBUS_TYPE_INVALID);
1018
1019                 if (dbus_error_is_set(&err)) {
1020                         printf("<<<<< Get arguments error (%s)\n", err.message);
1021                         dbus_error_free(&err);
1022                         result = STT_ERROR_OPERATION_FAILED;
1023                 }
1024                 dbus_message_unref(result_msg);
1025         } else {
1026                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1027         }
1028
1029         if (0 == result) {
1030                 *volume = (float)vol;
1031                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get audio volume : result = %d, volume = %f \n", result, *volume);
1032         } else {
1033                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get audio volume : result = %d\n", result);
1034         }
1035
1036         dbus_message_unref(msg);
1037
1038         return result;
1039 }
1040
1041