server/ttsd_dbus_server.c

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