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                 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, get_tag(), "[OUT] tts finalize : result(%d) \n", ret);
 133                 } else {
 134                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts finalize : result(%d) \n", ret);
 135                 }
 136
 137                 if (!dbus_connection_send(conn, reply, NULL)) {
 138                         SLOG(LOG_ERROR, get_tag(), "[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, get_tag(), "[OUT ERROR] tts finalize : fail to create reply message!!");
 145         }
 146
 147         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 148         SLOG(LOG_DEBUG, get_tag(), "  ");
 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, get_tag(), ">>>>> TTS GET VOICES");
 165
 166         if (dbus_error_is_set(&err)) {
 167                 SLOG(LOG_ERROR, get_tag(), "[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, get_tag(), "[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, get_tag(), "[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, get_tag(), "[OUT] tts supported voices : result(%d) \n", ret);
 218                 } else {
 219                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts supported voices : result(%d) \n", ret);
 220                 }
 221
 222                 if (!dbus_connection_send(conn, reply, NULL)) {
 223                         SLOG(LOG_ERROR, get_tag(), "[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, get_tag(), "[OUT ERROR] tts supported voices : fail to create reply message!!");
 230         }
 231
 232         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 233         SLOG(LOG_DEBUG, get_tag(), "  ");
 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, get_tag(), ">>>>> TTS GET DEFAULT VOICE");
 251
 252         if (dbus_error_is_set(&err)) {
 253                 SLOG(LOG_ERROR, get_tag(), "[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, get_tag(), "[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, get_tag(), "[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, get_tag(), "[OUT ERROR] tts default voice : result(%d) \n", ret);
 278                 }
 279
 280                 if (!dbus_connection_send(conn, reply, NULL)) {
 281                         SLOG(LOG_ERROR, get_tag(), "[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, get_tag(), "[OUT ERROR] tts default voice : fail to create reply message!!");
 288         }
 289
 290         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 291         SLOG(LOG_DEBUG, get_tag(), "  ");
 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, get_tag(), ">>>>> TTS ADD TEXT");
 315
 316         if (dbus_error_is_set(&err)) {
 317                 SLOG(LOG_ERROR, get_tag(), "[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, get_tag(), "[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, get_tag(), "[OUT] tts add text : result(%d) \n", ret);
 335                 } else {
 336                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts add text : result(%d) \n", ret);
 337                 }
 338
 339                 if (!dbus_connection_send(conn, reply, NULL)) {
 340                         SLOG(LOG_ERROR, get_tag(), "[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, get_tag(), "[OUT ERROR] tts add text : fail to create reply message!!");
 347         }
 348
 349         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 350         SLOG(LOG_DEBUG, get_tag(), "  ");
 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, get_tag(), ">>>>> TTS PLAY");
 366
 367         if (dbus_error_is_set(&err)) {
 368                 SLOG(LOG_ERROR, get_tag(), "[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, get_tag(), "[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, get_tag(), "[OUT] tts play : result(%d) \n", ret);
 384                 } else {
 385                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts play : result(%d) \n", ret);
 386                 }
 387
 388                 if (!dbus_connection_send(conn, reply, NULL)) {
 389                         SLOG(LOG_ERROR, get_tag(), "[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, get_tag(), "[OUT ERROR] tts play : fail to create reply message!!");
 396         }
 397
 398         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 399         SLOG(LOG_DEBUG, get_tag(), "  ");
 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, get_tag(), ">>>>> TTS STOP");
 416
 417         if (dbus_error_is_set(&err)) {
 418                 SLOG(LOG_ERROR, get_tag(), "[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, get_tag(), "[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, get_tag(), "[OUT] tts stop : result(%d) \n", ret);
 436                 } else {
 437                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts stop : result(%d) \n", ret);
 438                 }
 439
 440                 if (!dbus_connection_send(conn, reply, NULL)) {
 441                         SLOG(LOG_ERROR, get_tag(), "[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, get_tag(), "[OUT ERROR] tts stop : fail to create reply message!!");
 448         }
 449
 450         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 451         SLOG(LOG_DEBUG, get_tag(), "  ");
 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, get_tag(), ">>>>> TTS PAUSE");
 469
 470         if (dbus_error_is_set(&err)) {
 471                 SLOG(LOG_ERROR, get_tag(), "[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, get_tag(), "[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, get_tag(), "[OUT] tts pause : result(%d) \n", ret);
 489                 } else {
 490                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] tts pause : result(%d) \n", ret);
 491                 }
 492
 493                 if (!dbus_connection_send(conn, reply, NULL)) {
 494                         SLOG(LOG_ERROR, get_tag(), "[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, get_tag(), "[OUT ERROR] tts pause : fail to create reply message!!");
 501         }
 502
 503         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 504         SLOG(LOG_DEBUG, get_tag(), "  ");
 505
 506         return 0;
 507 }
 508
 509 /*
 510 * Dbus Server functions for tts daemon internal
 511 */
 512 int ttsd_dbus_server_start_next_synthesis()
 513 {
 514         return ttsd_server_start_next_synthesis();
 515 }
 516
 517 /*
 518 * Dbus Setting-Daemon Server
 519 */
 520
 521 int ttsd_dbus_server_setting_initialize(DBusConnection* conn, DBusMessage* msg)
 522 {
 523         DBusError err;
 524         dbus_error_init(&err);
 525
 526         int pid;
 527         int ret = 0;
 528
 529         dbus_message_get_args(msg, &err,
 530                 DBUS_TYPE_INT32, &pid,
 531                 DBUS_TYPE_INVALID);
 532
 533         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING INITIALIZE");
 534
 535         if (dbus_error_is_set(&err)) {
 536                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] Receivce setting initialize : Get arguments error (%s)\n", err.message);
 537                 dbus_error_free(&err);
 538                 ret = TTSD_ERROR_OPERATION_FAILED;
 539         } else {
 540                 SLOG(LOG_DEBUG, get_tag(), "[IN] Receivce setting initialize : pid(%d) \n", pid);
 541                 ret =  ttsd_server_setting_initialize(pid);
 542         }
 543
 544         DBusMessage* reply;
 545         reply = dbus_message_new_method_return(msg);
 546
 547         if (NULL != reply) {
 548                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 549
 550                 if (0 == ret) {
 551                         SLOG(LOG_DEBUG, get_tag(), "[OUT] setting initialize : result(%d) \n", ret);
 552                 } else {
 553                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting initialize : result(%d) \n", ret);
 554                 }
 555
 556                 if (!dbus_connection_send(conn, reply, NULL)) {
 557                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting initialize : Out Of Memory!\n");
 558                 }
 559
 560                 dbus_connection_flush(conn);
 561                 dbus_message_unref(reply);
 562         } else {
 563                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting initialize : fail to create reply message!!");
 564         }
 565
 566         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 567         SLOG(LOG_DEBUG, get_tag(), "  ");
 568
 569         return 0;
 570 }
 571
 572 int ttsd_dbus_server_setting_finalize(DBusConnection* conn, DBusMessage* msg)
 573 {
 574         DBusError err;
 575         dbus_error_init(&err);
 576
 577         int pid;
 578         int ret = 0;
 579
 580         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 581
 582         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING FINALIZE");
 583
 584         if (dbus_error_is_set(&err)) {
 585                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting finalize : Get arguments error (%s)\n", err.message);
 586                 dbus_error_free(&err);
 587                 ret = TTSD_ERROR_OPERATION_FAILED;
 588         } else {
 589                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting finalize : pid(%d)\n", pid);
 590                 ret =  ttsd_server_setting_finalize(pid);
 591         }
 592
 593         DBusMessage* reply;
 594         reply = dbus_message_new_method_return(msg);
 595
 596         if (NULL != reply) {
 597                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 598
 599                 if (0 == ret) {
 600                         SLOG(LOG_DEBUG, get_tag(), "[OUT] setting finalize : result(%d) \n", ret);
 601                 } else {
 602                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting finalize : result(%d) \n", ret);
 603                 }
 604
 605                 if (!dbus_connection_send(conn, reply, NULL)) {
 606                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting finalize : Out Of Memory!\n");
 607                 }
 608
 609                 dbus_connection_flush(conn);
 610                 dbus_message_unref(reply);
 611         } else {
 612                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting finalize : fail to create reply message!!");
 613         }
 614
 615         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 616         SLOG(LOG_DEBUG, get_tag(), "  ");
 617
 618         return 0;
 619 }
 620
 621 int ttsd_dbus_server_setting_get_engine_list(DBusConnection* conn, DBusMessage* msg)
 622 {
 623         DBusError err;
 624         dbus_error_init(&err);
 625
 626         int pid;
 627         int ret = 0;
 628         GList* engine_list = NULL;
 629
 630         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 631
 632         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING GET ENGINE LIST");
 633
 634         if (dbus_error_is_set(&err)) {
 635                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting engine list : Get arguments error (%s)\n", err.message);
 636                 dbus_error_free(&err);
 637                 ret = TTSD_ERROR_OPERATION_FAILED;
 638         } else {
 639                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting engine list : pid(%d) \n", pid);
 640                 ret = ttsd_server_setting_get_engine_list(pid, &engine_list);
 641         }
 642
 643         DBusMessage* reply;
 644         reply = dbus_message_new_method_return(msg);
 645
 646         if (NULL != reply) {
 647                 DBusMessageIter args;
 648                 dbus_message_iter_init_append(reply, &args);
 649
 650                 /* Append result*/
 651                 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret) );
 652
 653                 if (0 == ret) {
 654                         /* Append size */
 655                         int size = g_list_length(engine_list);
 656                         if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
 657                                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting engine list : fail to append engine size \n");
 658                         } else {
 659
 660                                 GList *iter = NULL;
 661                                 engine_s* engine;
 662
 663                                 iter = g_list_first(engine_list);
 664
 665                                 while (NULL != iter) {
 666                                         engine = iter->data;
 667
 668                                         if (NULL != engine) {
 669                                                 SLOG(LOG_DEBUG, get_tag(), "engine id : %s, engine name : %s, ug_name, : %s",
 670                                                         engine->engine_id, engine->engine_name, engine->ug_name);
 671
 672                                                 dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->engine_id) );
 673                                                 dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->engine_name) );
 674                                                 dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->ug_name) );
 675
 676                                                 if (NULL != engine->engine_id)
 677                                                         g_free(engine->engine_id);
 678                                                 if (NULL != engine->engine_name)
 679                                                         g_free(engine->engine_name);
 680                                                 if (NULL != engine->ug_name)
 681                                                         g_free(engine->ug_name);
 682
 683                                                 g_free(engine);
 684                                         }
 685
 686                                         engine_list = g_list_remove_link(engine_list, iter);
 687
 688                                         iter = g_list_first(engine_list);
 689                                 }
 690                                 SLOG(LOG_DEBUG, get_tag(), "[OUT] setting engine list : result(%d) \n", ret);
 691                         }
 692                 } else {
 693                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting engine list : result(%d) \n", ret);
 694                 }
 695
 696                 if (!dbus_connection_send(conn, reply, NULL)) {
 697                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting engine list : Out Of Memory!\n");
 698                 }
 699
 700                 dbus_connection_flush(conn);
 701                 dbus_message_unref(reply);
 702         } else {
 703                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting engine list : fail to create reply message!!");
 704         }
 705
 706         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 707         SLOG(LOG_DEBUG, get_tag(), "  ");
 708
 709         return 0;
 710 }
 711
 712 int ttsd_dbus_server_setting_get_engine(DBusConnection* conn, DBusMessage* msg)
 713 {
 714         DBusError err;
 715         dbus_error_init(&err);
 716
 717         int pid;
 718         int ret = 0;
 719         char* engine_id = NULL;
 720
 721         dbus_message_get_args(msg, &err,
 722                 DBUS_TYPE_INT32, &pid,
 723                 DBUS_TYPE_INVALID);
 724
 725         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING GET ENGINE");
 726
 727         if (dbus_error_is_set(&err)) {
 728                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting get engine : Get arguments error (%s)\n", err.message);
 729                 dbus_error_free(&err);
 730                 ret = TTSD_ERROR_OPERATION_FAILED;
 731         } else {
 732                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting get engine : pid(%d)\n", pid);
 733                 ret = ttsd_server_setting_get_current_engine(pid, &engine_id);
 734         }
 735
 736         DBusMessage* reply;
 737         reply = dbus_message_new_method_return(msg);
 738
 739         if (NULL != reply) {
 740                 if (0 == ret) {
 741                         dbus_message_append_args( reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_STRING, &engine_id, DBUS_TYPE_INVALID);
 742                         SLOG(LOG_DEBUG, get_tag(), "[OUT] setting get engine : result(%d), engine id(%s)\n", ret, engine_id);
 743                 } else {
 744                         dbus_message_append_args( reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 745                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get engine : result(%d)", ret);
 746                 }
 747
 748                 if (!dbus_connection_send(conn, reply, NULL)) {
 749                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get engine : Out Of Memory!\n");
 750                 }
 751
 752                 dbus_connection_flush(conn);
 753                 dbus_message_unref(reply);
 754         } else {
 755                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get engine : fail to create reply message!!");
 756         }
 757
 758         if (NULL != engine_id)
 759                 free(engine_id);
 760
 761         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 762         SLOG(LOG_DEBUG, get_tag(), "  ");
 763
 764         return 0;
 765 }
 766
 767 int ttsd_dbus_server_setting_set_engine(DBusConnection* conn, DBusMessage* msg)
 768 {
 769         DBusError err;
 770         dbus_error_init(&err);
 771
 772         int pid;
 773         char* engine_id;
 774         int ret = 0;
 775
 776         dbus_message_get_args(msg, &err,
 777                 DBUS_TYPE_INT32, &pid,
 778                 DBUS_TYPE_STRING, &engine_id,
 779                 DBUS_TYPE_INVALID);
 780
 781         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING SET ENGINE");
 782
 783         if (dbus_error_is_set(&err)) {
 784                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting set engine : Get arguments error (%s)\n", err.message);
 785                 dbus_error_free(&err);
 786                 ret = TTSD_ERROR_OPERATION_FAILED;
 787         } else {
 788                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting set engine : pid(%d), engine id(%s)\n", pid,  engine_id);
 789                 ret = ttsd_server_setting_set_current_engine(pid, engine_id);
 790         }
 791
 792         DBusMessage* reply;
 793         reply = dbus_message_new_method_return(msg);
 794
 795         if (NULL != reply) {
 796                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 797
 798                 if (0 == ret) {
 799                         SLOG(LOG_DEBUG, get_tag(), "[OUT] setting set engine : result(%d) \n", ret);
 800                 } else {
 801                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set engine : result(%d) \n", ret);
 802                 }
 803
 804                 if (!dbus_connection_send(conn, reply, NULL)) {
 805                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set engine : Out Of Memory!\n");
 806                 }
 807
 808                 dbus_connection_flush(conn);
 809                 dbus_message_unref(reply);
 810         } else {
 811                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set engine : fail to create reply message!!");
 812         }
 813
 814         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 815         SLOG(LOG_DEBUG, get_tag(), "  ");
 816
 817         return 0;
 818 }
 819
 820 int ttsd_dbus_server_setting_get_voice_list(DBusConnection* conn, DBusMessage* msg)
 821 {
 822         DBusError err;
 823         dbus_error_init(&err);
 824
 825         int pid;
 826         char* engine_id = NULL;
 827         int ret = 0;
 828         GList* voice_list = NULL;
 829
 830         dbus_message_get_args(msg, &err,
 831                 DBUS_TYPE_INT32, &pid,
 832                 DBUS_TYPE_INVALID);
 833
 834         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING GET VOICE LIST");
 835
 836         if (dbus_error_is_set(&err)) {
 837                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting voice list : Get arguments error (%s)\n", err.message);
 838                 dbus_error_free(&err);
 839                 ret = TTSD_ERROR_OPERATION_FAILED;
 840         } else {
 841                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting voice list : pid(%d)\n", pid);
 842                 ret = ttsd_server_setting_get_voice_list(pid, &engine_id, &voice_list);
 843         }
 844
 845         DBusMessage* reply;
 846         reply = dbus_message_new_method_return(msg);
 847
 848         if (NULL != reply) {
 849                 DBusMessageIter args;
 850
 851                 dbus_message_iter_init_append(reply, &args);
 852
 853                 /* Append result*/
 854                 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret) );
 855
 856                 if (0 == ret) {
 857                         if (dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine_id))) {
 858                                 /* Append voice size */
 859                                 int size = g_list_length(voice_list);
 860                                 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
 861                                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting voice list : Fail to append type \n");
 862                                         ret = TTSD_ERROR_OPERATION_FAILED;
 863                                 } else {
 864
 865                                         GList *iter = NULL;
 866                                         voice_s* voice;
 867
 868                                         iter = g_list_first(voice_list);
 869
 870                                         while (NULL != iter) {
 871                                                 voice = iter->data;
 872
 873                                                 if (NULL != voice) {
 874                                                         dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(voice->language) );
 875                                                         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(voice->type) );
 876
 877                                                         if (NULL != voice->language)
 878                                                                 g_free(voice->language);
 879
 880                                                         g_free(voice);
 881                                                 }
 882
 883                                                 voice_list = g_list_remove_link(voice_list, iter);
 884
 885                                                 iter = g_list_first(voice_list);
 886                                         }
 887                                 }
 888                                 SLOG(LOG_DEBUG, get_tag(), "[OUT] setting voice list : result(%d) \n", ret);
 889                         } else {
 890                                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting voice list : Fail to append engine_id \n");
 891                         }
 892
 893                         if (NULL != engine_id)
 894                                 free(engine_id);
 895                 } else {
 896                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting voice list : result(%d) \n", ret);
 897                 }
 898
 899                 if (!dbus_connection_send(conn, reply, NULL)) {
 900                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting voice list : Out Of Memory!\n");
 901                 }
 902
 903                 dbus_connection_flush(conn);
 904                 dbus_message_unref(reply);
 905         } else {
 906                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting voice list : fail to create reply message!!");
 907         }
 908
 909         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 910         SLOG(LOG_DEBUG, get_tag(), "  ");
 911
 912         return 0;
 913 }
 914
 915 int ttsd_dbus_server_setting_get_default_voice(DBusConnection* conn, DBusMessage* msg)
 916 {
 917         DBusError err;
 918         dbus_error_init(&err);
 919
 920         int pid;
 921         int ret = 0;
 922         char* lang;
 923         ttsp_voice_type_e type;
 924
 925         dbus_message_get_args(msg, &err,
 926                 DBUS_TYPE_INT32, &pid,
 927                 DBUS_TYPE_INVALID);
 928
 929         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING GET DEFAULT VOICE");
 930
 931         if (dbus_error_is_set(&err)) {
 932                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting get default voice : Get arguments error (%s)\n", err.message);
 933                 dbus_error_free(&err);
 934                 ret = TTSD_ERROR_OPERATION_FAILED;
 935         } else {
 936                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting get default voice : pid(%d)\n", pid);
 937                 ret = ttsd_server_setting_get_default_voice(pid, &lang, &type);
 938         }
 939
 940         DBusMessage* reply;
 941         reply = dbus_message_new_method_return(msg);
 942
 943         if (NULL != reply) {
 944                 if (0 == ret) {
 945                         dbus_message_append_args(reply,
 946                                 DBUS_TYPE_INT32, &ret,
 947                                 DBUS_TYPE_STRING, &lang,
 948                                 DBUS_TYPE_INT32, &type,
 949                                 DBUS_TYPE_INVALID);
 950                         SLOG(LOG_DEBUG, get_tag(), "[OUT] setting get default voice : result(%d), language(%s), type(%d) \n", ret, lang, type);
 951                 } else {
 952                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 953                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get default voice : result(%d) \n", ret);
 954                 }
 955
 956                 if (!dbus_connection_send(conn, reply, NULL)) {
 957                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get default voice : Out Of Memory!\n");
 958                 }
 959
 960                 dbus_connection_flush(conn);
 961                 dbus_message_unref(reply);
 962         } else {
 963                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get default voice : fail to create reply message!!");
 964         }
 965
 966         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
 967         SLOG(LOG_DEBUG, get_tag(), "  ");
 968
 969         return 0;
 970 }
 971
 972 int ttsd_dbus_server_setting_set_default_voice(DBusConnection* conn, DBusMessage* msg)
 973 {
 974         DBusError err;
 975         dbus_error_init(&err);
 976
 977         int pid;
 978         char* language;
 979         int voicetype;
 980         int ret = 0;
 981
 982         dbus_message_get_args(msg, &err,
 983                 DBUS_TYPE_INT32, &pid,
 984                 DBUS_TYPE_STRING, &language,
 985                 DBUS_TYPE_INT32, &voicetype,
 986                 DBUS_TYPE_INVALID);
 987
 988         SLOG(LOG_DEBUG, get_tag(), ">>>>> SET DEFAULT VOICE");
 989
 990         if (dbus_error_is_set(&err)) {
 991                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting set default voice : Get arguments error (%s)\n", err.message);
 992                 dbus_error_free(&err);
 993                 ret = TTSD_ERROR_OPERATION_FAILED;
 994         } else {
 995                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting set default voice : pid(%d), lang(%s), type(%d)\n"
 996                         , pid, language, voicetype);
 997                 ret =  ttsd_server_setting_set_default_voice(pid, language, voicetype);
 998         }
 999
1000         DBusMessage* reply;
1001         reply = dbus_message_new_method_return(msg);
1002
1003         if (NULL != reply) {
1004                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1005
1006                 if (0 == ret) {
1007                         SLOG(LOG_DEBUG, get_tag(), "[OUT] setting set default voice : result(%d) \n", ret);
1008                 } else {
1009                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set default voice : result(%d) \n", ret);
1010                 }
1011
1012                 if (!dbus_connection_send(conn, reply, NULL)) {
1013                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set default voice : Out Of Memory!\n");
1014                 }
1015
1016                 dbus_connection_flush(conn);
1017                 dbus_message_unref(reply);
1018         } else {
1019                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set default voice : fail to create reply message!!");
1020         }
1021
1022         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
1023         SLOG(LOG_DEBUG, get_tag(), "  ");
1024
1025         return 0;
1026 }
1027
1028 int ttsd_dbus_server_setting_get_speed(DBusConnection* conn, DBusMessage* msg)
1029 {
1030         DBusError err;
1031         dbus_error_init(&err);
1032
1033         int pid;
1034         int ret = 0;
1035         int speed;
1036
1037         dbus_message_get_args(msg, &err,
1038                 DBUS_TYPE_INT32, &pid,
1039                 DBUS_TYPE_INVALID);
1040
1041         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING GET SPEED");
1042
1043         if (dbus_error_is_set(&err)) {
1044                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting get speed : Get arguments error (%s)\n", err.message);
1045                 dbus_error_free(&err);
1046                 ret = TTSD_ERROR_OPERATION_FAILED;
1047         } else {
1048                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting get default speed : pid(%d)\n", pid);
1049                 ret =  ttsd_server_setting_get_default_speed(pid, &speed);
1050         }
1051
1052         DBusMessage* reply;
1053         reply = dbus_message_new_method_return(msg);
1054
1055         if (NULL != reply) {
1056                 if (0 == ret) {
1057                         dbus_message_append_args( reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INT32, &speed, DBUS_TYPE_INVALID);
1058                         SLOG(LOG_DEBUG, get_tag(), "[OUT] setting get default speed : result(%d), speed(%d) \n", ret, speed);
1059                 } else {
1060                         dbus_message_append_args( reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1061                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get default speed : result(%d) \n", ret);
1062                 }
1063
1064                 if (!dbus_connection_send(conn, reply, NULL)) {
1065                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get default speed : Out Of Memory!\n");
1066                 }
1067
1068                 dbus_connection_flush(conn);
1069                 dbus_message_unref(reply);
1070         } else {
1071                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get default speed : fail to create reply message!!");
1072         }
1073
1074         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
1075         SLOG(LOG_DEBUG, get_tag(), "  ");
1076
1077         return 0;
1078 }
1079
1080 int ttsd_dbus_server_setting_set_speed(DBusConnection* conn, DBusMessage* msg)
1081 {
1082         DBusError err;
1083         dbus_error_init(&err);
1084
1085         int pid;
1086         int speed;
1087         int ret = 0;
1088
1089         dbus_message_get_args(msg, &err,
1090                 DBUS_TYPE_INT32, &pid,
1091                 DBUS_TYPE_INT32, &speed,
1092                 DBUS_TYPE_INVALID);
1093
1094         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING GET SPEED");
1095
1096         if (dbus_error_is_set(&err)) {
1097                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting set default speed : Get arguments error (%s)\n", err.message);
1098                 dbus_error_free(&err);
1099                 ret = TTSD_ERROR_OPERATION_FAILED;
1100         } else {
1101                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting set default speed : pid(%d), speed(%d)\n", pid, speed);
1102                 ret = ttsd_server_setting_set_default_speed(pid, speed);
1103         }
1104
1105         DBusMessage* reply;
1106         reply = dbus_message_new_method_return(msg);
1107
1108         if (NULL != reply) {
1109                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1110
1111                 if (0 == ret) {
1112                         SLOG(LOG_DEBUG, get_tag(), "[OUT] setting set default speed : result(%d)", ret);
1113                 } else {
1114                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set default speed : result(%d)", ret);
1115                 }
1116
1117                 if (!dbus_connection_send(conn, reply, NULL)) {
1118                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set default speed : Out Of Memory!\n");
1119                 }
1120
1121                 dbus_connection_flush(conn);
1122                 dbus_message_unref(reply);
1123         } else {
1124                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set default speed : fail to create reply message!!");
1125         }
1126
1127         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
1128         SLOG(LOG_DEBUG, get_tag(), "  ");
1129
1130         return 0;
1131 }
1132
1133 int ttsd_dbus_server_setting_get_engine_setting(DBusConnection* conn, DBusMessage* msg)
1134 {
1135         DBusError err;
1136         dbus_error_init(&err);
1137
1138         int pid;
1139         int ret = 0;
1140         char* engine_id;
1141         GList* engine_setting_list = NULL;
1142
1143         dbus_message_get_args(msg, &err,
1144                 DBUS_TYPE_INT32, &pid,
1145                 DBUS_TYPE_INVALID);
1146
1147         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING GET ENGINE SETTING");
1148
1149         if (dbus_error_is_set(&err)) {
1150                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting get engine option : Get arguments error (%s)\n", err.message);
1151                 dbus_error_free(&err);
1152                 ret = TTSD_ERROR_OPERATION_FAILED;
1153         } else {
1154                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting get engine option : pid(%d)", pid);
1155                 ret = ttsd_server_setting_get_engine_setting(pid, &engine_id, &engine_setting_list);
1156         }
1157
1158         DBusMessage* reply;
1159         reply = dbus_message_new_method_return(msg);
1160
1161         if (NULL != reply) {
1162                 DBusMessageIter args;
1163                 dbus_message_iter_init_append(reply, &args);
1164
1165                 /* Append result*/
1166                 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret) );
1167
1168                 if (0 == ret) {
1169                         if (dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine_id))) {
1170                                 /* Append voice size */
1171                                 int size = g_list_length(engine_setting_list);
1172                                 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
1173                                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting voice list : Fail to append type \n");
1174                                         ret = TTSD_ERROR_OPERATION_FAILED;
1175                                 } else {
1176
1177                                         GList *iter = NULL;
1178                                         engine_setting_s* setting;
1179
1180                                         iter = g_list_first(engine_setting_list);
1181
1182                                         while (NULL != iter) {
1183                                                 setting = iter->data;
1184
1185                                                 if (NULL != setting) {
1186                                                         dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(setting->key) );
1187                                                         dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(setting->value) );
1188
1189                                                         if (NULL != setting->key)
1190                                                                 g_free(setting->key);
1191                                                         if (NULL != setting->value)
1192                                                                 g_free(setting->value);
1193
1194                                                         g_free(setting);
1195                                                 }
1196
1197                                                 engine_setting_list = g_list_remove_link(engine_setting_list, iter);
1198
1199                                                 iter = g_list_first(engine_setting_list);
1200                                         }
1201                                 }
1202                                 SLOG(LOG_DEBUG, get_tag(), "[OUT] setting engine setting list : result(%d) \n", ret);
1203                         } else {
1204                                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting voice list : Fail to append engine_id \n");
1205                         }
1206
1207                         if (NULL != engine_id)
1208                                 free(engine_id);
1209                 } else {
1210                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get engine option : result(%d) \n", ret);
1211                 }
1212
1213                 if (!dbus_connection_send(conn, reply, NULL)) {
1214                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get engine option : Out Of Memory!\n");
1215                 }
1216
1217                 dbus_connection_flush(conn);
1218                 dbus_message_unref(reply);
1219         } else {
1220                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting get engine option : fail to create reply message!!");
1221         }
1222
1223         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
1224         SLOG(LOG_DEBUG, get_tag(), "  ");
1225
1226         return 0;
1227 }
1228
1229 int ttsd_dbus_server_setting_set_engine_setting(DBusConnection* conn, DBusMessage* msg)
1230 {
1231         DBusError err;
1232         dbus_error_init(&err);
1233
1234         int pid;
1235         char* key;
1236         char* value;
1237         int ret = 0;
1238
1239         dbus_message_get_args(msg, &err,
1240                 DBUS_TYPE_INT32, &pid,
1241                 DBUS_TYPE_STRING, &key,
1242                 DBUS_TYPE_STRING, &value,
1243                 DBUS_TYPE_INVALID);
1244
1245         SLOG(LOG_DEBUG, get_tag(), ">>>>> SETTING SET ENGINE SETTING");
1246
1247         if (dbus_error_is_set(&err)) {
1248                 SLOG(LOG_ERROR, get_tag(), "[IN ERROR] setting set engine option : Get arguments error (%s)\n", err.message);
1249                 dbus_error_free(&err);
1250                 ret = TTSD_ERROR_OPERATION_FAILED;
1251         } else {
1252                 SLOG(LOG_DEBUG, get_tag(), "[IN] setting set engine option : pid(%d), key(%s), value(%s)\n", pid, key, value);
1253                 ret = ttsd_server_setting_set_engine_setting(pid, key, value);
1254         }
1255
1256         DBusMessage* reply;
1257         reply = dbus_message_new_method_return(msg);
1258
1259         if (NULL != reply) {
1260                 dbus_message_append_args( reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1261
1262                 if (0 == ret) {
1263                         SLOG(LOG_DEBUG, get_tag(), "[OUT] setting set engine option : result(%d)", ret);
1264                 } else {
1265                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set engine option : result(%d)", ret);
1266                 }
1267
1268                 if (!dbus_connection_send(conn, reply, NULL)) {
1269                         SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set engine option : Out Of Memory!\n");
1270                 }
1271                 dbus_connection_flush(conn);
1272                 dbus_message_unref(reply);
1273         } else {
1274                 SLOG(LOG_ERROR, get_tag(), "[OUT ERROR] setting set engine option : fail to create reply message!!");
1275         }
1276
1277         SLOG(LOG_DEBUG, get_tag(), "<<<<<");
1278         SLOG(LOG_DEBUG, get_tag(), "  ");
1279
1280         return 0;
1281 }
1282