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