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 int int_silence_supported = (int)silence_supported;
82 int int_credential_needed = (int)credential_needed;
84 dbus_message_append_args(reply,
85 DBUS_TYPE_INT32, &ret,
86 DBUS_TYPE_INT32, &int_silence_supported,
87 DBUS_TYPE_INT32, &int_credential_needed,
92 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), silence(%d), credential(%d)",
93 ret, silence_supported, credential_needed);
95 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
98 if (!dbus_connection_send(conn, reply, NULL)) {
99 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
102 dbus_connection_flush(conn);
103 dbus_message_unref(reply);
105 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
108 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
109 SLOG(LOG_DEBUG, TAG_STTD, " ");
114 int sttd_dbus_server_finalize(DBusConnection* conn, DBusMessage* msg)
117 dbus_error_init(&err);
120 int ret = STTD_ERROR_OPERATION_FAILED;
121 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
123 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Finalize");
125 if (dbus_error_is_set(&err)) {
126 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt finalize : get arguments error (%s)", err.message);
127 dbus_error_free(&err);
128 ret = STTD_ERROR_OPERATION_FAILED;
130 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt finalize : uid(%d)", uid);
131 ret = sttd_server_finalize(uid);
136 reply = dbus_message_new_method_return(msg);
139 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
142 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
144 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
147 if (!dbus_connection_send(conn, reply, NULL)) {
148 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
151 dbus_connection_flush(conn);
152 dbus_message_unref(reply);
154 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
157 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
158 SLOG(LOG_DEBUG, TAG_STTD, " ");
163 int sttd_dbus_server_get_support_engines(DBusConnection* conn, DBusMessage* msg)
166 dbus_error_init(&err);
169 int ret = STTD_ERROR_OPERATION_FAILED;
170 GSList* engine_list = NULL;
172 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
174 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get supported engines");
176 if (dbus_error_is_set(&err)) {
177 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt supported engines : get arguments error (%s)", err.message);
178 dbus_error_free(&err);
179 ret = STTD_ERROR_OPERATION_FAILED;
181 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt supported engines : uid(%d)", uid);
182 ret = sttd_server_get_supported_engines(uid, &engine_list);
186 reply = dbus_message_new_method_return(msg);
189 DBusMessageIter args;
191 dbus_message_iter_init_append(reply, &args);
194 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret));
198 int size = g_slist_length(engine_list);
199 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
200 ret = STTD_ERROR_OPERATION_FAILED;
205 iter = g_slist_nth(engine_list, 0);
207 while (NULL != iter) {
210 if (NULL != engine) {
211 if (NULL != engine->engine_id && NULL != engine->engine_name && NULL != engine->ug_name) {
212 SLOG(LOG_DEBUG, TAG_STTD, "engine id : %s, engine name : %s, ug_name, : %s",
213 engine->engine_id, engine->engine_name, engine->ug_name);
215 dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->engine_id));
216 dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->engine_name));
217 /* dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->ug_name)); */
219 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Engine info is NULL");
222 if (NULL != engine->engine_id) {
223 free(engine->engine_id);
224 engine->engine_id = NULL;
226 if (NULL != engine->engine_name) {
227 free(engine->engine_name);
228 engine->engine_name = NULL;
230 if (NULL != engine->ug_name) {
231 free(engine->ug_name);
232 engine->ug_name = NULL;
238 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Engine info is NULL");
241 engine_list = g_slist_remove_link(engine_list, iter);
243 iter = g_slist_nth(engine_list, 0);
246 SLOG(LOG_DEBUG, TAG_STTD, "[OUT] Result(%d)", ret);
248 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
251 if (!dbus_connection_send(conn, reply, NULL)) {
252 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
255 dbus_connection_flush(conn);
256 dbus_message_unref(reply);
258 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
261 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
262 SLOG(LOG_DEBUG, TAG_STTD, " ");
267 int sttd_dbus_server_set_current_engine(DBusConnection* conn, DBusMessage* msg)
270 dbus_error_init(&err);
274 bool silence_supported = false;
275 bool credential_needed = false;
276 int ret = STTD_ERROR_OPERATION_FAILED;
278 dbus_message_get_args(msg, &err,
279 DBUS_TYPE_INT32, &uid,
280 DBUS_TYPE_STRING, &engine_id,
283 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Set current engine");
285 if (dbus_error_is_set(&err)) {
286 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt set current engine : get arguments error (%s)", err.message);
287 dbus_error_free(&err);
288 ret = STTD_ERROR_OPERATION_FAILED;
290 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set current engine : uid(%d), engine_id(%s)", uid, (NULL == engine_id) ? "NULL" : engine_id);
291 ret = sttd_server_set_current_engine(uid, engine_id, &silence_supported, &credential_needed);
295 reply = dbus_message_new_method_return(msg);
298 int int_silence_supported = (int)silence_supported;
299 int int_credential_needed = (int)credential_needed;
301 dbus_message_append_args(reply,
302 DBUS_TYPE_INT32, &ret,
303 DBUS_TYPE_INT32, &int_silence_supported,
304 DBUS_TYPE_INT32, &int_credential_needed,
308 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), silence(%d), credential(%d)",
309 ret, silence_supported, credential_needed);
311 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d) ", ret);
314 if (!dbus_connection_send(conn, reply, NULL)) {
315 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
318 dbus_connection_flush(conn);
319 dbus_message_unref(reply);
321 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
324 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
325 SLOG(LOG_DEBUG, TAG_STTD, " ");
330 int sttd_dbus_server_get_current_engine(DBusConnection* conn, DBusMessage* msg)
333 dbus_error_init(&err);
337 int ret = STTD_ERROR_OPERATION_FAILED;
339 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
341 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get current engine");
343 if (dbus_error_is_set(&err)) {
344 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt get current engine : get arguments error (%s)", err.message);
345 dbus_error_free(&err);
346 ret = STTD_ERROR_OPERATION_FAILED;
348 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get current engine : uid(%d)", uid);
349 ret = sttd_server_get_current_engine(uid, &engine);
353 reply = dbus_message_new_method_return(msg);
357 /* Append result and language */
358 dbus_message_append_args(reply,
359 DBUS_TYPE_INT32, &ret,
360 DBUS_TYPE_STRING, &engine,
363 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
365 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
367 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
370 if (!dbus_connection_send(conn, reply, NULL)) {
371 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
374 dbus_connection_flush(conn);
375 dbus_message_unref(reply);
377 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
380 if (NULL != engine) free(engine);
382 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
383 SLOG(LOG_DEBUG, TAG_STTD, " ");
388 int sttd_dbus_server_check_app_agreed(DBusConnection* conn, DBusMessage* msg)
391 dbus_error_init(&err);
395 int ret = STTD_ERROR_OPERATION_FAILED;
396 bool available = false;
398 dbus_message_get_args(msg, &err,
399 DBUS_TYPE_INT32, &uid,
400 DBUS_TYPE_STRING, &appid,
403 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Is engine available");
405 if (dbus_error_is_set(&err)) {
406 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt Is engine available : get arguments error (%s)", err.message);
407 dbus_error_free(&err);
408 ret = STTD_ERROR_OPERATION_FAILED;
410 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt Is engine available : uid(%d)", uid);
411 ret = sttd_server_check_app_agreed(uid, appid, &available);
415 reply = dbus_message_new_method_return(msg);
418 /* Append result and language */
419 dbus_message_append_args(reply,
420 DBUS_TYPE_INT32, &ret,
421 DBUS_TYPE_INT32, &available,
425 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
427 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
430 if (!dbus_connection_send(conn, reply, NULL)) {
431 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
434 dbus_connection_flush(conn);
435 dbus_message_unref(reply);
437 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
440 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
441 SLOG(LOG_DEBUG, TAG_STTD, " ");
446 int sttd_dbus_server_get_support_lang(DBusConnection* conn, DBusMessage* msg)
449 dbus_error_init(&err);
452 int ret = STTD_ERROR_OPERATION_FAILED;
453 GSList* lang_list = NULL;
455 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
457 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get supported langs");
459 if (dbus_error_is_set(&err)) {
460 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt supported langs : get arguments error (%s)", err.message);
461 dbus_error_free(&err);
462 ret = STTD_ERROR_OPERATION_FAILED;
464 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt supported langs : uid(%d)", uid);
465 ret = sttd_server_get_supported_languages(uid, &lang_list);
469 reply = dbus_message_new_method_return(msg);
472 DBusMessageIter args;
473 dbus_message_iter_init_append(reply, &args);
476 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret));
479 /* Append language size */
480 int size = g_slist_length(lang_list);
482 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
483 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to append type");
484 ret = STTD_ERROR_OPERATION_FAILED;
489 iter = g_slist_nth(lang_list, 0);
491 while (NULL != iter) {
492 temp_lang = iter->data;
494 dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(temp_lang));
496 if (NULL != temp_lang)
499 lang_list = g_slist_remove_link(lang_list, iter);
501 iter = g_slist_nth(lang_list, 0);
504 SLOG(LOG_DEBUG, TAG_STTD, "[OUT] Result(%d)", ret);
506 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
509 if (!dbus_connection_send(conn, reply, NULL)) {
510 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
513 dbus_connection_flush(conn);
514 dbus_message_unref(reply);
516 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
519 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
520 SLOG(LOG_DEBUG, TAG_STTD, " ");
525 int sttd_dbus_server_get_default_lang(DBusConnection* conn, DBusMessage* msg)
528 dbus_error_init(&err);
532 int ret = STTD_ERROR_OPERATION_FAILED;
534 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
536 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get default langs");
538 if (dbus_error_is_set(&err)) {
539 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt get default lang : get arguments error (%s)", err.message);
540 dbus_error_free(&err);
541 ret = STTD_ERROR_OPERATION_FAILED;
543 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get default lang : uid(%d)", uid);
544 ret = sttd_server_get_current_langauage(uid, &lang);
548 reply = dbus_message_new_method_return(msg);
552 /* Append result and language */
553 dbus_message_append_args(reply,
554 DBUS_TYPE_INT32, &ret,
555 DBUS_TYPE_STRING, &lang,
558 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
560 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
562 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
565 if (!dbus_connection_send(conn, reply, NULL)) {
566 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
569 dbus_connection_flush(conn);
570 dbus_message_unref(reply);
572 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
575 if (NULL != lang) free(lang);
577 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
578 SLOG(LOG_DEBUG, TAG_STTD, " ");
583 int sttd_dbus_server_set_private_data(DBusConnection* conn, DBusMessage* msg)
586 dbus_error_init(&err);
591 int ret = STTD_ERROR_OPERATION_FAILED;
592 dbus_message_get_args(msg, &err,
593 DBUS_TYPE_INT32, &uid,
594 DBUS_TYPE_STRING, &key,
595 DBUS_TYPE_STRING, &data,
598 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Set private data");
600 if (dbus_error_is_set(&err)) {
601 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt set private data : get arguments error (%s)", err.message);
602 dbus_error_free(&err);
603 ret = STTD_ERROR_OPERATION_FAILED;
605 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set private data : uid(%d)", uid);
606 ret = sttd_server_set_private_data(uid, key, data);
610 reply = dbus_message_new_method_return(msg);
613 dbus_message_append_args(reply,
614 DBUS_TYPE_INT32, &ret,
618 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
620 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
623 if (!dbus_connection_send(conn, reply, NULL)) {
624 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
627 dbus_connection_flush(conn);
628 dbus_message_unref(reply);
630 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
633 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
634 SLOG(LOG_DEBUG, TAG_STTD, " ");
639 int sttd_dbus_server_get_private_data(DBusConnection* conn, DBusMessage* msg)
642 dbus_error_init(&err);
647 int ret = STTD_ERROR_OPERATION_FAILED;
648 dbus_message_get_args(msg, &err,
649 DBUS_TYPE_INT32, &uid,
650 DBUS_TYPE_STRING, &key,
653 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get private data");
655 if (dbus_error_is_set(&err)) {
656 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt get private data : get arguments error (%s)", err.message);
657 dbus_error_free(&err);
658 ret = STTD_ERROR_OPERATION_FAILED;
660 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get private data : uid(%d), key(%s)", uid, (NULL == key) ? "NULL" : key);
661 ret = sttd_server_get_private_data(uid, key, &data);
665 reply = dbus_message_new_method_return(msg);
668 /* Append result and private data */
669 dbus_message_append_args(reply,
670 DBUS_TYPE_INT32, &ret,
671 DBUS_TYPE_STRING, &data,
675 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), data(%s)", ret, (NULL == data) ? "NULL" : data);
677 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
680 if (!dbus_connection_send(conn, reply, NULL)) {
681 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
684 dbus_connection_flush(conn);
685 dbus_message_unref(reply);
687 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
690 if (NULL != data) free(data);
692 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
693 SLOG(LOG_DEBUG, TAG_STTD, " ");
698 int sttd_dbus_server_is_recognition_type_supported(DBusConnection* conn, DBusMessage* msg)
701 dbus_error_init(&err);
706 int ret = STTD_ERROR_OPERATION_FAILED;
708 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_STRING, &type, DBUS_TYPE_INVALID);
710 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT is recognition type supported");
712 if (dbus_error_is_set(&err)) {
713 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt is recognition type supported : get arguments error (%s)", err.message);
714 dbus_error_free(&err);
715 ret = STTD_ERROR_OPERATION_FAILED;
717 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt is recognition type supported : uid(%d)", uid);
718 ret = sttd_server_is_recognition_type_supported(uid, type, &support);
722 reply = dbus_message_new_method_return(msg);
725 /* Append result and language */
726 dbus_message_append_args(reply,
727 DBUS_TYPE_INT32, &ret,
728 DBUS_TYPE_INT32, &support,
732 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), Support(%s)", ret, support ? "true" : "false");
734 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
737 if (!dbus_connection_send(conn, reply, NULL)) {
738 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
741 dbus_connection_flush(conn);
742 dbus_message_unref(reply);
744 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
747 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
748 SLOG(LOG_DEBUG, TAG_STTD, " ");
753 int sttd_dbus_server_set_start_sound(DBusConnection* conn, DBusMessage* msg)
756 dbus_error_init(&err);
760 int ret = STTD_ERROR_OPERATION_FAILED;
762 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_STRING, &file, DBUS_TYPE_INVALID);
764 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT set start sound");
766 if (dbus_error_is_set(&err)) {
767 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt set start sound : get arguments error (%s)", err.message);
768 dbus_error_free(&err);
769 ret = STTD_ERROR_OPERATION_FAILED;
771 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set start sound : uid(%d) file(%s)", uid, file);
772 ret = sttd_server_set_start_sound(uid, file);
776 reply = dbus_message_new_method_return(msg);
779 /* Append result and language */
780 dbus_message_append_args(reply,
781 DBUS_TYPE_INT32, &ret,
785 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
787 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
790 if (!dbus_connection_send(conn, reply, NULL)) {
791 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
794 dbus_connection_flush(conn);
795 dbus_message_unref(reply);
797 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
800 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
801 SLOG(LOG_DEBUG, TAG_STTD, " ");
806 int sttd_dbus_server_unset_start_sound(DBusConnection* conn, DBusMessage* msg)
809 dbus_error_init(&err);
812 int ret = STTD_ERROR_OPERATION_FAILED;
814 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
816 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT unset start sound");
818 if (dbus_error_is_set(&err)) {
819 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt unset start sound : get arguments error (%s)", err.message);
820 dbus_error_free(&err);
821 ret = STTD_ERROR_OPERATION_FAILED;
823 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt unset start sound : uid(%d)", uid);
824 ret = sttd_server_set_start_sound(uid, NULL);
828 reply = dbus_message_new_method_return(msg);
831 /* Append result and language */
832 dbus_message_append_args(reply,
833 DBUS_TYPE_INT32, &ret,
837 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
839 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
842 if (!dbus_connection_send(conn, reply, NULL)) {
843 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
846 dbus_connection_flush(conn);
847 dbus_message_unref(reply);
849 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
852 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
853 SLOG(LOG_DEBUG, TAG_STTD, " ");
858 int sttd_dbus_server_set_stop_sound(DBusConnection* conn, DBusMessage* msg)
861 dbus_error_init(&err);
865 int ret = STTD_ERROR_OPERATION_FAILED;
867 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_STRING, &file, DBUS_TYPE_INVALID);
869 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT set stop sound");
871 if (dbus_error_is_set(&err)) {
872 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt set stop sound : get arguments error (%s)", err.message);
873 dbus_error_free(&err);
874 ret = STTD_ERROR_OPERATION_FAILED;
876 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set stop sound : uid(%d) file(%s)", uid, file);
877 ret = sttd_server_set_stop_sound(uid, file);
881 reply = dbus_message_new_method_return(msg);
884 /* Append result and language */
885 dbus_message_append_args(reply,
886 DBUS_TYPE_INT32, &ret,
890 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
892 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
895 if (!dbus_connection_send(conn, reply, NULL)) {
896 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
899 dbus_connection_flush(conn);
900 dbus_message_unref(reply);
902 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
905 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
906 SLOG(LOG_DEBUG, TAG_STTD, " ");
911 int sttd_dbus_server_unset_stop_sound(DBusConnection* conn, DBusMessage* msg)
914 dbus_error_init(&err);
917 int ret = STTD_ERROR_OPERATION_FAILED;
919 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
921 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT unset stop sound");
923 if (dbus_error_is_set(&err)) {
924 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt unset stop sound : get arguments error (%s)", err.message);
925 dbus_error_free(&err);
926 ret = STTD_ERROR_OPERATION_FAILED;
928 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt unset stop sound : uid(%d)", uid);
929 ret = sttd_server_set_stop_sound(uid, NULL);
933 reply = dbus_message_new_method_return(msg);
936 /* Append result and language */
937 dbus_message_append_args(reply,
938 DBUS_TYPE_INT32, &ret,
942 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
944 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
947 if (!dbus_connection_send(conn, reply, NULL)) {
948 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
951 dbus_connection_flush(conn);
952 dbus_message_unref(reply);
954 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
957 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
958 SLOG(LOG_DEBUG, TAG_STTD, " ");
963 int sttd_dbus_server_start(DBusConnection* conn, DBusMessage* msg)
966 dbus_error_init(&err);
974 int ret = STTD_ERROR_OPERATION_FAILED;
976 dbus_message_get_args(msg, &err,
977 DBUS_TYPE_INT32, &uid,
978 DBUS_TYPE_STRING, &lang,
979 DBUS_TYPE_STRING, &type,
980 DBUS_TYPE_INT32, &silence,
981 DBUS_TYPE_STRING, &appid,
982 DBUS_TYPE_STRING, &credential,
985 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Start");
987 if (dbus_error_is_set(&err)) {
988 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt start : get arguments error (%s)", err.message);
989 dbus_error_free(&err);
990 ret = STTD_ERROR_OPERATION_FAILED;
992 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt start : uid(%d), lang(%s), type(%s), silence(%d) appid(%s) credential(%s)"
993 , uid, lang, type, silence, appid, credential);
994 ret = sttd_server_start(uid, lang, type, silence, appid, credential);
998 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1000 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1001 if (0 != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to start")) {
1002 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
1008 reply = dbus_message_new_method_return(msg);
1010 if (NULL != reply) {
1011 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1014 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1016 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1019 if (!dbus_connection_send(conn, reply, NULL)) {
1020 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1023 dbus_connection_flush(conn);
1024 dbus_message_unref(reply);
1026 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1030 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1031 SLOG(LOG_DEBUG, TAG_STTD, " ");
1036 int sttd_dbus_server_stop(DBusConnection* conn, DBusMessage* msg)
1039 dbus_error_init(&err);
1042 int ret = STTD_ERROR_OPERATION_FAILED;
1043 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
1045 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Stop");
1047 if (dbus_error_is_set(&err)) {
1048 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt stop : get arguments error (%s)", err.message);
1049 dbus_error_free(&err);
1050 ret = STTD_ERROR_OPERATION_FAILED;
1052 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt stop : uid(%d)", uid);
1053 ret = sttd_server_stop(uid);
1057 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1059 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1060 if (0 != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to stop")) {
1061 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
1066 reply = dbus_message_new_method_return(msg);
1068 if (NULL != reply) {
1069 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1072 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1074 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1077 if (!dbus_connection_send(conn, reply, NULL)) {
1078 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1081 dbus_connection_flush(conn);
1082 dbus_message_unref(reply);
1084 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1088 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1089 SLOG(LOG_DEBUG, TAG_STTD, " ");
1094 int sttd_dbus_server_cancel(DBusConnection* conn, DBusMessage* msg)
1097 dbus_error_init(&err);
1100 int ret = STTD_ERROR_OPERATION_FAILED;
1101 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
1103 SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Cancel");
1105 if (dbus_error_is_set(&err)) {
1106 SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt cancel : get arguments error (%s)", err.message);
1107 dbus_error_free(&err);
1108 ret = STTD_ERROR_OPERATION_FAILED;
1110 SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt cancel : uid(%d)", uid);
1111 ret = sttd_server_cancel(uid);
1115 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1117 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1118 if (0 != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to cancel")) {
1119 SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
1124 reply = dbus_message_new_method_return(msg);
1126 if (NULL != reply) {
1127 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
1130 SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
1132 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
1135 if (!dbus_connection_send(conn, reply, NULL)) {
1136 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
1139 dbus_connection_flush(conn);
1140 dbus_message_unref(reply);
1142 SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
1145 SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
1146 SLOG(LOG_DEBUG, TAG_STTD, " ");