server/sttd_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 "sttd_main.h"
  16 #include "sttd_dbus.h"
  17 #include "sttd_dbus_server.h"
  18 #include "sttd_server.h"
  19 #include "sttd_client_data.h"
  20 #include "stt_defs.h"
  21
  22 /*
  23 * Dbus Client-Daemon Server
  24 */
  25
  26 int sttd_dbus_server_hello(DBusConnection* conn, DBusMessage* msg)
  27 {
  28         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Hello");
  29
  30         DBusMessage* reply;
  31         reply = dbus_message_new_method_return(msg);
  32
  33         if (NULL != reply) {
  34                 if (!dbus_connection_send(conn, reply, NULL)) {
  35                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
  36                 }
  37
  38                 dbus_connection_flush(conn);
  39                 dbus_message_unref(reply);
  40         } else {
  41                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
  42         }
  43
  44         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
  45         SLOG(LOG_DEBUG, TAG_STTD, "  ");
  46
  47         return 0;
  48 }
  49
  50 int sttd_dbus_server_initialize(DBusConnection* conn, DBusMessage* msg)
  51 {
  52         DBusError err;
  53         dbus_error_init(&err);
  54
  55         int pid;
  56         int uid;
  57         bool silence_supported = false;
  58         bool profanity_supported = false;
  59         bool punctuation_supported = false;
  60
  61         int ret = STTD_ERROR_OPERATION_FAILED;
  62
  63         dbus_message_get_args(msg, &err,
  64                 DBUS_TYPE_INT32, &pid,
  65                 DBUS_TYPE_INT32, &uid,
  66                 DBUS_TYPE_INVALID);
  67
  68         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Initialize");
  69
  70         if (dbus_error_is_set(&err)) {
  71                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt initialize : get arguments error (%s)", err.message);
  72                 dbus_error_free(&err);
  73                 ret = STTD_ERROR_OPERATION_FAILED;
  74         } else {
  75                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt initialize : pid(%d), uid(%d)", pid , uid);
  76                 ret =  sttd_server_initialize(pid, uid, &silence_supported, &profanity_supported, &punctuation_supported);
  77         }
  78
  79         DBusMessage* reply;
  80         reply = dbus_message_new_method_return(msg);
  81
  82         if (NULL != reply) {
  83                 dbus_message_append_args(reply,
  84                         DBUS_TYPE_INT32, &ret,
  85                         DBUS_TYPE_INT32, &silence_supported,
  86                         DBUS_TYPE_INT32, &profanity_supported,
  87                         DBUS_TYPE_INT32, &punctuation_supported,
  88                         DBUS_TYPE_INVALID);
  89
  90                 if (0 == ret) {
  91                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), silence(%d), profanity(%d), punctuation(%d)",
  92                                 ret, silence_supported, profanity_supported, punctuation_supported);
  93                 } else {
  94                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
  95                 }
  96
  97                 if (!dbus_connection_send(conn, reply, NULL)) {
  98                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
  99                 }
 100
 101                 dbus_connection_flush(conn);
 102                 dbus_message_unref(reply);
 103         } else {
 104                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 105         }
 106
 107         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 108         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 109
 110         return 0;
 111 }
 112
 113 int sttd_dbus_server_finalize(DBusConnection* conn, DBusMessage* msg)
 114 {
 115         DBusError err;
 116         dbus_error_init(&err);
 117
 118         int uid;
 119         int ret = STTD_ERROR_OPERATION_FAILED;
 120         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 121
 122         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Finalize");
 123
 124         if (dbus_error_is_set(&err)) {
 125                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt finalize : get arguments error (%s)", err.message);
 126                 dbus_error_free(&err);
 127                 ret = STTD_ERROR_OPERATION_FAILED;
 128         } else {
 129                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt finalize : uid(%d)", uid);
 130                 ret =  sttd_server_finalize(uid);
 131         }
 132
 133         DBusMessage* reply;
 134
 135         reply = dbus_message_new_method_return(msg);
 136
 137         if (NULL != reply) {
 138                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 139
 140                 if (0 == ret) {
 141                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 142                 } else {
 143                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 144                 }
 145
 146                 if (!dbus_connection_send(conn, reply, NULL)) {
 147                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 148                 }
 149
 150                 dbus_connection_flush(conn);
 151                 dbus_message_unref(reply);
 152         } else {
 153                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 154         }
 155
 156         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 157         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 158
 159         return 0;
 160 }
 161
 162 int sttd_dbus_server_get_support_lang(DBusConnection* conn, DBusMessage* msg)
 163 {
 164         DBusError err;
 165         dbus_error_init(&err);
 166
 167         int uid;
 168         int ret = STTD_ERROR_OPERATION_FAILED;
 169         GList* lang_list = NULL;
 170
 171         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 172
 173         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get supported langs");
 174
 175         if (dbus_error_is_set(&err)) {
 176                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt supported langs : get arguments error (%s)", err.message);
 177                 dbus_error_free(&err);
 178                 ret = STTD_ERROR_OPERATION_FAILED;
 179         } else {
 180                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt supported langs : uid(%d)", uid);
 181                 ret = sttd_server_get_supported_languages(uid, &lang_list);
 182         }
 183
 184         DBusMessage* reply;
 185         reply = dbus_message_new_method_return(msg);
 186
 187         if (NULL != reply) {
 188                 DBusMessageIter args;
 189                 dbus_message_iter_init_append(reply, &args);
 190
 191                 /* Append result*/
 192                 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret));
 193
 194                 if (0 == ret) {
 195                         /* Append language size */
 196                         int size = g_list_length(lang_list);
 197
 198                         if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
 199                                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to append type");
 200                                 ret = STTD_ERROR_OPERATION_FAILED;
 201                         } else {
 202                                 GList *iter = NULL;
 203                                 char* temp_lang;
 204
 205                                 iter = g_list_first(lang_list);
 206
 207                                 while (NULL != iter) {
 208                                         temp_lang = iter->data;
 209
 210                                         dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(temp_lang) );
 211
 212                                         if (NULL != temp_lang)
 213                                                 free(temp_lang);
 214
 215                                         lang_list = g_list_remove_link(lang_list, iter);
 216
 217                                         iter = g_list_first(lang_list);
 218                                 }
 219                         }
 220                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT] Result(%d)", ret);
 221                 } else {
 222                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 223                 }
 224
 225                 if (!dbus_connection_send(conn, reply, NULL)) {
 226                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 227                 }
 228
 229                 dbus_connection_flush(conn);
 230                 dbus_message_unref(reply);
 231         } else {
 232                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 233         }
 234
 235         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 236         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 237
 238         return 0;
 239 }
 240
 241 int sttd_dbus_server_get_default_lang(DBusConnection* conn, DBusMessage* msg)
 242 {
 243         DBusError err;
 244         dbus_error_init(&err);
 245
 246         int uid;
 247         char* lang;
 248         int ret = STTD_ERROR_OPERATION_FAILED;
 249
 250         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 251
 252         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get default langs");
 253
 254         if (dbus_error_is_set(&err)) {
 255                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt get default lang : get arguments error (%s)", err.message);
 256                 dbus_error_free(&err);
 257                 ret = STTD_ERROR_OPERATION_FAILED;
 258         } else {
 259                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get default lang : uid(%d)", uid);
 260                 ret = sttd_server_get_current_langauage(uid, &lang);
 261         }
 262
 263         DBusMessage* reply;
 264         reply = dbus_message_new_method_return(msg);
 265
 266         if (NULL != reply) {
 267                 if (0 == ret) {
 268                         /* Append result and language */
 269                         dbus_message_append_args( reply,
 270                                 DBUS_TYPE_INT32, &ret,
 271                                 DBUS_TYPE_STRING, &lang,
 272                                 DBUS_TYPE_INVALID);
 273
 274                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 275
 276                         if (NULL != lang) {
 277                                 g_free(lang);
 278                         }
 279                 } else {
 280                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 281
 282                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 283                 }
 284
 285                 if (!dbus_connection_send(conn, reply, NULL)) {
 286                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 287                 }
 288
 289                 dbus_connection_flush(conn);
 290                 dbus_message_unref(reply);
 291         } else {
 292                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 293         }
 294
 295         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 296         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 297
 298         return 0;
 299 }
 300
 301 int sttd_dbus_server_is_partial_result_supported(DBusConnection* conn, DBusMessage* msg)
 302 {
 303         DBusError err;
 304         dbus_error_init(&err);
 305
 306         int uid;
 307         int support = -1;
 308         int ret = STTD_ERROR_OPERATION_FAILED;
 309
 310         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 311
 312         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT is partial result supported");
 313
 314         if (dbus_error_is_set(&err)) {
 315                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt is partial result supported : get arguments error (%s)", err.message);
 316                 dbus_error_free(&err);
 317                 ret = STTD_ERROR_OPERATION_FAILED;
 318         } else {
 319                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt is partial result supported : uid(%d)", uid);
 320                 ret = sttd_server_is_partial_result_supported(uid, &support);
 321         }
 322
 323         DBusMessage* reply;
 324         reply = dbus_message_new_method_return(msg);
 325
 326         if (NULL != reply) {
 327                 /* Append result and language */
 328                 dbus_message_append_args(reply,
 329                         DBUS_TYPE_INT32, &ret,
 330                         DBUS_TYPE_INT32, &support,
 331                         DBUS_TYPE_INVALID);
 332
 333                 if (0 == ret) {
 334                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), Support(%s)", ret, support ? "true" : "false");
 335                 } else {
 336                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 337                 }
 338
 339                 if (!dbus_connection_send(conn, reply, NULL)) {
 340                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 341                 }
 342
 343                 dbus_connection_flush(conn);
 344                 dbus_message_unref(reply);
 345         } else {
 346                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 347         }
 348
 349         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 350         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 351
 352         return 0;
 353 }
 354
 355 int sttd_dbus_server_get_audio_volume(DBusConnection* conn, DBusMessage* msg)
 356 {
 357         DBusError err;
 358         dbus_error_init(&err);
 359
 360         int uid;
 361         float current_volume = 0.0;
 362         int ret = STTD_ERROR_OPERATION_FAILED;
 363
 364         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 365
 366         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get audio volume");
 367
 368         if (dbus_error_is_set(&err)) {
 369                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt get audio volume : get arguments error (%s)", err.message);
 370                 dbus_error_free(&err);
 371                 ret = STTD_ERROR_OPERATION_FAILED;
 372         } else {
 373                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get audio volume : uid(%d)", uid);
 374                 ret =  sttd_server_get_audio_volume(uid, &current_volume);
 375         }
 376
 377         DBusMessage* reply;
 378         reply = dbus_message_new_method_return(msg);
 379
 380         if (NULL != reply) {
 381                 double temp = (double)current_volume;
 382
 383                 dbus_message_append_args(reply,
 384                         DBUS_TYPE_INT32, &ret,
 385                         DBUS_TYPE_DOUBLE, &temp,
 386                         DBUS_TYPE_INVALID);
 387
 388                 if (0 == ret) {
 389                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), volume - double(%f), float(%f)", ret, temp, current_volume);
 390                 } else {
 391                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 392                 }
 393
 394                 if (!dbus_connection_send(conn, reply, NULL)) {
 395                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 396                 }
 397
 398                 dbus_connection_flush(conn);
 399                 dbus_message_unref(reply);
 400         } else {
 401                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 402         }
 403
 404         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 405         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 406
 407         return 0;
 408 }
 409
 410 int sttd_dbus_server_start(DBusConnection* conn, DBusMessage* msg)
 411 {
 412         DBusError err;
 413         dbus_error_init(&err);
 414
 415         int uid;
 416         char* lang;
 417         char* type;
 418         int profanity;
 419         int punctuation;
 420         int silence;
 421         int ret = STTD_ERROR_OPERATION_FAILED;
 422
 423         dbus_message_get_args(msg, &err,
 424                 DBUS_TYPE_INT32, &uid,
 425                 DBUS_TYPE_STRING, &lang,
 426                 DBUS_TYPE_STRING, &type,
 427                 DBUS_TYPE_INT32, &profanity,
 428                 DBUS_TYPE_INT32, &punctuation,
 429                 DBUS_TYPE_INT32, &silence,
 430                 DBUS_TYPE_INVALID);
 431
 432         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Start");
 433
 434         if (dbus_error_is_set(&err)) {
 435                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt start : get arguments error (%s)", err.message);
 436                 dbus_error_free(&err);
 437                 ret = STTD_ERROR_OPERATION_FAILED;
 438         } else {
 439                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt start : uid(%d), lang(%s), type(%s), profanity(%d), punctuation(%d), silence(%d)"
 440                                         , uid, lang, type, profanity, punctuation, silence);
 441                 ret = sttd_server_start(uid, lang, type, profanity, punctuation, silence);
 442         }
 443
 444         DBusMessage* reply;
 445         reply = dbus_message_new_method_return(msg);
 446
 447         if (NULL != reply) {
 448                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 449
 450                 if (0 == ret) {
 451                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 452                 } else {
 453                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 454                 }
 455
 456                 if (!dbus_connection_send(conn, reply, NULL)) {
 457                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 458                 }
 459
 460                 dbus_connection_flush(conn);
 461                 dbus_message_unref(reply);
 462         } else {
 463                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 464         }
 465
 466         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 467         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 468
 469         return 0;
 470 }
 471
 472 int sttd_dbus_server_stop(DBusConnection* conn, DBusMessage* msg)
 473 {
 474         DBusError err;
 475         dbus_error_init(&err);
 476
 477         int uid;
 478         int ret = STTD_ERROR_OPERATION_FAILED;
 479         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 480
 481         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Stop");
 482
 483         if (dbus_error_is_set(&err)) {
 484                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt stop : get arguments error (%s)", err.message);
 485                 dbus_error_free(&err);
 486                 ret = STTD_ERROR_OPERATION_FAILED;
 487         } else {
 488                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt stop : uid(%d)", uid);
 489                 ret = sttd_server_stop(uid);
 490         }
 491
 492         DBusMessage* reply;
 493         reply = dbus_message_new_method_return(msg);
 494
 495         if (NULL != reply) {
 496                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 497
 498                 if (0 == ret) {
 499                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 500                 } else {
 501                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 502                 }
 503
 504                 if (!dbus_connection_send(conn, reply, NULL)) {
 505                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 506                 }
 507
 508                 dbus_connection_flush(conn);
 509                 dbus_message_unref(reply);
 510         } else {
 511                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 512         }
 513
 514         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 515         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 516
 517         return 0;
 518 }
 519
 520 int sttd_dbus_server_cancel(DBusConnection* conn, DBusMessage* msg)
 521 {
 522         DBusError err;
 523         dbus_error_init(&err);
 524
 525         int uid;
 526         int ret = STTD_ERROR_OPERATION_FAILED;
 527         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 528
 529         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Cancel");
 530
 531         if (dbus_error_is_set(&err)) {
 532                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt cancel : get arguments error (%s)", err.message);
 533                 dbus_error_free(&err);
 534                 ret = STTD_ERROR_OPERATION_FAILED;
 535         } else {
 536                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt cancel : uid(%d)", uid);
 537                 ret = sttd_server_cancel(uid);
 538         }
 539
 540         DBusMessage* reply;
 541         reply = dbus_message_new_method_return(msg);
 542
 543         if (NULL != reply) {
 544                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 545
 546                 if (0 == ret) {
 547                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 548                 } else {
 549                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 550                 }
 551
 552                 if (!dbus_connection_send(conn, reply, NULL)) {
 553                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 554                 }
 555
 556                 dbus_connection_flush(conn);
 557                 dbus_message_unref(reply);
 558         } else {
 559                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 560         }
 561
 562         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 563         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 564
 565         return 0;
 566 }
 567
 568
 569 /*
 570 * Dbus Setting-Daemon Server
 571 */
 572
 573 int sttd_dbus_server_setting_initialize(DBusConnection* conn, DBusMessage* msg)
 574 {
 575         DBusError err;
 576         dbus_error_init(&err);
 577
 578         int pid;
 579         int ret = STTD_ERROR_OPERATION_FAILED;
 580
 581         dbus_message_get_args(msg, &err,
 582                 DBUS_TYPE_INT32, &pid,
 583                 DBUS_TYPE_INVALID);
 584
 585         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Initialize");
 586
 587         if (dbus_error_is_set(&err)) {
 588                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting initializie : get arguments error (%s)", err.message);
 589                 dbus_error_free(&err);
 590                 ret = STTD_ERROR_OPERATION_FAILED;
 591         } else {
 592                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting initializie : uid(%d)", pid);
 593                 ret =  sttd_server_setting_initialize(pid);
 594         }
 595
 596         DBusMessage* reply;
 597         reply = dbus_message_new_method_return(msg);
 598
 599         if (NULL != reply) {
 600                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 601
 602                 if (0 == ret) {
 603                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 604                 } else {
 605                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 606                 }
 607
 608                 if (!dbus_connection_send(conn, reply, NULL)) {
 609                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 610                 }
 611                 dbus_connection_flush(conn);
 612                 dbus_message_unref(reply);
 613         } else {
 614                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 615         }
 616
 617         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 618         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 619
 620         return 0;
 621 }
 622
 623 int sttd_dbus_server_setting_finalize(DBusConnection* conn, DBusMessage* msg)
 624 {
 625         DBusError err;
 626         dbus_error_init(&err);
 627
 628         int pid;
 629         int ret = STTD_ERROR_OPERATION_FAILED;
 630
 631         dbus_message_get_args(msg, &err,
 632                 DBUS_TYPE_INT32, &pid,
 633                 DBUS_TYPE_INVALID);
 634
 635         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Finalize");
 636
 637         if (dbus_error_is_set(&err)) {
 638                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting finalize : get arguments error (%s)", err.message);
 639                 dbus_error_free(&err);
 640                 ret = STTD_ERROR_OPERATION_FAILED;
 641         } else {
 642                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting finalize : uid(%d)", pid);
 643                 ret =  sttd_server_setting_finalize(pid);
 644         }
 645
 646         DBusMessage* reply;
 647         reply = dbus_message_new_method_return(msg);
 648
 649         if (NULL != reply) {
 650                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 651
 652                 if (0 == ret) {
 653                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 654                 } else {
 655                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 656                 }
 657
 658                 if (!dbus_connection_send(conn, reply, NULL)) {
 659                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 660                 }
 661
 662                 dbus_connection_flush(conn);
 663                 dbus_message_unref(reply);
 664         } else {
 665                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 666         }
 667
 668         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 669         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 670
 671         return 0;
 672 }
 673
 674 int sttd_dbus_server_setting_get_engine_list(DBusConnection* conn, DBusMessage* msg)
 675 {
 676         DBusError err;
 677         dbus_error_init(&err);
 678
 679         int pid;
 680         GList* engine_list = NULL;
 681         int ret = STTD_ERROR_OPERATION_FAILED;
 682
 683         dbus_message_get_args(msg, &err,
 684                 DBUS_TYPE_INT32, &pid,
 685                 DBUS_TYPE_INVALID);
 686
 687         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Engine List");
 688
 689         if (dbus_error_is_set(&err)) {
 690                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get engine list : get arguments error (%s)", err.message);
 691                 dbus_error_free(&err);
 692                 ret = STTD_ERROR_OPERATION_FAILED;
 693         } else {
 694                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get engine list : uid(%d)", pid);
 695                 ret = sttd_server_setting_get_engine_list(pid, &engine_list);
 696         }
 697
 698         DBusMessage* reply;
 699         reply = dbus_message_new_method_return(msg);
 700
 701         if (NULL != reply) {
 702                 DBusMessageIter args;
 703
 704                 dbus_message_iter_init_append(reply, &args);
 705
 706                 /* Append result*/
 707                 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret) );
 708
 709                 if (0 == ret) {
 710                         /* Append size */
 711                         int size = g_list_length(engine_list);
 712                         if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
 713                                 ret = STTD_ERROR_OPERATION_FAILED;
 714                         } else {
 715                                 GList *iter = NULL;
 716                                 engine_s* engine;
 717
 718                                 iter = g_list_first(engine_list);
 719
 720                                 while (NULL != iter) {
 721                                         engine = iter->data;
 722
 723                                         if (NULL != engine) {
 724
 725                                                 if (NULL != engine->engine_id && NULL != engine->engine_name && NULL != engine->ug_name) {
 726                                                         SLOG(LOG_DEBUG, TAG_STTD, "engine id : %s, engine name : %s, ug_name, : %s",
 727                                                                 engine->engine_id, engine->engine_name, engine->ug_name);
 728
 729                                                         dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->engine_id) );
 730                                                         dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->engine_name) );
 731                                                         dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->ug_name) );
 732                                                 } else {
 733                                                         SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Engine info is NULL");
 734                                                 }
 735
 736                                                 if (NULL != engine->engine_id)
 737                                                         g_free(engine->engine_id);
 738                                                 if (NULL != engine->engine_name)
 739                                                         g_free(engine->engine_name);
 740                                                 if (NULL != engine->ug_name)
 741                                                         g_free(engine->ug_name);
 742
 743                                                 g_free(engine);
 744                                         } else {
 745                                                 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Engine info is NULL");
 746                                         }
 747
 748                                         engine_list = g_list_remove_link(engine_list, iter);
 749
 750                                         iter = g_list_first(engine_list);
 751                                 }
 752                         }
 753                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT] Result(%d)", ret);
 754                 } else {
 755                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 756                 }
 757
 758                 if (!dbus_connection_send(conn, reply, NULL)) {
 759                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 760                 }
 761
 762                 dbus_connection_flush(conn);
 763                 dbus_message_unref(reply);
 764         } else {
 765                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 766         }
 767
 768         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 769         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 770
 771         return 0;
 772 }
 773
 774 int sttd_dbus_server_setting_get_engine(DBusConnection* conn, DBusMessage* msg)
 775 {
 776         DBusError err;
 777         dbus_error_init(&err);
 778
 779         int pid;
 780         char* engine_id;
 781         int ret = STTD_ERROR_OPERATION_FAILED;
 782
 783         dbus_message_get_args(msg, &err,
 784                 DBUS_TYPE_INT32, &pid,
 785                 DBUS_TYPE_INVALID);
 786
 787         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Engine");
 788
 789         if (dbus_error_is_set(&err)) {
 790                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get engine : get arguments error (%s)", err.message);
 791                 dbus_error_free(&err);
 792                 ret = STTD_ERROR_OPERATION_FAILED;
 793         } else {
 794                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get engine : uid(%d)", pid);
 795                 ret = sttd_server_setting_get_engine(pid, &engine_id);
 796         }
 797
 798         DBusMessage* reply;
 799         reply = dbus_message_new_method_return(msg);
 800
 801         if (NULL != reply) {
 802                 if (0 == ret) {
 803                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_STRING, &engine_id, DBUS_TYPE_INVALID);
 804
 805                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), Engine id(%s)", ret, engine_id);
 806                         g_free(engine_id);
 807                 } else {
 808                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 809                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 810                 }
 811
 812                 if (!dbus_connection_send(conn, reply, NULL)) {
 813                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 814                 }
 815
 816                 dbus_connection_flush(conn);
 817                 dbus_message_unref(reply);
 818         } else {
 819                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 820         }
 821
 822         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 823         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 824
 825         return 0;
 826 }
 827
 828 int sttd_dbus_server_setting_set_engine(DBusConnection* conn, DBusMessage* msg)
 829 {
 830         DBusError err;
 831         dbus_error_init(&err);
 832
 833         int pid;
 834         char* engine_id;
 835         int ret = STTD_ERROR_OPERATION_FAILED;
 836
 837         dbus_message_get_args(msg, &err,
 838                 DBUS_TYPE_INT32, &pid,
 839                 DBUS_TYPE_STRING, &engine_id,
 840                 DBUS_TYPE_INVALID);
 841
 842         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Set Engine");
 843
 844         if (dbus_error_is_set(&err)) {
 845                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting set engine : get arguments error (%s)", err.message);
 846                 dbus_error_free(&err);
 847                 ret = STTD_ERROR_OPERATION_FAILED;
 848         } else {
 849                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting set engine : uid(%d)", pid);
 850                 ret = sttd_server_setting_set_engine(pid, engine_id);
 851         }
 852
 853         DBusMessage* reply;
 854         reply = dbus_message_new_method_return(msg);
 855
 856         if (NULL != reply) {
 857                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 858
 859                 if (0 == ret) {
 860                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d) ", ret);
 861                 } else {
 862                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d) ", ret);
 863                 }
 864
 865                 if (!dbus_connection_send(conn, reply, NULL)) {
 866                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 867                 }
 868
 869                 dbus_connection_flush(conn);
 870                 dbus_message_unref(reply);
 871         } else {
 872                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 873         }
 874
 875         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 876         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 877
 878         return 0;
 879 }
 880
 881 int sttd_dbus_server_setting_get_language_list(DBusConnection* conn, DBusMessage* msg)
 882 {
 883         DBusError err;
 884         dbus_error_init(&err);
 885
 886         int pid;
 887         GList* lang_list = NULL;
 888         char* engine_id;
 889         int ret = STTD_ERROR_OPERATION_FAILED;
 890
 891         dbus_message_get_args(msg, &err,
 892                 DBUS_TYPE_INT32, &pid,
 893                 DBUS_TYPE_INVALID);
 894
 895         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Language List");
 896
 897         if (dbus_error_is_set(&err)) {
 898                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get language list : get arguments error (%s)", err.message);
 899                 dbus_error_free(&err);
 900                 ret = STTD_ERROR_OPERATION_FAILED;
 901         } else {
 902                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get language list : uid(%d)", pid);
 903                 ret = sttd_server_setting_get_lang_list(pid, &engine_id, &lang_list);
 904         }
 905
 906         DBusMessage* reply;
 907         reply = dbus_message_new_method_return(msg);
 908
 909         if (NULL != reply) {
 910                 DBusMessageIter args;
 911                 dbus_message_iter_init_append(reply, &args);
 912
 913                 /* Append result*/
 914                 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &ret);
 915
 916                 if (0 == ret) {
 917                         dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine_id));
 918
 919                         int size = g_list_length(lang_list);
 920                         SLOG(LOG_ERROR, TAG_STTD, "[OUT DEBUG] Count(%d) ", size);
 921
 922                         /* Append size */
 923                         if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
 924                                 ret = STTD_ERROR_OPERATION_FAILED;
 925                                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d) ", ret);
 926                         } else {
 927                                 GList *iter = NULL;
 928                                 char* temp_lang;
 929
 930                                 iter = g_list_first(lang_list);
 931
 932                                 while (NULL != iter) {
 933                                         temp_lang = iter->data;
 934
 935                                         dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(temp_lang) );
 936
 937                                         if (NULL != temp_lang)
 938                                                 free(temp_lang);
 939
 940                                         lang_list = g_list_remove_link(lang_list, iter);
 941
 942                                         iter = g_list_first(lang_list);
 943                                 }
 944                                 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d) ", ret);
 945                         }
 946                 } else {
 947                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d) ", ret);
 948                 }
 949
 950                 if (!dbus_connection_send(conn, reply, NULL)) {
 951                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 952                 }
 953
 954                 dbus_connection_flush(conn);
 955                 dbus_message_unref(reply);
 956         } else {
 957                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 958         }
 959
 960         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 961         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 962
 963         return 0;
 964 }
 965
 966 int sttd_dbus_server_setting_get_default_language(DBusConnection* conn, DBusMessage* msg)
 967 {
 968         DBusError err;
 969         dbus_error_init(&err);
 970
 971         int pid;
 972         char* language;
 973         int ret = STTD_ERROR_OPERATION_FAILED;
 974
 975         dbus_message_get_args(msg, &err,
 976                 DBUS_TYPE_INT32, &pid,
 977                 DBUS_TYPE_INVALID);
 978
 979         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Default Language");
 980
 981         if (dbus_error_is_set(&err)) {
 982                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get default language : get arguments error (%s)", err.message);
 983                 dbus_error_free(&err);
 984                 ret = STTD_ERROR_OPERATION_FAILED;
 985         } else {
 986                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get default language : uid(%d)", pid);
 987                 ret = sttd_server_setting_get_default_language(pid, &language);
 988         }
 989
 990         DBusMessage* reply;
 991         reply = dbus_message_new_method_return(msg);
 992
 993         if (NULL != reply) {
 994                 if (0 == ret) {
 995                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_STRING, &language, DBUS_TYPE_INVALID);
 996                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), Default Language(%s)", ret, language);
 997                         free(language);
 998                 } else {
 999                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1000                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1001                 }
1002
1003                 if (!dbus_connection_send(conn, reply, NULL)) {
1004                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1005                 }
1006
1007                 dbus_connection_flush(conn);
1008                 dbus_message_unref(reply);
1009         } else {
1010                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1011         }
1012
1013         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1014         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1015
1016         return 0;
1017 }
1018
1019 int sttd_dbus_server_setting_set_default_language(DBusConnection* conn, DBusMessage* msg)
1020 {
1021         DBusError err;
1022         dbus_error_init(&err);
1023
1024         int pid;
1025         char* language;
1026         int ret = STTD_ERROR_OPERATION_FAILED;
1027
1028         dbus_message_get_args(msg, &err,
1029                 DBUS_TYPE_INT32, &pid,
1030                 DBUS_TYPE_STRING, &language,
1031                 DBUS_TYPE_INVALID);
1032
1033         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Set Default Language");
1034
1035         if (dbus_error_is_set(&err)) {
1036                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting set default language : get arguments error (%s)", err.message);
1037                 dbus_error_free(&err);
1038                 ret = STTD_ERROR_OPERATION_FAILED;
1039         } else {
1040                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting set default language : uid(%d), language(%s)", pid, language);
1041                 ret = sttd_server_setting_set_default_language(pid, language);
1042         }
1043
1044         DBusMessage* reply;
1045         reply = dbus_message_new_method_return(msg);
1046
1047         if (NULL != reply) {
1048                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1049
1050                 if (0 == ret) {
1051                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1052                 } else {
1053                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1054                 }
1055
1056                 if (!dbus_connection_send(conn, reply, NULL)) {
1057                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1058                 }
1059
1060                 dbus_connection_flush(conn);
1061                 dbus_message_unref(reply);
1062         } else {
1063                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1064         }
1065
1066         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1067         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1068
1069         return 0;
1070 }
1071
1072 int sttd_dbus_server_setting_get_profanity_filter(DBusConnection* conn, DBusMessage* msg)
1073 {
1074         DBusError err;
1075         dbus_error_init(&err);
1076
1077         int pid;
1078         bool value;
1079         int ret = STTD_ERROR_OPERATION_FAILED;
1080
1081         dbus_message_get_args(msg, &err,
1082                 DBUS_TYPE_INT32, &pid,
1083                 DBUS_TYPE_INVALID);
1084
1085         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Profanity Filter");
1086
1087         if (dbus_error_is_set(&err)) {
1088                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get profanity filter : get arguments error (%s)", err.message);
1089                 dbus_error_free(&err);
1090                 ret = STTD_ERROR_OPERATION_FAILED;
1091         } else {
1092                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get profanity filter : uid(%d)", pid);
1093                 ret = sttd_server_setting_get_profanity_filter(pid, &value);
1094         }
1095
1096         DBusMessage* reply;
1097         reply = dbus_message_new_method_return(msg);
1098
1099         if (NULL != reply) {
1100                 if (0 == ret) {
1101                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INT32, &value, DBUS_TYPE_INVALID);
1102                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d) , value(%s)", ret, value ? "true":"false");
1103                 } else {
1104                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1105                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1106                 }
1107
1108                 if (!dbus_connection_send(conn, reply, NULL)) {
1109                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1110                 }
1111
1112                 dbus_connection_flush(conn);
1113                 dbus_message_unref(reply);
1114         } else {
1115                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1116         }
1117
1118         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1119         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1120
1121         return 0;
1122 }
1123
1124 int sttd_dbus_server_setting_set_profanity_filter(DBusConnection* conn, DBusMessage* msg)
1125 {
1126         DBusError err;
1127         dbus_error_init(&err);
1128
1129         int pid;
1130         bool value;
1131         int ret = STTD_ERROR_OPERATION_FAILED;
1132
1133         dbus_message_get_args(msg, &err,
1134                 DBUS_TYPE_INT32, &pid,
1135                 DBUS_TYPE_INT32, &value,
1136                 DBUS_TYPE_INVALID);
1137
1138         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Set Profanity Filter");
1139
1140         if (dbus_error_is_set(&err)) {
1141                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting set profanity filter : get arguments error (%s)", err.message);
1142                 dbus_error_free(&err);
1143                 ret = STTD_ERROR_OPERATION_FAILED;
1144         } else {
1145                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting set profanity filter : uid(%d), value(%s)", pid, value ? "true":"false");
1146                 ret =  sttd_server_setting_set_profanity_filter(pid, (bool)value);
1147         }
1148
1149         DBusMessage* reply;
1150         reply = dbus_message_new_method_return(msg);
1151
1152         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1153
1154         if (NULL != reply) {
1155                 if (0 == ret) {
1156                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1157                 } else {
1158                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1159                 }
1160
1161                 if (!dbus_connection_send(conn, reply, NULL)) {
1162                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1163                 }
1164
1165                 dbus_connection_flush(conn);
1166                 dbus_message_unref(reply);
1167         } else {
1168                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1169         }
1170
1171         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1172         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1173
1174         return 0;
1175 }
1176
1177 int sttd_dbus_server_setting_get_punctuation_override(DBusConnection* conn, DBusMessage* msg)
1178 {
1179         DBusError err;
1180         dbus_error_init(&err);
1181
1182         int pid;
1183         bool value;
1184         int ret = STTD_ERROR_OPERATION_FAILED;
1185
1186         dbus_message_get_args(msg, &err,
1187                 DBUS_TYPE_INT32, &pid,
1188                 DBUS_TYPE_INVALID);
1189
1190         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Punctuation Override");
1191
1192         if (dbus_error_is_set(&err)) {
1193                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get punctuation override : get arguments error (%s)", err.message);
1194                 dbus_error_free(&err);
1195                 ret = STTD_ERROR_OPERATION_FAILED;
1196         } else {
1197                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get punctuation override : uid(%d)", pid);
1198                 ret =  sttd_server_setting_get_punctuation_override(pid, &value);
1199         }
1200
1201         DBusMessage* reply;
1202         reply = dbus_message_new_method_return(msg);
1203
1204         if (NULL != reply) {
1205                 if (0 == ret) {
1206                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INT32, &value, DBUS_TYPE_INVALID);
1207                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d) , value(%s)", ret, value ? "true":"false");
1208                 } else {
1209                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1210                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1211                 }
1212
1213                 if (!dbus_connection_send(conn, reply, NULL)) {
1214                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1215                         return -1;
1216                 }
1217
1218                 dbus_connection_flush(conn);
1219                 dbus_message_unref(reply);
1220         } else {
1221                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1222         }
1223
1224         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1225         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1226
1227         return 0;
1228 }
1229
1230 int sttd_dbus_server_setting_set_punctuation_override(DBusConnection* conn, DBusMessage* msg)
1231 {
1232         DBusError err;
1233         dbus_error_init(&err);
1234
1235         int pid;
1236         bool value;
1237         int ret = STTD_ERROR_OPERATION_FAILED;
1238
1239         dbus_message_get_args(msg, &err,
1240                 DBUS_TYPE_INT32, &pid,
1241                 DBUS_TYPE_INT32, &value,
1242                 DBUS_TYPE_INVALID);
1243
1244         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Set Profanity Filter");
1245
1246         if (dbus_error_is_set(&err)) {
1247                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting set punctuation override : get arguments error (%s)", err.message);
1248                 dbus_error_free(&err);
1249                 ret = STTD_ERROR_OPERATION_FAILED;
1250         } else {
1251                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting set punctuation override : uid(%d), value(%s)", pid, value ? "true":"false");
1252                 ret =  sttd_server_setting_set_punctuation_override(pid, value);
1253         }
1254
1255         DBusMessage* reply;
1256         reply = dbus_message_new_method_return(msg);
1257
1258         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1259
1260         if (NULL != reply) {
1261                 if (0 == ret) {
1262                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1263                 } else {
1264                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1265                 }
1266
1267                 if (!dbus_connection_send(conn, reply, NULL)) {
1268                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1269                         return -1;
1270                 }
1271
1272                 dbus_connection_flush(conn);
1273                 dbus_message_unref(reply);
1274         } else {
1275                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1276         }
1277
1278         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1279         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1280
1281         return 0;
1282 }
1283
1284 int sttd_dbus_server_setting_get_silence_detection(DBusConnection* conn, DBusMessage* msg)
1285 {
1286         DBusError err;
1287         dbus_error_init(&err);
1288
1289         int pid;
1290         bool value;
1291         int ret = STTD_ERROR_OPERATION_FAILED;
1292
1293         dbus_message_get_args(msg, &err,
1294                 DBUS_TYPE_INT32, &pid,
1295                 DBUS_TYPE_INVALID);
1296
1297         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Silence Detection");
1298
1299         if (dbus_error_is_set(&err)) {
1300                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get silence detection : get arguments error (%s)", err.message);
1301                 dbus_error_free(&err);
1302                 ret = STTD_ERROR_OPERATION_FAILED;
1303         } else {
1304                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get silence detection : uid(%d)", pid);
1305                 ret =  sttd_server_setting_get_silence_detection(pid, &value);
1306         }
1307
1308         DBusMessage* reply;
1309         reply = dbus_message_new_method_return(msg);
1310
1311         if (NULL != reply) {
1312                 if (0 == ret) {
1313                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INT32, &value, DBUS_TYPE_INVALID);
1314                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d) , Value(%s)", ret, value ? "true":"false");
1315                 } else {
1316                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1317                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1318                 }
1319
1320                 if (!dbus_connection_send(conn, reply, NULL)) {
1321                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1322                         return -1;
1323                 }
1324
1325                 dbus_connection_flush(conn);
1326                 dbus_message_unref(reply);
1327         } else {
1328                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1329         }
1330
1331         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1332         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1333
1334         return 0;
1335 }
1336
1337 int sttd_dbus_server_setting_set_silence_detection(DBusConnection* conn, DBusMessage* msg)
1338 {
1339         DBusError err;
1340         dbus_error_init(&err);
1341
1342         int pid;
1343         bool value;
1344         int ret = STTD_ERROR_OPERATION_FAILED;
1345
1346         dbus_message_get_args(msg, &err,
1347                 DBUS_TYPE_INT32, &pid,
1348                 DBUS_TYPE_INT32, &value,
1349                 DBUS_TYPE_INVALID);
1350         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Set Silence Detection");
1351
1352         if (dbus_error_is_set(&err)) {
1353                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting set silence detection : get arguments error (%s)", err.message);
1354                 dbus_error_free(&err);
1355                 ret = STTD_ERROR_OPERATION_FAILED;
1356         } else {
1357                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting set silence detection : uid(%d), value(%s)", pid, value ? "true":"false");
1358                 ret =  sttd_server_setting_set_silence_detection(pid, value);
1359         }
1360
1361         DBusMessage* reply;
1362         reply = dbus_message_new_method_return(msg);
1363
1364         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1365
1366         if (NULL != reply) {
1367                 if (0 == ret) {
1368                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1369                 } else {
1370                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1371                 }
1372
1373                 if (!dbus_connection_send(conn, reply, NULL)) {
1374                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1375                 }
1376
1377                 dbus_connection_flush(conn);
1378                 dbus_message_unref(reply);
1379         } else {
1380                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1381         }
1382
1383         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1384         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1385
1386         return 0;
1387 }
1388
1389
1390 int sttd_dbus_server_setting_get_engine_setting(DBusConnection* conn, DBusMessage* msg)
1391 {
1392         DBusError err;
1393         dbus_error_init(&err);
1394
1395         int pid;
1396         char* engine_id;
1397         GList* engine_setting_list = NULL;
1398         int ret = STTD_ERROR_OPERATION_FAILED;
1399
1400         dbus_message_get_args(msg, &err,
1401                 DBUS_TYPE_INT32, &pid,
1402                 DBUS_TYPE_INVALID);
1403
1404         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Engine Setting");
1405
1406         if (dbus_error_is_set(&err)) {
1407                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get engine setting : get arguments error (%s)", err.message);
1408                 dbus_error_free(&err);
1409                 ret = STTD_ERROR_OPERATION_FAILED;
1410         } else {
1411                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get engine setting : uid(%d)", pid);
1412                 ret = sttd_server_setting_get_engine_setting(pid, &engine_id, &engine_setting_list);
1413         }
1414
1415         DBusMessage* reply;
1416         reply = dbus_message_new_method_return(msg);
1417
1418         if (NULL != reply) {
1419                 DBusMessageIter args;
1420                 dbus_message_iter_init_append(reply, &args);
1421
1422                 /* Append result*/
1423                 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret) );
1424
1425                 if (0 == ret) {
1426                         if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine_id))) {
1427                                 ret = STTD_ERROR_OPERATION_FAILED;
1428                                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to add engine id");
1429                         } else {
1430                                 if (NULL != engine_id)  free(engine_id);
1431
1432                                 /* Append size */
1433                                 int size = g_list_length(engine_setting_list);
1434                                 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
1435                                         ret = STTD_ERROR_OPERATION_FAILED;
1436                                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] setting get engine setting : result(%d)", ret);
1437                                 } else {
1438                                         GList *iter = NULL;
1439                                         engine_setting_s* setting;
1440
1441                                         iter = g_list_first(engine_setting_list);
1442
1443                                         while (NULL != iter) {
1444                                                 setting = iter->data;
1445
1446                                                 if (NULL != setting) {
1447                                                         if (NULL != setting->key && NULL != setting->value) {
1448                                                                 dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(setting->key) );
1449                                                                 dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(setting->value) );
1450                                                         } else {
1451                                                                 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] setting key is NULL");
1452                                                         }
1453
1454                                                         if (NULL != setting->key)
1455                                                                 g_free(setting->key);
1456                                                         if (NULL != setting->value)
1457                                                                 g_free(setting->value);
1458
1459                                                         g_free(setting);
1460                                                 } else {
1461                                                         SLOG(LOG_ERROR, TAG_STTD, "[ERROR] setting key is NULL");
1462                                                 }
1463
1464                                                 engine_setting_list = g_list_remove_link(engine_setting_list, iter);
1465
1466                                                 iter = g_list_first(engine_setting_list);
1467                                         }
1468                                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] setting engine setting list : result(%d) \n", ret);
1469                                 }
1470                         }
1471                 } else {
1472                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1473                 }
1474
1475                 if (!dbus_connection_send(conn, reply, NULL)) {
1476                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1477                 }
1478
1479                 dbus_connection_flush(conn);
1480                 dbus_message_unref(reply);
1481         } else {
1482                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1483         }
1484
1485         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1486         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1487
1488         return 0;
1489 }
1490
1491 int sttd_dbus_server_setting_set_engine_setting(DBusConnection* conn, DBusMessage* msg)
1492 {
1493         DBusError err;
1494         dbus_error_init(&err);
1495
1496         int pid;
1497         char* key;
1498         char* value;
1499         int ret = STTD_ERROR_OPERATION_FAILED;
1500
1501         dbus_message_get_args(msg, &err,
1502                 DBUS_TYPE_INT32, &pid,
1503                 DBUS_TYPE_STRING, &key,
1504                 DBUS_TYPE_STRING, &value,
1505                 DBUS_TYPE_INVALID);
1506
1507         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Set Engine Setting");
1508
1509         if (dbus_error_is_set(&err)) {
1510                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting set engine setting : get arguments error (%s)", err.message);
1511                 dbus_error_free(&err);
1512                 ret = STTD_ERROR_OPERATION_FAILED;
1513         } else {
1514                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting set engine setting : uid(%d), key(%s), value(%s)", pid, key, value);
1515                 ret = sttd_server_setting_set_engine_setting(pid, key, value);
1516         }
1517
1518         DBusMessage* reply;
1519         reply = dbus_message_new_method_return(msg);
1520
1521         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1522
1523         if (NULL != reply) {
1524                 if (0 == ret) {
1525                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1526                 } else {
1527                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1528                 }
1529
1530                 if (!dbus_connection_send(conn, reply, NULL)) {
1531                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1532                 }
1533
1534                 dbus_connection_flush(conn);
1535                 dbus_message_unref(reply);
1536         } else {
1537                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1538         }
1539
1540         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1541         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1542
1543         return 0;
1544 }
1545
1546 int sttd_dbus_server_stop_by_daemon(DBusMessage* msg)
1547 {
1548         DBusError err;
1549         dbus_error_init(&err);
1550
1551         int uid;
1552
1553         dbus_message_get_args(msg, &err,
1554                 DBUS_TYPE_INT32, &uid,
1555                 DBUS_TYPE_INVALID);
1556
1557         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Stop by daemon");
1558
1559         if (dbus_error_is_set(&err)) {
1560                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] sttd stop by daemon : Get arguments error (%s)", err.message);
1561                 dbus_error_free(&err);
1562         } else {
1563                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] sttd stop by daemon : uid(%d)", uid);
1564                 sttd_server_stop(uid);
1565
1566                 /* check silence detection option from config */
1567                 int ret = sttdc_send_set_state(uid, (int)APP_STATE_PROCESSING);
1568                 if (0 == ret) {
1569                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1570                 } else {
1571                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1572                         /* Remove client */
1573                         sttd_server_finalize(uid);
1574                 }
1575         }
1576
1577         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1578         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1579
1580         return 0;
1581 }