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