client/stt_dbus.c

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