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.
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"
23 * Dbus Client-Daemon Server
26 int sttd_dbus_server_hello(DBusConnection* conn, DBusMessage* msg)
28 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Hello");
31 reply = dbus_message_new_method_return(msg);
33 if (!dbus_connection_send(conn, reply, NULL)) {
34 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
37 dbus_connection_flush(conn);
38 dbus_message_unref(reply);
40 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
43 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
44 SLOG(LOG_DEBUG, TAG_STTD, " ");
49 int sttd_dbus_server_initialize(DBusConnection* conn, DBusMessage* msg)
52 dbus_error_init(&err);
56 bool silence_supported = false;
57 bool credential_needed = false;
59 int ret = STTD_ERROR_OPERATION_FAILED;
61 dbus_message_get_args(msg, &err,
62 DBUS_TYPE_INT32, &pid,
63 DBUS_TYPE_INT32, &uid,
66 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Initialize");
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;
73 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt initialize : pid(%d), uid(%d)", pid , uid);
74 ret = sttd_server_initialize(pid, uid, &silence_supported, &credential_needed);
78 reply = dbus_message_new_method_return(msg);
81 dbus_message_append_args(reply,
82 DBUS_TYPE_INT32, &ret,
83 DBUS_TYPE_INT32, &silence_supported,
84 DBUS_TYPE_INT32, &credential_needed,
88 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), silence(%d), credential(%d)",
89 ret, silence_supported, credential_needed);
91 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
94 if (!dbus_connection_send(conn, reply, NULL)) {
95 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
98 dbus_connection_flush(conn);
99 dbus_message_unref(reply);
101 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
104 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
105 SLOG(LOG_DEBUG, TAG_STTD, " ");
110 int sttd_dbus_server_finalize(DBusConnection* conn, DBusMessage* msg)
113 dbus_error_init(&err);
116 int ret = STTD_ERROR_OPERATION_FAILED;
117 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
119 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Finalize");
121 if (dbus_error_is_set(&err)) {
122 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt finalize : get arguments error (%s)", err.message);
123 dbus_error_free(&err);
124 ret = STTD_ERROR_OPERATION_FAILED;
126 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt finalize : uid(%d)", uid);
127 ret = sttd_server_finalize(uid);
132 reply = dbus_message_new_method_return(msg);
135 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
138 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
140 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
143 if (!dbus_connection_send(conn, reply, NULL)) {
144 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
147 dbus_connection_flush(conn);
148 dbus_message_unref(reply);
150 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
153 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
154 SLOG(LOG_DEBUG, TAG_STTD, " ");
159 int sttd_dbus_server_get_support_engines(DBusConnection* conn, DBusMessage* msg)
162 dbus_error_init(&err);
165 int ret = STTD_ERROR_OPERATION_FAILED;
166 GSList* engine_list = NULL;
168 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
170 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get supported engines");
172 if (dbus_error_is_set(&err)) {
173 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt supported engines : get arguments error (%s)", err.message);
174 dbus_error_free(&err);
175 ret = STTD_ERROR_OPERATION_FAILED;
177 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt supported engines : uid(%d)", uid);
178 ret = sttd_server_get_supported_engines(uid, &engine_list);
182 reply = dbus_message_new_method_return(msg);
185 DBusMessageIter args;
187 dbus_message_iter_init_append(reply, &args);
190 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret));
194 int size = g_slist_length(engine_list);
195 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
196 ret = STTD_ERROR_OPERATION_FAILED;
201 iter = g_slist_nth(engine_list, 0);
203 while (NULL != iter) {
206 if (NULL != engine) {
207 if (NULL != engine->engine_id && NULL != engine->engine_name && NULL != engine->ug_name) {
208 SLOG(LOG_DEBUG, TAG_STTD, "engine id : %s, engine name : %s, ug_name, : %s",
209 engine->engine_id, engine->engine_name, engine->ug_name);
211 dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->engine_id));
212 dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->engine_name));
213 /* dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->ug_name)); */
215 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Engine info is NULL");
218 if (NULL != engine->engine_id) {
219 free(engine->engine_id);
220 engine->engine_id = NULL;
222 if (NULL != engine->engine_name) {
223 free(engine->engine_name);
224 engine->engine_name = NULL;
226 if (NULL != engine->ug_name) {
227 free(engine->ug_name);
228 engine->ug_name = NULL;
234 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Engine info is NULL");
237 engine_list = g_slist_remove_link(engine_list, iter);
239 iter = g_slist_nth(engine_list, 0);
242 SLOG(LOG_DEBUG, TAG_STTD, "[OUT] Result(%d)", ret);
244 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
247 if (!dbus_connection_send(conn, reply, NULL)) {
248 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
251 dbus_connection_flush(conn);
252 dbus_message_unref(reply);
254 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
257 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
258 SLOG(LOG_DEBUG, TAG_STTD, " ");
263 int sttd_dbus_server_set_current_engine(DBusConnection* conn, DBusMessage* msg)
266 dbus_error_init(&err);
270 bool silence_supported = false;
271 bool credential_needed = false;
272 int ret = STTD_ERROR_OPERATION_FAILED;
274 dbus_message_get_args(msg, &err,
275 DBUS_TYPE_INT32, &uid,
276 DBUS_TYPE_STRING, &engine_id,
279 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Set current engine");
281 if (dbus_error_is_set(&err)) {
282 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt set current engine : get arguments error (%s)", err.message);
283 dbus_error_free(&err);
284 ret = STTD_ERROR_OPERATION_FAILED;
286 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set current engine : uid(%d), engine_id(%s)", uid, (NULL == engine_id) ? "NULL" : engine_id);
287 ret = sttd_server_set_current_engine(uid, engine_id, &silence_supported, &credential_needed);
291 reply = dbus_message_new_method_return(msg);
294 dbus_message_append_args(reply,
295 DBUS_TYPE_INT32, &ret,
296 DBUS_TYPE_INT32, &silence_supported,
297 DBUS_TYPE_INT32, &credential_needed,
301 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), silence(%d), credential(%d)",
302 ret, silence_supported, credential_needed);
304 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d) ", ret);
307 if (!dbus_connection_send(conn, reply, NULL)) {
308 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
311 dbus_connection_flush(conn);
312 dbus_message_unref(reply);
314 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
317 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
318 SLOG(LOG_DEBUG, TAG_STTD, " ");
323 int sttd_dbus_server_get_current_engine(DBusConnection* conn, DBusMessage* msg)
326 dbus_error_init(&err);
330 int ret = STTD_ERROR_OPERATION_FAILED;
332 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
334 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get current engine");
336 if (dbus_error_is_set(&err)) {
337 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt get current engine : get arguments error (%s)", err.message);
338 dbus_error_free(&err);
339 ret = STTD_ERROR_OPERATION_FAILED;
341 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get current engine : uid(%d)", uid);
342 ret = sttd_server_get_current_engine(uid, &engine);
346 reply = dbus_message_new_method_return(msg);
350 /* Append result and language */
351 dbus_message_append_args(reply,
352 DBUS_TYPE_INT32, &ret,
353 DBUS_TYPE_STRING, &engine,
356 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
358 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
360 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
363 if (!dbus_connection_send(conn, reply, NULL)) {
364 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
367 dbus_connection_flush(conn);
368 dbus_message_unref(reply);
370 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
373 if (NULL != engine) free(engine);
375 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
376 SLOG(LOG_DEBUG, TAG_STTD, " ");
381 int sttd_dbus_server_check_app_agreed(DBusConnection* conn, DBusMessage* msg)
384 dbus_error_init(&err);
388 int ret = STTD_ERROR_OPERATION_FAILED;
389 bool available = false;
391 dbus_message_get_args(msg, &err,
392 DBUS_TYPE_INT32, &uid,
393 DBUS_TYPE_STRING, &appid,
396 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Is engine available");
398 if (dbus_error_is_set(&err)) {
399 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt Is engine available : get arguments error (%s)", err.message);
400 dbus_error_free(&err);
401 ret = STTD_ERROR_OPERATION_FAILED;
403 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt Is engine available : uid(%d)", uid);
404 ret = sttd_server_check_app_agreed(uid, appid, &available);
408 reply = dbus_message_new_method_return(msg);
411 /* Append result and language */
412 dbus_message_append_args(reply,
413 DBUS_TYPE_INT32, &ret,
414 DBUS_TYPE_INT32, &available,
418 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
420 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
423 if (!dbus_connection_send(conn, reply, NULL)) {
424 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
427 dbus_connection_flush(conn);
428 dbus_message_unref(reply);
430 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
433 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
434 SLOG(LOG_DEBUG, TAG_STTD, " ");
439 int sttd_dbus_server_get_support_lang(DBusConnection* conn, DBusMessage* msg)
442 dbus_error_init(&err);
445 int ret = STTD_ERROR_OPERATION_FAILED;
446 GSList* lang_list = NULL;
448 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
450 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get supported langs");
452 if (dbus_error_is_set(&err)) {
453 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt supported langs : get arguments error (%s)", err.message);
454 dbus_error_free(&err);
455 ret = STTD_ERROR_OPERATION_FAILED;
457 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt supported langs : uid(%d)", uid);
458 ret = sttd_server_get_supported_languages(uid, &lang_list);
462 reply = dbus_message_new_method_return(msg);
465 DBusMessageIter args;
466 dbus_message_iter_init_append(reply, &args);
469 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret));
472 /* Append language size */
473 int size = g_slist_length(lang_list);
475 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
476 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to append type");
477 ret = STTD_ERROR_OPERATION_FAILED;
482 iter = g_slist_nth(lang_list, 0);
484 while (NULL != iter) {
485 temp_lang = iter->data;
487 dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(temp_lang));
489 if (NULL != temp_lang)
492 lang_list = g_slist_remove_link(lang_list, iter);
494 iter = g_slist_nth(lang_list, 0);
497 SLOG(LOG_DEBUG, TAG_STTD, "[OUT] Result(%d)", ret);
499 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
502 if (!dbus_connection_send(conn, reply, NULL)) {
503 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
506 dbus_connection_flush(conn);
507 dbus_message_unref(reply);
509 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
512 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
513 SLOG(LOG_DEBUG, TAG_STTD, " ");
518 int sttd_dbus_server_get_default_lang(DBusConnection* conn, DBusMessage* msg)
521 dbus_error_init(&err);
525 int ret = STTD_ERROR_OPERATION_FAILED;
527 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
529 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get default langs");
531 if (dbus_error_is_set(&err)) {
532 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt get default lang : get arguments error (%s)", err.message);
533 dbus_error_free(&err);
534 ret = STTD_ERROR_OPERATION_FAILED;
536 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get default lang : uid(%d)", uid);
537 ret = sttd_server_get_current_langauage(uid, &lang);
541 reply = dbus_message_new_method_return(msg);
545 /* Append result and language */
546 dbus_message_append_args(reply,
547 DBUS_TYPE_INT32, &ret,
548 DBUS_TYPE_STRING, &lang,
551 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
553 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
555 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
558 if (!dbus_connection_send(conn, reply, NULL)) {
559 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
562 dbus_connection_flush(conn);
563 dbus_message_unref(reply);
565 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
568 if (NULL != lang) free(lang);
570 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
571 SLOG(LOG_DEBUG, TAG_STTD, " ");
576 int sttd_dbus_server_set_private_data(DBusConnection* conn, DBusMessage* msg)
579 dbus_error_init(&err);
584 int ret = STTD_ERROR_OPERATION_FAILED;
585 dbus_message_get_args(msg, &err,
586 DBUS_TYPE_INT32, &uid,
587 DBUS_TYPE_STRING, &key,
588 DBUS_TYPE_STRING, &data,
591 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Set private data");
593 if (dbus_error_is_set(&err)) {
594 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt set private data : get arguments error (%s)", err.message);
595 dbus_error_free(&err);
596 ret = STTD_ERROR_OPERATION_FAILED;
598 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set private data : uid(%d)", uid);
599 ret = sttd_server_set_private_data(uid, key, data);
603 reply = dbus_message_new_method_return(msg);
606 dbus_message_append_args(reply,
607 DBUS_TYPE_INT32, &ret,
611 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
613 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
616 if (!dbus_connection_send(conn, reply, NULL)) {
617 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
620 dbus_connection_flush(conn);
621 dbus_message_unref(reply);
623 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
626 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
627 SLOG(LOG_DEBUG, TAG_STTD, " ");
632 int sttd_dbus_server_get_private_data(DBusConnection* conn, DBusMessage* msg)
635 dbus_error_init(&err);
640 int ret = STTD_ERROR_OPERATION_FAILED;
641 dbus_message_get_args(msg, &err,
642 DBUS_TYPE_INT32, &uid,
643 DBUS_TYPE_STRING, &key,
646 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get private data");
648 if (dbus_error_is_set(&err)) {
649 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt get private data : get arguments error (%s)", err.message);
650 dbus_error_free(&err);
651 ret = STTD_ERROR_OPERATION_FAILED;
653 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get private data : uid(%d), key(%s)", uid, (NULL == key) ? "NULL" : key);
654 ret = sttd_server_get_private_data(uid, key, &data);
658 reply = dbus_message_new_method_return(msg);
661 /* Append result and private data */
662 dbus_message_append_args(reply,
663 DBUS_TYPE_INT32, &ret,
664 DBUS_TYPE_STRING, &data,
668 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), data(%s)", ret, (NULL == data) ? "NULL" : data);
670 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
673 if (!dbus_connection_send(conn, reply, NULL)) {
674 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
677 dbus_connection_flush(conn);
678 dbus_message_unref(reply);
680 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
683 if (NULL != data) free(data);
685 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
686 SLOG(LOG_DEBUG, TAG_STTD, " ");
691 int sttd_dbus_server_is_recognition_type_supported(DBusConnection* conn, DBusMessage* msg)
694 dbus_error_init(&err);
699 int ret = STTD_ERROR_OPERATION_FAILED;
701 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_STRING, &type, DBUS_TYPE_INVALID);
703 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT is recognition type supported");
705 if (dbus_error_is_set(&err)) {
706 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt is recognition type supported : get arguments error (%s)", err.message);
707 dbus_error_free(&err);
708 ret = STTD_ERROR_OPERATION_FAILED;
710 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt is recognition type supported : uid(%d)", uid);
711 ret = sttd_server_is_recognition_type_supported(uid, type, &support);
715 reply = dbus_message_new_method_return(msg);
718 /* Append result and language */
719 dbus_message_append_args(reply,
720 DBUS_TYPE_INT32, &ret,
721 DBUS_TYPE_INT32, &support,
725 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), Support(%s)", ret, support ? "true" : "false");
727 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
730 if (!dbus_connection_send(conn, reply, NULL)) {
731 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
734 dbus_connection_flush(conn);
735 dbus_message_unref(reply);
737 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
740 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
741 SLOG(LOG_DEBUG, TAG_STTD, " ");
746 int sttd_dbus_server_set_start_sound(DBusConnection* conn, DBusMessage* msg)
749 dbus_error_init(&err);
753 int ret = STTD_ERROR_OPERATION_FAILED;
755 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_STRING, &file, DBUS_TYPE_INVALID);
757 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT set start sound");
759 if (dbus_error_is_set(&err)) {
760 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt set start sound : get arguments error (%s)", err.message);
761 dbus_error_free(&err);
762 ret = STTD_ERROR_OPERATION_FAILED;
764 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set start sound : uid(%d) file(%s)", uid, file);
765 ret = sttd_server_set_start_sound(uid, file);
769 reply = dbus_message_new_method_return(msg);
772 /* Append result and language */
773 dbus_message_append_args(reply,
774 DBUS_TYPE_INT32, &ret,
778 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
780 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
783 if (!dbus_connection_send(conn, reply, NULL)) {
784 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
787 dbus_connection_flush(conn);
788 dbus_message_unref(reply);
790 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
793 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
794 SLOG(LOG_DEBUG, TAG_STTD, " ");
799 int sttd_dbus_server_unset_start_sound(DBusConnection* conn, DBusMessage* msg)
802 dbus_error_init(&err);
805 int ret = STTD_ERROR_OPERATION_FAILED;
807 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
809 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT unset start sound");
811 if (dbus_error_is_set(&err)) {
812 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt unset start sound : get arguments error (%s)", err.message);
813 dbus_error_free(&err);
814 ret = STTD_ERROR_OPERATION_FAILED;
816 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt unset start sound : uid(%d)", uid);
817 ret = sttd_server_set_start_sound(uid, NULL);
821 reply = dbus_message_new_method_return(msg);
824 /* Append result and language */
825 dbus_message_append_args(reply,
826 DBUS_TYPE_INT32, &ret,
830 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
832 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
835 if (!dbus_connection_send(conn, reply, NULL)) {
836 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
839 dbus_connection_flush(conn);
840 dbus_message_unref(reply);
842 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
845 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
846 SLOG(LOG_DEBUG, TAG_STTD, " ");
851 int sttd_dbus_server_set_stop_sound(DBusConnection* conn, DBusMessage* msg)
854 dbus_error_init(&err);
858 int ret = STTD_ERROR_OPERATION_FAILED;
860 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_STRING, &file, DBUS_TYPE_INVALID);
862 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT set stop sound");
864 if (dbus_error_is_set(&err)) {
865 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt set stop sound : get arguments error (%s)", err.message);
866 dbus_error_free(&err);
867 ret = STTD_ERROR_OPERATION_FAILED;
869 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set stop sound : uid(%d) file(%s)", uid, file);
870 ret = sttd_server_set_stop_sound(uid, file);
874 reply = dbus_message_new_method_return(msg);
877 /* Append result and language */
878 dbus_message_append_args(reply,
879 DBUS_TYPE_INT32, &ret,
883 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
885 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
888 if (!dbus_connection_send(conn, reply, NULL)) {
889 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
892 dbus_connection_flush(conn);
893 dbus_message_unref(reply);
895 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
898 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
899 SLOG(LOG_DEBUG, TAG_STTD, " ");
904 int sttd_dbus_server_unset_stop_sound(DBusConnection* conn, DBusMessage* msg)
907 dbus_error_init(&err);
910 int ret = STTD_ERROR_OPERATION_FAILED;
912 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
914 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT unset stop sound");
916 if (dbus_error_is_set(&err)) {
917 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt unset stop sound : get arguments error (%s)", err.message);
918 dbus_error_free(&err);
919 ret = STTD_ERROR_OPERATION_FAILED;
921 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt unset stop sound : uid(%d)", uid);
922 ret = sttd_server_set_stop_sound(uid, NULL);
926 reply = dbus_message_new_method_return(msg);
929 /* Append result and language */
930 dbus_message_append_args(reply,
931 DBUS_TYPE_INT32, &ret,
935 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
937 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
940 if (!dbus_connection_send(conn, reply, NULL)) {
941 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
944 dbus_connection_flush(conn);
945 dbus_message_unref(reply);
947 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
950 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
951 SLOG(LOG_DEBUG, TAG_STTD, " ");
956 int sttd_dbus_server_start(DBusConnection* conn, DBusMessage* msg)
959 dbus_error_init(&err);
967 int ret = STTD_ERROR_OPERATION_FAILED;
969 dbus_message_get_args(msg, &err,
970 DBUS_TYPE_INT32, &uid,
971 DBUS_TYPE_STRING, &lang,
972 DBUS_TYPE_STRING, &type,
973 DBUS_TYPE_INT32, &silence,
974 DBUS_TYPE_STRING, &appid,
975 DBUS_TYPE_STRING, &credential,
978 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Start");
980 if (dbus_error_is_set(&err)) {
981 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt start : get arguments error (%s)", err.message);
982 dbus_error_free(&err);
983 ret = STTD_ERROR_OPERATION_FAILED;
985 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt start : uid(%d), lang(%s), type(%s), silence(%d) appid(%s) credential(%s)"
986 , uid, lang, type, silence, appid, credential);
987 ret = sttd_server_start(uid, lang, type, silence, appid, credential);
991 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
993 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
994 if (0 != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to start")) {
995 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
1001 reply = dbus_message_new_method_return(msg);
1003 if (NULL != reply) {
1004 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1007 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1009 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1012 if (!dbus_connection_send(conn, reply, NULL)) {
1013 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1016 dbus_connection_flush(conn);
1017 dbus_message_unref(reply);
1019 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1023 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1024 SLOG(LOG_DEBUG, TAG_STTD, " ");
1029 int sttd_dbus_server_stop(DBusConnection* conn, DBusMessage* msg)
1032 dbus_error_init(&err);
1035 int ret = STTD_ERROR_OPERATION_FAILED;
1036 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
1038 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Stop");
1040 if (dbus_error_is_set(&err)) {
1041 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt stop : get arguments error (%s)", err.message);
1042 dbus_error_free(&err);
1043 ret = STTD_ERROR_OPERATION_FAILED;
1045 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt stop : uid(%d)", uid);
1046 ret = sttd_server_stop(uid);
1050 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1052 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1053 if (0 != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to stop")) {
1054 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
1059 reply = dbus_message_new_method_return(msg);
1061 if (NULL != reply) {
1062 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1065 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1067 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1070 if (!dbus_connection_send(conn, reply, NULL)) {
1071 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1074 dbus_connection_flush(conn);
1075 dbus_message_unref(reply);
1077 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1081 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1082 SLOG(LOG_DEBUG, TAG_STTD, " ");
1087 int sttd_dbus_server_cancel(DBusConnection* conn, DBusMessage* msg)
1090 dbus_error_init(&err);
1093 int ret = STTD_ERROR_OPERATION_FAILED;
1094 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
1096 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Cancel");
1098 if (dbus_error_is_set(&err)) {
1099 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt cancel : get arguments error (%s)", err.message);
1100 dbus_error_free(&err);
1101 ret = STTD_ERROR_OPERATION_FAILED;
1103 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt cancel : uid(%d)", uid);
1104 ret = sttd_server_cancel(uid);
1108 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1110 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1111 if (0 != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to cancel")) {
1112 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
1117 reply = dbus_message_new_method_return(msg);
1119 if (NULL != reply) {
1120 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1123 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1125 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1128 if (!dbus_connection_send(conn, reply, NULL)) {
1129 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1132 dbus_connection_flush(conn);
1133 dbus_message_unref(reply);
1135 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1138 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1139 SLOG(LOG_DEBUG, TAG_STTD, " ");