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 = STTD_ERROR_OPERATION_FAILED;
 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] Out Of Memory!");
 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         int ret = STTD_ERROR_OPERATION_FAILED;
 631         dbus_message_get_args(msg, &err,
 632                 DBUS_TYPE_INT32, &uid,
 633                 DBUS_TYPE_STRING, &key,
 634                 DBUS_TYPE_INVALID);
 635
 636         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get private data");
 637
 638         if (dbus_error_is_set(&err)) {
 639                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt get private data : get arguments error (%s)", err.message);
 640                 dbus_error_free(&err);
 641                 ret = STTD_ERROR_OPERATION_FAILED;
 642         } else {
 643                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get private data : uid(%d), key(%s)", uid, (NULL == key) ? "NULL" : key);
 644                 ret = sttd_server_get_private_data(uid, key, &data);
 645         }
 646
 647         DBusMessage* reply;
 648         reply = dbus_message_new_method_return(msg);
 649
 650         if (NULL != reply) {
 651                 /* Append result and private data */
 652                 dbus_message_append_args(reply,
 653                         DBUS_TYPE_INT32, &ret,
 654                         DBUS_TYPE_STRING, &data,
 655                         DBUS_TYPE_INVALID);
 656
 657                 if (0 == ret) {
 658                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), data(%s)", ret, (NULL == data) ? "NULL" : data);
 659                 } else {
 660                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 661                 }
 662
 663                 if (!dbus_connection_send(conn, reply, NULL)) {
 664                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 665                 }
 666
 667                 dbus_connection_flush(conn);
 668                 dbus_message_unref(reply);
 669         } else {
 670                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 671         }
 672
 673         if (NULL != data)       free(data);
 674
 675         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 676         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 677
 678         return 0;
 679 }
 680
 681 int sttd_dbus_server_is_recognition_type_supported(DBusConnection* conn, DBusMessage* msg)
 682 {
 683         DBusError err;
 684         dbus_error_init(&err);
 685
 686         int uid;
 687         char* type = NULL;
 688         int support = -1;
 689         int ret = STTD_ERROR_OPERATION_FAILED;
 690
 691         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_STRING, &type, DBUS_TYPE_INVALID);
 692
 693         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT is recognition type supported");
 694
 695         if (dbus_error_is_set(&err)) {
 696                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt is recognition type supported : get arguments error (%s)", err.message);
 697                 dbus_error_free(&err);
 698                 ret = STTD_ERROR_OPERATION_FAILED;
 699         } else {
 700                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt is recognition type supported : uid(%d)", uid);
 701                 ret = sttd_server_is_recognition_type_supported(uid, type, &support);
 702         }
 703
 704         DBusMessage* reply;
 705         reply = dbus_message_new_method_return(msg);
 706
 707         if (NULL != reply) {
 708                 /* Append result and language */
 709                 dbus_message_append_args(reply,
 710                         DBUS_TYPE_INT32, &ret,
 711                         DBUS_TYPE_INT32, &support,
 712                         DBUS_TYPE_INVALID);
 713
 714                 if (0 == ret) {
 715                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), Support(%s)", ret, support ? "true" : "false");
 716                 } else {
 717                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 718                 }
 719
 720                 if (!dbus_connection_send(conn, reply, NULL)) {
 721                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 722                 }
 723
 724                 dbus_connection_flush(conn);
 725                 dbus_message_unref(reply);
 726         } else {
 727                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 728         }
 729
 730         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 731         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 732
 733         return 0;
 734 }
 735
 736 int sttd_dbus_server_set_start_sound(DBusConnection* conn, DBusMessage* msg)
 737 {
 738         DBusError err;
 739         dbus_error_init(&err);
 740
 741         int uid;
 742         char* file = NULL;
 743         int ret = STTD_ERROR_OPERATION_FAILED;
 744
 745         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_STRING, &file, DBUS_TYPE_INVALID);
 746
 747         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT set start sound");
 748
 749         if (dbus_error_is_set(&err)) {
 750                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt set start sound : get arguments error (%s)", err.message);
 751                 dbus_error_free(&err);
 752                 ret = STTD_ERROR_OPERATION_FAILED;
 753         } else {
 754                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set start sound : uid(%d) file(%s)", uid, file);
 755                 ret = sttd_server_set_start_sound(uid, file);
 756         }
 757
 758         DBusMessage* reply;
 759         reply = dbus_message_new_method_return(msg);
 760
 761         if (NULL != reply) {
 762                 /* Append result and language */
 763                 dbus_message_append_args(reply,
 764                         DBUS_TYPE_INT32, &ret,
 765                         DBUS_TYPE_INVALID);
 766
 767                 if (0 == ret) {
 768                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 769                 } else {
 770                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 771                 }
 772
 773                 if (!dbus_connection_send(conn, reply, NULL)) {
 774                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 775                 }
 776
 777                 dbus_connection_flush(conn);
 778                 dbus_message_unref(reply);
 779         } else {
 780                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 781         }
 782
 783         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 784         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 785
 786         return 0;
 787 }
 788
 789 int sttd_dbus_server_unset_start_sound(DBusConnection* conn, DBusMessage* msg)
 790 {
 791         DBusError err;
 792         dbus_error_init(&err);
 793
 794         int uid;
 795         int ret = STTD_ERROR_OPERATION_FAILED;
 796
 797         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 798
 799         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT unset start sound");
 800
 801         if (dbus_error_is_set(&err)) {
 802                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt unset start sound : get arguments error (%s)", err.message);
 803                 dbus_error_free(&err);
 804                 ret = STTD_ERROR_OPERATION_FAILED;
 805         } else {
 806                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt unset start sound : uid(%d)", uid);
 807                 ret = sttd_server_set_start_sound(uid, NULL);
 808         }
 809
 810         DBusMessage* reply;
 811         reply = dbus_message_new_method_return(msg);
 812
 813         if (NULL != reply) {
 814                 /* Append result and language */
 815                 dbus_message_append_args(reply,
 816                         DBUS_TYPE_INT32, &ret,
 817                         DBUS_TYPE_INVALID);
 818
 819                 if (0 == ret) {
 820                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 821                 } else {
 822                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 823                 }
 824
 825                 if (!dbus_connection_send(conn, reply, NULL)) {
 826                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 827                 }
 828
 829                 dbus_connection_flush(conn);
 830                 dbus_message_unref(reply);
 831         } else {
 832                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 833         }
 834
 835         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 836         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 837
 838         return 0;
 839 }
 840
 841 int sttd_dbus_server_set_stop_sound(DBusConnection* conn, DBusMessage* msg)
 842 {
 843         DBusError err;
 844         dbus_error_init(&err);
 845
 846         int uid;
 847         char* file = NULL;
 848         int ret = STTD_ERROR_OPERATION_FAILED;
 849
 850         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_STRING, &file, DBUS_TYPE_INVALID);
 851
 852         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT set stop sound");
 853
 854         if (dbus_error_is_set(&err)) {
 855                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt set stop sound : get arguments error (%s)", err.message);
 856                 dbus_error_free(&err);
 857                 ret = STTD_ERROR_OPERATION_FAILED;
 858         } else {
 859                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set stop sound : uid(%d) file(%s)", uid, file);
 860                 ret = sttd_server_set_stop_sound(uid, file);
 861         }
 862
 863         DBusMessage* reply;
 864         reply = dbus_message_new_method_return(msg);
 865
 866         if (NULL != reply) {
 867                 /* Append result and language */
 868                 dbus_message_append_args(reply,
 869                         DBUS_TYPE_INT32, &ret,
 870                         DBUS_TYPE_INVALID);
 871
 872                 if (0 == ret) {
 873                         SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 874                 } else {
 875                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 876                 }
 877
 878                 if (!dbus_connection_send(conn, reply, NULL)) {
 879                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 880                 }
 881
 882                 dbus_connection_flush(conn);
 883                 dbus_message_unref(reply);
 884         } else {
 885                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 886         }
 887
 888         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 889         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 890
 891         return 0;
 892 }
 893
 894 int sttd_dbus_server_unset_stop_sound(DBusConnection* conn, DBusMessage* msg)
 895 {
 896         DBusError err;
 897         dbus_error_init(&err);
 898
 899         int uid;
 900         int ret = STTD_ERROR_OPERATION_FAILED;
 901
 902         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 903
 904         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT unset stop sound");
 905
 906         if (dbus_error_is_set(&err)) {
 907                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt unset stop sound : get arguments error (%s)", err.message);
 908                 dbus_error_free(&err);
 909                 ret = STTD_ERROR_OPERATION_FAILED;
 910         } else {
 911                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt unset stop sound : uid(%d)", uid);
 912                 ret = sttd_server_set_stop_sound(uid, NULL);
 913         }
 914
 915         DBusMessage* reply;
 916         reply = dbus_message_new_method_return(msg);
 917
 918         if (NULL != reply) {
 919                 /* Append result and language */
 920                 dbus_message_append_args(reply,
 921                         DBUS_TYPE_INT32, &ret,
 922                         DBUS_TYPE_INVALID);
 923
 924                 if (0 == ret) {
 925                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 926                 } else {
 927                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 928                 }
 929
 930                 if (!dbus_connection_send(conn, reply, NULL)) {
 931                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
 932                 }
 933
 934                 dbus_connection_flush(conn);
 935                 dbus_message_unref(reply);
 936         } else {
 937                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
 938         }
 939
 940         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
 941         SLOG(LOG_DEBUG, TAG_STTD, "  ");
 942
 943         return 0;
 944 }
 945
 946 int sttd_dbus_server_start(DBusConnection* conn, DBusMessage* msg)
 947 {
 948         DBusError err;
 949         dbus_error_init(&err);
 950
 951         int uid;
 952         char* lang;
 953         char* type;
 954         char* appid;
 955         int silence;
 956         char* credential;
 957         int ret = STTD_ERROR_OPERATION_FAILED;
 958
 959         dbus_message_get_args(msg, &err,
 960                 DBUS_TYPE_INT32, &uid,
 961                 DBUS_TYPE_STRING, &lang,
 962                 DBUS_TYPE_STRING, &type,
 963                 DBUS_TYPE_INT32, &silence,
 964                 DBUS_TYPE_STRING, &appid,
 965                 DBUS_TYPE_STRING, &credential,
 966                 DBUS_TYPE_INVALID);
 967
 968         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Start");
 969
 970         if (dbus_error_is_set(&err)) {
 971                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt start : get arguments error (%s)", err.message);
 972                 dbus_error_free(&err);
 973                 ret = STTD_ERROR_OPERATION_FAILED;
 974         } else {
 975                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt start : uid(%d), lang(%s), type(%s), silence(%d) appid(%s) credential(%s)"
 976                         , uid, lang, type, silence, appid, credential);
 977                 ret = sttd_server_start(uid, lang, type, silence, appid, credential);
 978         }
 979
 980         if (0 <= ret) {
 981                 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 982         } else {
 983                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
 984                 if (0 != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to start")) {
 985                         SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
 986                 }
 987         }
 988
 989 #if 0
 990         DBusMessage* reply;
 991         reply = dbus_message_new_method_return(msg);
 992
 993         if (NULL != reply) {
 994                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 995
 996                 if (0 <= ret) {
 997                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
 998                 } else {
 999                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1000                 }
1001
1002                 if (!dbus_connection_send(conn, reply, NULL)) {
1003                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1004                 }
1005
1006                 dbus_connection_flush(conn);
1007                 dbus_message_unref(reply);
1008         } else {
1009                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1010         }
1011 #endif
1012
1013         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1014         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1015
1016         return 0;
1017 }
1018
1019 int sttd_dbus_server_stop(DBusConnection* conn, DBusMessage* msg)
1020 {
1021         DBusError err;
1022         dbus_error_init(&err);
1023
1024         int uid;
1025         int ret = STTD_ERROR_OPERATION_FAILED;
1026         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
1027
1028         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Stop");
1029
1030         if (dbus_error_is_set(&err)) {
1031                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt stop : get arguments error (%s)", err.message);
1032                 dbus_error_free(&err);
1033                 ret = STTD_ERROR_OPERATION_FAILED;
1034         } else {
1035                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt stop : uid(%d)", uid);
1036                 ret = sttd_server_stop(uid);
1037         }
1038
1039         if (0 <= ret) {
1040                 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1041         } else {
1042                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1043                 if (0 != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to stop")) {
1044                         SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
1045                 }
1046         }
1047 #if 0
1048         DBusMessage* reply;
1049         reply = dbus_message_new_method_return(msg);
1050
1051         if (NULL != reply) {
1052                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1053
1054                 if (0 <= ret) {
1055                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1056                 } else {
1057                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1058                 }
1059
1060                 if (!dbus_connection_send(conn, reply, NULL)) {
1061                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1062                 }
1063
1064                 dbus_connection_flush(conn);
1065                 dbus_message_unref(reply);
1066         } else {
1067                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1068         }
1069 #endif
1070
1071         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1072         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1073
1074         return 0;
1075 }
1076
1077 int sttd_dbus_server_cancel(DBusConnection* conn, DBusMessage* msg)
1078 {
1079         DBusError err;
1080         dbus_error_init(&err);
1081
1082         int uid;
1083         int ret = STTD_ERROR_OPERATION_FAILED;
1084         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
1085
1086         SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Cancel");
1087
1088         if (dbus_error_is_set(&err)) {
1089                 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt cancel : get arguments error (%s)", err.message);
1090                 dbus_error_free(&err);
1091                 ret = STTD_ERROR_OPERATION_FAILED;
1092         } else {
1093                 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt cancel : uid(%d)", uid);
1094                 ret = sttd_server_cancel(uid);
1095         }
1096
1097         if (0 <= ret) {
1098                 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1099         } else {
1100                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1101                 if (0 != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to cancel")) {
1102                         SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
1103                 }
1104         }
1105 #if 0
1106         DBusMessage* reply;
1107         reply = dbus_message_new_method_return(msg);
1108
1109         if (NULL != reply) {
1110                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1111
1112                 if (0 == ret) {
1113                         SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1114                 } else {
1115                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1116                 }
1117
1118                 if (!dbus_connection_send(conn, reply, NULL)) {
1119                         SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1120                 }
1121
1122                 dbus_connection_flush(conn);
1123                 dbus_message_unref(reply);
1124         } else {
1125                 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1126         }
1127 #endif
1128         SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1129         SLOG(LOG_DEBUG, TAG_STTD, "  ");
1130
1131         return 0;
1132 }