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, char* err_msg);
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 extern int __stt_cb_set_volume(int uid, float volume);
38 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
40 if (NULL == g_conn_listener) return ECORE_CALLBACK_RENEW;
42 dbus_connection_read_write_dispatch(g_conn_listener, 50);
45 DBusMessage* msg = NULL;
46 msg = dbus_connection_pop_message(g_conn_listener);
48 if (true != dbus_connection_get_is_connected(g_conn_listener)) {
49 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is disconnected");
53 /* loop again if we haven't read a message */
58 SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] Message is arrived");
61 dbus_error_init(&err);
63 DBusMessage *reply = NULL;
66 snprintf(if_name, 64, "%s%d", STT_CLIENT_SERVICE_INTERFACE, getpid());
68 if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_HELLO)) {
69 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Hello");
73 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
74 if (dbus_error_is_set(&err)) {
75 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
76 dbus_error_free(&err);
80 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get hello : uid(%d)", uid);
83 stt_client_s* client = stt_client_get_by_uid(uid);
89 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get hello : invalid uid");
92 reply = dbus_message_new_method_return(msg);
95 dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
97 if (!dbus_connection_send(g_conn_listener, reply, NULL))
98 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to send reply");
100 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get hello : result(%d)", response);
102 dbus_connection_flush(g_conn_listener);
103 dbus_message_unref(reply);
105 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to create reply message");
108 SLOG(LOG_DEBUG, TAG_STTC, "=====");
109 SLOG(LOG_DEBUG, TAG_STTC, " ");
110 } /* STTD_METHOD_HELLO */
112 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_SET_STATE)) {
113 SLOG(LOG_DEBUG, TAG_STTC, "===== Set State");
117 dbus_message_get_args(msg, &err,
118 DBUS_TYPE_INT32, &uid,
119 DBUS_TYPE_INT32, &state,
122 if (dbus_error_is_set(&err)) {
123 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
124 dbus_error_free(&err);
127 if (uid > 0 && state >= 0) {
128 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set state : uid(%d), state(%d)", uid, state);
129 __stt_cb_set_state(uid, state);
131 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set state : invalid uid or state");
134 SLOG(LOG_DEBUG, TAG_STTC, "=====");
135 SLOG(LOG_DEBUG, TAG_STTC, " ");
136 } /* STTD_METHOD_SET_STATE */
138 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_SET_VOLUME)) {
139 SLOG(LOG_DEBUG, TAG_STTC, "===== Set volume : signal");
143 dbus_message_get_args(msg, &err,
144 DBUS_TYPE_INT32, &uid,
145 DBUS_TYPE_INT32, &volume,
148 if (dbus_error_is_set(&err)) {
149 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
150 dbus_error_free(&err);
153 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set volume : uid(%d), volume(%f)", uid, volume);
154 __stt_cb_set_volume(uid, volume);
156 /* SLOG(LOG_DEBUG, TAG_STTC, "====="); */
157 /* SLOG(LOG_DEBUG, TAG_STTC, " "); */
158 } /* STTD_METHOD_SET_VOLUME */
160 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_RESULT)) {
161 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Result : signal");
163 DBusMessageIter args;
165 dbus_message_iter_init(msg, &args);
168 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
169 dbus_message_iter_get_basic(&args, &uid);
170 dbus_message_iter_next(&args);
173 stt_client_s* client = NULL;
174 client = stt_client_get_by_uid(uid);
175 if (NULL != client) {
176 char** temp_result = NULL;
177 char* temp_msg = NULL;
178 char* temp_char = NULL;
181 int temp_result_id = 0;
183 /* Get recognition type */
184 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
185 dbus_message_iter_get_basic(&args, &temp_event);
186 dbus_message_iter_next(&args);
189 if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&args)) {
190 dbus_message_iter_get_basic(&args, &(temp_msg));
191 dbus_message_iter_next(&args);
195 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
196 dbus_message_iter_get_basic(&args, &temp_count);
197 dbus_message_iter_next(&args);
201 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
202 dbus_message_iter_get_basic(&args, &temp_result_id);
203 dbus_message_iter_next(&args);
206 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get result : uid(%d) event(%d) message(%s) count(%d) result id(%d)",
207 uid, temp_event, temp_msg, temp_count, temp_result_id);
209 if (temp_count <= 0) {
210 __stt_cb_result(uid, temp_event, NULL, 0, temp_msg);
212 temp_result = (char**)calloc(temp_count, sizeof(char*));
214 if (NULL == temp_result) {
215 SLOG(LOG_ERROR, TAG_STTC, "Fail : memory allocation error");
218 for (i = 0; i < temp_count; i++) {
219 dbus_message_iter_get_basic(&args, &(temp_char));
220 dbus_message_iter_next(&args);
222 if (NULL != temp_char) {
223 temp_result[i] = strdup(temp_char);
224 SLOG(LOG_DEBUG, TAG_STTC, "result[%d] : %s", i, temp_result[i]);
228 __stt_cb_result(uid, temp_event, temp_result, temp_count, temp_msg);
230 for (i = 0; i < temp_count; i++) {
231 if (NULL != temp_result[i])
232 free(temp_result[i]);
239 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get result : invalid uid");
242 SLOG(LOG_DEBUG, TAG_STTC, "=====");
243 SLOG(LOG_DEBUG, TAG_STTC, " ");
244 } /* STTD_METHOD_RESULT */
246 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_ERROR)) {
247 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Error");
252 dbus_message_get_args(msg, &err,
253 DBUS_TYPE_INT32, &uid,
254 DBUS_TYPE_INT32, &reason,
255 DBUS_TYPE_STRING, &err_msg,
258 if (dbus_error_is_set(&err)) {
259 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt Get Error message : Get arguments error (%s)", err.message);
260 dbus_error_free(&err);
262 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt Get Error message : uid(%d), reason(%d), err_msg(%s)", uid, reason, (NULL == err_msg) ? "NULL" : err_msg);
263 __stt_cb_error(uid, reason, err_msg);
266 SLOG(LOG_DEBUG, TAG_STTC, "=====");
267 SLOG(LOG_DEBUG, TAG_STTC, " ");
268 } /* STTD_METHOD_ERROR */
271 SLOG(LOG_DEBUG, TAG_STTC, "Message is NOT valid");
272 dbus_message_unref(msg);
276 /* free the message */
277 dbus_message_unref(msg);
280 return ECORE_CALLBACK_RENEW;
283 int stt_dbus_open_connection()
285 if (NULL != g_conn_sender && NULL != g_conn_listener) {
286 SLOG(LOG_WARN, TAG_STTC, "already existed connection ");
292 /* initialise the error value */
293 dbus_error_init(&err);
295 /* connect to the DBUS system bus, and check for errors */
296 g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
297 if (dbus_error_is_set(&err)) {
298 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Dbus Connection Error (%s)", err.message);
299 dbus_error_free(&err);
302 if (NULL == g_conn_sender) {
303 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to get dbus connection");
304 return STT_ERROR_OPERATION_FAILED;
307 dbus_connection_set_exit_on_disconnect(g_conn_sender, false);
309 /* connect to the DBUS system bus, and check for errors */
310 g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
312 if (dbus_error_is_set(&err)) {
313 SLOG(LOG_ERROR, TAG_STTC, "Dbus Connection Error (%s)", err.message);
314 dbus_error_free(&err);
317 if (NULL == g_conn_listener) {
318 SLOG(LOG_ERROR, TAG_STTC, "Fail to get dbus connection");
319 return STT_ERROR_OPERATION_FAILED;
324 char service_name[64];
325 memset(service_name, '\0', 64);
326 snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
328 SLOG(LOG_DEBUG, TAG_STTC, "service name is %s", service_name);
330 /* register our name on the bus, and check for errors */
331 dbus_bus_request_name(g_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
333 if (dbus_error_is_set(&err)) {
334 SLOG(LOG_ERROR, TAG_STTC, "Name Error (%s)", err.message);
335 dbus_error_free(&err);
338 char rule[128] = {0, };
339 snprintf(rule, 128, "type='signal',interface='%s%d'", STT_CLIENT_SERVICE_INTERFACE, pid);
341 /* add a rule for which messages we want to see */
342 dbus_bus_add_match(g_conn_listener, rule, &err);
343 dbus_connection_flush(g_conn_listener);
345 if (dbus_error_is_set(&err)) {
346 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)", err.message);
347 dbus_error_free(&err);
348 return STT_ERROR_OPERATION_FAILED;
352 if (true != dbus_connection_get_unix_fd(g_conn_listener, &fd)) {
353 SLOG(LOG_ERROR, TAG_STTC, "Fail to get fd from dbus");
354 return STT_ERROR_OPERATION_FAILED;
356 SLOG(LOG_DEBUG, TAG_STTC, "Get fd from dbus : %d", fd);
359 g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
360 if (NULL == g_fd_handler) {
361 SLOG(LOG_ERROR, TAG_STTC, "fail to get fd handler from ecore");
362 return STT_ERROR_OPERATION_FAILED;
368 int stt_dbus_close_connection()
371 dbus_error_init(&err);
373 if (NULL != g_fd_handler) {
374 ecore_main_fd_handler_del(g_fd_handler);
380 char service_name[64];
381 memset(service_name, '\0', 64);
382 snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
384 dbus_bus_release_name(g_conn_listener, service_name, &err);
385 if (dbus_error_is_set(&err)) {
386 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Release name Error (%s)", err.message);
387 dbus_error_free(&err);
390 dbus_connection_close(g_conn_sender);
391 dbus_connection_close(g_conn_listener);
393 g_conn_sender = NULL;
394 g_conn_listener = NULL;
399 int stt_dbus_reconnect()
401 bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
402 bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
403 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Sender(%s) Listener(%s)",
404 sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
406 if (false == sender_connected || false == listener_connected) {
407 stt_dbus_close_connection();
409 if (0 != stt_dbus_open_connection()) {
410 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to reconnect");
414 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Reconnect");
420 int stt_dbus_request_hello()
424 msg = dbus_message_new_method_call(
425 STT_SERVER_SERVICE_NAME,
426 STT_SERVER_SERVICE_OBJECT_PATH,
427 STT_SERVER_SERVICE_INTERFACE,
431 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request stt hello : Fail to make message");
432 return STT_ERROR_OPERATION_FAILED;
436 dbus_error_init(&err);
438 DBusMessage* result_msg = NULL;
442 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
443 dbus_message_unref(msg);
444 if (dbus_error_is_set(&err)) {
445 dbus_error_free(&err);
448 if (NULL != result_msg) {
449 dbus_message_unref(result_msg);
451 if (dbus_error_is_set(&err)) {
452 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
453 dbus_error_free(&err);
456 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt hello");
458 if (dbus_error_is_set(&err)) {
459 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
460 dbus_error_free(&err);
463 SLOG(LOG_ERROR, TAG_STTC, "STT_ERROR_TIME_OUT");
464 result = STT_ERROR_TIMED_OUT;
467 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
468 result = STT_ERROR_OPERATION_FAILED;
475 int stt_dbus_request_initialize(int uid, bool* silence_supported, bool* credential_needed)
479 msg = dbus_message_new_method_call(
480 STT_SERVER_SERVICE_NAME,
481 STT_SERVER_SERVICE_OBJECT_PATH,
482 STT_SERVER_SERVICE_INTERFACE,
483 STT_METHOD_INITIALIZE);
486 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt initialize : Fail to make message");
487 return STT_ERROR_OPERATION_FAILED;
489 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt initialize : uid(%d)", uid);
493 dbus_message_append_args(msg,
494 DBUS_TYPE_INT32, &pid,
495 DBUS_TYPE_INT32, &uid,
499 dbus_error_init(&err);
501 DBusMessage* result_msg;
502 int result = STT_ERROR_OPERATION_FAILED;
505 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
506 dbus_message_unref(msg);
507 if (dbus_error_is_set(&err)) {
508 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
509 dbus_error_free(&err);
512 if (NULL != result_msg) {
513 dbus_message_get_args(result_msg, &err,
514 DBUS_TYPE_INT32, &result,
515 DBUS_TYPE_INT32, silence_supported,
516 DBUS_TYPE_INT32, credential_needed,
519 if (dbus_error_is_set(&err)) {
520 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
521 dbus_error_free(&err);
522 result = STT_ERROR_OPERATION_FAILED;
526 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt initialize : result = %d, silence(%d), credential(%d)",
527 result, *silence_supported, *credential_needed);
529 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt initialize : result = %d", result);
532 dbus_message_unref(result_msg);
534 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
535 stt_dbus_reconnect();
536 result = STT_ERROR_TIMED_OUT;
539 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
540 result = STT_ERROR_OPERATION_FAILED;
546 int stt_dbus_request_finalize(int uid)
550 msg = dbus_message_new_method_call(
551 STT_SERVER_SERVICE_NAME,
552 STT_SERVER_SERVICE_OBJECT_PATH,
553 STT_SERVER_SERVICE_INTERFACE,
554 STT_METHOD_FINALIZE);
557 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt finalize : Fail to make message");
558 return STT_ERROR_OPERATION_FAILED;
560 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt finalize : uid(%d)", uid);
563 dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
566 dbus_error_init(&err);
568 DBusMessage* result_msg;
569 int result = STT_ERROR_OPERATION_FAILED;
571 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
572 dbus_message_unref(msg);
573 if (dbus_error_is_set(&err)) {
574 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
575 dbus_error_free(&err);
578 if (NULL != result_msg) {
579 dbus_message_get_args(result_msg, &err,
580 DBUS_TYPE_INT32, &result,
583 if (dbus_error_is_set(&err)) {
584 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
585 dbus_error_free(&err);
586 result = STT_ERROR_OPERATION_FAILED;
589 dbus_message_unref(result_msg);
592 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt finalize : result = %d", result);
594 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt finalize : result = %d", result);
597 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
598 stt_dbus_reconnect();
599 result = STT_ERROR_TIMED_OUT;
605 int stt_dbus_request_set_current_engine(int uid, const char* engine_id, bool* silence_supported, bool* credential_needed)
609 msg = dbus_message_new_method_call(
610 STT_SERVER_SERVICE_NAME,
611 STT_SERVER_SERVICE_OBJECT_PATH,
612 STT_SERVER_SERVICE_INTERFACE,
613 STT_METHOD_SET_CURRENT_ENGINE);
616 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set engine : Fail to make message");
617 return STT_ERROR_OPERATION_FAILED;
619 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set engine : uid(%d)", uid);
622 dbus_message_append_args(msg,
623 DBUS_TYPE_INT32, &uid,
624 DBUS_TYPE_STRING, &engine_id,
628 dbus_error_init(&err);
630 DBusMessage* result_msg;
631 int result = STT_ERROR_OPERATION_FAILED;
633 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
634 dbus_message_unref(msg);
635 if (dbus_error_is_set(&err)) {
636 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
637 dbus_error_free(&err);
640 if (NULL != result_msg) {
641 dbus_message_get_args(result_msg, &err,
642 DBUS_TYPE_INT32, &result,
643 DBUS_TYPE_INT32, silence_supported,
644 DBUS_TYPE_INT32, credential_needed,
647 if (dbus_error_is_set(&err)) {
648 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
649 dbus_error_free(&err);
650 result = STT_ERROR_OPERATION_FAILED;
653 dbus_message_unref(result_msg);
656 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set engine : result = %d , silence(%d), credential(%d)",
657 result, *silence_supported, *credential_needed);
659 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set engine : result = %d", result);
662 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
663 stt_dbus_reconnect();
664 result = STT_ERROR_TIMED_OUT;
670 int stt_dbus_request_check_app_agreed(int uid, const char* appid, bool* value)
672 if (NULL == appid || NULL == value) {
673 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
674 return STT_ERROR_INVALID_PARAMETER;
679 msg = dbus_message_new_method_call(
680 STT_SERVER_SERVICE_NAME,
681 STT_SERVER_SERVICE_OBJECT_PATH,
682 STT_SERVER_SERVICE_INTERFACE,
683 STT_METHOD_CHECK_APP_AGREED);
686 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt check app agreed : Fail to make message");
687 return STT_ERROR_OPERATION_FAILED;
689 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt check app agreed : uid(%d) appid(%s)", uid, appid);
692 dbus_message_append_args(msg,
693 DBUS_TYPE_INT32, &uid,
694 DBUS_TYPE_STRING, &appid,
698 dbus_error_init(&err);
700 DBusMessage* result_msg;
701 int result = STT_ERROR_OPERATION_FAILED;
704 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
705 dbus_message_unref(msg);
706 if (dbus_error_is_set(&err)) {
707 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
708 dbus_error_free(&err);
711 if (NULL != result_msg) {
712 dbus_message_get_args(result_msg, &err,
713 DBUS_TYPE_INT32, &result,
714 DBUS_TYPE_INT32, &available,
717 if (dbus_error_is_set(&err)) {
718 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
719 dbus_error_free(&err);
720 result = STT_ERROR_OPERATION_FAILED;
722 dbus_message_unref(result_msg);
725 *value = (bool)available;
726 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt check app agreed : result = %d, available = %d", result, *value);
728 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt check app agreed : result = %d", result);
731 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
732 stt_dbus_reconnect();
733 result = STT_ERROR_TIMED_OUT;
739 int stt_dbus_request_get_support_langs(int uid, stt_h stt, stt_supported_language_cb callback, void* user_data)
741 if (NULL == stt || NULL == callback) {
742 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
743 return STT_ERROR_INVALID_PARAMETER;
748 msg = dbus_message_new_method_call(
749 STT_SERVER_SERVICE_NAME,
750 STT_SERVER_SERVICE_OBJECT_PATH,
751 STT_SERVER_SERVICE_INTERFACE,
752 STT_METHOD_GET_SUPPORT_LANGS);
755 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get supported languages : Fail to make message");
756 return STT_ERROR_OPERATION_FAILED;
758 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get supported languages : uid(%d)", uid);
761 dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
764 dbus_error_init(&err);
766 DBusMessage* result_msg;
767 DBusMessageIter args;
768 int result = STT_ERROR_OPERATION_FAILED;
770 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
771 dbus_message_unref(msg);
772 if (dbus_error_is_set(&err)) {
773 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
774 dbus_error_free(&err);
777 if (NULL != result_msg) {
778 if (dbus_message_iter_init(result_msg, &args)) {
780 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
781 dbus_message_iter_get_basic(&args, &result);
782 dbus_message_iter_next(&args);
786 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get support languages : result = %d", result);
790 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
791 dbus_message_iter_get_basic(&args, &size);
792 dbus_message_iter_next(&args);
796 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt size of language error : size = %d", size);
801 for (i = 0; i < size; i++) {
802 dbus_message_iter_get_basic(&args, &(temp_lang));
803 dbus_message_iter_next(&args);
805 if (true != callback(stt, temp_lang, user_data)) {
811 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result = %d", result);
814 dbus_message_unref(result_msg);
816 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result message is NULL");
817 stt_dbus_reconnect();
818 result = STT_ERROR_TIMED_OUT;
824 int stt_dbus_request_get_default_lang(int uid, char** language)
826 if (NULL == language) {
827 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
828 return STT_ERROR_INVALID_PARAMETER;
833 msg = dbus_message_new_method_call(
834 STT_SERVER_SERVICE_NAME,
835 STT_SERVER_SERVICE_OBJECT_PATH,
836 STT_SERVER_SERVICE_INTERFACE,
837 STT_METHOD_GET_CURRENT_LANG);
840 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get default language : Fail to make message");
841 return STT_ERROR_OPERATION_FAILED;
843 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get default language : uid(%d)", uid);
846 dbus_message_append_args(msg,
847 DBUS_TYPE_INT32, &uid,
851 dbus_error_init(&err);
853 DBusMessage* result_msg;
854 int result = STT_ERROR_OPERATION_FAILED;
855 char* temp_lang = NULL;
857 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
858 dbus_message_unref(msg);
859 if (dbus_error_is_set(&err)) {
860 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
861 dbus_error_free(&err);
864 if (NULL != result_msg) {
865 dbus_message_get_args(result_msg, &err,
866 DBUS_TYPE_INT32, &result,
867 DBUS_TYPE_STRING, &temp_lang,
870 if (dbus_error_is_set(&err)) {
871 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
872 dbus_error_free(&err);
873 result = STT_ERROR_OPERATION_FAILED;
875 dbus_message_unref(result_msg);
878 *language = strdup(temp_lang);
879 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get default language : result = %d, language = %s", result, *language);
881 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get default language : result = %d", result);
884 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
885 stt_dbus_reconnect();
886 result = STT_ERROR_TIMED_OUT;
892 int stt_dbus_request_is_recognition_type_supported(int uid, const char* type, bool* support)
894 if (NULL == support || NULL == type) {
895 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
896 return STT_ERROR_INVALID_PARAMETER;
901 msg = dbus_message_new_method_call(
902 STT_SERVER_SERVICE_NAME,
903 STT_SERVER_SERVICE_OBJECT_PATH,
904 STT_SERVER_SERVICE_INTERFACE,
905 STT_METHOD_IS_TYPE_SUPPORTED);
908 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt is partial result supported : Fail to make message");
909 return STT_ERROR_OPERATION_FAILED;
911 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt is recognition type supported : uid(%d) type(%s)", uid, type);
914 dbus_message_append_args(msg,
915 DBUS_TYPE_INT32, &uid,
916 DBUS_TYPE_STRING, &type,
920 dbus_error_init(&err);
922 DBusMessage* result_msg;
923 int result = STT_ERROR_OPERATION_FAILED;
924 int result_support = -1;
926 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
927 dbus_message_unref(msg);
928 if (dbus_error_is_set(&err)) {
929 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
930 dbus_error_free(&err);
933 if (NULL != result_msg) {
934 dbus_message_get_args(result_msg, &err,
935 DBUS_TYPE_INT32, &result,
936 DBUS_TYPE_INT32, &result_support,
939 if (dbus_error_is_set(&err)) {
940 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
941 dbus_error_free(&err);
942 result = STT_ERROR_OPERATION_FAILED;
944 dbus_message_unref(result_msg);
947 *support = (bool)result_support;
948 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt is recognition type supported : result = %d, support = %s", result, *support ? "true" : "false");
950 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt is recognition type supported : result = %d", result);
953 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
954 stt_dbus_reconnect();
955 result = STT_ERROR_TIMED_OUT;
961 int stt_dbus_request_set_start_sound(int uid, const char* file)
964 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
965 return STT_ERROR_INVALID_PARAMETER;
970 msg = dbus_message_new_method_call(
971 STT_SERVER_SERVICE_NAME,
972 STT_SERVER_SERVICE_OBJECT_PATH,
973 STT_SERVER_SERVICE_INTERFACE,
974 STT_METHOD_SET_START_SOUND);
977 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set start sound : Fail to make message");
978 return STT_ERROR_OPERATION_FAILED;
980 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set start sound : uid(%d) file(%s)", uid, file);
983 dbus_message_append_args(msg,
984 DBUS_TYPE_INT32, &uid,
985 DBUS_TYPE_STRING, &file,
989 dbus_error_init(&err);
991 DBusMessage* result_msg;
992 int result = STT_ERROR_OPERATION_FAILED;
994 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
995 dbus_message_unref(msg);
996 if (dbus_error_is_set(&err)) {
997 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
998 dbus_error_free(&err);
1001 if (NULL != result_msg) {
1002 dbus_message_get_args(result_msg, &err,
1003 DBUS_TYPE_INT32, &result,
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;
1011 dbus_message_unref(result_msg);
1014 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1016 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1019 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1020 stt_dbus_reconnect();
1021 result = STT_ERROR_TIMED_OUT;
1027 int stt_dbus_request_unset_start_sound(int uid)
1031 msg = dbus_message_new_method_call(
1032 STT_SERVER_SERVICE_NAME,
1033 STT_SERVER_SERVICE_OBJECT_PATH,
1034 STT_SERVER_SERVICE_INTERFACE,
1035 STT_METHOD_UNSET_START_SOUND);
1038 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset start sound : Fail to make message");
1039 return STT_ERROR_OPERATION_FAILED;
1041 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset start sound : uid(%d)", uid);
1044 dbus_message_append_args(msg,
1045 DBUS_TYPE_INT32, &uid,
1049 dbus_error_init(&err);
1051 DBusMessage* result_msg;
1052 int result = STT_ERROR_OPERATION_FAILED;
1054 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1055 dbus_message_unref(msg);
1056 if (dbus_error_is_set(&err)) {
1057 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1058 dbus_error_free(&err);
1061 if (NULL != result_msg) {
1062 dbus_message_get_args(result_msg, &err,
1063 DBUS_TYPE_INT32, &result,
1066 if (dbus_error_is_set(&err)) {
1067 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1068 dbus_error_free(&err);
1069 result = STT_ERROR_OPERATION_FAILED;
1071 dbus_message_unref(result_msg);
1074 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1076 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1079 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1080 stt_dbus_reconnect();
1081 result = STT_ERROR_TIMED_OUT;
1087 int stt_dbus_request_set_stop_sound(int uid, const char* file)
1090 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1091 return STT_ERROR_INVALID_PARAMETER;
1096 msg = dbus_message_new_method_call(
1097 STT_SERVER_SERVICE_NAME,
1098 STT_SERVER_SERVICE_OBJECT_PATH,
1099 STT_SERVER_SERVICE_INTERFACE,
1100 STT_METHOD_SET_STOP_SOUND);
1103 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set stop sound : Fail to make message");
1104 return STT_ERROR_OPERATION_FAILED;
1106 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set stop sound : uid(%d) file(%s)", uid, file);
1109 dbus_message_append_args(msg,
1110 DBUS_TYPE_INT32, &uid,
1111 DBUS_TYPE_STRING, &file,
1115 dbus_error_init(&err);
1117 DBusMessage* result_msg;
1118 int result = STT_ERROR_OPERATION_FAILED;
1120 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1121 dbus_message_unref(msg);
1122 if (dbus_error_is_set(&err)) {
1123 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1124 dbus_error_free(&err);
1127 if (NULL != result_msg) {
1128 dbus_message_get_args(result_msg, &err,
1129 DBUS_TYPE_INT32, &result,
1132 if (dbus_error_is_set(&err)) {
1133 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1134 dbus_error_free(&err);
1135 result = STT_ERROR_OPERATION_FAILED;
1137 dbus_message_unref(result_msg);
1140 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1142 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1145 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1146 stt_dbus_reconnect();
1147 result = STT_ERROR_TIMED_OUT;
1153 int stt_dbus_request_unset_stop_sound(int uid)
1157 msg = dbus_message_new_method_call(
1158 STT_SERVER_SERVICE_NAME,
1159 STT_SERVER_SERVICE_OBJECT_PATH,
1160 STT_SERVER_SERVICE_INTERFACE,
1161 STT_METHOD_UNSET_STOP_SOUND);
1164 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset stop sound : Fail to make message");
1165 return STT_ERROR_OPERATION_FAILED;
1167 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset stop sound : uid(%d)", uid);
1170 dbus_message_append_args(msg,
1171 DBUS_TYPE_INT32, &uid,
1175 dbus_error_init(&err);
1177 DBusMessage* result_msg;
1178 int result = STT_ERROR_OPERATION_FAILED;
1180 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1181 dbus_message_unref(msg);
1182 if (dbus_error_is_set(&err)) {
1183 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1184 dbus_error_free(&err);
1187 if (NULL != result_msg) {
1188 dbus_message_get_args(result_msg, &err,
1189 DBUS_TYPE_INT32, &result,
1192 if (dbus_error_is_set(&err)) {
1193 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1194 dbus_error_free(&err);
1195 result = STT_ERROR_OPERATION_FAILED;
1197 dbus_message_unref(result_msg);
1200 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1202 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1205 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1206 stt_dbus_reconnect();
1207 result = STT_ERROR_TIMED_OUT;
1213 int stt_dbus_request_start(int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential)
1215 if (NULL == lang || NULL == type || NULL == appid) {
1216 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1217 return STT_ERROR_INVALID_PARAMETER;
1222 /* create a signal & check for errors */
1223 msg = dbus_message_new_method_call(
1224 STT_SERVER_SERVICE_NAME,
1225 STT_SERVER_SERVICE_OBJECT_PATH,
1226 STT_SERVER_SERVICE_INTERFACE,
1230 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start : Fail to make message");
1231 return STT_ERROR_OPERATION_FAILED;
1233 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start : uid(%d), language(%s), type(%s)", uid, lang, type);
1237 if (NULL == credential) {
1238 temp = strdup("NULL");
1240 temp = strdup(credential);
1243 dbus_message_append_args(msg,
1244 DBUS_TYPE_INT32, &uid,
1245 DBUS_TYPE_STRING, &lang,
1246 DBUS_TYPE_STRING, &type,
1247 DBUS_TYPE_INT32, &silence,
1248 DBUS_TYPE_STRING, &appid,
1249 DBUS_TYPE_STRING, &temp,
1252 if (g_conn_sender) {
1253 dbus_message_set_no_reply(msg, TRUE);
1255 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1256 SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt start message : Out Of Memory !");
1261 return STT_ERROR_OUT_OF_MEMORY;
1263 dbus_connection_flush(g_conn_sender);
1266 dbus_message_unref(msg);
1269 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1274 return STT_ERROR_OPERATION_FAILED;
1284 dbus_error_init(&err);
1286 DBusMessage* result_msg;
1287 int result = STT_ERROR_OPERATION_FAILED;
1289 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1290 dbus_message_unref(msg);
1291 if (dbus_error_is_set(&err)) {
1292 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1293 dbus_error_free(&err);
1296 if (NULL != result_msg) {
1297 dbus_message_get_args(result_msg, &err,
1298 DBUS_TYPE_INT32, &result,
1301 if (dbus_error_is_set(&err)) {
1302 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1303 dbus_error_free(&err);
1304 result = STT_ERROR_OPERATION_FAILED;
1306 dbus_message_unref(result_msg);
1309 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt start : result = %d ", result);
1311 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt start : result = %d ", result);
1314 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1315 stt_dbus_reconnect();
1316 result = STT_ERROR_TIMED_OUT;
1323 int stt_dbus_request_stop(int uid)
1327 /* create a signal & check for errors */
1328 msg = dbus_message_new_method_call(
1329 STT_SERVER_SERVICE_NAME,
1330 STT_SERVER_SERVICE_OBJECT_PATH,
1331 STT_SERVER_SERVICE_INTERFACE,
1335 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt stop : Fail to make message");
1336 return STT_ERROR_OPERATION_FAILED;
1338 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt stop : uid(%d)", uid);
1341 dbus_message_append_args(msg,
1342 DBUS_TYPE_INT32, &uid,
1345 if (g_conn_sender) {
1346 dbus_message_set_no_reply(msg, TRUE);
1348 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1349 SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
1350 return STT_ERROR_OUT_OF_MEMORY;
1352 dbus_connection_flush(g_conn_sender);
1355 dbus_message_unref(msg);
1357 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1358 return STT_ERROR_OPERATION_FAILED;
1364 dbus_error_init(&err);
1366 DBusMessage* result_msg;
1367 int result = STT_ERROR_OPERATION_FAILED;
1369 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1370 dbus_message_unref(msg);
1371 if (dbus_error_is_set(&err)) {
1372 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1373 dbus_error_free(&err);
1376 if (NULL != result_msg) {
1377 dbus_message_get_args(result_msg, &err,
1378 DBUS_TYPE_INT32, &result,
1381 if (dbus_error_is_set(&err)) {
1382 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1383 dbus_error_free(&err);
1384 result = STT_ERROR_OPERATION_FAILED;
1386 dbus_message_unref(result_msg);
1389 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt stop : result = %d ", result);
1391 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt stop : result = %d ", result);
1394 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1395 stt_dbus_reconnect();
1396 result = STT_ERROR_TIMED_OUT;
1403 int stt_dbus_request_cancel(int uid)
1407 /* create a signal & check for errors */
1408 msg = dbus_message_new_method_call(
1409 STT_SERVER_SERVICE_NAME,
1410 STT_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
1411 STT_SERVER_SERVICE_INTERFACE, /* interface name of the signal */
1412 STT_METHOD_CANCEL); /* name of the signal */
1415 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel : Fail to make message");
1416 return STT_ERROR_OPERATION_FAILED;
1418 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel : uid(%d)", uid);
1421 dbus_message_append_args(msg,
1422 DBUS_TYPE_INT32, &uid,
1425 if (g_conn_sender) {
1426 dbus_message_set_no_reply(msg, TRUE);
1428 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1429 SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
1430 return STT_ERROR_OUT_OF_MEMORY;
1432 dbus_connection_flush(g_conn_sender);
1435 dbus_message_unref(msg);
1437 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1438 return STT_ERROR_OPERATION_FAILED;
1444 dbus_error_init(&err);
1446 DBusMessage* result_msg;
1447 int result = STT_ERROR_OPERATION_FAILED;
1449 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1450 dbus_message_unref(msg);
1451 if (dbus_error_is_set(&err)) {
1452 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1453 dbus_error_free(&err);
1456 if (NULL != result_msg) {
1457 dbus_message_get_args(result_msg, &err,
1458 DBUS_TYPE_INT32, &result,
1461 if (dbus_error_is_set(&err)) {
1462 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1463 dbus_error_free(&err);
1464 result = STT_ERROR_OPERATION_FAILED;
1466 dbus_message_unref(result_msg);
1469 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt cancel : result = %d ", result);
1471 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt cancel : result = %d ", result);
1474 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1475 stt_dbus_reconnect();
1476 result = STT_ERROR_TIMED_OUT;