server/sttd_dbus_server.c

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