server/sttd_dbus_server.c

   1 /*
   2 * Copyright (c) 2011-2016 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         if (NULL != reply) {
  33                 if (!dbus_connection_send(conn, reply, NULL)) {
  34                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
  35                 }
  36
  37                 dbus_connection_flush(conn);
  38                 dbus_message_unref(reply);
  39         } else {
  40                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
  41         }
  42
  43         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
  44         SLOG(LOG_DEBUG, TAG_STTD, "  ");
  45
  46         return 0;
  47 }
  48
  49 int sttd_dbus_server_initialize(DBusConnection* conn, DBusMessage* msg)
  50 {
  51         DBusError err;
  52         dbus_error_init(&err);
  53
  54         int pid;
  55         int uid;
  56         bool silence_supported = false;
  57         bool credential_needed = false;
  58
  59         int ret = STTD_ERROR_OPERATION_FAILED;
  60
  61         dbus_message_get_args(msg, &err,
  62                 DBUS_TYPE_INT32, &pid,
  63                 DBUS_TYPE_INT32, &uid,
  64                 DBUS_TYPE_INVALID);
  65
  66         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Initialize");
  67
  68         if (dbus_error_is_set(&err)) {
  69                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt initialize : get arguments error (%s)", err.message);
  70                 dbus_error_free(&err);
  71                 ret = STTD_ERROR_OPERATION_FAILED;
  72         } else {
  73                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt initialize : pid(%d), uid(%d)", pid , uid);
  74                 ret =  sttd_server_initialize(pid, uid, &silence_supported, &credential_needed);
  75         }
  76
  77         DBusMessage* reply;
  78         reply = dbus_message_new_method_return(msg);
  79
  80         if (NULL != reply) {
  81                 dbus_message_append_args(reply,
  82                         DBUS_TYPE_INT32, &ret,
  83                         DBUS_TYPE_INT32, &silence_supported,
  84                         DBUS_TYPE_INT32, &credential_needed,
  85                         DBUS_TYPE_INVALID);
  86
  87                 if (0 == ret) {
  88                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), silence(%d), credential(%d)",
  89                                 ret, silence_supported, credential_needed);
  90                 } else {
  91                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
  92                 }
  93
  94                 if (!dbus_connection_send(conn, reply, NULL)) {
  95                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
  96                 }
  97
  98                 dbus_connection_flush(conn);
  99                 dbus_message_unref(reply);
 100         } else {
 101                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 102         }
 103
 104         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 105         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 106
 107         return 0;
 108 }
 109
 110 int sttd_dbus_server_finalize(DBusConnection* conn, DBusMessage* msg)
 111 {
 112         DBusError err;
 113         dbus_error_init(&err);
 114
 115         int uid;
 116         int ret = STTD_ERROR_OPERATION_FAILED;
 117         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 118
 119         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Finalize");
 120
 121         if (dbus_error_is_set(&err)) {
 122                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt finalize : get arguments error (%s)", err.message);
 123                 dbus_error_free(&err);
 124                 ret = STTD_ERROR_OPERATION_FAILED;
 125         } else {
 126                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt finalize : uid(%d)", uid);
 127                 ret =  sttd_server_finalize(uid);
 128         }
 129
 130         DBusMessage* reply;
 131
 132         reply = dbus_message_new_method_return(msg);
 133
 134         if (NULL != reply) {
 135                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 136
 137                 if (0 == ret) {
 138                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 139                 } else {
 140                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 141                 }
 142
 143                 if (!dbus_connection_send(conn, reply, NULL)) {
 144                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 145                 }
 146
 147                 dbus_connection_flush(conn);
 148                 dbus_message_unref(reply);
 149         } else {
 150                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 151         }
 152
 153         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 154         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 155
 156         return 0;
 157 }
 158
 159 int sttd_dbus_server_get_support_engines(DBusConnection* conn, DBusMessage* msg)
 160 {
 161         DBusError err;
 162         dbus_error_init(&err);
 163
 164         int uid;
 165         int ret = STTD_ERROR_OPERATION_FAILED;
 166         GSList* engine_list = NULL;
 167
 168         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 169
 170         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get supported engines");
 171
 172         if (dbus_error_is_set(&err)) {
 173                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt supported engines : get arguments error (%s)", err.message);
 174                 dbus_error_free(&err);
 175                 ret = STTD_ERROR_OPERATION_FAILED;
 176         } else {
 177                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt supported engines : uid(%d)", uid);
 178                 ret = sttd_server_get_supported_engines(uid, &engine_list);
 179         }
 180
 181         DBusMessage* reply;
 182         reply = dbus_message_new_method_return(msg);
 183
 184         if (NULL != reply) {
 185                 DBusMessageIter args;
 186
 187                 dbus_message_iter_init_append(reply, &args);
 188
 189                 /* Append result*/
 190                 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret));
 191
 192                 if (0 == ret) {
 193                         /* Append size */
 194                         int size = g_slist_length(engine_list);
 195                         if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
 196                                 ret = STTD_ERROR_OPERATION_FAILED;
 197                         } else {
 198                                 GSList *iter = NULL;
 199                                 engine_s* engine;
 200
 201                                 iter = g_slist_nth(engine_list, 0);
 202
 203                                 while (NULL != iter) {
 204                                         engine = iter->data;
 205
 206                                         if (NULL != engine) {
 207                                                 if (NULL != engine->engine_id && NULL != engine->engine_name && NULL != engine->ug_name) {
 208                                                         SLOG(LOG_DEBUG, TAG_STTD, "engine id : %s, engine name : %s, ug_name, : %s",
 209                                                                 engine->engine_id, engine->engine_name, engine->ug_name);
 210
 211                                                         dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->engine_id));
 212                                                         dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->engine_name));
 213                                                         /* dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->ug_name)); */
 214                                                 } else {
 215                                                         SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Engine info is NULL");
 216                                                 }
 217
 218                                                 if (NULL != engine->engine_id)          free(engine->engine_id);
 219                                                 if (NULL != engine->engine_name)        free(engine->engine_name);
 220                                                 if (NULL != engine->ug_name)            free(engine->ug_name);
 221
 222                                                 free(engine);
 223                                         } else {
 224                                                 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Engine info is NULL");
 225                                         }
 226
 227                                         engine_list = g_slist_remove_link(engine_list, iter);
 228
 229                                         iter = g_slist_nth(engine_list, 0);
 230                                 }
 231                         }
 232                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT] Result(%d)", ret);
 233                 } else {
 234                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 235                 }
 236
 237                 if (!dbus_connection_send(conn, reply, NULL)) {
 238                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 239                 }
 240
 241                 dbus_connection_flush(conn);
 242                 dbus_message_unref(reply);
 243         } else {
 244                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 245         }
 246
 247         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 248         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 249
 250         return 0;
 251 }
 252
 253 int sttd_dbus_server_set_current_engine(DBusConnection* conn, DBusMessage* msg)
 254 {
 255         DBusError err;
 256         dbus_error_init(&err);
 257
 258         int uid;
 259         char* engine_id;
 260         bool silence_supported = false;
 261         bool credential_needed = false;
 262         int ret = STTD_ERROR_OPERATION_FAILED;
 263
 264         dbus_message_get_args(msg, &err,
 265                 DBUS_TYPE_INT32, &uid,
 266                 DBUS_TYPE_STRING, &engine_id,
 267                 DBUS_TYPE_INVALID);
 268
 269         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Set current engine");
 270
 271         if (dbus_error_is_set(&err)) {
 272                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt set current engine : get arguments error (%s)", err.message);
 273                 dbus_error_free(&err);
 274                 ret = STTD_ERROR_OPERATION_FAILED;
 275         } else {
 276                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set current engine : uid(%d), engine_id(%s)", uid, (NULL == engine_id) ? "NULL" : engine_id);
 277                 ret = sttd_server_set_current_engine(uid, engine_id, &silence_supported, &credential_needed);
 278         }
 279
 280         DBusMessage* reply;
 281         reply = dbus_message_new_method_return(msg);
 282
 283         if (NULL != reply) {
 284                 dbus_message_append_args(reply,
 285                         DBUS_TYPE_INT32, &ret,
 286                         DBUS_TYPE_INT32, &silence_supported,
 287                         DBUS_TYPE_INT32, &credential_needed,
 288                         DBUS_TYPE_INVALID);
 289
 290                 if (0 == ret) {
 291                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), silence(%d), credential(%d)",
 292                                 ret, silence_supported, credential_needed);
 293                 } else {
 294                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d) ", ret);
 295                 }
 296
 297                 if (!dbus_connection_send(conn, reply, NULL)) {
 298                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 299                 }
 300
 301                 dbus_connection_flush(conn);
 302                 dbus_message_unref(reply);
 303         } else {
 304                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 305         }
 306
 307         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 308         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 309
 310         return 0;
 311 }
 312
 313 int sttd_dbus_server_get_current_engine(DBusConnection* conn, DBusMessage* msg)
 314 {
 315         DBusError err;
 316         dbus_error_init(&err);
 317
 318         int uid;
 319         char* engine = NULL;
 320         int ret = STTD_ERROR_OPERATION_FAILED;
 321
 322         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 323
 324         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get current engine");
 325
 326         if (dbus_error_is_set(&err)) {
 327                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt get current engine : get arguments error (%s)", err.message);
 328                 dbus_error_free(&err);
 329                 ret = STTD_ERROR_OPERATION_FAILED;
 330         } else {
 331                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get current engine : uid(%d)", uid);
 332                 ret = sttd_server_get_current_engine(uid, &engine);
 333         }
 334
 335         DBusMessage* reply;
 336         reply = dbus_message_new_method_return(msg);
 337
 338         if (NULL != reply) {
 339                 if (0 == ret) {
 340                         /* Append result and language */
 341                         dbus_message_append_args(reply,
 342                                 DBUS_TYPE_INT32, &ret,
 343                                 DBUS_TYPE_STRING, &engine,
 344                                 DBUS_TYPE_INVALID);
 345
 346                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 347                 } else {
 348                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 349
 350                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 351                 }
 352
 353                 if (!dbus_connection_send(conn, reply, NULL)) {
 354                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 355                 }
 356
 357                 dbus_connection_flush(conn);
 358                 dbus_message_unref(reply);
 359         } else {
 360                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 361         }
 362
 363         if (NULL != engine)     free(engine);
 364
 365         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 366         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 367
 368         return 0;
 369 }
 370
 371 int sttd_dbus_server_check_app_agreed(DBusConnection* conn, DBusMessage* msg)
 372 {
 373         DBusError err;
 374         dbus_error_init(&err);
 375
 376         int uid;
 377         char* appid;
 378         int ret = STTD_ERROR_OPERATION_FAILED;
 379         bool available = false;
 380
 381         dbus_message_get_args(msg, &err,
 382                 DBUS_TYPE_INT32, &uid,
 383                 DBUS_TYPE_STRING, &appid,
 384                 DBUS_TYPE_INVALID);
 385
 386         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Is engine available");
 387
 388         if (dbus_error_is_set(&err)) {
 389                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt Is engine available : get arguments error (%s)", err.message);
 390                 dbus_error_free(&err);
 391                 ret = STTD_ERROR_OPERATION_FAILED;
 392         } else {
 393                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt Is engine available : uid(%d)", uid);
 394                 ret = sttd_server_check_app_agreed(uid, appid, &available);
 395         }
 396
 397         DBusMessage* reply;
 398         reply = dbus_message_new_method_return(msg);
 399
 400         if (NULL != reply) {
 401                 /* Append result and language */
 402                 dbus_message_append_args(reply,
 403                         DBUS_TYPE_INT32, &ret,
 404                         DBUS_TYPE_INT32, &available,
 405                         DBUS_TYPE_INVALID);
 406
 407                 if (0 == ret) {
 408                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 409                 } else {
 410                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 411                 }
 412
 413                 if (!dbus_connection_send(conn, reply, NULL)) {
 414                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 415                 }
 416
 417                 dbus_connection_flush(conn);
 418                 dbus_message_unref(reply);
 419         } else {
 420                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 421         }
 422
 423         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 424         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 425
 426         return 0;
 427 }
 428
 429 int sttd_dbus_server_get_support_lang(DBusConnection* conn, DBusMessage* msg)
 430 {
 431         DBusError err;
 432         dbus_error_init(&err);
 433
 434         int uid;
 435         int ret = STTD_ERROR_OPERATION_FAILED;
 436         GSList* lang_list = NULL;
 437
 438         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 439
 440         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get supported langs");
 441
 442         if (dbus_error_is_set(&err)) {
 443                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt supported langs : get arguments error (%s)", err.message);
 444                 dbus_error_free(&err);
 445                 ret = STTD_ERROR_OPERATION_FAILED;
 446         } else {
 447                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt supported langs : uid(%d)", uid);
 448                 ret = sttd_server_get_supported_languages(uid, &lang_list);
 449         }
 450
 451         DBusMessage* reply;
 452         reply = dbus_message_new_method_return(msg);
 453
 454         if (NULL != reply) {
 455                 DBusMessageIter args;
 456                 dbus_message_iter_init_append(reply, &args);
 457
 458                 /* Append result*/
 459                 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret));
 460
 461                 if (0 == ret) {
 462                         /* Append language size */
 463                         int size = g_slist_length(lang_list);
 464
 465                         if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
 466                                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to append type");
 467                                 ret = STTD_ERROR_OPERATION_FAILED;
 468                         } else {
 469                                 GSList *iter = NULL;
 470                                 char* temp_lang;
 471
 472                                 iter = g_slist_nth(lang_list, 0);
 473
 474                                 while (NULL != iter) {
 475                                         temp_lang = iter->data;
 476
 477                                         dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(temp_lang));
 478
 479                                         if (NULL != temp_lang)
 480                                                 free(temp_lang);
 481
 482                                         lang_list = g_slist_remove_link(lang_list, iter);
 483
 484                                         iter = g_slist_nth(lang_list, 0);
 485                                 }
 486                         }
 487                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT] Result(%d)", ret);
 488                 } else {
 489                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 490                 }
 491
 492                 if (!dbus_connection_send(conn, reply, NULL)) {
 493                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 494                 }
 495
 496                 dbus_connection_flush(conn);
 497                 dbus_message_unref(reply);
 498         } else {
 499                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 500         }
 501
 502         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 503         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 504
 505         return 0;
 506 }
 507
 508 int sttd_dbus_server_get_default_lang(DBusConnection* conn, DBusMessage* msg)
 509 {
 510         DBusError err;
 511         dbus_error_init(&err);
 512
 513         int uid;
 514         char* lang = NULL;
 515         int ret = STTD_ERROR_OPERATION_FAILED;
 516
 517         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 518
 519         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get default langs");
 520
 521         if (dbus_error_is_set(&err)) {
 522                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt get default lang : get arguments error (%s)", err.message);
 523                 dbus_error_free(&err);
 524                 ret = STTD_ERROR_OPERATION_FAILED;
 525         } else {
 526                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get default lang : uid(%d)", uid);
 527                 ret = sttd_server_get_current_langauage(uid, &lang);
 528         }
 529
 530         DBusMessage* reply;
 531         reply = dbus_message_new_method_return(msg);
 532
 533         if (NULL != reply) {
 534                 if (0 == ret) {
 535                         /* Append result and language */
 536                         dbus_message_append_args(reply,
 537                                 DBUS_TYPE_INT32, &ret,
 538                                 DBUS_TYPE_STRING, &lang,
 539                                 DBUS_TYPE_INVALID);
 540
 541                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 542                 } else {
 543                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 544
 545                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 546                 }
 547
 548                 if (!dbus_connection_send(conn, reply, NULL)) {
 549                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 550                 }
 551
 552                 dbus_connection_flush(conn);
 553                 dbus_message_unref(reply);
 554         } else {
 555                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 556         }
 557
 558         if (NULL != lang)       free(lang);
 559
 560         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 561         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 562
 563         return 0;
 564 }
 565
 566 int sttd_dbus_server_set_private_data(DBusConnection* conn, DBusMessage* msg)
 567 {
 568         DBusError err;
 569         dbus_error_init(&err);
 570
 571         int uid;
 572         char* key;
 573         char* data;
 574         int ret = 0;
 575         dbus_message_get_args(msg, &err,
 576                 DBUS_TYPE_INT32, &uid,
 577                 DBUS_TYPE_STRING, &key,
 578                 DBUS_TYPE_STRING, &data,
 579                 DBUS_TYPE_INVALID);
 580
 581         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Set private data");
 582
 583         if (dbus_error_is_set(&err)) {
 584                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt set private data : get arguments error (%s)", err.message);
 585                 dbus_error_free(&err);
 586                 ret = STTD_ERROR_OPERATION_FAILED;
 587         } else {
 588                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set private data : uid(%d)", uid);
 589                 ret = sttd_server_set_private_data(uid, key, data);
 590         }
 591
 592         DBusMessage* reply;
 593         reply = dbus_message_new_method_return(msg);
 594
 595         if (NULL != reply) {
 596                 dbus_message_append_args(reply,
 597                         DBUS_TYPE_INT32, &ret,
 598                         DBUS_TYPE_INVALID);
 599
 600                 if (0 == ret) {
 601                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 602                 } else {
 603                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 604                 }
 605
 606                 if (!dbus_connection_send(conn, reply, NULL)) {
 607                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to send reply");
 608                 }
 609
 610                 dbus_connection_flush(conn);
 611                 dbus_message_unref(reply);
 612         } else {
 613                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 614         }
 615
 616         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 617         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 618
 619         return 0;
 620 }
 621
 622 int sttd_dbus_server_get_private_data(DBusConnection* conn, DBusMessage* msg)
 623 {
 624         DBusError err;
 625         dbus_error_init(&err);
 626
 627         int uid;
 628         char* key = NULL;
 629         char* data = NULL;
 630
 631         int ret = 0;
 632         dbus_message_get_args(msg, &err,
 633                 DBUS_TYPE_INT32, &uid,
 634                 DBUS_TYPE_STRING, &key,
 635                 DBUS_TYPE_INVALID);
 636
 637         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get private data");
 638
 639         if (dbus_error_is_set(&err)) {
 640                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt get private data : get arguments error (%s)", err.message);
 641                 dbus_error_free(&err);
 642                 ret = STTD_ERROR_OPERATION_FAILED;
 643         } else {
 644                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get private data : uid(%d), key(%s)", uid, (NULL == key) ? "NULL" : key);
 645                 ret = sttd_server_get_private_data(uid, key, &data);
 646         }
 647
 648         DBusMessage* reply;
 649         reply = dbus_message_new_method_return(msg);
 650
 651         if (NULL != reply) {
 652                 /* Append result and private data */
 653                 dbus_message_append_args(reply,
 654                         DBUS_TYPE_INT32, &ret,
 655                         DBUS_TYPE_STRING, &data,
 656                         DBUS_TYPE_INVALID);
 657
 658                 if (0 == ret) {
 659                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), data(%s)", ret, (NULL == data) ? "NULL" : data);
 660                 } else {
 661                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 662                 }
 663
 664                 if (!dbus_connection_send(conn, reply, NULL)) {
 665                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to send reply");
 666                 }
 667
 668                 dbus_connection_flush(conn);
 669                 dbus_message_unref(reply);
 670         } else {
 671                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 672         }
 673
 674         if (NULL != data)       free(data);
 675
 676         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 677         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 678
 679         return 0;
 680 }
 681
 682 int sttd_dbus_server_is_recognition_type_supported(DBusConnection* conn, DBusMessage* msg)
 683 {
 684         DBusError err;
 685         dbus_error_init(&err);
 686
 687         int uid;
 688         char* type = NULL;
 689         int support = -1;
 690         int ret = STTD_ERROR_OPERATION_FAILED;
 691
 692         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_STRING, &type, DBUS_TYPE_INVALID);
 693
 694         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT is recognition type supported");
 695
 696         if (dbus_error_is_set(&err)) {
 697                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt is recognition type supported : 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] stt is recognition type supported : uid(%d)", uid);
 702                 ret = sttd_server_is_recognition_type_supported(uid, type, &support);
 703         }
 704
 705         DBusMessage* reply;
 706         reply = dbus_message_new_method_return(msg);
 707
 708         if (NULL != reply) {
 709                 /* Append result and language */
 710                 dbus_message_append_args(reply,
 711                         DBUS_TYPE_INT32, &ret,
 712                         DBUS_TYPE_INT32, &support,
 713                         DBUS_TYPE_INVALID);
 714
 715                 if (0 == ret) {
 716                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), Support(%s)", ret, support ? "true" : "false");
 717                 } else {
 718                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 719                 }
 720
 721                 if (!dbus_connection_send(conn, reply, NULL)) {
 722                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 723                 }
 724
 725                 dbus_connection_flush(conn);
 726                 dbus_message_unref(reply);
 727         } else {
 728                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 729         }
 730
 731         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 732         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 733
 734         return 0;
 735 }
 736
 737 int sttd_dbus_server_set_start_sound(DBusConnection* conn, DBusMessage* msg)
 738 {
 739         DBusError err;
 740         dbus_error_init(&err);
 741
 742         int uid;
 743         char* file = NULL;
 744         int ret = STTD_ERROR_OPERATION_FAILED;
 745
 746         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_STRING, &file, DBUS_TYPE_INVALID);
 747
 748         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT set start sound");
 749
 750         if (dbus_error_is_set(&err)) {
 751                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt set start sound : get arguments error (%s)", err.message);
 752                 dbus_error_free(&err);
 753                 ret = STTD_ERROR_OPERATION_FAILED;
 754         } else {
 755                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set start sound : uid(%d) file(%s)", uid, file);
 756                 ret = sttd_server_set_start_sound(uid, file);
 757         }
 758
 759         DBusMessage* reply;
 760         reply = dbus_message_new_method_return(msg);
 761
 762         if (NULL != reply) {
 763                 /* Append result and language */
 764                 dbus_message_append_args(reply,
 765                         DBUS_TYPE_INT32, &ret,
 766                         DBUS_TYPE_INVALID);
 767
 768                 if (0 == ret) {
 769                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 770                 } else {
 771                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 772                 }
 773
 774                 if (!dbus_connection_send(conn, reply, NULL)) {
 775                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 776                 }
 777
 778                 dbus_connection_flush(conn);
 779                 dbus_message_unref(reply);
 780         } else {
 781                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 782         }
 783
 784         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 785         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 786
 787         return 0;
 788 }
 789
 790 int sttd_dbus_server_unset_start_sound(DBusConnection* conn, DBusMessage* msg)
 791 {
 792         DBusError err;
 793         dbus_error_init(&err);
 794
 795         int uid;
 796         int ret = STTD_ERROR_OPERATION_FAILED;
 797
 798         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 799
 800         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT unset start sound");
 801
 802         if (dbus_error_is_set(&err)) {
 803                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt unset start sound : get arguments error (%s)", err.message);
 804                 dbus_error_free(&err);
 805                 ret = STTD_ERROR_OPERATION_FAILED;
 806         } else {
 807                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt unset start sound : uid(%d)", uid);
 808                 ret = sttd_server_set_start_sound(uid, NULL);
 809         }
 810
 811         DBusMessage* reply;
 812         reply = dbus_message_new_method_return(msg);
 813
 814         if (NULL != reply) {
 815                 /* Append result and language */
 816                 dbus_message_append_args(reply,
 817                         DBUS_TYPE_INT32, &ret,
 818                         DBUS_TYPE_INVALID);
 819
 820                 if (0 == ret) {
 821                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 822                 } else {
 823                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 824                 }
 825
 826                 if (!dbus_connection_send(conn, reply, NULL)) {
 827                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 828                 }
 829
 830                 dbus_connection_flush(conn);
 831                 dbus_message_unref(reply);
 832         } else {
 833                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 834         }
 835
 836         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 837         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 838
 839         return 0;
 840 }
 841
 842 int sttd_dbus_server_set_stop_sound(DBusConnection* conn, DBusMessage* msg)
 843 {
 844         DBusError err;
 845         dbus_error_init(&err);
 846
 847         int uid;
 848         char* file = NULL;
 849         int ret = STTD_ERROR_OPERATION_FAILED;
 850
 851         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_STRING, &file, DBUS_TYPE_INVALID);
 852
 853         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT set stop sound");
 854
 855         if (dbus_error_is_set(&err)) {
 856                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt set stop sound : get arguments error (%s)", err.message);
 857                 dbus_error_free(&err);
 858                 ret = STTD_ERROR_OPERATION_FAILED;
 859         } else {
 860                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set stop sound : uid(%d) file(%s)", uid, file);
 861                 ret = sttd_server_set_stop_sound(uid, file);
 862         }
 863
 864         DBusMessage* reply;
 865         reply = dbus_message_new_method_return(msg);
 866
 867         if (NULL != reply) {
 868                 /* Append result and language */
 869                 dbus_message_append_args(reply,
 870                         DBUS_TYPE_INT32, &ret,
 871                         DBUS_TYPE_INVALID);
 872
 873                 if (0 == ret) {
 874                         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 875                 } else {
 876                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 877                 }
 878
 879                 if (!dbus_connection_send(conn, reply, NULL)) {
 880                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 881                 }
 882
 883                 dbus_connection_flush(conn);
 884                 dbus_message_unref(reply);
 885         } else {
 886                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 887         }
 888
 889         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 890         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 891
 892         return 0;
 893 }
 894
 895 int sttd_dbus_server_unset_stop_sound(DBusConnection* conn, DBusMessage* msg)
 896 {
 897         DBusError err;
 898         dbus_error_init(&err);
 899
 900         int uid;
 901         int ret = STTD_ERROR_OPERATION_FAILED;
 902
 903         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 904
 905         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT unset stop sound");
 906
 907         if (dbus_error_is_set(&err)) {
 908                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt unset stop sound : get arguments error (%s)", err.message);
 909                 dbus_error_free(&err);
 910                 ret = STTD_ERROR_OPERATION_FAILED;
 911         } else {
 912                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt unset stop sound : uid(%d)", uid);
 913                 ret = sttd_server_set_stop_sound(uid, NULL);
 914         }
 915
 916         DBusMessage* reply;
 917         reply = dbus_message_new_method_return(msg);
 918
 919         if (NULL != reply) {
 920                 /* Append result and language */
 921                 dbus_message_append_args(reply,
 922                         DBUS_TYPE_INT32, &ret,
 923                         DBUS_TYPE_INVALID);
 924
 925                 if (0 == ret) {
 926                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 927                 } else {
 928                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 929                 }
 930
 931                 if (!dbus_connection_send(conn, reply, NULL)) {
 932                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 933                 }
 934
 935                 dbus_connection_flush(conn);
 936                 dbus_message_unref(reply);
 937         } else {
 938                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 939         }
 940
 941         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 942         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 943
 944         return 0;
 945 }
 946
 947 int sttd_dbus_server_start(DBusConnection* conn, DBusMessage* msg)
 948 {
 949         DBusError err;
 950         dbus_error_init(&err);
 951
 952         int uid;
 953         char* lang;
 954         char* type;
 955         char* appid;
 956         int silence;
 957         char* credential;
 958         int ret = STTD_ERROR_OPERATION_FAILED;
 959
 960         dbus_message_get_args(msg, &err,
 961                 DBUS_TYPE_INT32, &uid,
 962                 DBUS_TYPE_STRING, &lang,
 963                 DBUS_TYPE_STRING, &type,
 964                 DBUS_TYPE_INT32, &silence,
 965                 DBUS_TYPE_STRING, &appid,
 966                 DBUS_TYPE_STRING, &credential,
 967                 DBUS_TYPE_INVALID);
 968
 969         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Start");
 970
 971         if (dbus_error_is_set(&err)) {
 972                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt start : get arguments error (%s)", err.message);
 973                 dbus_error_free(&err);
 974                 ret = STTD_ERROR_OPERATION_FAILED;
 975         } else {
 976                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt start : uid(%d), lang(%s), type(%s), silence(%d) appid(%s) credential(%s)"
 977                         , uid, lang, type, silence, appid, credential);
 978                 ret = sttd_server_start(uid, lang, type, silence, appid, credential);
 979         }
 980
 981         if (0 <= ret) {
 982                 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 983         } else {
 984                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 985                 if (0 != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to start")) {
 986                         SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
 987                 }
 988         }
 989
 990 #if 0
 991         DBusMessage* reply;
 992         reply = dbus_message_new_method_return(msg);
 993
 994         if (NULL != reply) {
 995                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 996
 997                 if (0 <= ret) {
 998                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 999                 } else {
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 #endif
1013
1014         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1015         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1016
1017         return 0;
1018 }
1019
1020 int sttd_dbus_server_stop(DBusConnection* conn, DBusMessage* msg)
1021 {
1022         DBusError err;
1023         dbus_error_init(&err);
1024
1025         int uid;
1026         int ret = STTD_ERROR_OPERATION_FAILED;
1027         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
1028
1029         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Stop");
1030
1031         if (dbus_error_is_set(&err)) {
1032                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt stop : get arguments error (%s)", err.message);
1033                 dbus_error_free(&err);
1034                 ret = STTD_ERROR_OPERATION_FAILED;
1035         } else {
1036                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt stop : uid(%d)", uid);
1037                 ret = sttd_server_stop(uid);
1038         }
1039
1040         if (0 <= ret) {
1041                 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1042         } else {
1043                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1044                 if (0 != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to stop")) {
1045                         SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
1046                 }
1047         }
1048 #if 0
1049         DBusMessage* reply;
1050         reply = dbus_message_new_method_return(msg);
1051
1052         if (NULL != reply) {
1053                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1054
1055                 if (0 <= ret) {
1056                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1057                 } else {
1058                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1059                 }
1060
1061                 if (!dbus_connection_send(conn, reply, NULL)) {
1062                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1063                 }
1064
1065                 dbus_connection_flush(conn);
1066                 dbus_message_unref(reply);
1067         } else {
1068                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1069         }
1070 #endif
1071
1072         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1073         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1074
1075         return 0;
1076 }
1077
1078 int sttd_dbus_server_cancel(DBusConnection* conn, DBusMessage* msg)
1079 {
1080         DBusError err;
1081         dbus_error_init(&err);
1082
1083         int uid;
1084         int ret = STTD_ERROR_OPERATION_FAILED;
1085         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
1086
1087         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Cancel");
1088
1089         if (dbus_error_is_set(&err)) {
1090                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt cancel : get arguments error (%s)", err.message);
1091                 dbus_error_free(&err);
1092                 ret = STTD_ERROR_OPERATION_FAILED;
1093         } else {
1094                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt cancel : uid(%d)", uid);
1095                 ret = sttd_server_cancel(uid);
1096         }
1097
1098         if (0 <= ret) {
1099                 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1100         } else {
1101                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1102                 if (0 != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to cancel")) {
1103                         SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
1104                 }
1105         }
1106 #if 0
1107         DBusMessage* reply;
1108         reply = dbus_message_new_method_return(msg);
1109
1110         if (NULL != reply) {
1111                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1112
1113                 if (0 == ret) {
1114                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1115                 } else {
1116                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1117                 }
1118
1119                 if (!dbus_connection_send(conn, reply, NULL)) {
1120                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1121                 }
1122
1123                 dbus_connection_flush(conn);
1124                 dbus_message_unref(reply);
1125         } else {
1126                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1127         }
1128 #endif
1129         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1130         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1131
1132         return 0;
1133 }