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