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