client/tts_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 "tts_setting.h"
  16 #include "tts_main.h"
  17 #include "tts_setting_dbus.h"
  18
  19
  20 static DBusConnection* g_conn = NULL;
  21
  22 int tts_setting_dbus_open_connection()
  23 {
  24         if (NULL != g_conn) {
  25                 SLOG(LOG_WARN, TAG_TTSC, "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_TTSC, "Dbus Connection Error (%s)\n", err.message);
  40                 dbus_error_free(&err);
  41         }
  42
  43         if (NULL == g_conn) {
  44                 SLOG(LOG_ERROR, TAG_TTSC, "Fail to get dbus connection \n");
  45                 return TTS_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", TTS_SETTING_SERVICE_NAME, pid);
  53
  54         SLOG(LOG_DEBUG, TAG_TTSC, "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_TTSC, "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_TTSC, "[Dbus ERROR] fail to be primary owner \n");
  66                 return TTS_SETTING_ERROR_OPERATION_FAILED;
  67         }
  68
  69         return 0;
  70 }
  71
  72 int tts_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", TTS_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 int tts_setting_dbus_request_hello()
  93 {
  94         DBusMessage* msg;
  95
  96         msg = dbus_message_new_method_call(
  97                 TTS_SERVER_SERVICE_NAME,
  98                 TTS_SERVER_SERVICE_OBJECT_PATH,
  99                 TTS_SERVER_SERVICE_INTERFACE,
 100                 TTS_SETTING_METHOD_HELLO);
 101
 102         if (NULL == msg) {
 103                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request setting hello : Fail to make message \n");
 104                 return TTS_SETTING_ERROR_OPERATION_FAILED;
 105         }
 106
 107         DBusError err;
 108         dbus_error_init(&err);
 109
 110         DBusMessage* result_msg = NULL;
 111         int result = 0;
 112
 113         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 500, &err);
 114
 115         dbus_message_unref(msg);
 116
 117         if (NULL != result_msg) {
 118                 dbus_message_unref(result_msg);
 119
 120                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< setting hello");
 121                 result = 0;
 122         } else {
 123                 result = -1;
 124         }
 125
 126         return result;
 127 }
 128
 129 int tts_setting_dbus_request_initialize()
 130 {
 131         DBusMessage* msg;
 132
 133         msg = dbus_message_new_method_call(
 134                 TTS_SERVER_SERVICE_NAME,
 135                 TTS_SERVER_SERVICE_OBJECT_PATH,
 136                 TTS_SERVER_SERVICE_INTERFACE,
 137                 TTS_SETTING_METHOD_INITIALIZE);
 138
 139         if (NULL == msg) {
 140                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request setting initialize : Fail to make message \n");
 141                 return TTS_SETTING_ERROR_OPERATION_FAILED;
 142         } else {
 143                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request setting initialize");
 144         }
 145
 146         int pid = getpid();
 147
 148         dbus_message_append_args( msg,
 149                 DBUS_TYPE_INT32, &pid,
 150                 DBUS_TYPE_INVALID);
 151
 152         DBusError err;
 153         dbus_error_init(&err);
 154
 155         DBusMessage* result_msg;
 156         int result = TTS_SETTING_ERROR_OPERATION_FAILED;
 157
 158         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 3000, &err);
 159
 160         if (NULL != result_msg) {
 161                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 162
 163                 if (dbus_error_is_set(&err)) {
 164                         SLOG(LOG_ERROR, TAG_TTSC, "Get arguments error (%s)\n", err.message);
 165                         dbus_error_free(&err);
 166                         result = TTS_SETTING_ERROR_OPERATION_FAILED;
 167                 }
 168                 dbus_message_unref(result_msg);
 169         }
 170
 171         if (0 == result) {
 172                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< setting initialize : result = %d \n", result);
 173         } else {
 174                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< setting initialize : result = %d \n", result);
 175         }
 176
 177         dbus_message_unref(msg);
 178
 179         return result;
 180 }
 181
 182 int tts_setting_dbus_request_finalilze()
 183 {
 184         DBusMessage* msg;
 185
 186         msg = dbus_message_new_method_call(
 187                 TTS_SERVER_SERVICE_NAME,
 188                 TTS_SERVER_SERVICE_OBJECT_PATH,
 189                 TTS_SERVER_SERVICE_INTERFACE,
 190                 TTS_SETTING_METHOD_FINALIZE);
 191
 192         if (NULL == msg) {
 193                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request setting finalize : Fail to make message \n");
 194                 return TTS_SETTING_ERROR_OPERATION_FAILED;
 195         } else {
 196                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request setting finalize");
 197         }
 198
 199         int pid = getpid();
 200
 201         dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 202
 203         DBusError err;
 204         dbus_error_init(&err);
 205
 206         DBusMessage* result_msg;
 207         int result = 0;
 208
 209         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 3000, &err);
 210
 211         if (NULL != result_msg) {
 212                 dbus_message_get_args(result_msg, &err,
 213                         DBUS_TYPE_INT32, &result,
 214                         DBUS_TYPE_INVALID);
 215
 216                 if (dbus_error_is_set(&err)) {
 217                         SLOG(LOG_ERROR, TAG_TTSC, "Get arguments error (%s)\n", err.message);
 218                         dbus_error_free(&err);
 219                         result = TTS_SETTING_ERROR_OPERATION_FAILED;
 220                 }
 221                 dbus_message_unref(result_msg);
 222         }
 223
 224         if (0 == result) {
 225                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< setting finalize : result = %d \n", result);
 226         } else {
 227                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< setting finalize : result = %d \n", result);
 228         }
 229
 230         dbus_message_unref(msg);
 231
 232         return result;
 233 }
 234
 235 int tts_setting_dbus_request_get_engine_list(tts_setting_supported_engine_cb callback, void* user_data)
 236 {
 237         DBusMessage* msg;
 238
 239         msg = dbus_message_new_method_call(
 240                 TTS_SERVER_SERVICE_NAME,
 241                 TTS_SERVER_SERVICE_OBJECT_PATH,
 242                 TTS_SERVER_SERVICE_INTERFACE,
 243                 TTS_SETTING_METHOD_GET_ENGINE_LIST);
 244
 245         if (NULL == msg) {
 246                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request setting get engine list : Fail to make message \n");
 247                 return TTS_SETTING_ERROR_OPERATION_FAILED;
 248         } else {
 249                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request setting get engine list");
 250         }
 251
 252         int pid = getpid();
 253
 254         dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 255
 256         DBusError err;
 257         dbus_error_init(&err);
 258
 259         DBusMessage* result_msg;
 260         int result = TTS_SETTING_ERROR_OPERATION_FAILED;
 261
 262         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 3000, &err);
 263
 264         if (NULL != result_msg) {
 265                 DBusMessageIter args;
 266
 267                 if (dbus_message_iter_init(result_msg, &args)) {
 268                         /* Get result */
 269                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 270                                 dbus_message_iter_get_basic(&args, &result);
 271                                 dbus_message_iter_next(&args);
 272                         }
 273
 274                         if (0 == result) {
 275                                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< setting get engine list : result = %d \n", result);
 276
 277                                 int size ;
 278                                 char* temp_id;
 279                                 char* temp_name;
 280                                 char* temp_path;
 281
 282                                 /* Get engine count */
 283                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 284                                         dbus_message_iter_get_basic(&args, &size);
 285                                         dbus_message_iter_next(&args);
 286                                 }
 287
 288                                 int i=0;
 289                                 for (i=0 ; i<size ; i++) {
 290                                         dbus_message_iter_get_basic(&args, &(temp_id));
 291                                         dbus_message_iter_next(&args);
 292
 293                                         dbus_message_iter_get_basic(&args, &(temp_name));
 294                                         dbus_message_iter_next(&args);
 295
 296                                         dbus_message_iter_get_basic(&args, &(temp_path));
 297                                         dbus_message_iter_next(&args);
 298
 299                                         if (true != callback(temp_id, temp_name, temp_path, user_data)) {
 300                                                 break;
 301                                         }
 302                                 }
 303                         }  else {
 304                                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< setting get engine list : result = %d \n", result);
 305                         }
 306                 } else {
 307                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< setting get engine list : invalid message \n");
 308                 }
 309
 310                 dbus_message_unref(result_msg);
 311         } else {
 312                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< setting get engine list : result message is NULL!! \n");
 313         }
 314
 315         dbus_message_unref(msg);
 316
 317         return result;
 318 }
 319
 320 int tts_setting_dbus_request_get_engine(char** engine_id)
 321 {
 322         if (NULL == engine_id)  {
 323                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 324                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 325         }
 326
 327         DBusMessage* msg;
 328
 329         msg = dbus_message_new_method_call(
 330                 TTS_SERVER_SERVICE_NAME,
 331                 TTS_SERVER_SERVICE_OBJECT_PATH,
 332                 TTS_SERVER_SERVICE_INTERFACE,
 333                 TTS_SETTING_METHOD_GET_ENGINE);
 334
 335         if (NULL == msg) {
 336                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request setting get engine : Fail to make message \n");
 337                 return TTS_SETTING_ERROR_OPERATION_FAILED;
 338         } else {
 339                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request setting get engine ");
 340         }
 341
 342         int pid = getpid();
 343
 344         dbus_message_append_args( msg,
 345                 DBUS_TYPE_INT32, &pid,
 346                 DBUS_TYPE_INVALID);
 347
 348         DBusError err;
 349         dbus_error_init(&err);
 350
 351         DBusMessage* result_msg;
 352         int result = TTS_SETTING_ERROR_OPERATION_FAILED;
 353         char* temp;
 354
 355         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 3000, &err);
 356
 357         if (NULL != result_msg) {
 358                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_STRING, &temp, DBUS_TYPE_INVALID);
 359
 360                 if (dbus_error_is_set(&err)) {
 361                         SLOG(LOG_ERROR, TAG_TTSC, "Get arguments error (%s)\n", err.message);
 362                         dbus_error_free(&err);
 363                         result = TTS_SETTING_ERROR_OPERATION_FAILED;
 364                 }
 365                 dbus_message_unref(result_msg);
 366         }
 367
 368         if (0 == result) {
 369                 *engine_id = strdup(temp);
 370
 371                 if (NULL == *engine_id) {
 372                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< setting get engine : Out of memory \n");
 373                         result = TTS_SETTING_ERROR_OUT_OF_MEMORY;
 374                 } else {
 375                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< setting get engine : result(%d), engine id(%s)\n", result, *engine_id);
 376                 }
 377         } else {
 378                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< setting get engine : result(%d) \n", result);
 379         }
 380
 381         dbus_message_unref(msg);
 382
 383         return result;
 384 }
 385
 386
 387 int tts_setting_dbus_request_set_engine(const char* engine_id)
 388 {
 389         if (NULL == engine_id)  {
 390                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 391                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 392         }
 393
 394         DBusMessage* msg;
 395
 396         msg = dbus_message_new_method_call(
 397                 TTS_SERVER_SERVICE_NAME,
 398                 TTS_SERVER_SERVICE_OBJECT_PATH,
 399                 TTS_SERVER_SERVICE_INTERFACE,
 400                 TTS_SETTING_METHOD_SET_ENGINE);
 401
 402         if (NULL == msg) {
 403                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request setting set engine : Fail to make message \n");
 404                 return TTS_SETTING_ERROR_OPERATION_FAILED;
 405         } else {
 406                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request setting set engine : engine id(%s)", engine_id);
 407         }
 408
 409         int pid = getpid();
 410
 411         dbus_message_append_args( msg,
 412                 DBUS_TYPE_INT32, &pid,
 413                 DBUS_TYPE_STRING, &engine_id,
 414                 DBUS_TYPE_INVALID);
 415
 416         DBusError err;
 417         dbus_error_init(&err);
 418
 419         DBusMessage* result_msg;
 420         int result = TTS_SETTING_ERROR_OPERATION_FAILED;
 421
 422         result_msg = dbus_connection_send_with_reply_and_block  ( g_conn, msg, 3000, &err);
 423
 424         if (NULL != result_msg) {
 425                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 426
 427                 if (dbus_error_is_set(&err)) {
 428                         SLOG(LOG_ERROR, TAG_TTSC, "Get arguments error (%s)\n", err.message);
 429                         dbus_error_free(&err);
 430                         result = TTS_SETTING_ERROR_OPERATION_FAILED;
 431                 }
 432                 dbus_message_unref(result_msg);
 433         }
 434
 435         if (0 == result) {
 436                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< setting set engine : result(%d) \n", result);
 437         } else {
 438                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< setting set engine : result(%d) \n", result);
 439         }
 440
 441         dbus_message_unref(msg);
 442
 443         return result;
 444 }
 445
 446 int tts_setting_dbus_request_get_voice_list(tts_setting_supported_voice_cb callback, void* user_data)
 447 {
 448         if (NULL == callback) {
 449                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 450                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 451         }
 452
 453         DBusMessage* msg;
 454
 455         msg = dbus_message_new_method_call(
 456                 TTS_SERVER_SERVICE_NAME,
 457                 TTS_SERVER_SERVICE_OBJECT_PATH,
 458                 TTS_SERVER_SERVICE_INTERFACE,
 459                 TTS_SETTING_METHOD_GET_VOICE_LIST);
 460
 461         if (NULL == msg) {
 462                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request setting get voice list : Fail to make message \n");
 463                 return TTS_SETTING_ERROR_OPERATION_FAILED;
 464         } else {
 465                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request setting get voice list");
 466         }
 467
 468         int pid = getpid();
 469
 470         dbus_message_append_args( msg,
 471                 DBUS_TYPE_INT32, &pid,
 472                 DBUS_TYPE_INVALID);
 473
 474         DBusError err;
 475         dbus_error_init(&err);
 476
 477         DBusMessage* result_msg;
 478         int result = TTS_SETTING_ERROR_OPERATION_FAILED;
 479
 480         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 3000, &err);
 481
 482         DBusMessageIter args;
 483
 484         if (NULL != result_msg) {
 485                 if (dbus_message_iter_init(result_msg, &args)) {
 486                         /* Get result */
 487                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 488                                 dbus_message_iter_get_basic(&args, &result);
 489                                 dbus_message_iter_next(&args);
 490                         }
 491
 492                         if (0 == result) {
 493                                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< setting get voice list : result = %d \n", result);
 494
 495                                 int size = 0;
 496                                 char* temp_id = NULL;
 497                                 char* temp_lang = NULL;
 498                                 int temp_type;
 499
 500                                 /* Get current voice */
 501                                 dbus_message_iter_get_basic(&args, &temp_id);
 502                                 dbus_message_iter_next(&args);
 503
 504                                 if (NULL != temp_id) {
 505                                         /* Get voice count */
 506                                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 507                                                 dbus_message_iter_get_basic(&args, &size);
 508                                                 dbus_message_iter_next(&args);
 509                                         }
 510
 511                                         int i=0;
 512                                         for (i=0 ; i<size ; i++) {
 513                                                 dbus_message_iter_get_basic(&args, &(temp_lang) );
 514                                                 dbus_message_iter_next(&args);
 515
 516                                                 dbus_message_iter_get_basic(&args, &(temp_type) );
 517                                                 dbus_message_iter_next(&args);
 518
 519                                                 if (true != callback(temp_id, temp_lang, temp_type, user_data)) {
 520                                                         break;
 521                                                 }
 522                                         }
 523                                 } else {
 524                                         SLOG(LOG_ERROR, TAG_TTSC, "Engine ID is NULL \n");
 525                                         result = TTS_SETTING_ERROR_OPERATION_FAILED;
 526                                 }
 527
 528                         } else {
 529                                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< setting get voice list : result = %d \n", result);
 530                         }
 531                 }
 532
 533                 dbus_message_unref(result_msg);
 534         } else {
 535                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< setting get voice list : Result message is NULL!!");
 536         }
 537
 538         dbus_message_unref(msg);
 539
 540         return result;
 541 }
 542
 543 int tts_setting_dbus_request_get_default_voice(char** language, tts_setting_voice_type_e* voice_type)
 544 {
 545         if (NULL == language || NULL == voice_type) {
 546                 SLOG(LOG_ERROR, TAG_TTSC, "Input Parameter is NULL");
 547                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 548         }
 549
 550         DBusMessage* msg;
 551
 552         msg = dbus_message_new_method_call(
 553                 TTS_SERVER_SERVICE_NAME,
 554                 TTS_SERVER_SERVICE_OBJECT_PATH,
 555                 TTS_SERVER_SERVICE_INTERFACE,
 556                 TTS_SETTING_METHOD_GET_DEFAULT_VOICE);
 557
 558         if (NULL == msg) {
 559                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request setting get default voice : Fail to make message \n");
 560                 return TTS_SETTING_ERROR_OPERATION_FAILED;
 561         } else {
 562                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request setting get default voice");
 563         }
 564
 565         int pid = getpid();
 566
 567         dbus_message_append_args( msg,
 568                 DBUS_TYPE_INT32, &pid,
 569                 DBUS_TYPE_INVALID);
 570
 571         DBusError err;
 572         dbus_error_init(&err);
 573
 574         DBusMessage* result_msg;
 575         int result = TTS_SETTING_ERROR_OPERATION_FAILED;
 576         char* temp_char;
 577         int temp_int;
 578
 579         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 3000, &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_INT32, &temp_int,
 586                         DBUS_TYPE_INVALID);
 587
 588                 if (dbus_error_is_set(&err)) {
 589                         SLOG(LOG_ERROR, TAG_TTSC, "Get arguments error (%s)\n", err.message);
 590                         dbus_error_free(&err);
 591                         result = TTS_SETTING_ERROR_OPERATION_FAILED;
 592                 }
 593
 594                 dbus_message_unref(result_msg);
 595         }
 596
 597         if (0 == result) {
 598                 *language = strdup(temp_char);
 599                 *voice_type = (tts_setting_voice_type_e)temp_int;
 600
 601                 if (NULL == *language) {
 602                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< setting get default voice : Out of memory \n");
 603                         result = TTS_SETTING_ERROR_OUT_OF_MEMORY;
 604                 } else {
 605                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< setting get default voice : result(%d), lang(%s), vctype(%d) \n", result, *language, *voice_type);
 606                 }
 607         } else {
 608                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< setting get default voice : result(%d) \n", result);
 609         }
 610
 611         dbus_message_unref(msg);
 612
 613         return result;
 614 }
 615
 616 int tts_setting_dbus_request_set_default_voice(const char* language, const int voicetype )
 617 {
 618         if (NULL == language) {
 619                 SLOG(LOG_ERROR, TAG_TTSC, "Input Parameter is NULL");
 620                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 621         }
 622
 623         DBusMessage* msg;
 624
 625         msg = dbus_message_new_method_call(
 626                 TTS_SERVER_SERVICE_NAME,
 627                 TTS_SERVER_SERVICE_OBJECT_PATH,
 628                 TTS_SERVER_SERVICE_INTERFACE,
 629                 TTS_SETTING_METHOD_SET_DEFAULT_VOICE);
 630
 631         if (NULL == msg) {
 632                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request setting set default voice : Fail to make message \n");
 633                 return TTS_SETTING_ERROR_OPERATION_FAILED;
 634         } else {
 635                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request setting set default voice : language(%s), type(%d)", language, voicetype);
 636         }
 637
 638         int pid = getpid();
 639
 640         dbus_message_append_args( msg,
 641                 DBUS_TYPE_INT32, &pid,
 642                 DBUS_TYPE_STRING, &language,
 643                 DBUS_TYPE_INT32, &voicetype,
 644                 DBUS_TYPE_INVALID);
 645
 646         DBusError err;
 647         dbus_error_init(&err);
 648
 649         DBusMessage* result_msg;
 650         int result = TTS_SETTING_ERROR_OPERATION_FAILED;
 651
 652         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 3000, &err);
 653
 654         if (NULL != result_msg) {
 655                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 656
 657                 if (dbus_error_is_set(&err)) {
 658                         SLOG(LOG_ERROR, TAG_TTSC, "Get arguments error (%s)\n", err.message);
 659                         dbus_error_free(&err);
 660                         result = TTS_SETTING_ERROR_OPERATION_FAILED;
 661                 }
 662                 dbus_message_unref(result_msg);
 663         }
 664
 665         if (0 == result) {
 666                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< setting set default voice : result(%d)", result);
 667         } else {
 668                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< setting set default voice : result(%d)", result);
 669         }
 670
 671         dbus_message_unref(msg);
 672
 673         return result;
 674 }
 675
 676 int tts_setting_dbus_request_get_default_speed(int* speed)
 677 {
 678         if (NULL == speed) {
 679                 SLOG(LOG_ERROR, TAG_TTSC, "Input Parameter is NULL");
 680                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 681         }
 682
 683         DBusMessage* msg;
 684
 685         msg = dbus_message_new_method_call(
 686                 TTS_SERVER_SERVICE_NAME,
 687                 TTS_SERVER_SERVICE_OBJECT_PATH,
 688                 TTS_SERVER_SERVICE_INTERFACE,
 689                 TTS_SETTING_METHOD_GET_DEFAULT_SPEED);
 690
 691         if (NULL == msg) {
 692                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request setting get default speed : Fail to make message \n");
 693                 return TTS_SETTING_ERROR_OPERATION_FAILED;
 694         } else {
 695                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request setting get default speed ");
 696         }
 697
 698         int pid = getpid();
 699
 700         dbus_message_append_args( msg,
 701                 DBUS_TYPE_INT32, &pid,
 702                 DBUS_TYPE_INVALID);
 703
 704         DBusError err;
 705         dbus_error_init(&err);
 706
 707         DBusMessage* result_msg;
 708         int temp_int;
 709         int result = TTS_SETTING_ERROR_OPERATION_FAILED;
 710
 711         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 3000, &err);
 712
 713         if (NULL != result_msg) {
 714                 dbus_message_get_args(result_msg, &err,
 715                         DBUS_TYPE_INT32, &result,
 716                         DBUS_TYPE_INT32, &temp_int,
 717                         DBUS_TYPE_INVALID);
 718
 719                 if (dbus_error_is_set(&err)) {
 720                         SLOG(LOG_ERROR, TAG_TTSC, "Get arguments error (%s)\n", err.message);
 721                         dbus_error_free(&err);
 722                         result = TTS_SETTING_ERROR_OPERATION_FAILED;
 723                 }
 724                 dbus_message_unref(result_msg);
 725         }
 726
 727         if (0 == result) {
 728                 *speed = temp_int;
 729                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< setting get default speed : result(%d), speed(%d)", result, *speed);
 730         } else {
 731                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< setting get default speed : result(%d)", result);
 732         }
 733
 734         dbus_message_unref(msg);
 735
 736         return result;
 737 }
 738
 739 int tts_setting_dbus_request_set_default_speed(const int speed)
 740 {
 741         DBusMessage* msg;
 742
 743         msg = dbus_message_new_method_call(
 744                 TTS_SERVER_SERVICE_NAME,
 745                 TTS_SERVER_SERVICE_OBJECT_PATH,
 746                 TTS_SERVER_SERVICE_INTERFACE,
 747                 TTS_SETTING_METHOD_SET_DEFAULT_SPEED);
 748
 749         if (NULL == msg) {
 750                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request setting set default speed : Fail to make message \n");
 751                 return TTS_SETTING_ERROR_OPERATION_FAILED;
 752         } else {
 753                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request setting set default speed : speed(%d)", speed);
 754         }
 755
 756         int pid = getpid();
 757
 758         dbus_message_append_args(msg,
 759                 DBUS_TYPE_INT32, &pid,
 760                 DBUS_TYPE_INT32, &speed,
 761                 DBUS_TYPE_INVALID);
 762
 763         DBusError err;
 764         dbus_error_init(&err);
 765
 766         DBusMessage* result_msg;
 767         int result = TTS_SETTING_ERROR_OPERATION_FAILED;
 768         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 3000, &err);
 769
 770         if (NULL != result_msg) {
 771                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 772
 773                 if (dbus_error_is_set(&err)) {
 774                         SLOG(LOG_ERROR, TAG_TTSC, "Get arguments error (%s)\n", err.message);
 775                         dbus_error_free(&err);
 776                         result = TTS_SETTING_ERROR_OPERATION_FAILED;
 777                 }
 778                 dbus_message_unref(result_msg);
 779         }
 780
 781         if (0 == result) {
 782                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< setting set default speed : result(%d)", result);
 783         } else {
 784                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< setting set default speed : result(%d)", result);
 785         }
 786
 787         dbus_message_unref(msg);
 788
 789         return result;
 790 }
 791
 792 int tts_setting_dbus_request_get_engine_setting(tts_setting_engine_setting_cb callback, void* user_data)
 793 {
 794         if (NULL == callback) {
 795                 SLOG(LOG_ERROR, TAG_TTSC, "Input Parameter is NULL");
 796                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 797         }
 798
 799         DBusMessage* msg;
 800
 801         msg = dbus_message_new_method_call(
 802                    TTS_SERVER_SERVICE_NAME,
 803                    TTS_SERVER_SERVICE_OBJECT_PATH,
 804                    TTS_SERVER_SERVICE_INTERFACE,
 805                    TTS_SETTING_METHOD_GET_ENGINE_SETTING);
 806
 807         if (NULL == msg) {
 808                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request setting get engine setting : Fail to make message \n");
 809                 return TTS_SETTING_ERROR_OPERATION_FAILED;
 810         } else {
 811                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request setting get engine setting");
 812         }
 813
 814         int pid = getpid();
 815
 816         dbus_message_append_args( msg,
 817                 DBUS_TYPE_INT32, &pid,
 818                 DBUS_TYPE_INVALID);
 819
 820         DBusError err;
 821         dbus_error_init(&err);
 822
 823         DBusMessage* result_msg;
 824         int result = TTS_SETTING_ERROR_OPERATION_FAILED;
 825
 826         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 3000, &err);
 827
 828         if (NULL != result_msg) {
 829                 DBusMessageIter args;
 830
 831                 if (dbus_message_iter_init(result_msg, &args)) {
 832                         /* Get result */
 833                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 834                                 dbus_message_iter_get_basic(&args, &result);
 835                                 dbus_message_iter_next(&args);
 836                         }
 837
 838                         if (0 == result) {
 839                                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< get engine setting : result = %d \n", result);
 840                                 int size;
 841                                 char* temp_id = NULL;
 842                                 char* temp_key;
 843                                 char* temp_value;
 844
 845                                 /* Get engine id */
 846                                 dbus_message_iter_get_basic(&args, &temp_id);
 847                                 dbus_message_iter_next(&args);
 848
 849                                 if (NULL != temp_id) {
 850                                         /* Get setting count */
 851                                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 852                                                 dbus_message_iter_get_basic(&args, &size);
 853                                                 dbus_message_iter_next(&args);
 854                                         }
 855
 856                                         int i=0;
 857                                         for (i=0 ; i<size ; i++) {
 858                                                 dbus_message_iter_get_basic(&args, &(temp_key) );
 859                                                 dbus_message_iter_next(&args);
 860
 861                                                 dbus_message_iter_get_basic(&args, &(temp_value) );
 862                                                 dbus_message_iter_next(&args);
 863
 864                                                 if (true != callback(temp_id, temp_key, temp_value, user_data)) {
 865                                                         break;
 866                                                 }
 867                                         }
 868                                 } else {
 869                                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< get engine setting : result message is invalid \n");
 870                                         result = TTS_SETTING_ERROR_OPERATION_FAILED;
 871                                 }
 872                         }
 873                 } else {
 874                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< get engine setting : result message is invalid \n");
 875                         result = TTS_SETTING_ERROR_OPERATION_FAILED;
 876                 }
 877
 878                 dbus_message_unref(result_msg);
 879         } else {
 880                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< get engine setting : Result message is NULL!! \n");
 881         }
 882
 883         dbus_message_unref(msg);
 884
 885         return result;
 886 }
 887
 888 int tts_setting_dbus_request_set_engine_setting(const char* key, const char* value)
 889 {
 890         if (NULL == key || NULL == value) {
 891                 SLOG(LOG_ERROR, TAG_TTSC, "Input Parameter is NULL");
 892                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 893         }
 894
 895         DBusMessage* msg;
 896
 897         msg = dbus_message_new_method_call(
 898                 TTS_SERVER_SERVICE_NAME,
 899                 TTS_SERVER_SERVICE_OBJECT_PATH,
 900                 TTS_SERVER_SERVICE_INTERFACE,
 901                 TTS_SETTING_METHOD_SET_ENGINE_SETTING);
 902
 903         if (NULL == msg) {
 904                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request setting set engine setting : Fail to make message \n");
 905                 return TTS_SETTING_ERROR_OPERATION_FAILED;
 906         } else {
 907                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request setting set engine setting : key(%s), value(%s)", key, value);
 908         }
 909
 910         int pid = getpid();
 911
 912         dbus_message_append_args( msg,
 913                 DBUS_TYPE_INT32, &pid,
 914                 DBUS_TYPE_STRING, &key,
 915                 DBUS_TYPE_STRING, &value,
 916                 DBUS_TYPE_INVALID);
 917
 918         DBusError err;
 919         dbus_error_init(&err);
 920
 921         DBusMessage* result_msg;
 922         int result = TTS_SETTING_ERROR_OPERATION_FAILED;
 923
 924         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 3000, &err);
 925
 926         if (NULL != result_msg) {
 927                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 928
 929                 if (dbus_error_is_set(&err)) {
 930                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)\n", err.message);
 931                         dbus_error_free(&err);
 932                         result = -1;
 933                 }
 934                 dbus_message_unref(result_msg);
 935         }
 936
 937         if (0 == result) {
 938                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< setting set engine setting : result(%d)", result);
 939         } else {
 940                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< setting set engine setting : result(%d)", result);
 941         }
 942
 943         dbus_message_unref(msg);
 944
 945         return result;
 946 }
 947