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_start(DBusConnection* conn, DBusMessage* msg)
 356 {
 357         DBusError err;
 358         dbus_error_init(&err);
 359
 360         int uid;
 361         char* lang;
 362         char* type;
 363         int profanity;
 364         int punctuation;
 365         int silence;
 366         int ret = STTD_ERROR_OPERATION_FAILED;
 367
 368         dbus_message_get_args(msg, &err,
 369                 DBUS_TYPE_INT32, &uid,
 370                 DBUS_TYPE_STRING, &lang,
 371                 DBUS_TYPE_STRING, &type,
 372                 DBUS_TYPE_INT32, &profanity,
 373                 DBUS_TYPE_INT32, &punctuation,
 374                 DBUS_TYPE_INT32, &silence,
 375                 DBUS_TYPE_INVALID);
 376
 377         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Start");
 378
 379         if (dbus_error_is_set(&err)) {
 380                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt start : get arguments error (%s)", err.message);
 381                 dbus_error_free(&err);
 382                 ret = STTD_ERROR_OPERATION_FAILED;
 383         } else {
 384                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt start : uid(%d), lang(%s), type(%s), profanity(%d), punctuation(%d), silence(%d)"
 385                                         , uid, lang, type, profanity, punctuation, silence);
 386                 ret = sttd_server_start(uid, lang, type, profanity, punctuation, silence);
 387         }
 388
 389         DBusMessage* reply;
 390         reply = dbus_message_new_method_return(msg);
 391
 392         if (NULL != reply) {
 393                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 394
 395                 if (0 == ret) {
 396                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 397                 } else {
 398                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 399                 }
 400
 401                 if (!dbus_connection_send(conn, reply, NULL)) {
 402                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 403                 }
 404
 405                 dbus_connection_flush(conn);
 406                 dbus_message_unref(reply);
 407         } else {
 408                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 409         }
 410
 411         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 412         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 413
 414         return 0;
 415 }
 416
 417 int sttd_dbus_server_stop(DBusConnection* conn, DBusMessage* msg)
 418 {
 419         DBusError err;
 420         dbus_error_init(&err);
 421
 422         int uid;
 423         int ret = STTD_ERROR_OPERATION_FAILED;
 424         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 425
 426         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Stop");
 427
 428         if (dbus_error_is_set(&err)) {
 429                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt stop : get arguments error (%s)", err.message);
 430                 dbus_error_free(&err);
 431                 ret = STTD_ERROR_OPERATION_FAILED;
 432         } else {
 433                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt stop : uid(%d)", uid);
 434                 ret = sttd_server_stop(uid);
 435         }
 436
 437         DBusMessage* reply;
 438         reply = dbus_message_new_method_return(msg);
 439
 440         if (NULL != reply) {
 441                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 442
 443                 if (0 == ret) {
 444                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 445                 } else {
 446                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 447                 }
 448
 449                 if (!dbus_connection_send(conn, reply, NULL)) {
 450                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 451                 }
 452
 453                 dbus_connection_flush(conn);
 454                 dbus_message_unref(reply);
 455         } else {
 456                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 457         }
 458
 459         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 460         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 461
 462         return 0;
 463 }
 464
 465 int sttd_dbus_server_cancel(DBusConnection* conn, DBusMessage* msg)
 466 {
 467         DBusError err;
 468         dbus_error_init(&err);
 469
 470         int uid;
 471         int ret = STTD_ERROR_OPERATION_FAILED;
 472         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 473
 474         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Cancel");
 475
 476         if (dbus_error_is_set(&err)) {
 477                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt cancel : get arguments error (%s)", err.message);
 478                 dbus_error_free(&err);
 479                 ret = STTD_ERROR_OPERATION_FAILED;
 480         } else {
 481                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt cancel : uid(%d)", uid);
 482                 ret = sttd_server_cancel(uid);
 483         }
 484
 485         DBusMessage* reply;
 486         reply = dbus_message_new_method_return(msg);
 487
 488         if (NULL != reply) {
 489                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 490
 491                 if (0 == ret) {
 492                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 493                 } else {
 494                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 495                 }
 496
 497                 if (!dbus_connection_send(conn, reply, NULL)) {
 498                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 499                 }
 500
 501                 dbus_connection_flush(conn);
 502                 dbus_message_unref(reply);
 503         } else {
 504                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 505         }
 506
 507         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 508         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 509
 510         return 0;
 511 }
 512
 513 int sttd_dbus_server_start_file_recognition(DBusConnection* conn, DBusMessage* msg)
 514 {
 515         DBusError err;
 516         dbus_error_init(&err);
 517
 518         int uid;
 519         char* filepath;
 520         char* lang;
 521         char* type;
 522         int profanity;
 523         int punctuation;
 524         int ret = STTD_ERROR_OPERATION_FAILED;
 525
 526         dbus_message_get_args(msg, &err,
 527                 DBUS_TYPE_INT32, &uid,
 528                 DBUS_TYPE_STRING, &filepath,
 529                 DBUS_TYPE_STRING, &lang,
 530                 DBUS_TYPE_STRING, &type,
 531                 DBUS_TYPE_INT32, &profanity,
 532                 DBUS_TYPE_INT32, &punctuation,
 533                 DBUS_TYPE_INVALID);
 534
 535         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Start File Recognition");
 536
 537         if (dbus_error_is_set(&err)) {
 538                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt start file recognition : get arguments error (%s)", err.message);
 539                 dbus_error_free(&err);
 540                 ret = STTD_ERROR_OPERATION_FAILED;
 541         } else {
 542                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt start file recognition : uid(%d), filepath(%s), lang(%s), type(%s), profanity(%d), punctuation(%d)"
 543                         , uid, filepath, lang, type, profanity, punctuation);
 544
 545                 ret = sttd_server_start_file_recognition(uid, filepath, lang, type,profanity, punctuation);
 546         }
 547
 548         DBusMessage* reply;
 549         reply = dbus_message_new_method_return(msg);
 550
 551         if (NULL != reply) {
 552                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 553
 554                 if (0 == ret) {
 555                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 556                 } else {
 557                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 558                 }
 559
 560                 if (!dbus_connection_send(conn, reply, NULL)) {
 561                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 562                 }
 563
 564                 dbus_connection_flush(conn);
 565                 dbus_message_unref(reply);
 566         } else {
 567                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 568         }
 569
 570         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 571         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 572
 573         return 0;
 574 }
 575
 576 /*
 577 * Dbus Setting-Daemon Server
 578 */
 579
 580 int sttd_dbus_server_setting_initialize(DBusConnection* conn, DBusMessage* msg)
 581 {
 582         DBusError err;
 583         dbus_error_init(&err);
 584
 585         int pid;
 586         int ret = STTD_ERROR_OPERATION_FAILED;
 587
 588         dbus_message_get_args(msg, &err,
 589                 DBUS_TYPE_INT32, &pid,
 590                 DBUS_TYPE_INVALID);
 591
 592         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Initialize");
 593
 594         if (dbus_error_is_set(&err)) {
 595                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting initializie : get arguments error (%s)", err.message);
 596                 dbus_error_free(&err);
 597                 ret = STTD_ERROR_OPERATION_FAILED;
 598         } else {
 599                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting initializie : uid(%d)", pid);
 600                 ret =  sttd_server_setting_initialize(pid);
 601         }
 602
 603         DBusMessage* reply;
 604         reply = dbus_message_new_method_return(msg);
 605
 606         if (NULL != reply) {
 607                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 608
 609                 if (0 == ret) {
 610                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 611                 } else {
 612                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 613                 }
 614
 615                 if (!dbus_connection_send(conn, reply, NULL)) {
 616                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 617                 }
 618                 dbus_connection_flush(conn);
 619                 dbus_message_unref(reply);
 620         } else {
 621                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 622         }
 623
 624         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 625         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 626
 627         return 0;
 628 }
 629
 630 int sttd_dbus_server_setting_finalize(DBusConnection* conn, DBusMessage* msg)
 631 {
 632         DBusError err;
 633         dbus_error_init(&err);
 634
 635         int pid;
 636         int ret = STTD_ERROR_OPERATION_FAILED;
 637
 638         dbus_message_get_args(msg, &err,
 639                 DBUS_TYPE_INT32, &pid,
 640                 DBUS_TYPE_INVALID);
 641
 642         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Finalize");
 643
 644         if (dbus_error_is_set(&err)) {
 645                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting finalize : get arguments error (%s)", err.message);
 646                 dbus_error_free(&err);
 647                 ret = STTD_ERROR_OPERATION_FAILED;
 648         } else {
 649                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting finalize : uid(%d)", pid);
 650                 ret =  sttd_server_setting_finalize(pid);
 651         }
 652
 653         DBusMessage* reply;
 654         reply = dbus_message_new_method_return(msg);
 655
 656         if (NULL != reply) {
 657                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 658
 659                 if (0 == ret) {
 660                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 661                 } else {
 662                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 663                 }
 664
 665                 if (!dbus_connection_send(conn, reply, NULL)) {
 666                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 667                 }
 668
 669                 dbus_connection_flush(conn);
 670                 dbus_message_unref(reply);
 671         } else {
 672                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 673         }
 674
 675         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 676         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 677
 678         return 0;
 679 }
 680
 681 int sttd_dbus_server_setting_get_engine_list(DBusConnection* conn, DBusMessage* msg)
 682 {
 683         DBusError err;
 684         dbus_error_init(&err);
 685
 686         int pid;
 687         GList* engine_list = NULL;
 688         int ret = STTD_ERROR_OPERATION_FAILED;
 689
 690         dbus_message_get_args(msg, &err,
 691                 DBUS_TYPE_INT32, &pid,
 692                 DBUS_TYPE_INVALID);
 693
 694         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Engine List");
 695
 696         if (dbus_error_is_set(&err)) {
 697                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get engine list : get arguments error (%s)", err.message);
 698                 dbus_error_free(&err);
 699                 ret = STTD_ERROR_OPERATION_FAILED;
 700         } else {
 701                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get engine list : uid(%d)", pid);
 702                 ret = sttd_server_setting_get_engine_list(pid, &engine_list);
 703         }
 704
 705         DBusMessage* reply;
 706         reply = dbus_message_new_method_return(msg);
 707
 708         if (NULL != reply) {
 709                 DBusMessageIter args;
 710
 711                 dbus_message_iter_init_append(reply, &args);
 712
 713                 /* Append result*/
 714                 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret) );
 715
 716                 if (0 == ret) {
 717                         /* Append size */
 718                         int size = g_list_length(engine_list);
 719                         if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
 720                                 ret = STTD_ERROR_OPERATION_FAILED;
 721                         } else {
 722                                 GList *iter = NULL;
 723                                 engine_s* engine;
 724
 725                                 iter = g_list_first(engine_list);
 726
 727                                 while (NULL != iter) {
 728                                         engine = iter->data;
 729
 730                                         if (NULL != engine) {
 731
 732                                                 if (NULL != engine->engine_id && NULL != engine->engine_name && NULL != engine->ug_name) {
 733                                                         SLOG(LOG_DEBUG, TAG_STTD, "engine id : %s, engine name : %s, ug_name, : %s",
 734                                                                 engine->engine_id, engine->engine_name, engine->ug_name);
 735
 736                                                         dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->engine_id) );
 737                                                         dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->engine_name) );
 738                                                         dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->ug_name) );
 739                                                 } else {
 740                                                         SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Engine info is NULL");
 741                                                 }
 742
 743                                                 if (NULL != engine->engine_id)
 744                                                         g_free(engine->engine_id);
 745                                                 if (NULL != engine->engine_name)
 746                                                         g_free(engine->engine_name);
 747                                                 if (NULL != engine->ug_name)
 748                                                         g_free(engine->ug_name);
 749
 750                                                 g_free(engine);
 751                                         } else {
 752                                                 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Engine info is NULL");
 753                                         }
 754
 755                                         engine_list = g_list_remove_link(engine_list, iter);
 756
 757                                         iter = g_list_first(engine_list);
 758                                 }
 759                         }
 760                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT] Result(%d)", ret);
 761                 } else {
 762                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 763                 }
 764
 765                 if (!dbus_connection_send(conn, reply, NULL)) {
 766                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 767                 }
 768
 769                 dbus_connection_flush(conn);
 770                 dbus_message_unref(reply);
 771         } else {
 772                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 773         }
 774
 775         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 776         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 777
 778         return 0;
 779 }
 780
 781 int sttd_dbus_server_setting_get_engine(DBusConnection* conn, DBusMessage* msg)
 782 {
 783         DBusError err;
 784         dbus_error_init(&err);
 785
 786         int pid;
 787         char* engine_id;
 788         int ret = STTD_ERROR_OPERATION_FAILED;
 789
 790         dbus_message_get_args(msg, &err,
 791                 DBUS_TYPE_INT32, &pid,
 792                 DBUS_TYPE_INVALID);
 793
 794         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Engine");
 795
 796         if (dbus_error_is_set(&err)) {
 797                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get engine : get arguments error (%s)", err.message);
 798                 dbus_error_free(&err);
 799                 ret = STTD_ERROR_OPERATION_FAILED;
 800         } else {
 801                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get engine : uid(%d)", pid);
 802                 ret = sttd_server_setting_get_engine(pid, &engine_id);
 803         }
 804
 805         DBusMessage* reply;
 806         reply = dbus_message_new_method_return(msg);
 807
 808         if (NULL != reply) {
 809                 if (0 == ret) {
 810                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_STRING, &engine_id, DBUS_TYPE_INVALID);
 811
 812                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), Engine id(%s)", ret, engine_id);
 813                         g_free(engine_id);
 814                 } else {
 815                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 816                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 817                 }
 818
 819                 if (!dbus_connection_send(conn, reply, NULL)) {
 820                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 821                 }
 822
 823                 dbus_connection_flush(conn);
 824                 dbus_message_unref(reply);
 825         } else {
 826                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 827         }
 828
 829         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 830         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 831
 832         return 0;
 833 }
 834
 835 int sttd_dbus_server_setting_set_engine(DBusConnection* conn, DBusMessage* msg)
 836 {
 837         DBusError err;
 838         dbus_error_init(&err);
 839
 840         int pid;
 841         char* engine_id;
 842         int ret = STTD_ERROR_OPERATION_FAILED;
 843
 844         dbus_message_get_args(msg, &err,
 845                 DBUS_TYPE_INT32, &pid,
 846                 DBUS_TYPE_STRING, &engine_id,
 847                 DBUS_TYPE_INVALID);
 848
 849         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Set Engine");
 850
 851         if (dbus_error_is_set(&err)) {
 852                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting set engine : get arguments error (%s)", err.message);
 853                 dbus_error_free(&err);
 854                 ret = STTD_ERROR_OPERATION_FAILED;
 855         } else {
 856                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting set engine : uid(%d)", pid);
 857                 ret = sttd_server_setting_set_engine(pid, engine_id);
 858         }
 859
 860         DBusMessage* reply;
 861         reply = dbus_message_new_method_return(msg);
 862
 863         if (NULL != reply) {
 864                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 865
 866                 if (0 == ret) {
 867                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d) ", ret);
 868                 } else {
 869                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d) ", ret);
 870                 }
 871
 872                 if (!dbus_connection_send(conn, reply, NULL)) {
 873                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 874                 }
 875
 876                 dbus_connection_flush(conn);
 877                 dbus_message_unref(reply);
 878         } else {
 879                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 880         }
 881
 882         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 883         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 884
 885         return 0;
 886 }
 887
 888 int sttd_dbus_server_setting_get_language_list(DBusConnection* conn, DBusMessage* msg)
 889 {
 890         DBusError err;
 891         dbus_error_init(&err);
 892
 893         int pid;
 894         GList* lang_list = NULL;
 895         char* engine_id;
 896         int ret = STTD_ERROR_OPERATION_FAILED;
 897
 898         dbus_message_get_args(msg, &err,
 899                 DBUS_TYPE_INT32, &pid,
 900                 DBUS_TYPE_INVALID);
 901
 902         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Language List");
 903
 904         if (dbus_error_is_set(&err)) {
 905                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get language list : get arguments error (%s)", err.message);
 906                 dbus_error_free(&err);
 907                 ret = STTD_ERROR_OPERATION_FAILED;
 908         } else {
 909                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get language list : uid(%d)", pid);
 910                 ret = sttd_server_setting_get_lang_list(pid, &engine_id, &lang_list);
 911         }
 912
 913         DBusMessage* reply;
 914         reply = dbus_message_new_method_return(msg);
 915
 916         if (NULL != reply) {
 917                 DBusMessageIter args;
 918                 dbus_message_iter_init_append(reply, &args);
 919
 920                 /* Append result*/
 921                 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &ret);
 922
 923                 if (0 == ret) {
 924                         dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine_id));
 925
 926                         int size = g_list_length(lang_list);
 927                         SLOG(LOG_ERROR, TAG_STTD, "[OUT DEBUG] Count(%d) ", size);
 928
 929                         /* Append size */
 930                         if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
 931                                 ret = STTD_ERROR_OPERATION_FAILED;
 932                                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d) ", ret);
 933                         } else {
 934                                 GList *iter = NULL;
 935                                 char* temp_lang;
 936
 937                                 iter = g_list_first(lang_list);
 938
 939                                 while (NULL != iter) {
 940                                         temp_lang = iter->data;
 941
 942                                         dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(temp_lang) );
 943
 944                                         if (NULL != temp_lang)
 945                                                 free(temp_lang);
 946
 947                                         lang_list = g_list_remove_link(lang_list, iter);
 948
 949                                         iter = g_list_first(lang_list);
 950                                 }
 951                                 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d) ", ret);
 952                         }
 953                 } else {
 954                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d) ", ret);
 955                 }
 956
 957                 if (!dbus_connection_send(conn, reply, NULL)) {
 958                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 959                 }
 960
 961                 dbus_connection_flush(conn);
 962                 dbus_message_unref(reply);
 963         } else {
 964                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 965         }
 966
 967         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 968         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 969
 970         return 0;
 971 }
 972
 973 int sttd_dbus_server_setting_get_default_language(DBusConnection* conn, DBusMessage* msg)
 974 {
 975         DBusError err;
 976         dbus_error_init(&err);
 977
 978         int pid;
 979         char* language;
 980         int ret = STTD_ERROR_OPERATION_FAILED;
 981
 982         dbus_message_get_args(msg, &err,
 983                 DBUS_TYPE_INT32, &pid,
 984                 DBUS_TYPE_INVALID);
 985
 986         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Default Language");
 987
 988         if (dbus_error_is_set(&err)) {
 989                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get default language : get arguments error (%s)", err.message);
 990                 dbus_error_free(&err);
 991                 ret = STTD_ERROR_OPERATION_FAILED;
 992         } else {
 993                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get default language : uid(%d)", pid);
 994                 ret = sttd_server_setting_get_default_language(pid, &language);
 995         }
 996
 997         DBusMessage* reply;
 998         reply = dbus_message_new_method_return(msg);
 999
1000         if (NULL != reply) {
1001                 if (0 == ret) {
1002                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_STRING, &language, DBUS_TYPE_INVALID);
1003                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), Default Language(%s)", ret, language);
1004                         free(language);
1005                 } else {
1006                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1007                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1008                 }
1009
1010                 if (!dbus_connection_send(conn, reply, NULL)) {
1011                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1012                 }
1013
1014                 dbus_connection_flush(conn);
1015                 dbus_message_unref(reply);
1016         } else {
1017                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1018         }
1019
1020         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1021         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1022
1023         return 0;
1024 }
1025
1026 int sttd_dbus_server_setting_set_default_language(DBusConnection* conn, DBusMessage* msg)
1027 {
1028         DBusError err;
1029         dbus_error_init(&err);
1030
1031         int pid;
1032         char* language;
1033         int ret = STTD_ERROR_OPERATION_FAILED;
1034
1035         dbus_message_get_args(msg, &err,
1036                 DBUS_TYPE_INT32, &pid,
1037                 DBUS_TYPE_STRING, &language,
1038                 DBUS_TYPE_INVALID);
1039
1040         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Set Default Language");
1041
1042         if (dbus_error_is_set(&err)) {
1043                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting set default language : get arguments error (%s)", err.message);
1044                 dbus_error_free(&err);
1045                 ret = STTD_ERROR_OPERATION_FAILED;
1046         } else {
1047                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting set default language : uid(%d), language(%s)", pid, language);
1048                 ret = sttd_server_setting_set_default_language(pid, language);
1049         }
1050
1051         DBusMessage* reply;
1052         reply = dbus_message_new_method_return(msg);
1053
1054         if (NULL != reply) {
1055                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1056
1057                 if (0 == ret) {
1058                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1059                 } else {
1060                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1061                 }
1062
1063                 if (!dbus_connection_send(conn, reply, NULL)) {
1064                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1065                 }
1066
1067                 dbus_connection_flush(conn);
1068                 dbus_message_unref(reply);
1069         } else {
1070                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1071         }
1072
1073         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1074         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1075
1076         return 0;
1077 }
1078
1079 int sttd_dbus_server_setting_get_profanity_filter(DBusConnection* conn, DBusMessage* msg)
1080 {
1081         DBusError err;
1082         dbus_error_init(&err);
1083
1084         int pid;
1085         bool value;
1086         int ret = STTD_ERROR_OPERATION_FAILED;
1087
1088         dbus_message_get_args(msg, &err,
1089                 DBUS_TYPE_INT32, &pid,
1090                 DBUS_TYPE_INVALID);
1091
1092         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Profanity Filter");
1093
1094         if (dbus_error_is_set(&err)) {
1095                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get profanity filter : get arguments error (%s)", err.message);
1096                 dbus_error_free(&err);
1097                 ret = STTD_ERROR_OPERATION_FAILED;
1098         } else {
1099                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get profanity filter : uid(%d)", pid);
1100                 ret = sttd_server_setting_get_profanity_filter(pid, &value);
1101         }
1102
1103         DBusMessage* reply;
1104         reply = dbus_message_new_method_return(msg);
1105
1106         if (NULL != reply) {
1107                 if (0 == ret) {
1108                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INT32, &value, DBUS_TYPE_INVALID);
1109                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d) , value(%s)", ret, value ? "true":"false");
1110                 } else {
1111                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1112                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1113                 }
1114
1115                 if (!dbus_connection_send(conn, reply, NULL)) {
1116                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1117                 }
1118
1119                 dbus_connection_flush(conn);
1120                 dbus_message_unref(reply);
1121         } else {
1122                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1123         }
1124
1125         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1126         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1127
1128         return 0;
1129 }
1130
1131 int sttd_dbus_server_setting_set_profanity_filter(DBusConnection* conn, DBusMessage* msg)
1132 {
1133         DBusError err;
1134         dbus_error_init(&err);
1135
1136         int pid;
1137         bool value;
1138         int ret = STTD_ERROR_OPERATION_FAILED;
1139
1140         dbus_message_get_args(msg, &err,
1141                 DBUS_TYPE_INT32, &pid,
1142                 DBUS_TYPE_INT32, &value,
1143                 DBUS_TYPE_INVALID);
1144
1145         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Set Profanity Filter");
1146
1147         if (dbus_error_is_set(&err)) {
1148                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting set profanity filter : get arguments error (%s)", err.message);
1149                 dbus_error_free(&err);
1150                 ret = STTD_ERROR_OPERATION_FAILED;
1151         } else {
1152                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting set profanity filter : uid(%d), value(%s)", pid, value ? "true":"false");
1153                 ret =  sttd_server_setting_set_profanity_filter(pid, (bool)value);
1154         }
1155
1156         DBusMessage* reply;
1157         reply = dbus_message_new_method_return(msg);
1158
1159         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1160
1161         if (NULL != reply) {
1162                 if (0 == ret) {
1163                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1164                 } else {
1165                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1166                 }
1167
1168                 if (!dbus_connection_send(conn, reply, NULL)) {
1169                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1170                 }
1171
1172                 dbus_connection_flush(conn);
1173                 dbus_message_unref(reply);
1174         } else {
1175                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1176         }
1177
1178         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1179         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1180
1181         return 0;
1182 }
1183
1184 int sttd_dbus_server_setting_get_punctuation_override(DBusConnection* conn, DBusMessage* msg)
1185 {
1186         DBusError err;
1187         dbus_error_init(&err);
1188
1189         int pid;
1190         bool value;
1191         int ret = STTD_ERROR_OPERATION_FAILED;
1192
1193         dbus_message_get_args(msg, &err,
1194                 DBUS_TYPE_INT32, &pid,
1195                 DBUS_TYPE_INVALID);
1196
1197         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Punctuation Override");
1198
1199         if (dbus_error_is_set(&err)) {
1200                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get punctuation override : get arguments error (%s)", err.message);
1201                 dbus_error_free(&err);
1202                 ret = STTD_ERROR_OPERATION_FAILED;
1203         } else {
1204                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get punctuation override : uid(%d)", pid);
1205                 ret =  sttd_server_setting_get_punctuation_override(pid, &value);
1206         }
1207
1208         DBusMessage* reply;
1209         reply = dbus_message_new_method_return(msg);
1210
1211         if (NULL != reply) {
1212                 if (0 == ret) {
1213                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INT32, &value, DBUS_TYPE_INVALID);
1214                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d) , value(%s)", ret, value ? "true":"false");
1215                 } else {
1216                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1217                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1218                 }
1219
1220                 if (!dbus_connection_send(conn, reply, NULL)) {
1221                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1222                         return -1;
1223                 }
1224
1225                 dbus_connection_flush(conn);
1226                 dbus_message_unref(reply);
1227         } else {
1228                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1229         }
1230
1231         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1232         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1233
1234         return 0;
1235 }
1236
1237 int sttd_dbus_server_setting_set_punctuation_override(DBusConnection* conn, DBusMessage* msg)
1238 {
1239         DBusError err;
1240         dbus_error_init(&err);
1241
1242         int pid;
1243         bool value;
1244         int ret = STTD_ERROR_OPERATION_FAILED;
1245
1246         dbus_message_get_args(msg, &err,
1247                 DBUS_TYPE_INT32, &pid,
1248                 DBUS_TYPE_INT32, &value,
1249                 DBUS_TYPE_INVALID);
1250
1251         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Set Profanity Filter");
1252
1253         if (dbus_error_is_set(&err)) {
1254                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting set punctuation override : get arguments error (%s)", err.message);
1255                 dbus_error_free(&err);
1256                 ret = STTD_ERROR_OPERATION_FAILED;
1257         } else {
1258                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting set punctuation override : uid(%d), value(%s)", pid, value ? "true":"false");
1259                 ret =  sttd_server_setting_set_punctuation_override(pid, value);
1260         }
1261
1262         DBusMessage* reply;
1263         reply = dbus_message_new_method_return(msg);
1264
1265         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1266
1267         if (NULL != reply) {
1268                 if (0 == ret) {
1269                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1270                 } else {
1271                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1272                 }
1273
1274                 if (!dbus_connection_send(conn, reply, NULL)) {
1275                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1276                         return -1;
1277                 }
1278
1279                 dbus_connection_flush(conn);
1280                 dbus_message_unref(reply);
1281         } else {
1282                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1283         }
1284
1285         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1286         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1287
1288         return 0;
1289 }
1290
1291 int sttd_dbus_server_setting_get_silence_detection(DBusConnection* conn, DBusMessage* msg)
1292 {
1293         DBusError err;
1294         dbus_error_init(&err);
1295
1296         int pid;
1297         bool value;
1298         int ret = STTD_ERROR_OPERATION_FAILED;
1299
1300         dbus_message_get_args(msg, &err,
1301                 DBUS_TYPE_INT32, &pid,
1302                 DBUS_TYPE_INVALID);
1303
1304         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Silence Detection");
1305
1306         if (dbus_error_is_set(&err)) {
1307                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get silence detection : get arguments error (%s)", err.message);
1308                 dbus_error_free(&err);
1309                 ret = STTD_ERROR_OPERATION_FAILED;
1310         } else {
1311                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get silence detection : uid(%d)", pid);
1312                 ret =  sttd_server_setting_get_silence_detection(pid, &value);
1313         }
1314
1315         DBusMessage* reply;
1316         reply = dbus_message_new_method_return(msg);
1317
1318         if (NULL != reply) {
1319                 if (0 == ret) {
1320                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INT32, &value, DBUS_TYPE_INVALID);
1321                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d) , Value(%s)", ret, value ? "true":"false");
1322                 } else {
1323                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1324                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1325                 }
1326
1327                 if (!dbus_connection_send(conn, reply, NULL)) {
1328                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1329                         return -1;
1330                 }
1331
1332                 dbus_connection_flush(conn);
1333                 dbus_message_unref(reply);
1334         } else {
1335                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1336         }
1337
1338         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1339         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1340
1341         return 0;
1342 }
1343
1344 int sttd_dbus_server_setting_set_silence_detection(DBusConnection* conn, DBusMessage* msg)
1345 {
1346         DBusError err;
1347         dbus_error_init(&err);
1348
1349         int pid;
1350         bool value;
1351         int ret = STTD_ERROR_OPERATION_FAILED;
1352
1353         dbus_message_get_args(msg, &err,
1354                 DBUS_TYPE_INT32, &pid,
1355                 DBUS_TYPE_INT32, &value,
1356                 DBUS_TYPE_INVALID);
1357         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Set Silence Detection");
1358
1359         if (dbus_error_is_set(&err)) {
1360                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting set silence detection : get arguments error (%s)", err.message);
1361                 dbus_error_free(&err);
1362                 ret = STTD_ERROR_OPERATION_FAILED;
1363         } else {
1364                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting set silence detection : uid(%d), value(%s)", pid, value ? "true":"false");
1365                 ret =  sttd_server_setting_set_silence_detection(pid, value);
1366         }
1367
1368         DBusMessage* reply;
1369         reply = dbus_message_new_method_return(msg);
1370
1371         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1372
1373         if (NULL != reply) {
1374                 if (0 == ret) {
1375                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1376                 } else {
1377                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1378                 }
1379
1380                 if (!dbus_connection_send(conn, reply, NULL)) {
1381                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1382                 }
1383
1384                 dbus_connection_flush(conn);
1385                 dbus_message_unref(reply);
1386         } else {
1387                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1388         }
1389
1390         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1391         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1392
1393         return 0;
1394 }
1395
1396
1397 int sttd_dbus_server_setting_get_engine_setting(DBusConnection* conn, DBusMessage* msg)
1398 {
1399         DBusError err;
1400         dbus_error_init(&err);
1401
1402         int pid;
1403         char* engine_id;
1404         GList* engine_setting_list = NULL;
1405         int ret = STTD_ERROR_OPERATION_FAILED;
1406
1407         dbus_message_get_args(msg, &err,
1408                 DBUS_TYPE_INT32, &pid,
1409                 DBUS_TYPE_INVALID);
1410
1411         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Get Engine Setting");
1412
1413         if (dbus_error_is_set(&err)) {
1414                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting get engine setting : get arguments error (%s)", err.message);
1415                 dbus_error_free(&err);
1416                 ret = STTD_ERROR_OPERATION_FAILED;
1417         } else {
1418                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting get engine setting : uid(%d)", pid);
1419                 ret = sttd_server_setting_get_engine_setting(pid, &engine_id, &engine_setting_list);
1420         }
1421
1422         DBusMessage* reply;
1423         reply = dbus_message_new_method_return(msg);
1424
1425         if (NULL != reply) {
1426                 DBusMessageIter args;
1427                 dbus_message_iter_init_append(reply, &args);
1428
1429                 /* Append result*/
1430                 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret) );
1431
1432                 if (0 == ret) {
1433                         if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine_id))) {
1434                                 ret = STTD_ERROR_OPERATION_FAILED;
1435                                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to add engine id");
1436                         } else {
1437                                 if (NULL != engine_id)  free(engine_id);
1438
1439                                 /* Append size */
1440                                 int size = g_list_length(engine_setting_list);
1441                                 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
1442                                         ret = STTD_ERROR_OPERATION_FAILED;
1443                                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] setting get engine setting : result(%d)", ret);
1444                                 } else {
1445                                         GList *iter = NULL;
1446                                         engine_setting_s* setting;
1447
1448                                         iter = g_list_first(engine_setting_list);
1449
1450                                         while (NULL != iter) {
1451                                                 setting = iter->data;
1452
1453                                                 if (NULL != setting) {
1454                                                         if (NULL != setting->key && NULL != setting->value) {
1455                                                                 dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(setting->key) );
1456                                                                 dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(setting->value) );
1457                                                         } else {
1458                                                                 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] setting key is NULL");
1459                                                         }
1460
1461                                                         if (NULL != setting->key)
1462                                                                 g_free(setting->key);
1463                                                         if (NULL != setting->value)
1464                                                                 g_free(setting->value);
1465
1466                                                         g_free(setting);
1467                                                 } else {
1468                                                         SLOG(LOG_ERROR, TAG_STTD, "[ERROR] setting key is NULL");
1469                                                 }
1470
1471                                                 engine_setting_list = g_list_remove_link(engine_setting_list, iter);
1472
1473                                                 iter = g_list_first(engine_setting_list);
1474                                         }
1475                                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] setting engine setting list : result(%d) \n", ret);
1476                                 }
1477                         }
1478                 } else {
1479                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1480                 }
1481
1482                 if (!dbus_connection_send(conn, reply, NULL)) {
1483                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1484                 }
1485
1486                 dbus_connection_flush(conn);
1487                 dbus_message_unref(reply);
1488         } else {
1489                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1490         }
1491
1492         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1493         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1494
1495         return 0;
1496 }
1497
1498 int sttd_dbus_server_setting_set_engine_setting(DBusConnection* conn, DBusMessage* msg)
1499 {
1500         DBusError err;
1501         dbus_error_init(&err);
1502
1503         int pid;
1504         char* key;
1505         char* value;
1506         int ret = STTD_ERROR_OPERATION_FAILED;
1507
1508         dbus_message_get_args(msg, &err,
1509                 DBUS_TYPE_INT32, &pid,
1510                 DBUS_TYPE_STRING, &key,
1511                 DBUS_TYPE_STRING, &value,
1512                 DBUS_TYPE_INVALID);
1513
1514         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Setting Set Engine Setting");
1515
1516         if (dbus_error_is_set(&err)) {
1517                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] setting set engine setting : get arguments error (%s)", err.message);
1518                 dbus_error_free(&err);
1519                 ret = STTD_ERROR_OPERATION_FAILED;
1520         } else {
1521                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] setting set engine setting : uid(%d), key(%s), value(%s)", pid, key, value);
1522                 ret = sttd_server_setting_set_engine_setting(pid, key, value);
1523         }
1524
1525         DBusMessage* reply;
1526         reply = dbus_message_new_method_return(msg);
1527
1528         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1529
1530         if (NULL != reply) {
1531                 if (0 == ret) {
1532                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1533                 } else {
1534                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1535                 }
1536
1537                 if (!dbus_connection_send(conn, reply, NULL)) {
1538                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1539                 }
1540
1541                 dbus_connection_flush(conn);
1542                 dbus_message_unref(reply);
1543         } else {
1544                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1545         }
1546
1547         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1548         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1549
1550         return 0;
1551 }
1552
1553 int sttd_dbus_server_stop_by_daemon(DBusMessage* msg)
1554 {
1555         DBusError err;
1556         dbus_error_init(&err);
1557
1558         int uid;
1559
1560         dbus_message_get_args(msg, &err,
1561                 DBUS_TYPE_INT32, &uid,
1562                 DBUS_TYPE_INVALID);
1563
1564         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> Stop by daemon");
1565
1566         if (dbus_error_is_set(&err)) {
1567                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] sttd stop by daemon : Get arguments error (%s)", err.message);
1568                 dbus_error_free(&err);
1569         } else {
1570                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] sttd stop by daemon : uid(%d)", uid);
1571                 sttd_server_stop(uid);
1572
1573                 /* check silence detection option from config */
1574                 int ret = sttdc_send_set_state(uid, (int)APP_STATE_PROCESSING);
1575                 if (0 == ret) {
1576                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1577                 } else {
1578                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1579                         /* Remove client */
1580                         sttd_server_finalize(uid);
1581                 }
1582         }
1583
1584         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1585         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1586
1587         return 0;
1588 }