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