server/ttsd_dbus_server.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 "ttsd_main.h"
  16 #include "ttsd_dbus.h"
  17 #include "ttsd_dbus_server.h"
  18 #include "ttsd_server.h"
  19
  20 extern int ttsd_data_get_pid(const int uid);
  21
  22 /*
  23 * Dbus Client-Daemon Server
  24 */
  25
  26 int ttsd_dbus_server_hello(DBusConnection* conn, DBusMessage* msg)
  27 {
  28         SLOG(LOG_DEBUG, get_tag(), ">>>>> TTS Hello");
  29
  30         DBusMessage* reply;
  31         reply = dbus_message_new_method_return(msg);
  32
  33         if (NULL != reply) {
  34                 if (!dbus_connection_send(conn, reply, NULL)) {
  35                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] Out Of Memory!");
  36                 }
  37
  38                 dbus_connection_flush(conn);
  39                 dbus_message_unref(reply);
  40         } else {
  41                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] Fail to create reply message!!");
  42         }
  43
  44         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
  45         SLOG(LOG_DEBUG, get_tag(), "  ");
  46
  47         return 0;
  48 }
  49
  50 int ttsd_dbus_server_initialize(DBusConnection* conn, DBusMessage* msg)
  51 {
  52         DBusError err;
  53         dbus_error_init(&err);
  54
  55         int pid, uid;
  56         int ret = 0;
  57
  58         dbus_message_get_args(msg, &err,
  59                 DBUS_TYPE_INT32, &pid,
  60                 DBUS_TYPE_INT32, &uid,
  61                 DBUS_TYPE_INVALID);
  62
  63         SLOG(LOG_DEBUG, get_tag(), ">>>>> TTS INITIALIZE");
  64
  65         if (dbus_error_is_set(&err)) {
  66                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] tts initialize : get arguments error (%s)\n", err.message);
  67                 dbus_error_free(&err);
  68                 ret = TTSD_ERROR_OPERATION_FAILED;
  69         } else {
  70
  71                 SLOG(LOG_DEBUG, get_tag(), "[IN] tts initialize : pid(%d), uid(%d) \n", pid , uid);
  72                 ret =  ttsd_server_initialize(pid, uid);
  73         }
  74
  75         DBusMessage* reply;
  76         reply = dbus_message_new_method_return(msg);
  77
  78         if (NULL != reply) {
  79                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
  80
  81                 if (0 == ret) {
  82                         SLOG(LOG_DEBUG, get_tag(), "[OUT] tts initialize : result(%d) \n", ret);
  83                 } else {
  84                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts initialize : result(%d) \n", ret);
  85                 }
  86
  87                 if (!dbus_connection_send(conn, reply, NULL)) {
  88                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts initialize : Out Of Memory!\n");
  89                 }
  90
  91                 dbus_connection_flush(conn);
  92                 dbus_message_unref(reply);
  93         } else {
  94                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts initialize : fail to create reply message!!");
  95         }
  96
  97         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
  98         SLOG(LOG_DEBUG, get_tag(), "  ");
  99
 100         return 0;
 101 }
 102
 103 int ttsd_dbus_server_finalize(DBusConnection* conn, DBusMessage* msg)
 104 {
 105         DBusError err;
 106         dbus_error_init(&err);
 107
 108         int uid;
 109         int ret = 0;
 110
 111         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 112
 113         SLOG(LOG_DEBUG, get_tag(), ">>>>> TTS FINALIZE");
 114
 115         if (dbus_error_is_set(&err)) {
 116                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] tts finalize : get arguments error (%s)\n", err.message);
 117                 dbus_error_free(&err);
 118                 ret = TTSD_ERROR_OPERATION_FAILED;
 119         } else {
 120
 121                 SLOG(LOG_DEBUG, get_tag(), "[IN] tts finalize : uid(%d) \n", uid);
 122
 123                 ret =  ttsd_server_finalize(uid);
 124         }
 125
 126         DBusMessage* reply;
 127         reply = dbus_message_new_method_return(msg);
 128
 129         if (NULL != reply) {
 130                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 131
 132                 if (0 == ret) {
 133                         SLOG(LOG_DEBUG, get_tag(), "[OUT] tts finalize : result(%d) \n", ret);
 134                 } else {
 135                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts finalize : result(%d) \n", ret);
 136                 }
 137
 138                 if (!dbus_connection_send(conn, reply, NULL)) {
 139                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts finalize : Out Of Memory!\n");
 140                 }
 141
 142                 dbus_connection_flush(conn);
 143                 dbus_message_unref(reply);
 144         } else {
 145                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts finalize : fail to create reply message!!");
 146         }
 147
 148         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 149         SLOG(LOG_DEBUG, get_tag(), "  ");
 150
 151         return 0;
 152 }
 153
 154 int ttsd_dbus_server_get_support_voices(DBusConnection* conn, DBusMessage* msg)
 155 {
 156         DBusError err;
 157         dbus_error_init(&err);
 158
 159         int uid;
 160         int ret = 0;
 161         GList* voice_list = NULL;
 162
 163         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 164
 165         SLOG(LOG_DEBUG, get_tag(), ">>>>> TTS GET VOICES");
 166
 167         if (dbus_error_is_set(&err)) {
 168                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] tts get supported voices : get arguments error (%s)\n", err.message);
 169                 dbus_error_free(&err);
 170                 ret = TTSD_ERROR_OPERATION_FAILED;
 171         } else {
 172                 SLOG(LOG_DEBUG, get_tag(), "[IN] get supported voices : uid(%d) \n", uid );
 173                 ret = ttsd_server_get_support_voices(uid, &voice_list);
 174         }
 175
 176         DBusMessage* reply;
 177         reply = dbus_message_new_method_return(msg);
 178
 179         if (NULL != reply) {
 180                 DBusMessageIter args;
 181                 dbus_message_iter_init_append(reply, &args);
 182
 183                 /* Append result*/
 184                 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret));
 185
 186                 if (0 == ret) {
 187                         /* Append voice size */
 188                         int size = g_list_length(voice_list);
 189
 190                         if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
 191                                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts supported voices : Fail to append type \n");
 192                                 ret = TTSD_ERROR_OPERATION_FAILED;
 193                         } else {
 194
 195                                 GList *iter = NULL;
 196                                 voice_s* voice;
 197
 198                                 iter = g_list_first(voice_list);
 199
 200                                 while (NULL != iter) {
 201                                         voice = iter->data;
 202
 203                                         if (NULL != voice) {
 204                                                 dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(voice->language) );
 205                                                 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(voice->type) );
 206
 207                                                 if (NULL != voice->language)
 208                                                         g_free(voice->language);
 209
 210                                                 g_free(voice);
 211                                         }
 212
 213                                         voice_list = g_list_remove_link(voice_list, iter);
 214
 215                                         iter = g_list_first(voice_list);
 216                                 }
 217                         }
 218                         SLOG(LOG_DEBUG, get_tag(), "[OUT] tts supported voices : result(%d) \n", ret);
 219                 } else {
 220                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts supported voices : result(%d) \n", ret);
 221                 }
 222
 223                 if (!dbus_connection_send(conn, reply, NULL)) {
 224                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] error : Out Of Memory!\n");
 225                 }
 226
 227                 dbus_connection_flush(conn);
 228                 dbus_message_unref(reply);
 229         } else {
 230                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts supported voices : fail to create reply message!!");
 231         }
 232
 233         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 234         SLOG(LOG_DEBUG, get_tag(), "  ");
 235
 236         return 0;
 237 }
 238
 239 int ttsd_dbus_server_get_current_voice(DBusConnection* conn, DBusMessage* msg)
 240 {
 241         DBusError err;
 242         dbus_error_init(&err);
 243
 244         int uid;
 245         char* lang;
 246         int voice_type;
 247         int ret;
 248
 249         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 250
 251         SLOG(LOG_DEBUG, get_tag(), ">>>>> TTS GET DEFAULT VOICE");
 252
 253         if (dbus_error_is_set(&err)) {
 254                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] tts get default voice : Get arguments error (%s)\n", err.message);
 255                 dbus_error_free(&err);
 256                 ret = TTSD_ERROR_OPERATION_FAILED;
 257         } else {
 258                 SLOG(LOG_DEBUG, get_tag(), "[IN] tts get default voice : uid(%d) \n", uid);
 259                 ret = ttsd_server_get_current_voice(uid, &lang, &voice_type);
 260         }
 261
 262         DBusMessage* reply;
 263         reply = dbus_message_new_method_return(msg);
 264
 265         if (NULL != reply) {
 266                 if (0 == ret) {
 267                         /* Append result and voice */
 268                         dbus_message_append_args( reply,
 269                                 DBUS_TYPE_INT32, &ret,
 270                                 DBUS_TYPE_STRING, &lang,
 271                                 DBUS_TYPE_INT32, &voice_type,
 272                                 DBUS_TYPE_INVALID);
 273                         SLOG(LOG_DEBUG, get_tag(), "[OUT] tts default voice : lang(%s), vctype(%d)\n", lang, voice_type );
 274                 } else {
 275                         dbus_message_append_args( reply,
 276                                 DBUS_TYPE_INT32, &ret,
 277                                 DBUS_TYPE_INVALID);
 278                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts default voice : result(%d) \n", ret);
 279                 }
 280
 281                 if (!dbus_connection_send(conn, reply, NULL)) {
 282                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts default voice : Out Of Memory!\n");
 283                 }
 284
 285                 dbus_connection_flush(conn);
 286                 dbus_message_unref(reply);
 287         } else {
 288                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts default voice : fail to create reply message!!");
 289         }
 290
 291         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 292         SLOG(LOG_DEBUG, get_tag(), "  ");
 293
 294         return 0;
 295 }
 296
 297 int ttsd_dbus_server_add_text(DBusConnection* conn, DBusMessage* msg)
 298 {
 299         DBusError err;
 300         dbus_error_init(&err);
 301
 302         int uid, voicetype, speed, uttid;
 303         char *text, *lang;
 304         int ret = 0;
 305
 306         dbus_message_get_args(msg, &err,
 307                 DBUS_TYPE_INT32, &uid,
 308                 DBUS_TYPE_STRING, &text,
 309                 DBUS_TYPE_STRING, &lang,
 310                 DBUS_TYPE_INT32, &voicetype,
 311                 DBUS_TYPE_INT32, &speed,
 312                 DBUS_TYPE_INT32, &uttid,
 313                 DBUS_TYPE_INVALID);
 314
 315         SLOG(LOG_DEBUG, get_tag(), ">>>>> TTS ADD TEXT");
 316
 317         if (dbus_error_is_set(&err)) {
 318                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] tts add text : Get arguments error (%s)\n", err.message);
 319                 dbus_error_free(&err);
 320                 ret = TTSD_ERROR_OPERATION_FAILED;
 321         } else {
 322
 323                 SLOG(LOG_DEBUG, get_tag(), "[IN] tts add text : uid(%d), text(%s), lang(%s), type(%d), speed(%d), uttid(%d) \n",
 324                         uid, text, lang, voicetype, speed, uttid);
 325                 ret =  ttsd_server_add_queue(uid, text, lang, voicetype, speed, uttid);
 326         }
 327
 328         DBusMessage* reply;
 329         reply = dbus_message_new_method_return(msg);
 330
 331         if (NULL != reply) {
 332                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 333
 334                 if (0 == ret) {
 335                         SLOG(LOG_DEBUG, get_tag(), "[OUT] tts add text : result(%d) \n", ret);
 336                 } else {
 337                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts add text : result(%d) \n", ret);
 338                 }
 339
 340                 if (!dbus_connection_send(conn, reply, NULL)) {
 341                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts add text : Out Of Memory!\n");
 342                 }
 343
 344                 dbus_connection_flush(conn);
 345                 dbus_message_unref(reply);
 346         } else {
 347                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts add text : fail to create reply message!!");
 348         }
 349
 350         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 351         SLOG(LOG_DEBUG, get_tag(), "  ");
 352
 353         return 0;
 354 }
 355
 356 int ttsd_dbus_server_play(DBusConnection* conn, DBusMessage* msg)
 357 {
 358         DBusError err;
 359         dbus_error_init(&err);
 360
 361         int uid;
 362         int ret = 0;
 363
 364         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 365
 366         SLOG(LOG_DEBUG, get_tag(), ">>>>> TTS PLAY");
 367
 368         if (dbus_error_is_set(&err)) {
 369                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] tts play : Get arguments error (%s)\n", err.message);
 370                 dbus_error_free(&err);
 371                 ret = TTSD_ERROR_OPERATION_FAILED;
 372         } else {
 373                 SLOG(LOG_DEBUG, get_tag(), "[IN] tts play : uid(%d) \n", uid );
 374                 ret =  ttsd_server_play(uid);
 375         }
 376
 377         DBusMessage* reply;
 378         reply = dbus_message_new_method_return(msg);
 379
 380         if (NULL != reply) {
 381                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 382
 383                 if (0 == ret) {
 384                         SLOG(LOG_DEBUG, get_tag(), "[OUT] tts play : result(%d) \n", ret);
 385                 } else {
 386                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts play : result(%d) \n", ret);
 387                 }
 388
 389                 if (!dbus_connection_send(conn, reply, NULL)) {
 390                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts play : Out Of Memory!\n");
 391                 }
 392
 393                 dbus_connection_flush(conn);
 394                 dbus_message_unref(reply);
 395         } else {
 396                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts play : fail to create reply message!!");
 397         }
 398
 399         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 400         SLOG(LOG_DEBUG, get_tag(), "  ");
 401
 402         return 0;
 403 }
 404
 405 int ttsd_dbus_server_stop(DBusConnection* conn, DBusMessage* msg)
 406 {
 407         DBusError err;
 408         dbus_error_init(&err);
 409
 410         int uid;
 411         int ret = 0;
 412         dbus_message_get_args(msg, &err,
 413                 DBUS_TYPE_INT32, &uid,
 414                 DBUS_TYPE_INVALID);
 415
 416         SLOG(LOG_DEBUG, get_tag(), ">>>>> TTS STOP");
 417
 418         if (dbus_error_is_set(&err)) {
 419                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] tts stop : Get arguments error (%s)\n", err.message);
 420                 dbus_error_free(&err);
 421                 ret = TTSD_ERROR_OPERATION_FAILED;
 422         } else {
 423                 SLOG(LOG_DEBUG, get_tag(), "[IN] tts stop : uid(%d)\n", uid);
 424                 ret = ttsd_server_stop(uid);
 425         }
 426
 427         DBusMessage* reply;
 428         reply = dbus_message_new_method_return(msg);
 429
 430         if (NULL != reply) {
 431                 dbus_message_append_args(reply,
 432                         DBUS_TYPE_INT32, &ret,
 433                         DBUS_TYPE_INVALID);
 434
 435                 if (0 == ret) {
 436                         SLOG(LOG_DEBUG, get_tag(), "[OUT] tts stop : result(%d) \n", ret);
 437                 } else {
 438                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts stop : result(%d) \n", ret);
 439                 }
 440
 441                 if (!dbus_connection_send(conn, reply, NULL)) {
 442                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts stop : Out Of Memory!\n");
 443                 }
 444
 445                 dbus_connection_flush(conn);
 446                 dbus_message_unref(reply);
 447         } else {
 448                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts stop : fail to create reply message!!");
 449         }
 450
 451         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 452         SLOG(LOG_DEBUG, get_tag(), "  ");
 453
 454         return 0;
 455 }
 456
 457 int ttsd_dbus_server_pause(DBusConnection* conn, DBusMessage* msg)
 458 {
 459         DBusError err;
 460         dbus_error_init(&err);
 461
 462         int uid;
 463         int uttid;
 464         int ret = 0;
 465         dbus_message_get_args(msg, &err,
 466                 DBUS_TYPE_INT32, &uid,
 467                 DBUS_TYPE_INVALID);
 468
 469         SLOG(LOG_DEBUG, get_tag(), ">>>>> TTS PAUSE");
 470
 471         if (dbus_error_is_set(&err)) {
 472                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] tts pause : Get arguments error (%s)\n", err.message);
 473                 dbus_error_free(&err);
 474                 ret = TTSD_ERROR_OPERATION_FAILED;
 475         } else {
 476                 SLOG(LOG_DEBUG, get_tag(), "[IN] tts pause : uid(%d)\n", uid);
 477                 ret = ttsd_server_pause(uid, &uttid);
 478         }
 479
 480         DBusMessage* reply;
 481         reply = dbus_message_new_method_return(msg);
 482
 483         if (NULL != reply) {
 484                 dbus_message_append_args(reply,
 485                         DBUS_TYPE_INT32, &ret,
 486                         DBUS_TYPE_INVALID);
 487
 488                 if (0 == ret) {
 489                         SLOG(LOG_DEBUG, get_tag(), "[OUT] tts pause : result(%d) \n", ret);
 490                 } else {
 491                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts pause : result(%d) \n", ret);
 492                 }
 493
 494                 if (!dbus_connection_send(conn, reply, NULL)) {
 495                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts pause : Out Of Memory!\n");
 496                 }
 497
 498                 dbus_connection_flush(conn);
 499                 dbus_message_unref(reply);
 500         } else {
 501                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts pause : fail to create reply message!!");
 502         }
 503
 504         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 505         SLOG(LOG_DEBUG, get_tag(), "  ");
 506
 507         return 0;
 508 }
 509
 510 #if 0
 511 /*
 512 * Dbus Server functions for tts daemon internal
 513 */
 514 int ttsd_dbus_server_start_next_synthesis()
 515 {
 516         return ttsd_server_start_next_synthesis();
 517 }
 518 #endif
 519
 520 /*
 521 * Dbus Setting-Daemon Server
 522 */
 523
 524 int ttsd_dbus_server_setting_initialize(DBusConnection* conn, DBusMessage* msg)
 525 {
 526         DBusError err;
 527         dbus_error_init(&err);
 528
 529         int pid;
 530         int ret = 0;
 531
 532         dbus_message_get_args(msg, &err,
 533                 DBUS_TYPE_INT32, &pid,
 534                 DBUS_TYPE_INVALID);
 535
 536         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING INITIALIZE");
 537
 538         if (dbus_error_is_set(&err)) {
 539                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] Receivce setting initialize : Get arguments error (%s)\n", err.message);
 540                 dbus_error_free(&err);
 541                 ret = TTSD_ERROR_OPERATION_FAILED;
 542         } else {
 543                 SLOG(LOG_DEBUG, get_tag(), "[IN] Receivce setting initialize : pid(%d) \n", pid);
 544                 ret =  ttsd_server_setting_initialize(pid);
 545         }
 546
 547         DBusMessage* reply;
 548         reply = dbus_message_new_method_return(msg);
 549
 550         if (NULL != reply) {
 551                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 552
 553                 if (0 == ret) {
 554                         SLOG(LOG_DEBUG, get_tag(), "[OUT] setting initialize : result(%d) \n", ret);
 555                 } else {
 556                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting initialize : result(%d) \n", ret);
 557                 }
 558
 559                 if (!dbus_connection_send(conn, reply, NULL)) {
 560                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting initialize : Out Of Memory!\n");
 561                 }
 562
 563                 dbus_connection_flush(conn);
 564                 dbus_message_unref(reply);
 565         } else {
 566                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting initialize : fail to create reply message!!");
 567         }
 568
 569         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 570         SLOG(LOG_DEBUG, get_tag(), "  ");
 571
 572         return 0;
 573 }
 574
 575 int ttsd_dbus_server_setting_finalize(DBusConnection* conn, DBusMessage* msg)
 576 {
 577         DBusError err;
 578         dbus_error_init(&err);
 579
 580         int pid;
 581         int ret = 0;
 582
 583         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 584
 585         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING FINALIZE");
 586
 587         if (dbus_error_is_set(&err)) {
 588                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting finalize : Get arguments error (%s)\n", err.message);
 589                 dbus_error_free(&err);
 590                 ret = TTSD_ERROR_OPERATION_FAILED;
 591         } else {
 592                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting finalize : pid(%d)\n", pid);
 593                 ret =  ttsd_server_setting_finalize(pid);
 594         }
 595
 596         DBusMessage* reply;
 597         reply = dbus_message_new_method_return(msg);
 598
 599         if (NULL != reply) {
 600                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 601
 602                 if (0 == ret) {
 603                         SLOG(LOG_DEBUG, get_tag(), "[OUT] setting finalize : result(%d) \n", ret);
 604                 } else {
 605                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting finalize : result(%d) \n", ret);
 606                 }
 607
 608                 if (!dbus_connection_send(conn, reply, NULL)) {
 609                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting finalize : Out Of Memory!\n");
 610                 }
 611
 612                 dbus_connection_flush(conn);
 613                 dbus_message_unref(reply);
 614         } else {
 615                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting finalize : fail to create reply message!!");
 616         }
 617
 618         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 619         SLOG(LOG_DEBUG, get_tag(), "  ");
 620
 621         return 0;
 622 }
 623
 624 int ttsd_dbus_server_setting_get_engine_list(DBusConnection* conn, DBusMessage* msg)
 625 {
 626         DBusError err;
 627         dbus_error_init(&err);
 628
 629         int pid;
 630         int ret = 0;
 631         GList* engine_list = NULL;
 632
 633         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 634
 635         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING GET ENGINE LIST");
 636
 637         if (dbus_error_is_set(&err)) {
 638                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting engine list : Get arguments error (%s)\n", err.message);
 639                 dbus_error_free(&err);
 640                 ret = TTSD_ERROR_OPERATION_FAILED;
 641         } else {
 642                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting engine list : pid(%d) \n", pid);
 643                 ret = ttsd_server_setting_get_engine_list(pid, &engine_list);
 644         }
 645
 646         DBusMessage* reply;
 647         reply = dbus_message_new_method_return(msg);
 648
 649         if (NULL != reply) {
 650                 DBusMessageIter args;
 651                 dbus_message_iter_init_append(reply, &args);
 652
 653                 /* Append result*/
 654                 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret) );
 655
 656                 if (0 == ret) {
 657                         /* Append size */
 658                         int size = g_list_length(engine_list);
 659                         if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
 660                                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting engine list : fail to append engine size \n");
 661                         } else {
 662
 663                                 GList *iter = NULL;
 664                                 engine_s* engine;
 665
 666                                 iter = g_list_first(engine_list);
 667
 668                                 while (NULL != iter) {
 669                                         engine = iter->data;
 670
 671                                         if (NULL != engine) {
 672                                                 SLOG(LOG_DEBUG, get_tag(), "engine id : %s, engine name : %s, ug_name, : %s",
 673                                                         engine->engine_id, engine->engine_name, engine->ug_name);
 674
 675                                                 dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->engine_id) );
 676                                                 dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->engine_name) );
 677                                                 dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->ug_name) );
 678
 679                                                 if (NULL != engine->engine_id)
 680                                                         g_free(engine->engine_id);
 681                                                 if (NULL != engine->engine_name)
 682                                                         g_free(engine->engine_name);
 683                                                 if (NULL != engine->ug_name)
 684                                                         g_free(engine->ug_name);
 685
 686                                                 g_free(engine);
 687                                         }
 688
 689                                         engine_list = g_list_remove_link(engine_list, iter);
 690
 691                                         iter = g_list_first(engine_list);
 692                                 }
 693                                 SLOG(LOG_DEBUG, get_tag(), "[OUT] setting engine list : result(%d) \n", ret);
 694                         }
 695                 } else {
 696                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting engine list : result(%d) \n", ret);
 697                 }
 698
 699                 if (!dbus_connection_send(conn, reply, NULL)) {
 700                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting engine list : Out Of Memory!\n");
 701                 }
 702
 703                 dbus_connection_flush(conn);
 704                 dbus_message_unref(reply);
 705         } else {
 706                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting engine list : fail to create reply message!!");
 707         }
 708
 709         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 710         SLOG(LOG_DEBUG, get_tag(), "  ");
 711
 712         return 0;
 713 }
 714
 715 int ttsd_dbus_server_setting_get_engine(DBusConnection* conn, DBusMessage* msg)
 716 {
 717         DBusError err;
 718         dbus_error_init(&err);
 719
 720         int pid;
 721         int ret = 0;
 722         char* engine_id = NULL;
 723
 724         dbus_message_get_args(msg, &err,
 725                 DBUS_TYPE_INT32, &pid,
 726                 DBUS_TYPE_INVALID);
 727
 728         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING GET ENGINE");
 729
 730         if (dbus_error_is_set(&err)) {
 731                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting get engine : Get arguments error (%s)\n", err.message);
 732                 dbus_error_free(&err);
 733                 ret = TTSD_ERROR_OPERATION_FAILED;
 734         } else {
 735                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting get engine : pid(%d)\n", pid);
 736                 ret = ttsd_server_setting_get_current_engine(pid, &engine_id);
 737         }
 738
 739         DBusMessage* reply;
 740         reply = dbus_message_new_method_return(msg);
 741
 742         if (NULL != reply) {
 743                 if (0 == ret) {
 744                         dbus_message_append_args( reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_STRING, &engine_id, DBUS_TYPE_INVALID);
 745                         SLOG(LOG_DEBUG, get_tag(), "[OUT] setting get engine : result(%d), engine id(%s)\n", ret, engine_id);
 746                 } else {
 747                         dbus_message_append_args( reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 748                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get engine : result(%d)", ret);
 749                 }
 750
 751                 if (!dbus_connection_send(conn, reply, NULL)) {
 752                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get engine : Out Of Memory!\n");
 753                 }
 754
 755                 dbus_connection_flush(conn);
 756                 dbus_message_unref(reply);
 757         } else {
 758                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get engine : fail to create reply message!!");
 759         }
 760
 761         if (NULL != engine_id)
 762                 free(engine_id);
 763
 764         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 765         SLOG(LOG_DEBUG, get_tag(), "  ");
 766
 767         return 0;
 768 }
 769
 770 int ttsd_dbus_server_setting_set_engine(DBusConnection* conn, DBusMessage* msg)
 771 {
 772         DBusError err;
 773         dbus_error_init(&err);
 774
 775         int pid;
 776         char* engine_id;
 777         int ret = 0;
 778
 779         dbus_message_get_args(msg, &err,
 780                 DBUS_TYPE_INT32, &pid,
 781                 DBUS_TYPE_STRING, &engine_id,
 782                 DBUS_TYPE_INVALID);
 783
 784         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING SET ENGINE");
 785
 786         if (dbus_error_is_set(&err)) {
 787                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting set engine : Get arguments error (%s)\n", err.message);
 788                 dbus_error_free(&err);
 789                 ret = TTSD_ERROR_OPERATION_FAILED;
 790         } else {
 791                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting set engine : pid(%d), engine id(%s)\n", pid,  engine_id);
 792                 ret = ttsd_server_setting_set_current_engine(pid, engine_id);
 793         }
 794
 795         DBusMessage* reply;
 796         reply = dbus_message_new_method_return(msg);
 797
 798         if (NULL != reply) {
 799                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 800
 801                 if (0 == ret) {
 802                         SLOG(LOG_DEBUG, get_tag(), "[OUT] setting set engine : result(%d) \n", ret);
 803                 } else {
 804                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set engine : result(%d) \n", ret);
 805                 }
 806
 807                 if (!dbus_connection_send(conn, reply, NULL)) {
 808                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set engine : Out Of Memory!\n");
 809                 }
 810
 811                 dbus_connection_flush(conn);
 812                 dbus_message_unref(reply);
 813         } else {
 814                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set engine : fail to create reply message!!");
 815         }
 816
 817         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 818         SLOG(LOG_DEBUG, get_tag(), "  ");
 819
 820         return 0;
 821 }
 822
 823 int ttsd_dbus_server_setting_get_voice_list(DBusConnection* conn, DBusMessage* msg)
 824 {
 825         DBusError err;
 826         dbus_error_init(&err);
 827
 828         int pid;
 829         char* engine_id = NULL;
 830         int ret = 0;
 831         GList* voice_list = NULL;
 832
 833         dbus_message_get_args(msg, &err,
 834                 DBUS_TYPE_INT32, &pid,
 835                 DBUS_TYPE_INVALID);
 836
 837         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING GET VOICE LIST");
 838
 839         if (dbus_error_is_set(&err)) {
 840                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting voice list : Get arguments error (%s)\n", err.message);
 841                 dbus_error_free(&err);
 842                 ret = TTSD_ERROR_OPERATION_FAILED;
 843         } else {
 844                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting voice list : pid(%d)\n", pid);
 845                 ret = ttsd_server_setting_get_voice_list(pid, &engine_id, &voice_list);
 846         }
 847
 848         DBusMessage* reply;
 849         reply = dbus_message_new_method_return(msg);
 850
 851         if (NULL != reply) {
 852                 DBusMessageIter args;
 853
 854                 dbus_message_iter_init_append(reply, &args);
 855
 856                 /* Append result*/
 857                 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret) );
 858
 859                 if (0 == ret) {
 860                         if (dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine_id))) {
 861                                 /* Append voice size */
 862                                 int size = g_list_length(voice_list);
 863                                 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
 864                                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting voice list : Fail to append type \n");
 865                                         ret = TTSD_ERROR_OPERATION_FAILED;
 866                                 } else {
 867
 868                                         GList *iter = NULL;
 869                                         voice_s* voice;
 870
 871                                         iter = g_list_first(voice_list);
 872
 873                                         while (NULL != iter) {
 874                                                 voice = iter->data;
 875
 876                                                 if (NULL != voice) {
 877                                                         dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(voice->language) );
 878                                                         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(voice->type) );
 879
 880                                                         if (NULL != voice->language)
 881                                                                 g_free(voice->language);
 882
 883                                                         g_free(voice);
 884                                                 }
 885
 886                                                 voice_list = g_list_remove_link(voice_list, iter);
 887
 888                                                 iter = g_list_first(voice_list);
 889                                         }
 890                                 }
 891                                 SLOG(LOG_DEBUG, get_tag(), "[OUT] setting voice list : result(%d) \n", ret);
 892                         } else {
 893                                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting voice list : Fail to append engine_id \n");
 894                         }
 895
 896                         if (NULL != engine_id)
 897                                 free(engine_id);
 898                 } else {
 899                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting voice list : result(%d) \n", ret);
 900                 }
 901
 902                 if (!dbus_connection_send(conn, reply, NULL)) {
 903                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting voice list : Out Of Memory!\n");
 904                 }
 905
 906                 dbus_connection_flush(conn);
 907                 dbus_message_unref(reply);
 908         } else {
 909                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting voice list : fail to create reply message!!");
 910         }
 911
 912         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 913         SLOG(LOG_DEBUG, get_tag(), "  ");
 914
 915         return 0;
 916 }
 917
 918 int ttsd_dbus_server_setting_get_default_voice(DBusConnection* conn, DBusMessage* msg)
 919 {
 920         DBusError err;
 921         dbus_error_init(&err);
 922
 923         int pid;
 924         int ret = 0;
 925         char* lang;
 926         ttsp_voice_type_e type;
 927
 928         dbus_message_get_args(msg, &err,
 929                 DBUS_TYPE_INT32, &pid,
 930                 DBUS_TYPE_INVALID);
 931
 932         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING GET DEFAULT VOICE");
 933
 934         if (dbus_error_is_set(&err)) {
 935                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting get default voice : Get arguments error (%s)\n", err.message);
 936                 dbus_error_free(&err);
 937                 ret = TTSD_ERROR_OPERATION_FAILED;
 938         } else {
 939                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting get default voice : pid(%d)\n", pid);
 940                 ret = ttsd_server_setting_get_default_voice(pid, &lang, &type);
 941         }
 942
 943         DBusMessage* reply;
 944         reply = dbus_message_new_method_return(msg);
 945
 946         if (NULL != reply) {
 947                 if (0 == ret) {
 948                         dbus_message_append_args(reply,
 949                                 DBUS_TYPE_INT32, &ret,
 950                                 DBUS_TYPE_STRING, &lang,
 951                                 DBUS_TYPE_INT32, &type,
 952                                 DBUS_TYPE_INVALID);
 953                         SLOG(LOG_DEBUG, get_tag(), "[OUT] setting get default voice : result(%d), language(%s), type(%d) \n", ret, lang, type);
 954                 } else {
 955                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 956                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get default voice : result(%d) \n", ret);
 957                 }
 958
 959                 if (!dbus_connection_send(conn, reply, NULL)) {
 960                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get default voice : Out Of Memory!\n");
 961                 }
 962
 963                 dbus_connection_flush(conn);
 964                 dbus_message_unref(reply);
 965         } else {
 966                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get default voice : fail to create reply message!!");
 967         }
 968
 969         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 970         SLOG(LOG_DEBUG, get_tag(), "  ");
 971
 972         return 0;
 973 }
 974
 975 int ttsd_dbus_server_setting_set_default_voice(DBusConnection* conn, DBusMessage* msg)
 976 {
 977         DBusError err;
 978         dbus_error_init(&err);
 979
 980         int pid;
 981         char* language;
 982         int voicetype;
 983         int ret = 0;
 984
 985         dbus_message_get_args(msg, &err,
 986                 DBUS_TYPE_INT32, &pid,
 987                 DBUS_TYPE_STRING, &language,
 988                 DBUS_TYPE_INT32, &voicetype,
 989                 DBUS_TYPE_INVALID);
 990
 991         SLOG(LOG_DEBUG, get_tag(), ">>>>> SET DEFAULT VOICE");
 992
 993         if (dbus_error_is_set(&err)) {
 994                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting set default voice : Get arguments error (%s)\n", err.message);
 995                 dbus_error_free(&err);
 996                 ret = TTSD_ERROR_OPERATION_FAILED;
 997         } else {
 998                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting set default voice : pid(%d), lang(%s), type(%d)\n"
 999                         , pid, language, voicetype);
1000                 ret =  ttsd_server_setting_set_default_voice(pid, language, voicetype);
1001         }
1002
1003         DBusMessage* reply;
1004         reply = dbus_message_new_method_return(msg);
1005
1006         if (NULL != reply) {
1007                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1008
1009                 if (0 == ret) {
1010                         SLOG(LOG_DEBUG, get_tag(), "[OUT] setting set default voice : result(%d) \n", ret);
1011                 } else {
1012                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set default voice : result(%d) \n", ret);
1013                 }
1014
1015                 if (!dbus_connection_send(conn, reply, NULL)) {
1016                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set default voice : Out Of Memory!\n");
1017                 }
1018
1019                 dbus_connection_flush(conn);
1020                 dbus_message_unref(reply);
1021         } else {
1022                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set default voice : fail to create reply message!!");
1023         }
1024
1025         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
1026         SLOG(LOG_DEBUG, get_tag(), "  ");
1027
1028         return 0;
1029 }
1030
1031 int ttsd_dbus_server_setting_get_speed(DBusConnection* conn, DBusMessage* msg)
1032 {
1033         DBusError err;
1034         dbus_error_init(&err);
1035
1036         int pid;
1037         int ret = 0;
1038         int speed;
1039
1040         dbus_message_get_args(msg, &err,
1041                 DBUS_TYPE_INT32, &pid,
1042                 DBUS_TYPE_INVALID);
1043
1044         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING GET SPEED");
1045
1046         if (dbus_error_is_set(&err)) {
1047                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting get speed : Get arguments error (%s)\n", err.message);
1048                 dbus_error_free(&err);
1049                 ret = TTSD_ERROR_OPERATION_FAILED;
1050         } else {
1051                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting get default speed : pid(%d)\n", pid);
1052                 ret =  ttsd_server_setting_get_default_speed(pid, &speed);
1053         }
1054
1055         DBusMessage* reply;
1056         reply = dbus_message_new_method_return(msg);
1057
1058         if (NULL != reply) {
1059                 if (0 == ret) {
1060                         dbus_message_append_args( reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INT32, &speed, DBUS_TYPE_INVALID);
1061                         SLOG(LOG_DEBUG, get_tag(), "[OUT] setting get default speed : result(%d), speed(%d) \n", ret, speed);
1062                 } else {
1063                         dbus_message_append_args( reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1064                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get default speed : result(%d) \n", ret);
1065                 }
1066
1067                 if (!dbus_connection_send(conn, reply, NULL)) {
1068                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get default speed : Out Of Memory!\n");
1069                 }
1070
1071                 dbus_connection_flush(conn);
1072                 dbus_message_unref(reply);
1073         } else {
1074                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get default speed : fail to create reply message!!");
1075         }
1076
1077         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
1078         SLOG(LOG_DEBUG, get_tag(), "  ");
1079
1080         return 0;
1081 }
1082
1083 int ttsd_dbus_server_setting_set_speed(DBusConnection* conn, DBusMessage* msg)
1084 {
1085         DBusError err;
1086         dbus_error_init(&err);
1087
1088         int pid;
1089         int speed;
1090         int ret = 0;
1091
1092         dbus_message_get_args(msg, &err,
1093                 DBUS_TYPE_INT32, &pid,
1094                 DBUS_TYPE_INT32, &speed,
1095                 DBUS_TYPE_INVALID);
1096
1097         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING GET SPEED");
1098
1099         if (dbus_error_is_set(&err)) {
1100                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting set default speed : Get arguments error (%s)\n", err.message);
1101                 dbus_error_free(&err);
1102                 ret = TTSD_ERROR_OPERATION_FAILED;
1103         } else {
1104                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting set default speed : pid(%d), speed(%d)\n", pid, speed);
1105                 ret = ttsd_server_setting_set_default_speed(pid, speed);
1106         }
1107
1108         DBusMessage* reply;
1109         reply = dbus_message_new_method_return(msg);
1110
1111         if (NULL != reply) {
1112                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1113
1114                 if (0 == ret) {
1115                         SLOG(LOG_DEBUG, get_tag(), "[OUT] setting set default speed : result(%d)", ret);
1116                 } else {
1117                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set default speed : result(%d)", ret);
1118                 }
1119
1120                 if (!dbus_connection_send(conn, reply, NULL)) {
1121                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set default speed : Out Of Memory!\n");
1122                 }
1123
1124                 dbus_connection_flush(conn);
1125                 dbus_message_unref(reply);
1126         } else {
1127                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set default speed : fail to create reply message!!");
1128         }
1129
1130         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
1131         SLOG(LOG_DEBUG, get_tag(), "  ");
1132
1133         return 0;
1134 }
1135
1136 int ttsd_dbus_server_setting_get_engine_setting(DBusConnection* conn, DBusMessage* msg)
1137 {
1138         DBusError err;
1139         dbus_error_init(&err);
1140
1141         int pid;
1142         int ret = 0;
1143         char* engine_id;
1144         GList* engine_setting_list = NULL;
1145
1146         dbus_message_get_args(msg, &err,
1147                 DBUS_TYPE_INT32, &pid,
1148                 DBUS_TYPE_INVALID);
1149
1150         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING GET ENGINE SETTING");
1151
1152         if (dbus_error_is_set(&err)) {
1153                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting get engine option : Get arguments error (%s)\n", err.message);
1154                 dbus_error_free(&err);
1155                 ret = TTSD_ERROR_OPERATION_FAILED;
1156         } else {
1157                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting get engine option : pid(%d)", pid);
1158                 ret = ttsd_server_setting_get_engine_setting(pid, &engine_id, &engine_setting_list);
1159         }
1160
1161         DBusMessage* reply;
1162         reply = dbus_message_new_method_return(msg);
1163
1164         if (NULL != reply) {
1165                 DBusMessageIter args;
1166                 dbus_message_iter_init_append(reply, &args);
1167
1168                 /* Append result*/
1169                 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret) );
1170
1171                 if (0 == ret) {
1172                         if (dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine_id))) {
1173                                 /* Append voice size */
1174                                 int size = g_list_length(engine_setting_list);
1175                                 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
1176                                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting voice list : Fail to append type \n");
1177                                         ret = TTSD_ERROR_OPERATION_FAILED;
1178                                 } else {
1179
1180                                         GList *iter = NULL;
1181                                         engine_setting_s* setting;
1182
1183                                         iter = g_list_first(engine_setting_list);
1184
1185                                         while (NULL != iter) {
1186                                                 setting = iter->data;
1187
1188                                                 if (NULL != setting) {
1189                                                         dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(setting->key) );
1190                                                         dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(setting->value) );
1191
1192                                                         if (NULL != setting->key)
1193                                                                 g_free(setting->key);
1194                                                         if (NULL != setting->value)
1195                                                                 g_free(setting->value);
1196
1197                                                         g_free(setting);
1198                                                 }
1199
1200                                                 engine_setting_list = g_list_remove_link(engine_setting_list, iter);
1201
1202                                                 iter = g_list_first(engine_setting_list);
1203                                         }
1204                                 }
1205                                 SLOG(LOG_DEBUG, get_tag(), "[OUT] setting engine setting list : result(%d) \n", ret);
1206                         } else {
1207                                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting voice list : Fail to append engine_id \n");
1208                         }
1209
1210                         if (NULL != engine_id)
1211                                 free(engine_id);
1212                 } else {
1213                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get engine option : result(%d) \n", ret);
1214                 }
1215
1216                 if (!dbus_connection_send(conn, reply, NULL)) {
1217                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get engine option : Out Of Memory!\n");
1218                 }
1219
1220                 dbus_connection_flush(conn);
1221                 dbus_message_unref(reply);
1222         } else {
1223                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get engine option : fail to create reply message!!");
1224         }
1225
1226         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
1227         SLOG(LOG_DEBUG, get_tag(), "  ");
1228
1229         return 0;
1230 }
1231
1232 int ttsd_dbus_server_setting_set_engine_setting(DBusConnection* conn, DBusMessage* msg)
1233 {
1234         DBusError err;
1235         dbus_error_init(&err);
1236
1237         int pid;
1238         char* key;
1239         char* value;
1240         int ret = 0;
1241
1242         dbus_message_get_args(msg, &err,
1243                 DBUS_TYPE_INT32, &pid,
1244                 DBUS_TYPE_STRING, &key,
1245                 DBUS_TYPE_STRING, &value,
1246                 DBUS_TYPE_INVALID);
1247
1248         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING SET ENGINE SETTING");
1249
1250         if (dbus_error_is_set(&err)) {
1251                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting set engine option : Get arguments error (%s)\n", err.message);
1252                 dbus_error_free(&err);
1253                 ret = TTSD_ERROR_OPERATION_FAILED;
1254         } else {
1255                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting set engine option : pid(%d), key(%s), value(%s)\n", pid, key, value);
1256                 ret = ttsd_server_setting_set_engine_setting(pid, key, value);
1257         }
1258
1259         DBusMessage* reply;
1260         reply = dbus_message_new_method_return(msg);
1261
1262         if (NULL != reply) {
1263                 dbus_message_append_args( reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1264
1265                 if (0 == ret) {
1266                         SLOG(LOG_DEBUG, get_tag(), "[OUT] setting set engine option : result(%d)", ret);
1267                 } else {
1268                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set engine option : result(%d)", ret);
1269                 }
1270
1271                 if (!dbus_connection_send(conn, reply, NULL)) {
1272                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set engine option : Out Of Memory!\n");
1273                 }
1274                 dbus_connection_flush(conn);
1275                 dbus_message_unref(reply);
1276         } else {
1277                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set engine option : fail to create reply message!!");
1278         }
1279
1280         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
1281         SLOG(LOG_DEBUG, get_tag(), "  ");
1282
1283         return 0;
1284 }
1285