client/stt_setting_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_setting_dbus.h"
  17
  18 static int g_waiting_time = 1500;
  19
  20 static DBusConnection* g_conn = NULL;
  21
  22 int stt_setting_dbus_open_connection()
  23 {
  24         if( NULL != g_conn ) {
  25                 SLOG(LOG_WARN, TAG_STTC, "already existed connection");
  26                 return 0;
  27         }
  28
  29         DBusError err;
  30         int ret;
  31
  32         /* initialise the error value */
  33         dbus_error_init(&err);
  34
  35         /* connect to the DBUS system bus, and check for errors */
  36         g_conn = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
  37
  38         if (dbus_error_is_set(&err)) {
  39                 SLOG(LOG_ERROR, TAG_STTC, "Dbus Connection Error (%s)\n", err.message);
  40                 dbus_error_free(&err);
  41         }
  42
  43         if (NULL == g_conn) {
  44                 SLOG(LOG_ERROR, TAG_STTC, "fail to get dbus connection \n");
  45                 return STT_SETTING_ERROR_OPERATION_FAILED;
  46         }
  47
  48         int pid = getpid();
  49
  50         char service_name[64];
  51         memset(service_name, 0, 64);
  52         snprintf(service_name, 64, "%s%d", STT_SETTING_SERVICE_NAME, pid);
  53
  54         SLOG(LOG_DEBUG, TAG_STTC, "service name is %s\n", service_name);
  55
  56         /* register our name on the bus, and check for errors */
  57         ret = dbus_bus_request_name(g_conn, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
  58
  59         if (dbus_error_is_set(&err)) {
  60                 SLOG(LOG_ERROR, TAG_STTC, "Name Error (%s)\n", err.message);
  61                 dbus_error_free(&err);
  62         }
  63
  64         if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
  65                 SLOG(LOG_ERROR, TAG_STTC, "fail dbus_bus_request_name()\n");
  66                 return STT_SETTING_ERROR_OPERATION_FAILED;
  67         }
  68
  69         return 0;
  70 }
  71
  72 int stt_setting_dbus_close_connection()
  73 {
  74         DBusError err;
  75         dbus_error_init(&err);
  76
  77         int pid = getpid();
  78
  79         char service_name[64];
  80         memset(service_name, 0, 64);
  81         snprintf(service_name, 64, "%s%d", STT_SETTING_SERVICE_NAME, pid);
  82
  83         dbus_bus_release_name(g_conn, service_name, &err);
  84
  85         dbus_connection_close(g_conn);
  86
  87         g_conn = NULL;
  88
  89         return 0;
  90 }
  91
  92
  93 int stt_setting_dbus_request_hello()
  94 {
  95         DBusMessage* msg;
  96
  97         msg = dbus_message_new_method_call(
  98                 STT_SERVER_SERVICE_NAME,
  99                 STT_SERVER_SERVICE_OBJECT_PATH,
 100                 STT_SERVER_SERVICE_INTERFACE,
 101                 STT_SETTING_METHOD_HELLO);
 102
 103         if (NULL == msg) {
 104                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request setting hello : Fail to make message \n");
 105                 return STT_SETTING_ERROR_OPERATION_FAILED;
 106         }
 107
 108         DBusError err;
 109         dbus_error_init(&err);
 110
 111         DBusMessage* result_msg = NULL;
 112         int result = 0;
 113
 114         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 500, &err);
 115
 116         dbus_message_unref(msg);
 117
 118         if (NULL != result_msg) {
 119                 dbus_message_unref(result_msg);
 120
 121                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< setting hello");
 122                 result = 0;
 123         } else {
 124                 result = -1;
 125         }
 126
 127         return result;
 128 }
 129
 130 int stt_setting_dbus_request_initialize()
 131 {
 132         DBusMessage* msg;
 133
 134         msg = dbus_message_new_method_call(
 135                 STT_SERVER_SERVICE_NAME,
 136                 STT_SERVER_SERVICE_OBJECT_PATH,
 137                 STT_SERVER_SERVICE_INTERFACE,
 138                 STT_SETTING_METHOD_INITIALIZE);
 139
 140         if (NULL == msg) {
 141                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request setting initialize : Fail to make message \n");
 142                 return STT_SETTING_ERROR_OPERATION_FAILED;
 143         } else {
 144                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> Request setting initialize");
 145         }
 146
 147         int pid = getpid();
 148
 149         dbus_message_append_args( msg,
 150                 DBUS_TYPE_INT32, &pid,
 151                 DBUS_TYPE_INVALID);
 152
 153         DBusError err;
 154         dbus_error_init(&err);
 155
 156         DBusMessage* result_msg;
 157         int result = STT_SETTING_ERROR_OPERATION_FAILED;
 158
 159         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 160
 161         if (NULL != result_msg) {
 162                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 163
 164                 if (dbus_error_is_set(&err)) {
 165                         SLOG(LOG_ERROR, TAG_STTC, "Get arguments error (%s)\n", err.message);
 166                         dbus_error_free(&err);
 167                         result = STT_SETTING_ERROR_OPERATION_FAILED;
 168                 }
 169                 dbus_message_unref(result_msg);
 170         }
 171
 172         if (0 == result) {
 173                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< setting initialize : result = %d", result);
 174         } else {
 175                 SLOG(LOG_ERROR, TAG_STTC, "<<<< setting initialize : result = %d", result);
 176         }
 177
 178         dbus_message_unref(msg);
 179
 180         return result;
 181 }
 182
 183 int stt_setting_dbus_request_finalilze(void)
 184 {
 185         DBusMessage* msg;
 186
 187         msg = dbus_message_new_method_call(
 188                 STT_SERVER_SERVICE_NAME,
 189                 STT_SERVER_SERVICE_OBJECT_PATH,
 190                 STT_SERVER_SERVICE_INTERFACE,
 191                 STT_SETTING_METHOD_FINALIZE);
 192
 193         if (NULL == msg) {
 194                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request setting finalize : Fail to make message \n");
 195                 return STT_SETTING_ERROR_OPERATION_FAILED;
 196         } else {
 197                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> Request setting finalize");
 198         }
 199
 200         int pid = getpid();
 201
 202         dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 203
 204         DBusError err;
 205         dbus_error_init(&err);
 206
 207         DBusMessage* result_msg;
 208         int result = STT_SETTING_ERROR_OPERATION_FAILED;
 209
 210         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 211
 212         if (NULL != result_msg) {
 213                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 214
 215                 if (dbus_error_is_set(&err)) {
 216                         SLOG(LOG_ERROR, TAG_STTC, "Get arguments error (%s)\n", err.message);
 217                         dbus_error_free(&err);
 218                         result = STT_SETTING_ERROR_OPERATION_FAILED;
 219                 }
 220                 dbus_message_unref(result_msg);
 221         }
 222
 223         if (0 == result) {
 224                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< setting finallize : result = %d", result);
 225         } else {
 226                 SLOG(LOG_ERROR, TAG_STTC, "<<<< setting finallize : result = %d", result);
 227         }
 228
 229         dbus_message_unref(msg);
 230
 231         return result;
 232 }
 233
 234 int stt_setting_dbus_request_get_engine_list(stt_setting_supported_engine_cb callback, void* user_data)
 235 {
 236         if (NULL == callback) {
 237                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 238                 return -1;
 239         }
 240
 241         DBusMessage* msg;
 242
 243         msg = dbus_message_new_method_call(
 244                 STT_SERVER_SERVICE_NAME,
 245                 STT_SERVER_SERVICE_OBJECT_PATH,
 246                 STT_SERVER_SERVICE_INTERFACE,
 247                 STT_SETTING_METHOD_GET_ENGINE_LIST);
 248
 249         if (NULL == msg) {
 250                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request setting get engine list : Fail to make message \n");
 251                 return STT_SETTING_ERROR_OPERATION_FAILED;
 252         } else {
 253                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> Request setting get engine list");
 254         }
 255
 256         int pid = getpid();
 257
 258         dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 259
 260         DBusError err;
 261         dbus_error_init(&err);
 262
 263         DBusMessage* result_msg;
 264         int result = STT_SETTING_ERROR_OPERATION_FAILED;
 265
 266         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 267
 268         if (NULL != result_msg) {
 269                 DBusMessageIter args;
 270                 if (dbus_message_iter_init(result_msg, &args)) {
 271                         /* Get result */
 272                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 273                                 dbus_message_iter_get_basic(&args, &result);
 274                                 dbus_message_iter_next(&args);
 275                         }
 276
 277                         if (0 == result) {
 278                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< setting get engine list : result = %d \n", result);
 279
 280                                 int size ;
 281                                 char* temp_id;
 282                                 char* temp_name;
 283                                 char* temp_path;
 284
 285                                 /* Get engine count */
 286                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 287                                         dbus_message_iter_get_basic(&args, &size);
 288                                         dbus_message_iter_next(&args);
 289                                 }
 290
 291                                 int i=0;
 292                                 for (i=0 ; i<size ; i++) {
 293                                         dbus_message_iter_get_basic(&args, &(temp_id));
 294                                         dbus_message_iter_next(&args);
 295
 296                                         dbus_message_iter_get_basic(&args, &(temp_name));
 297                                         dbus_message_iter_next(&args);
 298
 299                                         dbus_message_iter_get_basic(&args, &(temp_path));
 300                                         dbus_message_iter_next(&args);
 301
 302                                         if (true != callback(temp_id, temp_name, temp_path, user_data)) {
 303                                                 break;
 304                                         }
 305                                 }
 306                         }  else {
 307                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< setting get engine list : result = %d \n", result);
 308                         }
 309                 } else {
 310                         SLOG(LOG_ERROR, TAG_STTC, "<<<< setting get engine list : invalid message \n");
 311                 }
 312
 313                 dbus_message_unref(result_msg);
 314         } else {
 315                 SLOG(LOG_ERROR, TAG_STTC, "<<<< setting get engine list : result message is NULL!! \n");
 316         }
 317
 318         dbus_message_unref(msg);
 319
 320         return result;
 321 }
 322
 323 int stt_setting_dbus_request_get_engine(char** engine_id)
 324 {
 325         if (NULL == engine_id)  {
 326                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 327                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 328         }
 329
 330         DBusMessage* msg;
 331
 332         msg = dbus_message_new_method_call(
 333                 STT_SERVER_SERVICE_NAME,
 334                 STT_SERVER_SERVICE_OBJECT_PATH,
 335                 STT_SERVER_SERVICE_INTERFACE,
 336                 STT_SETTING_METHOD_GET_ENGINE);
 337
 338         if (NULL == msg) {
 339                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request setting get engine : Fail to make message \n");
 340                 return STT_SETTING_ERROR_OPERATION_FAILED;
 341         } else {
 342                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> Request setting get engine ");
 343         }
 344
 345         int pid = getpid();
 346
 347         dbus_message_append_args( msg,
 348                 DBUS_TYPE_INT32, &pid,
 349                 DBUS_TYPE_INVALID);
 350
 351         DBusError err;
 352         dbus_error_init(&err);
 353
 354         DBusMessage* result_msg;
 355         int result = STT_SETTING_ERROR_OPERATION_FAILED;
 356         char* temp;
 357
 358         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 359
 360         if (NULL != result_msg) {
 361                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_STRING, &temp, DBUS_TYPE_INVALID);
 362
 363                 if (dbus_error_is_set(&err)) {
 364                         SLOG(LOG_ERROR, TAG_STTC, "Get arguments error (%s)\n", err.message);
 365                         dbus_error_free(&err);
 366                         result = STT_SETTING_ERROR_OPERATION_FAILED;
 367                 }
 368                 dbus_message_unref(result_msg);
 369         }
 370
 371         if (0 == result) {
 372                 *engine_id = strdup(temp);
 373
 374                 if (NULL == *engine_id) {
 375                         SLOG(LOG_ERROR, TAG_STTC, "<<<< setting get engine : Out of memory \n");
 376                         result = STT_SETTING_ERROR_OUT_OF_MEMORY;
 377                 } else {
 378                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< setting get engine : result(%d), engine id(%s)\n", result, *engine_id);
 379                 }
 380         } else {
 381                 SLOG(LOG_ERROR, TAG_STTC, "<<<< setting get engine : result(%d) \n", result);
 382         }
 383
 384         dbus_message_unref(msg);
 385
 386         return result;
 387 }
 388
 389 int stt_setting_dbus_request_set_engine(const char* engine_id)
 390 {
 391         if (NULL == engine_id) {
 392                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 393                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 394         }
 395
 396         DBusMessage* msg;
 397
 398         msg = dbus_message_new_method_call(
 399                 STT_SERVER_SERVICE_NAME,
 400                 STT_SERVER_SERVICE_OBJECT_PATH,
 401                 STT_SERVER_SERVICE_INTERFACE,
 402                 STT_SETTING_METHOD_SET_ENGINE);
 403
 404         if (NULL == msg) {
 405                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request setting set engine : Fail to make message \n");
 406                 return STT_SETTING_ERROR_OPERATION_FAILED;
 407         } else {
 408                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> Request setting set engine : engine id(%s)", engine_id);
 409         }
 410
 411         int pid = getpid();
 412
 413         dbus_message_append_args( msg,
 414                 DBUS_TYPE_INT32, &pid,
 415                 DBUS_TYPE_STRING, &engine_id,
 416                 DBUS_TYPE_INVALID);
 417
 418         DBusError err;
 419         dbus_error_init(&err);
 420
 421         DBusMessage* result_msg;
 422         int result = STT_SETTING_ERROR_OPERATION_FAILED;
 423
 424         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 425
 426         if (NULL != result_msg) {
 427                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 428
 429                 if (dbus_error_is_set(&err)) {
 430                         SLOG(LOG_ERROR, TAG_STTC, "Get arguments error (%s)\n", err.message);
 431                         dbus_error_free(&err);
 432                         result = STT_SETTING_ERROR_OPERATION_FAILED;
 433                 }
 434                 dbus_message_unref(result_msg);
 435         }
 436
 437         if (0 == result) {
 438                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< setting set engine : result(%d) \n", result);
 439         } else {
 440                 SLOG(LOG_ERROR, TAG_STTC, "<<<< setting set engine : result(%d) \n", result);
 441         }
 442
 443         dbus_message_unref(msg);
 444
 445         return result;
 446 }
 447
 448 int stt_setting_dbus_request_get_language_list(stt_setting_supported_language_cb callback, void* user_data)
 449 {
 450         if (NULL == callback) {
 451                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 452                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 453         }
 454
 455         DBusMessage* msg;
 456
 457         msg = dbus_message_new_method_call(
 458                 STT_SERVER_SERVICE_NAME,
 459                 STT_SERVER_SERVICE_OBJECT_PATH,
 460                 STT_SERVER_SERVICE_INTERFACE,
 461                 STT_SETTING_METHOD_GET_LANG_LIST);
 462
 463         if (NULL == msg) {
 464                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request setting get language list : Fail to make message \n");
 465                 return STT_SETTING_ERROR_OPERATION_FAILED;
 466         } else {
 467                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> Request setting get language list");
 468         }
 469
 470         int pid = getpid();
 471
 472         dbus_message_append_args( msg,
 473                 DBUS_TYPE_INT32, &pid,
 474                 DBUS_TYPE_INVALID);
 475
 476         DBusError err;
 477         dbus_error_init(&err);
 478
 479         DBusMessage* result_msg;
 480         int result = STT_SETTING_ERROR_OPERATION_FAILED;
 481
 482         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 483
 484         if (NULL != result_msg) {
 485                 DBusMessageIter args;
 486
 487                 if (dbus_message_iter_init(result_msg, &args)) {
 488                         /* Get result */
 489                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 490                                 dbus_message_iter_get_basic(&args, &result);
 491                                 dbus_message_iter_next(&args);
 492                         }
 493
 494                         if (0 == result) {
 495                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< setting get language list : result = %d \n", result);
 496
 497                                 int size = 0;
 498                                 char* temp_id = NULL;
 499                                 char* temp_lang = NULL;
 500
 501                                 /* Get engine id */
 502                                 dbus_message_iter_get_basic(&args, &temp_id);
 503                                 dbus_message_iter_next(&args);
 504
 505                                 if (NULL != temp_id) {
 506                                         /* Get language count */
 507                                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 508                                                 dbus_message_iter_get_basic(&args, &size);
 509                                                 dbus_message_iter_next(&args);
 510                                         }
 511
 512                                         int i=0;
 513                                         for (i=0 ; i<size ; i++) {
 514                                                 dbus_message_iter_get_basic(&args, &(temp_lang) );
 515                                                 dbus_message_iter_next(&args);
 516
 517                                                 if (true != callback(temp_id, temp_lang, user_data)) {
 518                                                         break;
 519                                                 }
 520                                         }
 521                                 } else {
 522                                         SLOG(LOG_ERROR, TAG_STTC, "Engine ID is NULL \n");
 523                                         result = STT_SETTING_ERROR_OPERATION_FAILED;
 524                                 }
 525
 526                         } else {
 527                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< setting get language list : result = %d \n", result);
 528                         }
 529                 }
 530
 531                 dbus_message_unref(result_msg);
 532         } else {
 533                 SLOG(LOG_ERROR, TAG_STTC, "<<<< setting get language list : Result message is NULL!!");
 534         }
 535
 536         dbus_message_unref(msg);
 537
 538         return result;
 539 }
 540
 541 int stt_setting_dbus_request_get_default_language(char** language)
 542 {
 543         if (NULL == language) {
 544                 SLOG(LOG_ERROR, TAG_STTC, "Input Parameter is NULL");
 545                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 546         }
 547
 548         DBusMessage* msg;
 549
 550         msg = dbus_message_new_method_call(
 551                 STT_SERVER_SERVICE_NAME,
 552                 STT_SERVER_SERVICE_OBJECT_PATH,
 553                 STT_SERVER_SERVICE_INTERFACE,
 554                 STT_SETTING_METHOD_GET_DEFAULT_LANG);
 555
 556         if (NULL == msg) {
 557                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request setting get default language : Fail to make message \n");
 558                 return STT_SETTING_ERROR_OPERATION_FAILED;
 559         } else {
 560                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> Request setting get default language");
 561         }
 562
 563         int pid = getpid();
 564
 565         dbus_message_append_args( msg,
 566                 DBUS_TYPE_INT32, &pid,
 567                 DBUS_TYPE_INVALID);
 568
 569         DBusError err;
 570         dbus_error_init(&err);
 571
 572         DBusMessage* result_msg;
 573         int result = STT_SETTING_ERROR_OPERATION_FAILED;
 574         char* temp_char;
 575
 576         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 577
 578         if (NULL != result_msg) {
 579                 dbus_message_get_args(result_msg, &err,
 580                         DBUS_TYPE_INT32, &result,
 581                         DBUS_TYPE_STRING, &temp_char,
 582                         DBUS_TYPE_INVALID);
 583
 584                 if (dbus_error_is_set(&err)) {
 585                         SLOG(LOG_ERROR, TAG_STTC, "Get arguments error (%s)\n", err.message);
 586                         dbus_error_free(&err);
 587                         result = STT_SETTING_ERROR_OPERATION_FAILED;
 588                 }
 589
 590                 dbus_message_unref(result_msg);
 591         }
 592
 593         if (0 == result) {
 594                 *language = strdup(temp_char);
 595
 596                 if (NULL == *language) {
 597                         SLOG(LOG_ERROR, TAG_STTC, "<<<< setting get default language : Out of memory \n");
 598                         result = STT_SETTING_ERROR_OUT_OF_MEMORY;
 599                 } else {
 600                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< setting get default language : result(%d), lang(%s)\n", result, *language);
 601                 }
 602         } else {
 603                 SLOG(LOG_ERROR, TAG_STTC, "<<<< setting get default language : result(%d) \n", result);
 604         }
 605
 606         dbus_message_unref(msg);
 607
 608         return result;
 609 }
 610
 611
 612 int stt_setting_dbus_request_set_default_language(const char* language)
 613 {
 614         if (NULL == language) {
 615                 SLOG(LOG_ERROR, TAG_STTC, "Input Parameter is NULL");
 616                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 617         }
 618
 619         DBusMessage* msg;
 620
 621         msg = dbus_message_new_method_call(
 622                 STT_SERVER_SERVICE_NAME,
 623                 STT_SERVER_SERVICE_OBJECT_PATH,
 624                 STT_SERVER_SERVICE_INTERFACE,
 625                 STT_SETTING_METHOD_SET_DEFAULT_LANG);
 626
 627         if (NULL == msg) {
 628                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request setting set default language : Fail to make message \n");
 629                 return STT_SETTING_ERROR_OPERATION_FAILED;
 630         } else {
 631                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> Request setting set default language : lang(%s)\n", language);
 632         }
 633
 634         int pid = getpid();
 635
 636         dbus_message_append_args( msg,
 637                 DBUS_TYPE_INT32, &pid,
 638                 DBUS_TYPE_STRING, &language,
 639                 DBUS_TYPE_INVALID);
 640
 641         DBusError err;
 642         dbus_error_init(&err);
 643
 644         DBusMessage* result_msg;
 645         int result = STT_SETTING_ERROR_OPERATION_FAILED;
 646
 647         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 648
 649         if (NULL != result_msg) {
 650                 dbus_message_get_args(result_msg, &err,
 651                         DBUS_TYPE_INT32, &result,
 652                         DBUS_TYPE_INVALID);
 653
 654                 if (dbus_error_is_set(&err)) {
 655                         SLOG(LOG_ERROR, TAG_STTC, "Get arguments error (%s)\n", err.message);
 656                         dbus_error_free(&err);
 657                         result = STT_SETTING_ERROR_OPERATION_FAILED;
 658                 }
 659
 660                 dbus_message_unref(result_msg);
 661         }
 662
 663         if (0 == result) {
 664                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< setting set default language : result(%d)", result);
 665         } else {
 666                 SLOG(LOG_ERROR, TAG_STTC, "<<<< setting set default language : result(%d)", result);
 667         }
 668
 669         dbus_message_unref(msg);
 670
 671         return result;
 672 }
 673
 674 int stt_setting_dbus_request_get_engine_setting(stt_setting_engine_setting_cb callback, void* user_data)
 675 {
 676         if (NULL == callback) {
 677                 SLOG(LOG_ERROR, TAG_STTC, "Input Parameter is NULL");
 678                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 679         }
 680
 681         DBusMessage* msg;
 682
 683         msg = dbus_message_new_method_call(
 684                 STT_SERVER_SERVICE_NAME,
 685                 STT_SERVER_SERVICE_OBJECT_PATH,
 686                 STT_SERVER_SERVICE_INTERFACE,
 687                 STT_SETTING_METHOD_GET_ENGINE_SETTING);
 688
 689         if (NULL == msg) {
 690                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request setting get engine setting : Fail to make message \n");
 691                 return STT_SETTING_ERROR_OPERATION_FAILED;
 692         } else {
 693                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> Request setting get engine setting");
 694         }
 695
 696         int pid = getpid();
 697
 698         dbus_message_append_args( msg,
 699                 DBUS_TYPE_INT32, &pid,
 700                 DBUS_TYPE_INVALID);
 701
 702         DBusError err;
 703         dbus_error_init(&err);
 704
 705         DBusMessage* result_msg;
 706         int result = STT_SETTING_ERROR_OPERATION_FAILED;
 707
 708         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 709
 710         if (NULL != result_msg) {
 711                 DBusMessageIter args;
 712
 713                 if (dbus_message_iter_init(result_msg, &args)) {
 714                         /* Get result */
 715                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 716                                 dbus_message_iter_get_basic(&args, &result);
 717                                 dbus_message_iter_next(&args);
 718                         }
 719
 720                         if (0 == result) {
 721                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< get engine setting : result = %d \n", result);
 722                                 int size;
 723                                 char* temp_id = NULL;
 724                                 char* temp_key;
 725                                 char* temp_value;
 726
 727                                 /* Get engine id */
 728                                 dbus_message_iter_get_basic(&args, &temp_id);
 729                                 dbus_message_iter_next(&args);
 730
 731                                 if (NULL != temp_id) {
 732                                         /* Get setting count */
 733                                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 734                                                 dbus_message_iter_get_basic(&args, &size);
 735                                                 dbus_message_iter_next(&args);
 736                                         }
 737
 738                                         int i=0;
 739                                         for (i=0 ; i<size ; i++) {
 740                                                 dbus_message_iter_get_basic(&args, &(temp_key) );
 741                                                 dbus_message_iter_next(&args);
 742
 743                                                 dbus_message_iter_get_basic(&args, &(temp_value) );
 744                                                 dbus_message_iter_next(&args);
 745
 746                                                 if (true != callback(temp_id, temp_key, temp_value, user_data)) {
 747                                                         break;
 748                                                 }
 749                                         }
 750                                 } else {
 751                                         SLOG(LOG_ERROR, TAG_STTC, "<<<< get engine setting : result message is invalid \n");
 752                                         result = STT_SETTING_ERROR_OPERATION_FAILED;
 753                                 }
 754                         }
 755                 } else {
 756                         SLOG(LOG_ERROR, TAG_STTC, "<<<< get engine setting : result message is invalid \n");
 757                         result = STT_SETTING_ERROR_OPERATION_FAILED;
 758                 }
 759
 760                 dbus_message_unref(result_msg);
 761         } else {
 762                 SLOG(LOG_ERROR, TAG_STTC, "<<<< get engine setting : Result message is NULL!! \n");
 763         }
 764
 765         dbus_message_unref(msg);
 766
 767         return result;
 768 }
 769
 770 int stt_setting_dbus_request_set_engine_setting(const char* key, const char* value)
 771 {
 772         if (NULL == key || NULL == value) {
 773                 SLOG(LOG_ERROR, TAG_STTC, "Input Parameter is NULL");
 774                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 775         }
 776
 777         DBusMessage* msg;
 778
 779         msg = dbus_message_new_method_call(
 780                 STT_SERVER_SERVICE_NAME,
 781                 STT_SERVER_SERVICE_OBJECT_PATH,
 782                 STT_SERVER_SERVICE_INTERFACE,
 783                 STT_SETTING_METHOD_SET_ENGINE_SETTING);
 784
 785         if (NULL == msg) {
 786                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request setting set engine setting : Fail to make message \n");
 787                 return STT_SETTING_ERROR_OPERATION_FAILED;
 788         } else {
 789                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> Request setting set engine setting : key(%s), value(%s)", key, value);
 790         }
 791
 792         int pid = getpid();
 793
 794         dbus_message_append_args( msg,
 795                 DBUS_TYPE_INT32, &pid,
 796                 DBUS_TYPE_STRING, &key,
 797                 DBUS_TYPE_STRING, &value,
 798                 DBUS_TYPE_INVALID);
 799
 800         DBusError err;
 801         dbus_error_init(&err);
 802
 803         DBusMessage* result_msg;
 804         int result = STT_SETTING_ERROR_OPERATION_FAILED;
 805
 806         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 807
 808         if (NULL != result_msg) {
 809                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 810
 811                 if (dbus_error_is_set(&err)) {
 812                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)\n", err.message);
 813                         dbus_error_free(&err);
 814                         result = -1;
 815                 }
 816                 dbus_message_unref(result_msg);
 817         }
 818
 819         if (0 == result) {
 820                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< setting set engine setting : result(%d)", result);
 821         } else {
 822                 SLOG(LOG_ERROR, TAG_STTC, "<<<< setting set engine setting : result(%d)", result);
 823         }
 824
 825         dbus_message_unref(msg);
 826
 827         return result;
 828 }
 829
 830 int stt_setting_dbus_request_get_profanity_filter(bool* value)
 831 {
 832         if (NULL == value) {
 833                 SLOG(LOG_ERROR, TAG_STTC, "Input Parameter is NULL");
 834                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 835         }
 836
 837         DBusMessage* msg;
 838
 839         msg = dbus_message_new_method_call(
 840                 STT_SERVER_SERVICE_NAME,
 841                 STT_SERVER_SERVICE_OBJECT_PATH,
 842                 STT_SERVER_SERVICE_INTERFACE,
 843                 STT_SETTING_METHOD_GET_PROFANITY);
 844
 845         if (NULL == msg) {
 846                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request setting set profanity filter : Fail to make message \n");
 847                 return STT_SETTING_ERROR_OPERATION_FAILED;
 848         } else {
 849                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> Request setting set profanity filter");
 850         }
 851
 852         int pid = getpid();
 853
 854         dbus_message_append_args( msg,
 855                 DBUS_TYPE_INT32, &pid,
 856                 DBUS_TYPE_INVALID);
 857
 858         DBusError err;
 859         dbus_error_init(&err);
 860
 861         DBusMessage* result_msg;
 862         int result = STT_SETTING_ERROR_OPERATION_FAILED;
 863
 864         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 865
 866         if (NULL != result_msg) {
 867                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INT32, value, DBUS_TYPE_INVALID);
 868
 869                 if (dbus_error_is_set(&err)) {
 870                         SLOG(LOG_ERROR, TAG_STTC, "Get arguments error (%s)\n", err.message);
 871                         dbus_error_free(&err);
 872                         result = STT_SETTING_ERROR_OPERATION_FAILED;
 873                 }
 874
 875                 dbus_message_unref(result_msg);
 876         }
 877
 878         if (0 == result) {
 879                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< setting get profanity filter : result(%d), value(%s)", result, *value ? "true":"false");
 880         } else {
 881                 SLOG(LOG_ERROR, TAG_STTC, "<<<< setting get profanity filter : result(%d)", result);
 882         }
 883
 884         dbus_message_unref(msg);
 885
 886         return result;
 887 }
 888
 889 int stt_setting_dbus_request_set_profanity_filter(const bool value)
 890 {
 891         DBusMessage* msg;
 892
 893         msg = dbus_message_new_method_call(
 894                 STT_SERVER_SERVICE_NAME,
 895                 STT_SERVER_SERVICE_OBJECT_PATH,
 896                 STT_SERVER_SERVICE_INTERFACE,
 897                 STT_SETTING_METHOD_SET_PROFANITY);
 898
 899         if (NULL == msg) {
 900                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request setting set profanity filter : Fail to make message \n");
 901                 return STT_SETTING_ERROR_OPERATION_FAILED;
 902         } else {
 903                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> Request setting set profanity filter : value(%s)", value ? "true":"false");
 904         }
 905
 906         int pid = getpid();
 907
 908         dbus_message_append_args( msg,
 909                 DBUS_TYPE_INT32, &pid,
 910                 DBUS_TYPE_INT32, &value,
 911                 DBUS_TYPE_INVALID);
 912
 913         DBusError err;
 914         dbus_error_init(&err);
 915
 916         DBusMessage* result_msg;
 917         int result = STT_SETTING_ERROR_OPERATION_FAILED;
 918
 919         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 920
 921         if (NULL != result_msg) {
 922                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 923
 924                 if (dbus_error_is_set(&err)) {
 925                         SLOG(LOG_ERROR, TAG_STTC, "Get arguments error (%s)\n", err.message);
 926                         dbus_error_free(&err);
 927                         result = STT_SETTING_ERROR_OPERATION_FAILED;
 928                 }
 929
 930                 dbus_message_unref(result_msg);
 931         }
 932
 933         if (0 == result) {
 934                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< setting set profanity filter : result(%d)", result);
 935         } else {
 936                 SLOG(LOG_ERROR, TAG_STTC, "<<<< setting set profanity filter : result(%d)", result);
 937         }
 938
 939         dbus_message_unref(msg);
 940
 941         return result;
 942 }
 943
 944 int stt_setting_dbus_request_get_punctuation_override(bool* value)
 945 {
 946         if (NULL == value) {
 947                 SLOG(LOG_ERROR, TAG_STTC, "Input Parameter is NULL");
 948                 return STT_SETTING_ERROR_INVALID_PARAMETER;
 949         }
 950
 951         DBusMessage* msg;
 952
 953         msg = dbus_message_new_method_call(
 954                 STT_SERVER_SERVICE_NAME,
 955                 STT_SERVER_SERVICE_OBJECT_PATH,
 956                 STT_SERVER_SERVICE_INTERFACE,
 957                 STT_SETTING_METHOD_GET_PUNCTUATION);
 958
 959         if (NULL == msg) {
 960                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request setting get punctuation override : Fail to make message \n");
 961                 return STT_SETTING_ERROR_OPERATION_FAILED;
 962         } else {
 963                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> Request setting get punctuation override ");
 964         }
 965
 966         int pid = getpid();
 967
 968         dbus_message_append_args( msg,
 969                 DBUS_TYPE_INT32, &pid,
 970                 DBUS_TYPE_INVALID);
 971
 972         DBusError err;
 973         dbus_error_init(&err);
 974
 975         DBusMessage* result_msg;
 976         int result = STT_SETTING_ERROR_OPERATION_FAILED;
 977
 978         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
 979
 980         if (NULL != result_msg) {
 981                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INT32, value, DBUS_TYPE_INVALID);
 982
 983                 if (dbus_error_is_set(&err)) {
 984                         SLOG(LOG_ERROR, TAG_STTC, "Get arguments error (%s)\n", err.message);
 985                         dbus_error_free(&err);
 986                         result = STT_SETTING_ERROR_OPERATION_FAILED;
 987                 }
 988
 989                 dbus_message_unref(result_msg);
 990         }
 991
 992         if (0 == result) {
 993                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< setting get punctuation override : result(%d), value(%s)", result, *value ? "true":"false");
 994         } else {
 995                 SLOG(LOG_ERROR, TAG_STTC, "<<<< setting get punctuation override : result(%d)", result);
 996         }
 997
 998         dbus_message_unref(msg);
 999
1000         return result;
1001 }
1002
1003 int stt_setting_dbus_request_set_punctuation_override(const bool value )
1004 {
1005         DBusMessage* msg;
1006
1007         msg = dbus_message_new_method_call(
1008                 STT_SERVER_SERVICE_NAME,
1009                 STT_SERVER_SERVICE_OBJECT_PATH,
1010                 STT_SERVER_SERVICE_INTERFACE,
1011                 STT_SETTING_METHOD_SET_PUNCTUATION);
1012
1013         if (NULL == msg) {
1014                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request setting set punctuation override : Fail to make message \n");
1015                 return STT_SETTING_ERROR_OPERATION_FAILED;
1016         } else {
1017                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> Request setting set punctuation override : value(%s)", value ? "true":"false");
1018         }
1019
1020         int pid = getpid();
1021
1022         dbus_message_append_args( msg,
1023                 DBUS_TYPE_INT32, &pid,
1024                 DBUS_TYPE_INT32, &value,
1025                 DBUS_TYPE_INVALID);
1026
1027         DBusError err;
1028         dbus_error_init(&err);
1029
1030         DBusMessage* result_msg;
1031         int result = STT_SETTING_ERROR_OPERATION_FAILED;
1032
1033         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
1034
1035         if (NULL != result_msg) {
1036                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
1037
1038                 if (dbus_error_is_set(&err)) {
1039                         SLOG(LOG_ERROR, TAG_STTC, "Get arguments error (%s)\n", err.message);
1040                         dbus_error_free(&err);
1041                         result = STT_SETTING_ERROR_OPERATION_FAILED;
1042                 }
1043
1044                 dbus_message_unref(result_msg);
1045         }
1046
1047         if (0 == result) {
1048                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< setting set punctuation override : result(%d)", result);
1049         } else {
1050                 SLOG(LOG_ERROR, TAG_STTC, "<<<< setting set punctuation override : result(%d)", result);
1051         }
1052
1053         dbus_message_unref(msg);
1054
1055         return result;
1056 }
1057
1058 int stt_setting_dbus_request_get_silence_detection(bool* value)
1059 {
1060         if (NULL == value) {
1061                 SLOG(LOG_ERROR, TAG_STTC, "Input Parameter is NULL");
1062                 return STT_SETTING_ERROR_INVALID_PARAMETER;
1063         }
1064
1065         DBusMessage* msg;
1066
1067         msg = dbus_message_new_method_call(
1068                 STT_SERVER_SERVICE_NAME,
1069                 STT_SERVER_SERVICE_OBJECT_PATH,
1070                 STT_SERVER_SERVICE_INTERFACE,
1071                 STT_SETTING_METHOD_GET_SILENCE);
1072
1073         if (NULL == msg) {
1074                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request setting get silence detection : Fail to make message \n");
1075                 return STT_SETTING_ERROR_OPERATION_FAILED;
1076         } else {
1077                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> Request setting get silence detection : value(%s)", value ? "true":"false");
1078         }
1079
1080         int pid = getpid();
1081
1082         dbus_message_append_args( msg,
1083                 DBUS_TYPE_INT32, &pid,
1084                 DBUS_TYPE_INT32, &value,
1085                 DBUS_TYPE_INVALID);
1086
1087         DBusError err;
1088         dbus_error_init(&err);
1089
1090         DBusMessage* result_msg;
1091         int result = STT_SETTING_ERROR_OPERATION_FAILED;
1092
1093         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
1094
1095         if (NULL == result_msg) {
1096                 dbus_message_unref(msg);
1097                 return STT_SETTING_ERROR_OPERATION_FAILED;
1098         }
1099
1100         dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INT32, value, DBUS_TYPE_INVALID);
1101
1102         if (dbus_error_is_set(&err)) {
1103                 SLOG(LOG_ERROR, TAG_STTC, "Get arguments error (%s)\n", err.message);
1104                 dbus_error_free(&err);
1105                 result = STT_SETTING_ERROR_OPERATION_FAILED;
1106         }
1107
1108         SLOG(LOG_DEBUG, TAG_STTC, "Get Silence Detection : result(%d), value(%d) \n", result, *value);
1109
1110         dbus_message_unref(msg);
1111
1112         return result;
1113 }
1114
1115 int stt_setting_dbus_request_set_silence_detection(const bool value)
1116 {
1117         DBusMessage* msg;
1118
1119         msg = dbus_message_new_method_call(
1120                 STT_SERVER_SERVICE_NAME,
1121                 STT_SERVER_SERVICE_OBJECT_PATH,
1122                 STT_SERVER_SERVICE_INTERFACE,
1123                 STT_SETTING_METHOD_SET_SILENCE);
1124
1125         if (NULL == msg) {
1126                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request setting set silence detection : Fail to make message \n");
1127                 return STT_SETTING_ERROR_OPERATION_FAILED;
1128         } else {
1129                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> Request setting set silence detection : value(%s)", value ? "true":"false");
1130         }
1131
1132         int pid = getpid();
1133
1134         dbus_message_append_args( msg,
1135                 DBUS_TYPE_INT32, &pid,
1136                 DBUS_TYPE_INT32, &value,
1137                 DBUS_TYPE_INVALID);
1138
1139         DBusError err;
1140         dbus_error_init(&err);
1141
1142         DBusMessage* result_msg;
1143         int result = STT_SETTING_ERROR_OPERATION_FAILED;
1144
1145         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
1146
1147         if (NULL != result_msg) {
1148                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
1149
1150                 if (dbus_error_is_set(&err)) {
1151                         SLOG(LOG_ERROR, TAG_STTC, "Get arguments error (%s)\n", err.message);
1152                         dbus_error_free(&err);
1153                         result = STT_SETTING_ERROR_OPERATION_FAILED;
1154                 }
1155
1156                 dbus_message_unref(result_msg);
1157         }
1158
1159         if (0 == result) {
1160                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< setting set set silence detection : result(%d)", result);
1161         } else {
1162                 SLOG(LOG_ERROR, TAG_STTC, "<<<< setting set set silence detection : result(%d)", result);
1163         }
1164
1165         dbus_message_unref(msg);
1166
1167         return result;
1168 }
1169
1170
1171
1172
1173
1174
1175