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.
19 #include "stt_client.h"
21 static int g_waiting_time = 3000;
22 static int g_waiting_short_time = 500;
24 static Ecore_Fd_Handler* g_fd_handler = NULL;
26 static DBusConnection* g_conn_sender = NULL;
27 static DBusConnection* g_conn_listener = NULL;
30 extern int __stt_cb_error(int uid, int reason);
32 extern int __stt_cb_result(int uid, int event, char** data, int data_count, const char* msg);
34 extern int __stt_cb_set_state(int uid, int state);
36 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
38 if (NULL == g_conn_listener) return ECORE_CALLBACK_RENEW;
40 dbus_connection_read_write_dispatch(g_conn_listener, 50);
42 DBusMessage* msg = NULL;
43 msg = dbus_connection_pop_message(g_conn_listener);
45 if (true != dbus_connection_get_is_connected(g_conn_listener)) {
46 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is disconnected");
47 return ECORE_CALLBACK_RENEW;
50 /* loop again if we haven't read a message */
52 return ECORE_CALLBACK_RENEW;
56 dbus_error_init(&err);
58 DBusMessage *reply = NULL;
61 snprintf(if_name, 64, "%s", STT_CLIENT_SERVICE_INTERFACE);
63 if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_HELLO)) {
64 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Hello");
68 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
69 if (dbus_error_is_set(&err)) {
70 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
71 dbus_error_free(&err);
75 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get hello : uid(%d)", uid);
78 stt_client_s* client = stt_client_get_by_uid(uid);
84 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get hello : invalid uid");
87 reply = dbus_message_new_method_return(msg);
90 dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
92 if (!dbus_connection_send(g_conn_listener, reply, NULL))
93 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to send reply");
95 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get hello : result(%d)", response);
97 dbus_connection_flush(g_conn_listener);
98 dbus_message_unref(reply);
100 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to create reply message");
103 SLOG(LOG_DEBUG, TAG_STTC, "=====");
104 SLOG(LOG_DEBUG, TAG_STTC, " ");
105 } /* STTD_METHOD_HELLO */
107 else if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_SET_STATE)) {
108 SLOG(LOG_DEBUG, TAG_STTC, "===== Set State");
112 dbus_message_get_args(msg, &err,
113 DBUS_TYPE_INT32, &uid,
114 DBUS_TYPE_INT32, &state,
117 if (dbus_error_is_set(&err)) {
118 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
119 dbus_error_free(&err);
122 if (uid > 0 && state >= 0) {
123 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set state : uid(%d), state(%d)", uid, state);
124 __stt_cb_set_state(uid, state);
126 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set state : invalid uid or state");
129 SLOG(LOG_DEBUG, TAG_STTC, "=====");
130 SLOG(LOG_DEBUG, TAG_STTC, " ");
131 } /* STTD_METHOD_SET_STATE */
132 else if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_GET_STATE)) {
133 SLOG(LOG_DEBUG, TAG_STTC, "===== Get state");
137 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
139 if (dbus_error_is_set(&err)) {
140 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
141 dbus_error_free(&err);
145 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get state : uid(%d)", uid);
148 stt_client_s* client = stt_client_get_by_uid(uid);
150 response = client->current_state;
152 SLOG(LOG_ERROR, TAG_STTC, "invalid uid");
155 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get state : invalid uid");
158 reply = dbus_message_new_method_return(msg);
161 dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
163 if (!dbus_connection_send(g_conn_listener, reply, NULL))
164 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get state : fail to send reply");
166 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get state : result(%d)", response);
168 dbus_connection_flush(g_conn_listener);
169 dbus_message_unref(reply);
171 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to create reply message");
174 SLOG(LOG_DEBUG, TAG_STTC, "=====");
175 SLOG(LOG_DEBUG, TAG_STTC, " ");
176 } /* STTD_METHOD_GET_STATE */
178 else if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_RESULT)) {
179 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Result");
181 DBusMessageIter args;
183 dbus_message_iter_init(msg, &args);
186 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
187 dbus_message_iter_get_basic(&args, &uid);
188 dbus_message_iter_next(&args);
192 char** temp_result = NULL;
193 char* temp_msg = NULL;
194 char* temp_char = NULL;
198 /* Get recognition type */
199 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
200 dbus_message_iter_get_basic(&args, &temp_event);
201 dbus_message_iter_next(&args);
204 if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&args)) {
205 dbus_message_iter_get_basic(&args, &(temp_msg) );
206 dbus_message_iter_next(&args);
210 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
211 dbus_message_iter_get_basic(&args, &temp_count);
212 dbus_message_iter_next(&args);
215 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get result : uid(%d) event(%d) message(%s) count(%d)",
216 uid, temp_event, temp_msg, temp_count);
218 if (temp_count <= 0) {
219 __stt_cb_result(uid, temp_event, NULL, 0, temp_msg);
221 temp_result = (char**)calloc(temp_count, sizeof(char*));
223 if (NULL == temp_result) {
224 SLOG(LOG_ERROR, TAG_STTC, "Fail : memory allocation error");
227 for (i = 0;i < temp_count;i++) {
228 dbus_message_iter_get_basic(&args, &(temp_char) );
229 dbus_message_iter_next(&args);
231 if (NULL != temp_char) {
232 temp_result[i] = strdup(temp_char);
233 SLOG(LOG_DEBUG, TAG_STTC, "result[%d] : %s", i, temp_result[i]);
237 __stt_cb_result(uid, temp_event, temp_result, temp_count, temp_msg);
239 for (i = 0;i < temp_count;i++) {
240 if (NULL != temp_result[i])
241 free(temp_result[i]);
248 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get result : invalid uid");
251 SLOG(LOG_DEBUG, TAG_STTC, "=====");
252 SLOG(LOG_DEBUG, TAG_STTC, " ");
253 }/* STTD_METHOD_RESULT */
255 else if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_ERROR)) {
256 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Error");
261 dbus_message_get_args(msg, &err,
262 DBUS_TYPE_INT32, &uid,
263 DBUS_TYPE_INT32, &reason,
264 DBUS_TYPE_STRING, &err_msg,
267 if (dbus_error_is_set(&err)) {
268 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt Get Error message : Get arguments error (%s)", err.message);
269 dbus_error_free(&err);
271 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt Get Error message : uid(%d), reason(%d), msg(%s)", uid, reason, err_msg);
272 __stt_cb_error(uid, reason);
275 SLOG(LOG_DEBUG, TAG_STTC, "=====");
276 SLOG(LOG_DEBUG, TAG_STTC, " ");
277 }/* STTD_METHOD_ERROR */
279 /* free the message */
280 dbus_message_unref(msg);
282 return ECORE_CALLBACK_PASS_ON;
285 int stt_dbus_open_connection()
287 if (NULL != g_conn_sender && NULL != g_conn_listener) {
288 SLOG(LOG_WARN, TAG_STTC, "already existed connection ");
294 /* initialise the error value */
295 dbus_error_init(&err);
297 /* connect to the DBUS system bus, and check for errors */
298 g_conn_sender = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
299 if (dbus_error_is_set(&err)) {
300 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Dbus Connection Error (%s)", err.message);
301 dbus_error_free(&err);
304 if (NULL == g_conn_sender) {
305 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to get dbus connection");
306 return STT_ERROR_OPERATION_FAILED;
309 dbus_connection_set_exit_on_disconnect(g_conn_sender, false);
311 /* connect to the DBUS system bus, and check for errors */
312 g_conn_listener = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
314 if (dbus_error_is_set(&err)) {
315 SLOG(LOG_ERROR, TAG_STTC, "Dbus Connection Error (%s)", err.message);
316 dbus_error_free(&err);
319 if (NULL == g_conn_listener) {
320 SLOG(LOG_ERROR, TAG_STTC, "Fail to get dbus connection");
321 return STT_ERROR_OPERATION_FAILED;
326 char service_name[64];
327 memset(service_name, '\0', 64);
328 snprintf(service_name, 64, "%s", STT_CLIENT_SERVICE_NAME);
330 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "service name is %s\n", service_name);
332 /* register our name on the bus, and check for errors */
333 dbus_bus_request_name(g_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
335 if (dbus_error_is_set(&err)) {
336 SLOG(LOG_ERROR, TAG_STTC, "Name Error (%s)\n", err.message);
337 dbus_error_free(&err);
341 snprintf(rule, 128, "type='signal',interface='%s'", STT_CLIENT_SERVICE_INTERFACE);
343 /* add a rule for which messages we want to see */
344 dbus_bus_add_match(g_conn_listener, rule, &err);
345 dbus_connection_flush(g_conn_listener);
347 if (dbus_error_is_set(&err)) {
348 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)\n", err.message);
349 dbus_error_free(&err);
350 return STT_ERROR_OPERATION_FAILED;
354 if (true != dbus_connection_get_unix_fd(g_conn_listener, &fd)) {
355 SLOG(LOG_ERROR, TAG_STTC, "Fail to get fd from dbus");
356 return STT_ERROR_OPERATION_FAILED;
358 SLOG(LOG_DEBUG, TAG_STTC, "Get fd from dbus : %d", fd);
361 g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
362 if (NULL == g_fd_handler) {
363 SLOG(LOG_ERROR, TAG_STTC, "fail to get fd handler from ecore");
364 return STT_ERROR_OPERATION_FAILED;
370 int stt_dbus_close_connection()
373 dbus_error_init(&err);
375 if (NULL != g_fd_handler) {
376 ecore_main_fd_handler_del(g_fd_handler);
382 char service_name[64];
383 memset(service_name, '\0', 64);
384 snprintf(service_name, 64, "%s", STT_CLIENT_SERVICE_NAME);
386 dbus_bus_release_name (g_conn_listener, service_name, &err);
387 if (dbus_error_is_set(&err)) {
388 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Release name Error (%s)", err.message);
389 dbus_error_free(&err);
392 g_conn_sender = NULL;
393 g_conn_listener = NULL;
398 int stt_dbus_reconnect()
400 bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
401 bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
402 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Sender(%s) Listener(%s)",
403 sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
405 if (false == sender_connected || false == listener_connected) {
406 stt_dbus_close_connection();
408 if(0 != stt_dbus_open_connection()) {
409 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to reconnect");
413 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Reconnect");
419 int stt_dbus_request_hello()
423 msg = dbus_message_new_method_call(
424 STT_SERVER_SERVICE_NAME,
425 STT_SERVER_SERVICE_OBJECT_PATH,
426 STT_SERVER_SERVICE_INTERFACE,
430 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request stt hello : Fail to make message");
431 return STT_ERROR_OPERATION_FAILED;
435 dbus_error_init(&err);
437 DBusMessage* result_msg = NULL;
440 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
441 dbus_message_unref(msg);
442 if (dbus_error_is_set(&err)) {
443 dbus_error_free(&err);
446 if (NULL != result_msg) {
447 dbus_message_unref(result_msg);
449 if (dbus_error_is_set(&err)) {
450 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
451 dbus_error_free(&err);
454 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt hello");
456 result = STT_ERROR_TIMED_OUT;
463 int stt_dbus_request_initialize(int uid, bool* silence_supported)
467 msg = dbus_message_new_method_call(
468 STT_SERVER_SERVICE_NAME,
469 STT_SERVER_SERVICE_OBJECT_PATH,
470 STT_SERVER_SERVICE_INTERFACE,
471 STT_METHOD_INITIALIZE);
474 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt initialize : Fail to make message");
475 return STT_ERROR_OPERATION_FAILED;
477 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt initialize : uid(%d)", uid);
481 dbus_message_append_args( msg,
482 DBUS_TYPE_INT32, &pid,
483 DBUS_TYPE_INT32, &uid,
487 dbus_error_init(&err);
489 DBusMessage* result_msg;
490 int result = STT_ERROR_OPERATION_FAILED;
492 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
493 dbus_message_unref(msg);
494 if (dbus_error_is_set(&err)) {
495 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
496 dbus_error_free(&err);
499 if (NULL != result_msg) {
500 dbus_message_get_args(result_msg, &err,
501 DBUS_TYPE_INT32, &result,
502 DBUS_TYPE_INT32, silence_supported,
505 if (dbus_error_is_set(&err)) {
506 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)\n", err.message);
507 dbus_error_free(&err);
508 result = STT_ERROR_OPERATION_FAILED;
512 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt initialize : result = %d, silence(%d)",
513 result, *silence_supported);
515 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt initialize : result = %d", result);
518 dbus_message_unref(result_msg);
520 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
521 stt_dbus_reconnect();
522 result = STT_ERROR_TIMED_OUT;
528 int stt_dbus_request_finalize(int uid)
532 msg = dbus_message_new_method_call(
533 STT_SERVER_SERVICE_NAME,
534 STT_SERVER_SERVICE_OBJECT_PATH,
535 STT_SERVER_SERVICE_INTERFACE,
536 STT_METHOD_FINALIZE);
539 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt finalize : Fail to make message");
540 return STT_ERROR_OPERATION_FAILED;
542 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt finalize : uid(%d)", uid);
545 dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
548 dbus_error_init(&err);
550 DBusMessage* result_msg;
551 int result = STT_ERROR_OPERATION_FAILED;
553 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
554 dbus_message_unref(msg);
555 if (dbus_error_is_set(&err)) {
556 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
557 dbus_error_free(&err);
560 if (NULL != result_msg) {
561 dbus_message_get_args(result_msg, &err,
562 DBUS_TYPE_INT32, &result,
565 if (dbus_error_is_set(&err)) {
566 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
567 dbus_error_free(&err);
568 result = STT_ERROR_OPERATION_FAILED;
571 dbus_message_unref(result_msg);
574 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt finalize : result = %d", result);
576 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt finalize : result = %d", result);
579 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
580 stt_dbus_reconnect();
581 result = STT_ERROR_TIMED_OUT;
587 int stt_dbus_request_set_current_engine(int uid, const char* engine_id, bool* silence_supported)
591 msg = dbus_message_new_method_call(
592 STT_SERVER_SERVICE_NAME,
593 STT_SERVER_SERVICE_OBJECT_PATH,
594 STT_SERVER_SERVICE_INTERFACE,
595 STT_METHOD_SET_CURRENT_ENGINE);
598 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set engine : Fail to make message");
599 return STT_ERROR_OPERATION_FAILED;
601 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set engine : uid(%d)", uid);
604 dbus_message_append_args( msg,
605 DBUS_TYPE_INT32, &uid,
606 DBUS_TYPE_STRING, &engine_id,
610 dbus_error_init(&err);
612 DBusMessage* result_msg;
613 int result = STT_ERROR_OPERATION_FAILED;
615 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
616 dbus_message_unref(msg);
617 if (dbus_error_is_set(&err)) {
618 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
619 dbus_error_free(&err);
622 if (NULL != result_msg) {
623 dbus_message_get_args(result_msg, &err,
624 DBUS_TYPE_INT32, &result,
625 DBUS_TYPE_INT32, silence_supported,
628 if (dbus_error_is_set(&err)) {
629 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)\n", err.message);
630 dbus_error_free(&err);
631 result = STT_ERROR_OPERATION_FAILED;
634 dbus_message_unref(result_msg);
637 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set engine : result = %d , silence(%d)",
638 result, *silence_supported);
640 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set engine : result = %d", result);
643 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
644 stt_dbus_reconnect();
645 result = STT_ERROR_TIMED_OUT;
651 int stt_dbus_request_check_app_agreed(int uid, const char* appid, bool* value)
653 if (NULL == appid || NULL == value) {
654 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
655 return STT_ERROR_INVALID_PARAMETER;
660 msg = dbus_message_new_method_call(
661 STT_SERVER_SERVICE_NAME,
662 STT_SERVER_SERVICE_OBJECT_PATH,
663 STT_SERVER_SERVICE_INTERFACE,
664 STT_METHOD_CHECK_APP_AGREED);
667 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt check app agreed : Fail to make message");
668 return STT_ERROR_OPERATION_FAILED;
670 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt check app agreed : uid(%d) appid(%s)", uid, appid);
673 dbus_message_append_args(msg,
674 DBUS_TYPE_INT32, &uid,
675 DBUS_TYPE_STRING, &appid,
679 dbus_error_init(&err);
681 DBusMessage* result_msg;
682 int result = STT_ERROR_OPERATION_FAILED;
685 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
686 dbus_message_unref(msg);
687 if (dbus_error_is_set(&err)) {
688 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
689 dbus_error_free(&err);
692 if (NULL != result_msg) {
693 dbus_message_get_args(result_msg, &err,
694 DBUS_TYPE_INT32, &result,
695 DBUS_TYPE_INT32, &available,
698 if (dbus_error_is_set(&err)) {
699 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
700 dbus_error_free(&err);
701 result = STT_ERROR_OPERATION_FAILED;
703 dbus_message_unref(result_msg);
706 *value = (bool)available;
707 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt check app agreed : result = %d, available = %d", result, *value);
709 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt check app agreed : result = %d", result);
712 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
713 stt_dbus_reconnect();
714 result = STT_ERROR_TIMED_OUT;
720 int stt_dbus_request_get_support_langs(int uid, stt_h stt, stt_supported_language_cb callback, void* user_data)
722 if (NULL == stt || NULL == callback) {
723 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
724 return STT_ERROR_INVALID_PARAMETER;
729 msg = dbus_message_new_method_call(
730 STT_SERVER_SERVICE_NAME,
731 STT_SERVER_SERVICE_OBJECT_PATH,
732 STT_SERVER_SERVICE_INTERFACE,
733 STT_METHOD_GET_SUPPORT_LANGS);
736 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get supported languages : Fail to make message");
737 return STT_ERROR_OPERATION_FAILED;
739 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get supported languages : uid(%d)", uid);
742 dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
745 dbus_error_init(&err);
747 DBusMessage* result_msg;
748 DBusMessageIter args;
749 int result = STT_ERROR_OPERATION_FAILED;
751 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
752 dbus_message_unref(msg);
753 if (dbus_error_is_set(&err)) {
754 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
755 dbus_error_free(&err);
758 if (NULL != result_msg) {
759 if (dbus_message_iter_init(result_msg, &args)) {
761 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
762 dbus_message_iter_get_basic(&args, &result);
763 dbus_message_iter_next(&args);
767 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get support languages : result = %d", result);
771 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
772 dbus_message_iter_get_basic(&args, &size);
773 dbus_message_iter_next(&args);
777 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt size of language error : size = %d", size);
782 for (i=0 ; i<size ; i++) {
783 dbus_message_iter_get_basic(&args, &(temp_lang));
784 dbus_message_iter_next(&args);
786 if (true != callback(stt, temp_lang, user_data)) {
792 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result = %d", result);
795 dbus_message_unref(result_msg);
797 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result message is NULL");
798 stt_dbus_reconnect();
799 result = STT_ERROR_TIMED_OUT;
805 int stt_dbus_request_get_default_lang(int uid, char** language)
807 if (NULL == language) {
808 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
809 return STT_ERROR_INVALID_PARAMETER;
814 msg = dbus_message_new_method_call(
815 STT_SERVER_SERVICE_NAME,
816 STT_SERVER_SERVICE_OBJECT_PATH,
817 STT_SERVER_SERVICE_INTERFACE,
818 STT_METHOD_GET_CURRENT_LANG);
821 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get default language : Fail to make message");
822 return STT_ERROR_OPERATION_FAILED;
824 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get default language : uid(%d)", uid);
827 dbus_message_append_args( msg,
828 DBUS_TYPE_INT32, &uid,
832 dbus_error_init(&err);
834 DBusMessage* result_msg;
835 int result = STT_ERROR_OPERATION_FAILED;
836 char* temp_lang = NULL;
838 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
839 dbus_message_unref(msg);
840 if (dbus_error_is_set(&err)) {
841 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
842 dbus_error_free(&err);
845 if (NULL != result_msg) {
846 dbus_message_get_args(result_msg, &err,
847 DBUS_TYPE_INT32, &result,
848 DBUS_TYPE_STRING, &temp_lang,
851 if (dbus_error_is_set(&err)) {
852 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
853 dbus_error_free(&err);
854 result = STT_ERROR_OPERATION_FAILED;
856 dbus_message_unref(result_msg);
859 *language = strdup(temp_lang);
860 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get default language : result = %d, language = %s", result, *language);
862 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get default language : result = %d", result);
865 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
866 stt_dbus_reconnect();
867 result = STT_ERROR_TIMED_OUT;
873 int stt_dbus_request_is_recognition_type_supported(int uid, const char* type, bool* support)
875 if (NULL == support || NULL == type) {
876 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
877 return STT_ERROR_INVALID_PARAMETER;
882 msg = dbus_message_new_method_call(
883 STT_SERVER_SERVICE_NAME,
884 STT_SERVER_SERVICE_OBJECT_PATH,
885 STT_SERVER_SERVICE_INTERFACE,
886 STT_METHOD_IS_TYPE_SUPPORTED);
889 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt is partial result supported : Fail to make message");
890 return STT_ERROR_OPERATION_FAILED;
892 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt is recognition type supported : uid(%d) type(%s)", uid, type);
895 dbus_message_append_args( msg,
896 DBUS_TYPE_INT32, &uid,
897 DBUS_TYPE_STRING, &type,
901 dbus_error_init(&err);
903 DBusMessage* result_msg;
904 int result = STT_ERROR_OPERATION_FAILED;
905 int result_support = -1;
907 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
908 dbus_message_unref(msg);
909 if (dbus_error_is_set(&err)) {
910 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
911 dbus_error_free(&err);
914 if (NULL != result_msg) {
915 dbus_message_get_args(result_msg, &err,
916 DBUS_TYPE_INT32, &result,
917 DBUS_TYPE_INT32, &result_support,
920 if (dbus_error_is_set(&err)) {
921 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
922 dbus_error_free(&err);
923 result = STT_ERROR_OPERATION_FAILED;
925 dbus_message_unref(result_msg);
928 *support = (bool)result_support;
929 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt is recognition type supported : result = %d, support = %s", result, *support ? "true" : "false");
931 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt is recognition type supported : result = %d", result);
934 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
935 stt_dbus_reconnect();
936 result = STT_ERROR_TIMED_OUT;
942 int stt_dbus_request_set_start_sound(int uid, const char* file)
945 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
946 return STT_ERROR_INVALID_PARAMETER;
951 msg = dbus_message_new_method_call(
952 STT_SERVER_SERVICE_NAME,
953 STT_SERVER_SERVICE_OBJECT_PATH,
954 STT_SERVER_SERVICE_INTERFACE,
955 STT_METHOD_SET_START_SOUND);
958 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set start sound : Fail to make message");
959 return STT_ERROR_OPERATION_FAILED;
961 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set start sound : uid(%d) file(%s)", uid, file);
964 dbus_message_append_args( msg,
965 DBUS_TYPE_INT32, &uid,
966 DBUS_TYPE_STRING, &file,
970 dbus_error_init(&err);
972 DBusMessage* result_msg;
973 int result = STT_ERROR_OPERATION_FAILED;
975 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
976 dbus_message_unref(msg);
977 if (dbus_error_is_set(&err)) {
978 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
979 dbus_error_free(&err);
982 if (NULL != result_msg) {
983 dbus_message_get_args(result_msg, &err,
984 DBUS_TYPE_INT32, &result,
987 if (dbus_error_is_set(&err)) {
988 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
989 dbus_error_free(&err);
990 result = STT_ERROR_OPERATION_FAILED;
992 dbus_message_unref(result_msg);
995 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set start sound : result = %d", result);
997 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1000 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1001 stt_dbus_reconnect();
1002 result = STT_ERROR_TIMED_OUT;
1008 int stt_dbus_request_unset_start_sound(int uid)
1012 msg = dbus_message_new_method_call(
1013 STT_SERVER_SERVICE_NAME,
1014 STT_SERVER_SERVICE_OBJECT_PATH,
1015 STT_SERVER_SERVICE_INTERFACE,
1016 STT_METHOD_UNSET_START_SOUND);
1019 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset start sound : Fail to make message");
1020 return STT_ERROR_OPERATION_FAILED;
1022 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset start sound : uid(%d)", uid);
1025 dbus_message_append_args( msg,
1026 DBUS_TYPE_INT32, &uid,
1030 dbus_error_init(&err);
1032 DBusMessage* result_msg;
1033 int result = STT_ERROR_OPERATION_FAILED;
1035 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1036 dbus_message_unref(msg);
1037 if (dbus_error_is_set(&err)) {
1038 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1039 dbus_error_free(&err);
1042 if (NULL != result_msg) {
1043 dbus_message_get_args(result_msg, &err,
1044 DBUS_TYPE_INT32, &result,
1047 if (dbus_error_is_set(&err)) {
1048 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1049 dbus_error_free(&err);
1050 result = STT_ERROR_OPERATION_FAILED;
1052 dbus_message_unref(result_msg);
1055 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1057 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1060 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1061 stt_dbus_reconnect();
1062 result = STT_ERROR_TIMED_OUT;
1068 int stt_dbus_request_set_stop_sound(int uid, const char* file)
1071 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1072 return STT_ERROR_INVALID_PARAMETER;
1077 msg = dbus_message_new_method_call(
1078 STT_SERVER_SERVICE_NAME,
1079 STT_SERVER_SERVICE_OBJECT_PATH,
1080 STT_SERVER_SERVICE_INTERFACE,
1081 STT_METHOD_SET_STOP_SOUND);
1084 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set stop sound : Fail to make message");
1085 return STT_ERROR_OPERATION_FAILED;
1087 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set stop sound : uid(%d) file(%s)", uid, file);
1090 dbus_message_append_args( msg,
1091 DBUS_TYPE_INT32, &uid,
1092 DBUS_TYPE_STRING, &file,
1096 dbus_error_init(&err);
1098 DBusMessage* result_msg;
1099 int result = STT_ERROR_OPERATION_FAILED;
1101 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1102 dbus_message_unref(msg);
1103 if (dbus_error_is_set(&err)) {
1104 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1105 dbus_error_free(&err);
1108 if (NULL != result_msg) {
1109 dbus_message_get_args(result_msg, &err,
1110 DBUS_TYPE_INT32, &result,
1113 if (dbus_error_is_set(&err)) {
1114 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1115 dbus_error_free(&err);
1116 result = STT_ERROR_OPERATION_FAILED;
1118 dbus_message_unref(result_msg);
1121 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1123 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1126 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1127 stt_dbus_reconnect();
1128 result = STT_ERROR_TIMED_OUT;
1134 int stt_dbus_request_unset_stop_sound(int uid)
1138 msg = dbus_message_new_method_call(
1139 STT_SERVER_SERVICE_NAME,
1140 STT_SERVER_SERVICE_OBJECT_PATH,
1141 STT_SERVER_SERVICE_INTERFACE,
1142 STT_METHOD_UNSET_STOP_SOUND);
1145 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset stop sound : Fail to make message");
1146 return STT_ERROR_OPERATION_FAILED;
1148 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset stop sound : uid(%d)", uid);
1151 dbus_message_append_args( msg,
1152 DBUS_TYPE_INT32, &uid,
1156 dbus_error_init(&err);
1158 DBusMessage* result_msg;
1159 int result = STT_ERROR_OPERATION_FAILED;
1161 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1162 dbus_message_unref(msg);
1163 if (dbus_error_is_set(&err)) {
1164 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1165 dbus_error_free(&err);
1168 if (NULL != result_msg) {
1169 dbus_message_get_args(result_msg, &err,
1170 DBUS_TYPE_INT32, &result,
1173 if (dbus_error_is_set(&err)) {
1174 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1175 dbus_error_free(&err);
1176 result = STT_ERROR_OPERATION_FAILED;
1178 dbus_message_unref(result_msg);
1181 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1183 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1186 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1187 stt_dbus_reconnect();
1188 result = STT_ERROR_TIMED_OUT;
1194 int stt_dbus_request_start(int uid, const char* lang, const char* type, int silence, const char* appid)
1196 if (NULL == lang || NULL == type || NULL == appid) {
1197 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1198 return STT_ERROR_INVALID_PARAMETER;
1203 /* create a signal & check for errors */
1204 msg = dbus_message_new_method_call(
1205 STT_SERVER_SERVICE_NAME,
1206 STT_SERVER_SERVICE_OBJECT_PATH,
1207 STT_SERVER_SERVICE_INTERFACE,
1211 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start : Fail to make message");
1212 return STT_ERROR_OPERATION_FAILED;
1214 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start : uid(%d), language(%s), type(%s)", uid, lang, type);
1217 dbus_message_append_args( msg,
1218 DBUS_TYPE_INT32, &uid,
1219 DBUS_TYPE_STRING, &lang,
1220 DBUS_TYPE_STRING, &type,
1221 DBUS_TYPE_INT32, &silence,
1222 DBUS_TYPE_STRING, &appid,
1226 dbus_error_init(&err);
1228 DBusMessage* result_msg;
1229 int result = STT_ERROR_OPERATION_FAILED;
1231 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1232 dbus_message_unref(msg);
1233 if (dbus_error_is_set(&err)) {
1234 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1235 dbus_error_free(&err);
1238 if (NULL != result_msg) {
1239 dbus_message_get_args(result_msg, &err,
1240 DBUS_TYPE_INT32, &result,
1243 if (dbus_error_is_set(&err)) {
1244 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1245 dbus_error_free(&err);
1246 result = STT_ERROR_OPERATION_FAILED;
1248 dbus_message_unref(result_msg);
1251 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt start : result = %d ", result);
1253 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt start : result = %d ", result);
1256 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1257 stt_dbus_reconnect();
1258 result = STT_ERROR_TIMED_OUT;
1264 int stt_dbus_request_stop(int uid)
1268 /* create a signal & check for errors */
1269 msg = dbus_message_new_method_call(
1270 STT_SERVER_SERVICE_NAME,
1271 STT_SERVER_SERVICE_OBJECT_PATH,
1272 STT_SERVER_SERVICE_INTERFACE,
1276 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt stop : Fail to make message");
1277 return STT_ERROR_OPERATION_FAILED;
1279 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt stop : uid(%d)", uid);
1282 dbus_message_append_args(msg,
1283 DBUS_TYPE_INT32, &uid,
1287 dbus_error_init(&err);
1289 DBusMessage* result_msg;
1290 int result = STT_ERROR_OPERATION_FAILED;
1292 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1293 dbus_message_unref(msg);
1294 if (dbus_error_is_set(&err)) {
1295 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1296 dbus_error_free(&err);
1299 if (NULL != result_msg) {
1300 dbus_message_get_args(result_msg, &err,
1301 DBUS_TYPE_INT32, &result,
1304 if (dbus_error_is_set(&err)) {
1305 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1306 dbus_error_free(&err);
1307 result = STT_ERROR_OPERATION_FAILED;
1309 dbus_message_unref(result_msg);
1312 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt stop : result = %d ", result);
1314 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt stop : result = %d ", result);
1317 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1318 stt_dbus_reconnect();
1319 result = STT_ERROR_TIMED_OUT;
1325 int stt_dbus_request_cancel(int uid)
1329 /* create a signal & check for errors */
1330 msg = dbus_message_new_method_call(
1331 STT_SERVER_SERVICE_NAME,
1332 STT_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
1333 STT_SERVER_SERVICE_INTERFACE, /* interface name of the signal */
1334 STT_METHOD_CANCEL); /* name of the signal */
1337 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel : Fail to make message");
1338 return STT_ERROR_OPERATION_FAILED;
1340 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel : uid(%d)", uid);
1343 dbus_message_append_args(msg,
1344 DBUS_TYPE_INT32, &uid,
1348 dbus_error_init(&err);
1350 DBusMessage* result_msg;
1351 int result = STT_ERROR_OPERATION_FAILED;
1353 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1354 dbus_message_unref(msg);
1355 if (dbus_error_is_set(&err)) {
1356 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1357 dbus_error_free(&err);
1360 if (NULL != result_msg) {
1361 dbus_message_get_args(result_msg, &err,
1362 DBUS_TYPE_INT32, &result,
1365 if (dbus_error_is_set(&err)) {
1366 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1367 dbus_error_free(&err);
1368 result = STT_ERROR_OPERATION_FAILED;
1370 dbus_message_unref(result_msg);
1373 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt cancel : result = %d ", result);
1375 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt cancel : result = %d ", result);
1378 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1379 stt_dbus_reconnect();
1380 result = STT_ERROR_TIMED_OUT;