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