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