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