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