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.
19 #include "stt_client.h"
21 #include <vconf/vconf.h>
24 static int g_waiting_time = 3000;
25 static int g_waiting_short_time = 500;
27 static char* g_server_service_name = NULL;
28 static char* g_server_service_object = NULL;
29 static char* g_server_service_interface = NULL;
31 static Ecore_Fd_Handler* g_fd_handler = NULL;
33 static DBusConnection* g_conn_sender = NULL;
34 static DBusConnection* g_conn_listener = NULL;
36 void __stt_dbus_service_free();
38 extern int __stt_cb_error(int uid, int reason, char* err_msg);
40 extern int __stt_cb_result(int uid, int event, char** data, int data_count, const char* msg);
42 extern int __stt_cb_set_state(int uid, int state);
44 extern int __stt_cb_set_volume(int uid, float volume);
46 extern int __stt_cb_speech_status(int uid, int status);
48 char* __stt_get_service_name(char* engine_id)
50 char* service_name = NULL;
51 const char* engine_default = NULL;
53 struct buxton_client * bux_cli;
54 struct buxton_layer * bux_layer;
55 struct buxton_value * bux_val;
57 int ret = buxton_open(&bux_cli, NULL, NULL);
59 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to open buxton client, ret(%d)", ret);
62 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS-BUXTON2] buxton_open: %d", ret);
63 bux_layer = buxton_create_layer("system");
64 if (NULL == bux_layer) {
65 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] buxton_create_layer FAIL");
66 buxton_close(bux_cli);
71 bux_val = buxton_value_create_string("stt-engine-default");
72 if (NULL == bux_val) {
73 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] buxton_value_create_string FAIL");
74 buxton_free_layer(bux_layer);
75 buxton_close(bux_cli);
81 ret = buxton_get_value_sync(bux_cli, bux_layer, STT_ENGINE_DB_DEFAULT, &bux_val);
83 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to get value sync, ret(%d)", ret);
84 buxton_value_free(bux_val);
85 buxton_free_layer(bux_layer);
86 buxton_close(bux_cli);
93 ret = buxton_value_get_string(bux_val, &engine_default);
95 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to get value string, ret(%d)", ret);
96 buxton_value_free(bux_val);
97 buxton_free_layer(bux_layer);
98 buxton_close(bux_cli);
105 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS-BUXTON2] buxton_value_get_string: engine_default: %s", engine_default);
108 if (NULL == engine_id || NULL == engine_default || 0 == strncmp(engine_id, engine_default, strlen(engine_id))) {
109 service_name = (char*)calloc(strlen(STT_SERVER_SERVICE_NAME) + 1, sizeof(char));
110 if (NULL == service_name) {
111 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Memory allocation Failed!!");
112 buxton_value_free(bux_val);
113 buxton_free_layer(bux_layer);
114 buxton_close(bux_cli);
121 snprintf(service_name, strlen(STT_SERVER_SERVICE_NAME) + 1, "%s", STT_SERVER_SERVICE_NAME);
123 service_name = (char*)calloc(strlen(STT_SERVER_SERVICE_NAME) + strlen(engine_id) - 8, sizeof(char));
124 if (NULL == service_name) {
125 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Memory allocation Failed!!");
126 buxton_value_free(bux_val);
127 buxton_free_layer(bux_layer);
128 buxton_close(bux_cli);
135 snprintf(service_name, strlen(STT_SERVER_SERVICE_NAME) + strlen(engine_id) - 8, "%s%s%s", STT_SERVER_SERVICE_NAME, ".", (engine_id + 10));
138 buxton_value_free(bux_val);
139 buxton_free_layer(bux_layer);
140 buxton_close(bux_cli);
146 SLOG(LOG_DEBUG, TAG_STTC, "[get_service_name] FINISH!! service name: %s", service_name);
151 char* __stt_get_service_object(char* engine_id)
153 char* service_object = NULL;
154 const char* engine_default = NULL;
156 struct buxton_client * bux_cli;
157 struct buxton_layer * bux_layer;
158 struct buxton_value * bux_val;
160 int ret = buxton_open(&bux_cli, NULL, NULL);
162 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to open buxton client, ret(%d)", ret);
165 bux_layer = buxton_create_layer("system");
166 if (NULL == bux_layer) {
167 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS-BUXTON2] buxton_create_layer FAIL");
168 buxton_close(bux_cli);
173 bux_val = buxton_value_create_string("stt-engine-default");
174 if (NULL == bux_val) {
175 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] buxton_value_create_string FAIL");
176 buxton_free_layer(bux_layer);
177 buxton_close(bux_cli);
183 ret = buxton_get_value_sync(bux_cli, bux_layer, STT_ENGINE_DB_DEFAULT, &bux_val);
185 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to get value sync, ret(%d)", ret);
186 buxton_value_free(bux_val);
187 buxton_free_layer(bux_layer);
188 buxton_close(bux_cli);
195 ret = buxton_value_get_string(bux_val, &engine_default);
197 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to get string, ret(%d)", ret);
198 buxton_value_free(bux_val);
199 buxton_free_layer(bux_layer);
200 buxton_close(bux_cli);
207 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS-BUXTON2] buxton_value_get_string: engine_default: %s", engine_default);
209 if (NULL == engine_id || NULL == engine_default || 0 == strncmp(engine_id, engine_default, strlen(engine_id))) {
210 service_object = (char*)calloc(strlen(STT_SERVER_SERVICE_OBJECT_PATH) + 1, sizeof(char));
211 if (NULL == service_object) {
212 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Memory allocation Failed!!");
213 buxton_value_free(bux_val);
214 buxton_free_layer(bux_layer);
215 buxton_close(bux_cli);
222 snprintf(service_object, strlen(STT_SERVER_SERVICE_OBJECT_PATH) + 1, "%s", STT_SERVER_SERVICE_OBJECT_PATH);
224 service_object = (char*)calloc(strlen(STT_SERVER_SERVICE_OBJECT_PATH) + strlen(engine_id) - 8, sizeof(char));
225 if (NULL == service_object) {
226 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Memory allocation Failed!!");
227 buxton_value_free(bux_val);
228 buxton_free_layer(bux_layer);
229 buxton_close(bux_cli);
236 snprintf(service_object, strlen(STT_SERVER_SERVICE_OBJECT_PATH) + strlen(engine_id) - 8, "%s%s%s", STT_SERVER_SERVICE_OBJECT_PATH, "/", (engine_id + 10));
239 buxton_value_free(bux_val);
240 buxton_free_layer(bux_layer);
241 buxton_close(bux_cli);
247 SLOG(LOG_DEBUG, TAG_STTC, "[get_service_object] FINISH!! service object: %s", service_object);
249 return service_object;
252 char* __stt_get_service_interface(char* engine_id)
254 char* service_interface = NULL;
255 const char* engine_default = NULL;
257 struct buxton_client * bux_cli;
258 struct buxton_layer * bux_layer;
259 struct buxton_value * bux_val;
261 int ret = buxton_open(&bux_cli, NULL, NULL);
263 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to open buxton client, ret(%d)", ret);
266 bux_layer = buxton_create_layer("system");
267 if (NULL == bux_layer) {
268 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] buxton_create_layer FAIL");
269 buxton_close(bux_cli);
274 bux_val = buxton_value_create_string("stt-engine-default");
275 if (NULL == bux_val) {
276 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] buxton_value_create_string FAIL");
277 buxton_free_layer(bux_layer);
278 buxton_close(bux_cli);
284 ret = buxton_get_value_sync(bux_cli, bux_layer, STT_ENGINE_DB_DEFAULT, &bux_val);
286 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to get value sync, ret(%d)", ret);
287 buxton_value_free(bux_val);
288 buxton_free_layer(bux_layer);
289 buxton_close(bux_cli);
296 ret = buxton_value_get_string(bux_val, &engine_default);
298 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to get string, ret(%d)", ret);
299 buxton_value_free(bux_val);
300 buxton_free_layer(bux_layer);
301 buxton_close(bux_cli);
308 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS-BUXTON2] buxton_value_get_string: engine_default: %s", engine_default);
310 if (NULL == engine_id || NULL == engine_default || 0 == strncmp(engine_id, engine_default, strlen(engine_id))) {
311 service_interface = (char*)calloc(strlen(STT_SERVER_SERVICE_INTERFACE) + 1, sizeof(char));
312 if (NULL == service_interface) {
313 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Memory allocation Failed!!");
314 buxton_value_free(bux_val);
315 buxton_free_layer(bux_layer);
316 buxton_close(bux_cli);
323 snprintf(service_interface, strlen(STT_SERVER_SERVICE_INTERFACE) + 1, "%s", STT_SERVER_SERVICE_INTERFACE);
325 service_interface = (char*)calloc(strlen(STT_SERVER_SERVICE_INTERFACE) + strlen(engine_id) - 8, sizeof(char));
326 if (NULL == service_interface) {
327 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Memory allocation Failed!!");
328 buxton_value_free(bux_val);
329 buxton_free_layer(bux_layer);
330 buxton_close(bux_cli);
337 snprintf(service_interface, strlen(STT_SERVER_SERVICE_INTERFACE) + strlen(engine_id) - 8, "%s%s%s", STT_SERVER_SERVICE_INTERFACE, ".", (engine_id + 10));
340 char* ret_char = strchr(service_interface, '-');
341 while (NULL != ret_char) {
343 ret_char = strchr(service_interface, '-');
346 buxton_value_free(bux_val);
347 buxton_free_layer(bux_layer);
348 ret = buxton_close(bux_cli);
354 SLOG(LOG_DEBUG, TAG_STTC, "[get_service_interface] FINISH!! service interface: %s", service_interface);
356 return service_interface;
360 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
362 if (NULL == g_conn_listener) return ECORE_CALLBACK_RENEW;
364 dbus_connection_read_write_dispatch(g_conn_listener, 50);
367 DBusMessage* msg = NULL;
368 msg = dbus_connection_pop_message(g_conn_listener);
370 if (true != dbus_connection_get_is_connected(g_conn_listener)) {
371 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is disconnected");
375 /* loop again if we haven't read a message */
380 SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] Message is arrived");
383 dbus_error_init(&err);
385 DBusMessage *reply = NULL;
388 snprintf(if_name, 64, "%s%d", STT_CLIENT_SERVICE_INTERFACE, getpid());
390 if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_HELLO)) {
391 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Hello");
395 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
396 if (dbus_error_is_set(&err)) {
397 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
398 dbus_error_free(&err);
402 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get hello : uid(%d)", uid);
405 stt_client_s* client = stt_client_get_by_uid(uid);
411 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get hello : invalid uid");
414 reply = dbus_message_new_method_return(msg);
417 dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
419 if (!dbus_connection_send(g_conn_listener, reply, NULL))
420 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to send reply");
422 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get hello : result(%d)", response);
424 dbus_connection_flush(g_conn_listener);
425 dbus_message_unref(reply);
427 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to create reply message");
430 SLOG(LOG_DEBUG, TAG_STTC, "=====");
431 SLOG(LOG_DEBUG, TAG_STTC, " ");
432 } /* STTD_METHOD_HELLO */
434 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_SET_STATE)) {
435 SLOG(LOG_DEBUG, TAG_STTC, "===== Set State");
439 dbus_message_get_args(msg, &err,
440 DBUS_TYPE_INT32, &uid,
441 DBUS_TYPE_INT32, &state,
444 if (dbus_error_is_set(&err)) {
445 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
446 dbus_error_free(&err);
449 if (uid > 0 && state >= 0) {
450 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set state : uid(%d), state(%d)", uid, state);
451 __stt_cb_set_state(uid, state);
453 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set state : invalid uid or state");
456 SLOG(LOG_DEBUG, TAG_STTC, "=====");
457 SLOG(LOG_DEBUG, TAG_STTC, " ");
458 } /* STTD_METHOD_SET_STATE */
460 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_SET_VOLUME)) {
461 SLOG(LOG_DEBUG, TAG_STTC, "===== Set volume : signal");
465 dbus_message_get_args(msg, &err,
466 DBUS_TYPE_INT32, &uid,
467 DBUS_TYPE_INT32, &volume,
470 if (dbus_error_is_set(&err)) {
471 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
472 dbus_error_free(&err);
475 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set volume : uid(%d), volume(%f)", uid, volume);
476 __stt_cb_set_volume(uid, volume);
478 /* SLOG(LOG_DEBUG, TAG_STTC, "====="); */
479 /* SLOG(LOG_DEBUG, TAG_STTC, " "); */
480 } /* STTD_METHOD_SET_VOLUME */
482 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_RESULT)) {
483 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Result : signal");
485 DBusMessageIter args;
487 dbus_message_iter_init(msg, &args);
490 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
491 dbus_message_iter_get_basic(&args, &uid);
492 dbus_message_iter_next(&args);
495 stt_client_s* client = NULL;
496 client = stt_client_get_by_uid(uid);
497 if (NULL != client) {
498 char** temp_result = NULL;
499 char* temp_msg = NULL;
500 char* temp_char = NULL;
503 int temp_result_id = 0;
505 /* Get recognition type */
506 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
507 dbus_message_iter_get_basic(&args, &temp_event);
508 dbus_message_iter_next(&args);
511 if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&args)) {
512 dbus_message_iter_get_basic(&args, &(temp_msg));
513 dbus_message_iter_next(&args);
517 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
518 dbus_message_iter_get_basic(&args, &temp_count);
519 dbus_message_iter_next(&args);
523 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
524 dbus_message_iter_get_basic(&args, &temp_result_id);
525 dbus_message_iter_next(&args);
528 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get result : uid(%d) event(%d) message(%s) count(%d) result id(%d)",
529 uid, temp_event, temp_msg, temp_count, temp_result_id);
531 if (temp_count <= 0) {
532 __stt_cb_result(uid, temp_event, NULL, 0, temp_msg);
534 temp_result = (char**)calloc(temp_count, sizeof(char*));
536 if (NULL == temp_result) {
537 SLOG(LOG_ERROR, TAG_STTC, "Fail : memory allocation error");
540 for (i = 0; i < temp_count; i++) {
541 dbus_message_iter_get_basic(&args, &(temp_char));
542 dbus_message_iter_next(&args);
544 if (NULL != temp_char) {
545 temp_result[i] = strdup(temp_char);
546 SLOG(LOG_DEBUG, TAG_STTC, "result[%d] : %s", i, temp_result[i]);
550 __stt_cb_result(uid, temp_event, temp_result, temp_count, temp_msg);
552 for (i = 0; i < temp_count; i++) {
553 if (NULL != temp_result[i])
554 free(temp_result[i]);
561 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get result : invalid uid");
564 SLOG(LOG_DEBUG, TAG_STTC, "=====");
565 SLOG(LOG_DEBUG, TAG_STTC, " ");
566 } /* STTD_METHOD_RESULT */
568 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_ERROR)) {
569 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Error");
574 dbus_message_get_args(msg, &err,
575 DBUS_TYPE_INT32, &uid,
576 DBUS_TYPE_INT32, &reason,
577 DBUS_TYPE_STRING, &err_msg,
580 if (dbus_error_is_set(&err)) {
581 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt Get Error message : Get arguments error (%s)", err.message);
582 dbus_error_free(&err);
584 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt Get Error message : uid(%d), reason(%d), err_msg(%s)", uid, reason, (NULL == err_msg) ? "NULL" : err_msg);
585 __stt_cb_error(uid, reason, err_msg);
588 SLOG(LOG_DEBUG, TAG_STTC, "=====");
589 SLOG(LOG_DEBUG, TAG_STTC, " ");
590 } /* STTD_METHOD_ERROR */
592 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_SPEECH_STATUS)) {
593 SLOG(LOG_DEBUG, TAG_STTC, "===== Speech status");
597 dbus_message_get_args(msg, &err,
598 DBUS_TYPE_INT32, &uid,
599 DBUS_TYPE_INT32, &status,
602 if (dbus_error_is_set(&err)) {
603 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
604 dbus_error_free(&err);
607 if (uid > 0 && status >= 0) {
608 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt speech status : uid(%d), status(%d)", uid, status);
609 __stt_cb_speech_status(uid, status);
611 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set status : invalid uid or status");
614 SLOG(LOG_DEBUG, TAG_STTC, "=====");
615 SLOG(LOG_DEBUG, TAG_STTC, " ");
616 } /* STTD_METHOD_SPEECH_STATUS */
618 else if (dbus_message_is_signal(msg, "org.freedesktop.DBus", "NameOwnerChanged")) {
619 SLOG(LOG_DEBUG, TAG_STTC, "===== Owner Changed");
621 dbus_error_init(&err);
623 /* remove a rule for daemon error */
624 char rule_err[256] = {0, };
625 snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", g_server_service_interface);
626 dbus_bus_remove_match(g_conn_listener, rule_err, &err);
627 dbus_connection_flush(g_conn_listener);
628 if (dbus_error_is_set(&err)) {
629 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)", err.message);
630 dbus_error_free(&err);
633 __stt_cb_error(-1, STT_ERROR_SERVICE_RESET, "Daemon Reset");
634 SLOG(LOG_DEBUG, TAG_STTC, "=====");
635 SLOG(LOG_DEBUG, TAG_STTC, " ");
636 } /* NameOwnerChanged */
639 SLOG(LOG_DEBUG, TAG_STTC, "Message is NOT valid");
640 dbus_message_unref(msg);
644 /* free the message */
645 dbus_message_unref(msg);
648 return ECORE_CALLBACK_RENEW;
651 static void __stt_dbus_connection_free()
653 if (NULL != g_conn_listener) {
654 dbus_connection_close(g_conn_listener);
655 dbus_connection_unref(g_conn_listener);
656 g_conn_listener = NULL;
658 if (NULL != g_conn_sender) {
659 dbus_connection_close(g_conn_sender);
660 dbus_connection_unref(g_conn_sender);
661 g_conn_sender = NULL;
665 int stt_dbus_open_connection()
667 if (NULL != g_conn_sender && NULL != g_conn_listener) {
668 SLOG(LOG_WARN, TAG_STTC, "already existed connection ");
674 /* initialise the error value */
675 dbus_error_init(&err);
677 /* connect to the DBUS system bus, and check for errors */
678 if (NULL == g_conn_sender) {
679 g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
680 if (dbus_error_is_set(&err)) {
681 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Dbus Connection Error (%s)", err.message);
682 dbus_error_free(&err);
686 if (NULL == g_conn_sender) {
687 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to get dbus connection");
688 return STT_ERROR_OPERATION_FAILED;
691 dbus_connection_set_exit_on_disconnect(g_conn_sender, false);
693 /* connect to the DBUS system bus, and check for errors */
694 if (NULL == g_conn_listener) {
695 g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
696 if (dbus_error_is_set(&err)) {
697 SLOG(LOG_ERROR, TAG_STTC, "Dbus Connection Error (%s)", err.message);
698 dbus_error_free(&err);
702 if (NULL == g_conn_listener) {
703 SLOG(LOG_ERROR, TAG_STTC, "Fail to get dbus connection");
704 __stt_dbus_connection_free();
705 return STT_ERROR_OPERATION_FAILED;
708 dbus_connection_set_exit_on_disconnect(g_conn_listener, false);
712 char service_name[64];
713 memset(service_name, '\0', 64);
714 snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
716 SLOG(LOG_DEBUG, TAG_STTC, "service name is %s", service_name);
718 /* register our name on the bus, and check for errors */
719 dbus_bus_request_name(g_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
721 if (dbus_error_is_set(&err)) {
722 SLOG(LOG_ERROR, TAG_STTC, "Name Error (%s)", err.message);
723 dbus_error_free(&err);
726 char rule[128] = {0, };
727 snprintf(rule, 128, "type='signal',interface='%s%d'", STT_CLIENT_SERVICE_INTERFACE, pid);
729 /* add a rule for which messages we want to see */
730 dbus_bus_add_match(g_conn_listener, rule, &err);
731 dbus_connection_flush(g_conn_listener);
733 if (dbus_error_is_set(&err)) {
734 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)", err.message);
735 dbus_error_free(&err);
736 __stt_dbus_connection_free();
737 return STT_ERROR_OPERATION_FAILED;
741 if (true != dbus_connection_get_unix_fd(g_conn_listener, &fd)) {
742 SLOG(LOG_ERROR, TAG_STTC, "Fail to get fd from dbus");
743 __stt_dbus_connection_free();
744 return STT_ERROR_OPERATION_FAILED;
746 SLOG(LOG_DEBUG, TAG_STTC, "Get fd from dbus : %d", fd);
749 g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
750 if (NULL == g_fd_handler) {
751 SLOG(LOG_ERROR, TAG_STTC, "fail to get fd handler from ecore");
752 __stt_dbus_connection_free();
753 return STT_ERROR_OPERATION_FAILED;
759 int stt_dbus_close_connection()
762 dbus_error_init(&err);
764 if (NULL != g_fd_handler) {
765 ecore_main_fd_handler_del(g_fd_handler);
769 if (NULL != g_conn_listener) {
772 char service_name[64];
773 memset(service_name, '\0', 64);
774 snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
776 dbus_bus_release_name(g_conn_listener, service_name, &err);
777 if (dbus_error_is_set(&err)) {
778 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Release name Error (%s)", err.message);
779 dbus_error_free(&err);
783 __stt_dbus_connection_free();
784 __stt_dbus_service_free();
789 int stt_dbus_reconnect()
791 if (!g_conn_sender || !g_conn_listener) {
792 stt_dbus_close_connection();
794 if (0 != stt_dbus_open_connection()) {
795 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to reconnect");
799 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Reconnect");
803 bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
804 bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
805 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Sender(%s) Listener(%s)",
806 sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
808 if (false == sender_connected || false == listener_connected) {
809 stt_dbus_close_connection();
811 if (0 != stt_dbus_open_connection()) {
812 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to reconnect");
816 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Reconnect");
822 void __stt_dbus_service_free()
824 if (NULL != g_server_service_name) {
825 free(g_server_service_name);
826 g_server_service_name = NULL;
828 if (NULL != g_server_service_object) {
829 free(g_server_service_object);
830 g_server_service_object = NULL;
832 if (NULL != g_server_service_interface) {
833 free(g_server_service_interface);
834 g_server_service_interface = NULL;
838 int stt_dbus_request_hello(int uid)
840 stt_client_s* client = stt_client_get_by_uid(uid);
842 /* Check whether there is any dbus whose name has owner or not */
843 dbus_bool_t is_exist = FALSE;
845 dbus_error_init(&err);
847 DBusMessage* msg = NULL;
848 DBusMessage* result_msg = NULL;
852 if (NULL != client) {
853 __stt_dbus_service_free();
855 if (NULL == client->current_engine_id) {
857 g_server_service_name = strdup(STT_SERVER_SERVICE_NAME);
858 if (NULL == g_server_service_name) {
859 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
860 return STT_ERROR_OUT_OF_MEMORY;
862 g_server_service_object = strdup(STT_SERVER_SERVICE_OBJECT_PATH);
863 if (NULL == g_server_service_name) {
864 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
865 return STT_ERROR_OUT_OF_MEMORY;
867 g_server_service_interface = strdup(STT_SERVER_SERVICE_INTERFACE);
868 if (NULL == g_server_service_name) {
869 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
870 return STT_ERROR_OUT_OF_MEMORY;
873 msg = dbus_message_new_method_call(
874 STT_SERVER_SERVICE_NAME,
875 STT_SERVER_SERVICE_OBJECT_PATH,
876 STT_SERVER_SERVICE_INTERFACE,
879 /* Get service name, object, interface */
880 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] current_engine_id: %s", client->current_engine_id);
882 g_server_service_name = __stt_get_service_name(client->current_engine_id);
883 g_server_service_object = __stt_get_service_object(client->current_engine_id);
884 g_server_service_interface = __stt_get_service_interface(client->current_engine_id);
886 if (NULL == g_server_service_name || NULL == g_server_service_object || NULL == g_server_service_interface) {
887 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] dbus service info invalid");
888 return STT_ERROR_OPERATION_FAILED;
891 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] service name: %s, object path: %s, interface: %s", g_server_service_name, g_server_service_object, g_server_service_interface);
894 is_exist = dbus_bus_name_has_owner(g_conn_sender, g_server_service_name, &err);
895 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] is there dbus name has owner??: %s (g_server_service_name: %s)", (is_exist == TRUE) ? "True" : "False", g_server_service_name);
897 if (TRUE == is_exist) {
898 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] dbus: is_exist: True");
899 msg = dbus_message_new_method_call(
900 g_server_service_name,
901 g_server_service_object,
902 g_server_service_interface,
905 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] dbus: is_exist: False");
906 msg = dbus_message_new_method_call(
907 STT_SERVER_CUSTOM_SERVICE_NAME,
908 STT_SERVER_CUSTOM_SERVICE_OBJECT_PATH,
909 STT_SERVER_CUSTOM_SERVICE_INTERFACE,
917 // SLOG(LOG_ERROR, TAG_STTC, ">>>> Request stt hello : Fail to make message");
918 result = stt_dbus_reconnect();
920 return STT_ERROR_OPERATION_FAILED;
924 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
925 dbus_message_unref(msg);
926 if (dbus_error_is_set(&err)) {
927 dbus_error_free(&err);
930 if (NULL != result_msg) {
931 dbus_message_unref(result_msg);
933 if (dbus_error_is_set(&err)) {
934 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
935 dbus_error_free(&err);
938 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt hello");
940 if (dbus_error_is_set(&err)) {
941 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
942 dbus_error_free(&err);
945 result = STT_ERROR_TIMED_OUT;
948 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
949 stt_dbus_reconnect();
950 result = STT_ERROR_OPERATION_FAILED;
957 int stt_dbus_request_initialize(int uid, bool* silence_supported, bool* credential_needed)
961 msg = dbus_message_new_method_call(
962 g_server_service_name,
963 g_server_service_object,
964 g_server_service_interface,
965 STT_METHOD_INITIALIZE);
968 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt initialize : Fail to make message");
969 return STT_ERROR_OPERATION_FAILED;
971 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt initialize : uid(%d)", uid);
975 dbus_message_append_args(msg,
976 DBUS_TYPE_INT32, &pid,
977 DBUS_TYPE_INT32, &uid,
981 dbus_error_init(&err);
983 DBusMessage* result_msg;
984 int result = STT_ERROR_OPERATION_FAILED;
987 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
988 dbus_message_unref(msg);
989 if (dbus_error_is_set(&err)) {
990 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
991 dbus_error_free(&err);
994 if (NULL != result_msg) {
995 int int_silence_supported = 0;
996 int int_credential_needed = 0;
997 dbus_message_get_args(result_msg, &err,
998 DBUS_TYPE_INT32, &result,
999 DBUS_TYPE_INT32, &int_silence_supported,
1000 DBUS_TYPE_INT32, &int_credential_needed,
1003 *silence_supported = (bool)(int_silence_supported);
1004 *credential_needed = (bool)(int_credential_needed);
1006 if (dbus_error_is_set(&err)) {
1007 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1008 dbus_error_free(&err);
1009 result = STT_ERROR_OPERATION_FAILED;
1013 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt initialize : result = %d, silence(%d), credential(%d)",
1014 result, *silence_supported, *credential_needed);
1016 /* add a rule for daemon error */
1017 char rule_err[256] = {0, };
1018 snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", g_server_service_interface);
1019 dbus_bus_add_match(g_conn_listener, rule_err, &err);
1020 dbus_connection_flush(g_conn_listener);
1022 if (dbus_error_is_set(&err)) {
1023 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)", err.message);
1024 dbus_error_free(&err);
1025 return STT_ERROR_OPERATION_FAILED;
1028 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt initialize : result = %d", result);
1031 dbus_message_unref(result_msg);
1033 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1034 stt_dbus_reconnect();
1035 result = STT_ERROR_TIMED_OUT;
1038 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1039 result = STT_ERROR_OPERATION_FAILED;
1045 int stt_dbus_request_finalize(int uid)
1050 dbus_error_init(&err);
1052 /* remove a rule for daemon error */
1053 char rule_err[256] = {0, };
1054 snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", g_server_service_interface);
1055 dbus_bus_remove_match(g_conn_listener, rule_err, &err);
1056 dbus_connection_flush(g_conn_listener);
1057 if (dbus_error_is_set(&err)) {
1058 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)", err.message);
1059 dbus_error_free(&err);
1062 SLOG(LOG_DEBUG, TAG_STTC, "[dbus_info] service name: %s, service object: %s, service interface: %s", g_server_service_name, g_server_service_object, g_server_service_interface);
1064 msg = dbus_message_new_method_call(
1065 g_server_service_name,
1066 g_server_service_object,
1067 g_server_service_interface,
1068 STT_METHOD_FINALIZE);
1071 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt finalize : Fail to make message");
1072 return STT_ERROR_OPERATION_FAILED;
1074 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt finalize : uid(%d)", uid);
1077 dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
1079 DBusMessage* result_msg;
1080 int result = STT_ERROR_OPERATION_FAILED;
1082 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
1083 dbus_message_unref(msg);
1084 if (dbus_error_is_set(&err)) {
1085 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1086 dbus_error_free(&err);
1089 if (NULL != result_msg) {
1090 dbus_message_get_args(result_msg, &err,
1091 DBUS_TYPE_INT32, &result,
1094 if (dbus_error_is_set(&err)) {
1095 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1096 dbus_error_free(&err);
1097 result = STT_ERROR_OPERATION_FAILED;
1100 dbus_message_unref(result_msg);
1103 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt finalize : result = %d", result);
1105 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt finalize : result = %d", result);
1108 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1109 stt_dbus_reconnect();
1110 result = STT_ERROR_TIMED_OUT;
1116 int stt_dbus_request_set_current_engine(int uid, const char* engine_id, bool* silence_supported, bool* credential_needed)
1120 msg = dbus_message_new_method_call(
1121 g_server_service_name,
1122 g_server_service_object,
1123 g_server_service_interface,
1124 STT_METHOD_SET_CURRENT_ENGINE);
1128 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set engine : Fail to make message");
1129 return STT_ERROR_OPERATION_FAILED;
1131 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set engine : uid(%d), engine_id(%s)", uid, (NULL == engine_id) ? "NULL" : engine_id);
1134 dbus_message_append_args(msg,
1135 DBUS_TYPE_INT32, &uid,
1136 DBUS_TYPE_STRING, &engine_id,
1140 dbus_error_init(&err);
1142 DBusMessage* result_msg;
1143 int result = STT_ERROR_OPERATION_FAILED;
1145 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1146 dbus_message_unref(msg);
1147 if (dbus_error_is_set(&err)) {
1148 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1149 dbus_error_free(&err);
1152 if (NULL != result_msg) {
1153 int int_silence_supported = 0;
1154 int int_credential_needed = 0;
1156 dbus_message_get_args(result_msg, &err,
1157 DBUS_TYPE_INT32, &result,
1158 DBUS_TYPE_INT32, &int_silence_supported,
1159 DBUS_TYPE_INT32, &int_credential_needed,
1162 *silence_supported = (bool)(int_silence_supported);
1163 *credential_needed = (bool)(int_credential_needed);
1165 if (dbus_error_is_set(&err)) {
1166 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1167 dbus_error_free(&err);
1168 result = STT_ERROR_OPERATION_FAILED;
1171 dbus_message_unref(result_msg);
1174 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set engine : result = %d , silence(%d), credential(%d)",
1175 result, *silence_supported, *credential_needed);
1177 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set engine : result = %d", result);
1180 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1181 stt_dbus_reconnect();
1182 result = STT_ERROR_TIMED_OUT;
1188 int stt_dbus_request_check_app_agreed(int uid, const char* appid, bool* value)
1190 if (NULL == appid || NULL == value) {
1191 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1192 return STT_ERROR_INVALID_PARAMETER;
1197 msg = dbus_message_new_method_call(
1198 g_server_service_name,
1199 g_server_service_object,
1200 g_server_service_interface,
1201 STT_METHOD_CHECK_APP_AGREED);
1204 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt check app agreed : Fail to make message");
1205 return STT_ERROR_OPERATION_FAILED;
1207 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt check app agreed : uid(%d) appid(%s)", uid, appid);
1210 dbus_message_append_args(msg,
1211 DBUS_TYPE_INT32, &uid,
1212 DBUS_TYPE_STRING, &appid,
1216 dbus_error_init(&err);
1218 DBusMessage* result_msg;
1219 int result = STT_ERROR_OPERATION_FAILED;
1222 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1223 dbus_message_unref(msg);
1224 if (dbus_error_is_set(&err)) {
1225 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1226 dbus_error_free(&err);
1229 if (NULL != result_msg) {
1230 dbus_message_get_args(result_msg, &err,
1231 DBUS_TYPE_INT32, &result,
1232 DBUS_TYPE_INT32, &available,
1235 if (dbus_error_is_set(&err)) {
1236 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1237 dbus_error_free(&err);
1238 result = STT_ERROR_OPERATION_FAILED;
1240 dbus_message_unref(result_msg);
1243 *value = (bool)available;
1244 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt check app agreed : result = %d, available = %d", result, *value);
1246 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt check app agreed : result = %d", result);
1249 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1250 stt_dbus_reconnect();
1251 result = STT_ERROR_TIMED_OUT;
1257 int stt_dbus_request_get_support_langs(int uid, stt_h stt, stt_supported_language_cb callback, void* user_data)
1259 if (NULL == stt || NULL == callback) {
1260 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1261 return STT_ERROR_INVALID_PARAMETER;
1266 msg = dbus_message_new_method_call(
1267 g_server_service_name,
1268 g_server_service_object,
1269 g_server_service_interface,
1270 STT_METHOD_GET_SUPPORT_LANGS);
1273 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get supported languages : Fail to make message");
1274 return STT_ERROR_OPERATION_FAILED;
1276 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get supported languages : uid(%d)", uid);
1279 dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
1282 dbus_error_init(&err);
1284 DBusMessage* result_msg;
1285 DBusMessageIter args;
1286 int result = STT_ERROR_OPERATION_FAILED;
1288 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1289 dbus_message_unref(msg);
1290 if (dbus_error_is_set(&err)) {
1291 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1292 dbus_error_free(&err);
1295 if (NULL != result_msg) {
1296 if (dbus_message_iter_init(result_msg, &args)) {
1298 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
1299 dbus_message_iter_get_basic(&args, &result);
1300 dbus_message_iter_next(&args);
1304 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get support languages : result = %d", result);
1306 /* Get voice size */
1308 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
1309 dbus_message_iter_get_basic(&args, &size);
1310 dbus_message_iter_next(&args);
1314 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt size of language error : size = %d", size);
1319 for (i = 0; i < size; i++) {
1320 dbus_message_iter_get_basic(&args, &(temp_lang));
1321 dbus_message_iter_next(&args);
1323 if (true != callback(stt, temp_lang, user_data)) {
1329 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result = %d", result);
1332 dbus_message_unref(result_msg);
1334 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result message is NULL");
1335 stt_dbus_reconnect();
1336 result = STT_ERROR_TIMED_OUT;
1342 int stt_dbus_request_get_default_lang(int uid, char** language)
1344 if (NULL == language) {
1345 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1346 return STT_ERROR_INVALID_PARAMETER;
1351 msg = dbus_message_new_method_call(
1352 g_server_service_name,
1353 g_server_service_object,
1354 g_server_service_interface,
1355 STT_METHOD_GET_CURRENT_LANG);
1358 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get default language : Fail to make message");
1359 return STT_ERROR_OPERATION_FAILED;
1361 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get default language : uid(%d)", uid);
1364 dbus_message_append_args(msg,
1365 DBUS_TYPE_INT32, &uid,
1369 dbus_error_init(&err);
1371 DBusMessage* result_msg;
1372 int result = STT_ERROR_OPERATION_FAILED;
1373 char* temp_lang = NULL;
1375 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1376 dbus_message_unref(msg);
1377 if (dbus_error_is_set(&err)) {
1378 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1379 dbus_error_free(&err);
1382 if (NULL != result_msg) {
1383 dbus_message_get_args(result_msg, &err,
1384 DBUS_TYPE_INT32, &result,
1385 DBUS_TYPE_STRING, &temp_lang,
1388 if (dbus_error_is_set(&err)) {
1389 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1390 dbus_error_free(&err);
1391 result = STT_ERROR_OPERATION_FAILED;
1393 dbus_message_unref(result_msg);
1396 *language = strdup(temp_lang);
1397 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get default language : result = %d, language = %s", result, *language);
1399 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get default language : result = %d", result);
1402 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1403 stt_dbus_reconnect();
1404 result = STT_ERROR_TIMED_OUT;
1410 int stt_dbus_request_set_private_data(int uid, const char* key, const char* data)
1412 if (NULL == key || NULL == data) {
1413 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1414 return STT_ERROR_INVALID_PARAMETER;
1419 msg = dbus_message_new_method_call(
1420 g_server_service_name,
1421 g_server_service_object,
1422 g_server_service_interface,
1423 STT_METHOD_SET_PRIVATE_DATA);
1426 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set private data : Fail to make message");
1427 return STT_ERROR_OPERATION_FAILED;
1429 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set private data : uid(%d)", uid);
1432 if (true != dbus_message_append_args(msg,
1433 DBUS_TYPE_INT32, &uid,
1434 DBUS_TYPE_STRING, &key,
1435 DBUS_TYPE_STRING, &data,
1436 DBUS_TYPE_INVALID)) {
1437 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to append args");
1438 return STT_ERROR_OPERATION_FAILED;
1442 dbus_error_init(&err);
1444 DBusMessage* result_msg;
1445 int result = STT_ERROR_OPERATION_FAILED;
1447 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1448 dbus_message_unref(msg);
1449 if (dbus_error_is_set(&err)) {
1450 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1451 dbus_error_free(&err);
1454 if (NULL != result_msg) {
1455 dbus_message_get_args(result_msg, &err,
1456 DBUS_TYPE_INT32, &result,
1459 if (dbus_error_is_set(&err)) {
1460 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1461 dbus_error_free(&err);
1462 result = STT_ERROR_OPERATION_FAILED;
1464 dbus_message_unref(result_msg);
1467 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set private data : result = %d", result);
1469 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set private data : result = %d", result);
1472 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1473 stt_dbus_reconnect();
1474 result = STT_ERROR_TIMED_OUT;
1480 int stt_dbus_request_get_private_data(int uid, const char* key, char** data)
1482 if (NULL == key || NULL == data) {
1483 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1484 return STT_ERROR_INVALID_PARAMETER;
1489 msg = dbus_message_new_method_call(
1490 g_server_service_name,
1491 g_server_service_object,
1492 g_server_service_interface,
1493 STT_METHOD_GET_PRIVATE_DATA);
1496 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get private data : Fail to make message");
1497 return STT_ERROR_OPERATION_FAILED;
1499 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get private data : uid(%d)", uid);
1502 if (true != dbus_message_append_args(msg,
1503 DBUS_TYPE_INT32, &uid,
1504 DBUS_TYPE_STRING, &key,
1505 DBUS_TYPE_INVALID)) {
1506 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to append args");
1507 return STT_ERROR_OPERATION_FAILED;
1511 dbus_error_init(&err);
1513 DBusMessage* result_msg;
1514 int result = STT_ERROR_OPERATION_FAILED;
1516 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1517 dbus_message_unref(msg);
1518 if (dbus_error_is_set(&err)) {
1519 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1520 dbus_error_free(&err);
1524 if (NULL != result_msg) {
1525 dbus_message_get_args(result_msg, &err,
1526 DBUS_TYPE_INT32, &result,
1527 DBUS_TYPE_STRING, &temp,
1530 if (dbus_error_is_set(&err)) {
1531 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1532 dbus_error_free(&err);
1533 result = STT_ERROR_OPERATION_FAILED;
1535 dbus_message_unref(result_msg);
1538 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get private data : result = %d", result);
1540 *data = strdup(temp);
1543 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get private data : result = %d", result);
1546 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1547 stt_dbus_reconnect();
1548 result = STT_ERROR_TIMED_OUT;
1556 int stt_dbus_request_is_recognition_type_supported(int uid, const char* type, bool* support)
1558 if (NULL == support || NULL == type) {
1559 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1560 return STT_ERROR_INVALID_PARAMETER;
1565 msg = dbus_message_new_method_call(
1566 g_server_service_name,
1567 g_server_service_object,
1568 g_server_service_interface,
1569 STT_METHOD_IS_TYPE_SUPPORTED);
1572 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt is partial result supported : Fail to make message");
1573 return STT_ERROR_OPERATION_FAILED;
1575 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt is recognition type supported : uid(%d) type(%s)", uid, type);
1578 dbus_message_append_args(msg,
1579 DBUS_TYPE_INT32, &uid,
1580 DBUS_TYPE_STRING, &type,
1584 dbus_error_init(&err);
1586 DBusMessage* result_msg;
1587 int result = STT_ERROR_OPERATION_FAILED;
1588 int result_support = -1;
1590 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1591 dbus_message_unref(msg);
1592 if (dbus_error_is_set(&err)) {
1593 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1594 dbus_error_free(&err);
1597 if (NULL != result_msg) {
1598 dbus_message_get_args(result_msg, &err,
1599 DBUS_TYPE_INT32, &result,
1600 DBUS_TYPE_INT32, &result_support,
1603 if (dbus_error_is_set(&err)) {
1604 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1605 dbus_error_free(&err);
1606 result = STT_ERROR_OPERATION_FAILED;
1608 dbus_message_unref(result_msg);
1611 *support = (bool)result_support;
1612 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt is recognition type supported : result = %d, support = %s", result, *support ? "true" : "false");
1614 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt is recognition type supported : result = %d", result);
1617 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1618 stt_dbus_reconnect();
1619 result = STT_ERROR_TIMED_OUT;
1625 int stt_dbus_request_set_start_sound(int uid, const char* file)
1628 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1629 return STT_ERROR_INVALID_PARAMETER;
1634 msg = dbus_message_new_method_call(
1635 g_server_service_name,
1636 g_server_service_object,
1637 g_server_service_interface,
1638 STT_METHOD_SET_START_SOUND);
1641 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set start sound : Fail to make message");
1642 return STT_ERROR_OPERATION_FAILED;
1644 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set start sound : uid(%d) file(%s)", uid, file);
1647 dbus_message_append_args(msg,
1648 DBUS_TYPE_INT32, &uid,
1649 DBUS_TYPE_STRING, &file,
1653 dbus_error_init(&err);
1655 DBusMessage* result_msg;
1656 int result = STT_ERROR_OPERATION_FAILED;
1658 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1659 dbus_message_unref(msg);
1660 if (dbus_error_is_set(&err)) {
1661 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1662 dbus_error_free(&err);
1665 if (NULL != result_msg) {
1666 dbus_message_get_args(result_msg, &err,
1667 DBUS_TYPE_INT32, &result,
1670 if (dbus_error_is_set(&err)) {
1671 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1672 dbus_error_free(&err);
1673 result = STT_ERROR_OPERATION_FAILED;
1675 dbus_message_unref(result_msg);
1678 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1680 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1683 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1684 stt_dbus_reconnect();
1685 result = STT_ERROR_TIMED_OUT;
1691 int stt_dbus_request_unset_start_sound(int uid)
1695 msg = dbus_message_new_method_call(
1696 g_server_service_name,
1697 g_server_service_object,
1698 g_server_service_interface,
1699 STT_METHOD_UNSET_START_SOUND);
1702 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset start sound : Fail to make message");
1703 return STT_ERROR_OPERATION_FAILED;
1705 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset start sound : uid(%d)", uid);
1708 dbus_message_append_args(msg,
1709 DBUS_TYPE_INT32, &uid,
1713 dbus_error_init(&err);
1715 DBusMessage* result_msg;
1716 int result = STT_ERROR_OPERATION_FAILED;
1718 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1719 dbus_message_unref(msg);
1720 if (dbus_error_is_set(&err)) {
1721 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1722 dbus_error_free(&err);
1725 if (NULL != result_msg) {
1726 dbus_message_get_args(result_msg, &err,
1727 DBUS_TYPE_INT32, &result,
1730 if (dbus_error_is_set(&err)) {
1731 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1732 dbus_error_free(&err);
1733 result = STT_ERROR_OPERATION_FAILED;
1735 dbus_message_unref(result_msg);
1738 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1740 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1743 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1744 stt_dbus_reconnect();
1745 result = STT_ERROR_TIMED_OUT;
1751 int stt_dbus_request_set_stop_sound(int uid, const char* file)
1754 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1755 return STT_ERROR_INVALID_PARAMETER;
1760 msg = dbus_message_new_method_call(
1761 g_server_service_name,
1762 g_server_service_object,
1763 g_server_service_interface,
1764 STT_METHOD_SET_STOP_SOUND);
1767 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set stop sound : Fail to make message");
1768 return STT_ERROR_OPERATION_FAILED;
1770 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set stop sound : uid(%d) file(%s)", uid, file);
1773 dbus_message_append_args(msg,
1774 DBUS_TYPE_INT32, &uid,
1775 DBUS_TYPE_STRING, &file,
1779 dbus_error_init(&err);
1781 DBusMessage* result_msg;
1782 int result = STT_ERROR_OPERATION_FAILED;
1784 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1785 dbus_message_unref(msg);
1786 if (dbus_error_is_set(&err)) {
1787 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1788 dbus_error_free(&err);
1791 if (NULL != result_msg) {
1792 dbus_message_get_args(result_msg, &err,
1793 DBUS_TYPE_INT32, &result,
1796 if (dbus_error_is_set(&err)) {
1797 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1798 dbus_error_free(&err);
1799 result = STT_ERROR_OPERATION_FAILED;
1801 dbus_message_unref(result_msg);
1804 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1806 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1809 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1810 stt_dbus_reconnect();
1811 result = STT_ERROR_TIMED_OUT;
1817 int stt_dbus_request_unset_stop_sound(int uid)
1821 msg = dbus_message_new_method_call(
1822 g_server_service_name,
1823 g_server_service_object,
1824 g_server_service_interface,
1825 STT_METHOD_UNSET_STOP_SOUND);
1828 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset stop sound : Fail to make message");
1829 return STT_ERROR_OPERATION_FAILED;
1831 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset stop sound : uid(%d)", uid);
1834 dbus_message_append_args(msg,
1835 DBUS_TYPE_INT32, &uid,
1839 dbus_error_init(&err);
1841 DBusMessage* result_msg;
1842 int result = STT_ERROR_OPERATION_FAILED;
1844 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1845 dbus_message_unref(msg);
1846 if (dbus_error_is_set(&err)) {
1847 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1848 dbus_error_free(&err);
1851 if (NULL != result_msg) {
1852 dbus_message_get_args(result_msg, &err,
1853 DBUS_TYPE_INT32, &result,
1856 if (dbus_error_is_set(&err)) {
1857 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1858 dbus_error_free(&err);
1859 result = STT_ERROR_OPERATION_FAILED;
1861 dbus_message_unref(result_msg);
1864 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1866 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1869 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1870 stt_dbus_reconnect();
1871 result = STT_ERROR_TIMED_OUT;
1877 int stt_dbus_request_start(int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential)
1879 if (NULL == lang || NULL == type || NULL == appid) {
1880 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1881 return STT_ERROR_INVALID_PARAMETER;
1886 /* create a signal & check for errors */
1887 msg = dbus_message_new_method_call(
1888 g_server_service_name,
1889 g_server_service_object,
1890 g_server_service_interface,
1894 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start : Fail to make message");
1895 return STT_ERROR_OPERATION_FAILED;
1897 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start : uid(%d), language(%s), type(%s)", uid, lang, type);
1901 if (NULL == credential) {
1902 temp = strdup("NULL");
1904 temp = strdup(credential);
1907 dbus_message_append_args(msg,
1908 DBUS_TYPE_INT32, &uid,
1909 DBUS_TYPE_STRING, &lang,
1910 DBUS_TYPE_STRING, &type,
1911 DBUS_TYPE_INT32, &silence,
1912 DBUS_TYPE_STRING, &appid,
1913 DBUS_TYPE_STRING, &temp,
1916 if (g_conn_sender) {
1917 dbus_message_set_no_reply(msg, TRUE);
1919 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1920 SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt start message : Out Of Memory !");
1925 return STT_ERROR_OUT_OF_MEMORY;
1927 dbus_connection_flush(g_conn_sender);
1930 dbus_message_unref(msg);
1933 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1938 return STT_ERROR_OPERATION_FAILED;
1948 dbus_error_init(&err);
1950 DBusMessage* result_msg;
1951 int result = STT_ERROR_OPERATION_FAILED;
1953 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1954 dbus_message_unref(msg);
1955 if (dbus_error_is_set(&err)) {
1956 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1957 dbus_error_free(&err);
1960 if (NULL != result_msg) {
1961 dbus_message_get_args(result_msg, &err,
1962 DBUS_TYPE_INT32, &result,
1965 if (dbus_error_is_set(&err)) {
1966 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1967 dbus_error_free(&err);
1968 result = STT_ERROR_OPERATION_FAILED;
1970 dbus_message_unref(result_msg);
1973 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt start : result = %d ", result);
1975 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt start : result = %d ", result);
1978 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1979 stt_dbus_reconnect();
1980 result = STT_ERROR_TIMED_OUT;
1987 int stt_dbus_request_stop(int uid)
1991 /* create a signal & check for errors */
1992 msg = dbus_message_new_method_call(
1993 g_server_service_name,
1994 g_server_service_object,
1995 g_server_service_interface,
1999 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt stop : Fail to make message");
2000 return STT_ERROR_OPERATION_FAILED;
2002 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt stop : uid(%d)", uid);
2005 dbus_message_append_args(msg,
2006 DBUS_TYPE_INT32, &uid,
2009 if (g_conn_sender) {
2010 dbus_message_set_no_reply(msg, TRUE);
2012 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
2013 SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
2014 return STT_ERROR_OUT_OF_MEMORY;
2016 dbus_connection_flush(g_conn_sender);
2019 dbus_message_unref(msg);
2021 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
2022 return STT_ERROR_OPERATION_FAILED;
2028 dbus_error_init(&err);
2030 DBusMessage* result_msg;
2031 int result = STT_ERROR_OPERATION_FAILED;
2033 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
2034 dbus_message_unref(msg);
2035 if (dbus_error_is_set(&err)) {
2036 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
2037 dbus_error_free(&err);
2040 if (NULL != result_msg) {
2041 dbus_message_get_args(result_msg, &err,
2042 DBUS_TYPE_INT32, &result,
2045 if (dbus_error_is_set(&err)) {
2046 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
2047 dbus_error_free(&err);
2048 result = STT_ERROR_OPERATION_FAILED;
2050 dbus_message_unref(result_msg);
2053 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt stop : result = %d ", result);
2055 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt stop : result = %d ", result);
2058 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
2059 stt_dbus_reconnect();
2060 result = STT_ERROR_TIMED_OUT;
2067 int stt_dbus_request_cancel(int uid)
2071 /* create a signal & check for errors */
2072 msg = dbus_message_new_method_call(
2073 g_server_service_name,
2074 g_server_service_object,
2075 g_server_service_interface,
2079 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel : Fail to make message");
2080 return STT_ERROR_OPERATION_FAILED;
2082 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel : uid(%d)", uid);
2085 dbus_message_append_args(msg,
2086 DBUS_TYPE_INT32, &uid,
2089 if (g_conn_sender) {
2090 dbus_message_set_no_reply(msg, TRUE);
2092 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
2093 SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
2094 return STT_ERROR_OUT_OF_MEMORY;
2096 dbus_connection_flush(g_conn_sender);
2099 dbus_message_unref(msg);
2101 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
2102 return STT_ERROR_OPERATION_FAILED;
2108 dbus_error_init(&err);
2110 DBusMessage* result_msg;
2111 int result = STT_ERROR_OPERATION_FAILED;
2113 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
2114 dbus_message_unref(msg);
2115 if (dbus_error_is_set(&err)) {
2116 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
2117 dbus_error_free(&err);
2120 if (NULL != result_msg) {
2121 dbus_message_get_args(result_msg, &err,
2122 DBUS_TYPE_INT32, &result,
2125 if (dbus_error_is_set(&err)) {
2126 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
2127 dbus_error_free(&err);
2128 result = STT_ERROR_OPERATION_FAILED;
2130 dbus_message_unref(result_msg);
2133 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt cancel : result = %d ", result);
2135 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt cancel : result = %d ", result);
2138 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
2139 stt_dbus_reconnect();
2140 result = STT_ERROR_TIMED_OUT;
2147 int stt_dbus_request_start_file(int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential, const char* filepath, stt_audio_type_e audio_type, int sample_rate)
2149 if (NULL == lang || NULL == type || NULL == appid) {
2150 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
2151 return STT_ERROR_INVALID_PARAMETER;
2156 /* create a signal & check for errors */
2157 msg = dbus_message_new_method_call(
2158 g_server_service_name,
2159 g_server_service_object,
2160 g_server_service_interface,
2161 STT_METHOD_START_FILE);
2164 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start file : Fail to make message");
2165 return STT_ERROR_OPERATION_FAILED;
2167 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start file : uid(%d), language(%s), type(%s), appid(%s), filepath(%s), audio_type(%d), sample_rate(%d)", uid, lang, type, appid, filepath, audio_type, sample_rate);
2171 if (NULL == credential) {
2172 temp = strdup("NULL");
2174 temp = strdup(credential);
2177 dbus_message_append_args(msg,
2178 DBUS_TYPE_INT32, &uid,
2179 DBUS_TYPE_STRING, &lang,
2180 DBUS_TYPE_STRING, &type,
2181 DBUS_TYPE_INT32, &silence,
2182 DBUS_TYPE_STRING, &appid,
2183 DBUS_TYPE_STRING, &temp,
2184 DBUS_TYPE_STRING, &filepath,
2185 DBUS_TYPE_INT32, &audio_type,
2186 DBUS_TYPE_INT32, &sample_rate,
2188 if (g_conn_sender) {
2189 dbus_message_set_no_reply(msg, TRUE);
2191 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
2192 SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt start message : Out Of Memory !");
2197 return STT_ERROR_OUT_OF_MEMORY;
2199 dbus_connection_flush(g_conn_sender);
2202 dbus_message_unref(msg);
2205 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
2210 return STT_ERROR_OPERATION_FAILED;
2220 int stt_dbus_request_cancel_file(int uid)
2224 /* create a signal & check for errors */
2225 msg = dbus_message_new_method_call(
2226 g_server_service_name,
2227 g_server_service_object,
2228 g_server_service_interface,
2229 STT_METHOD_CANCEL_FILE);
2232 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel file : Fail to make message");
2233 return STT_ERROR_OPERATION_FAILED;
2235 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel file : uid(%d)", uid);
2238 dbus_message_append_args(msg,
2239 DBUS_TYPE_INT32, &uid,
2242 if (g_conn_sender) {
2243 dbus_message_set_no_reply(msg, TRUE);
2245 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
2246 SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
2247 return STT_ERROR_OUT_OF_MEMORY;
2249 dbus_connection_flush(g_conn_sender);
2252 dbus_message_unref(msg);
2254 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
2255 return STT_ERROR_OPERATION_FAILED;