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 = NULL;
29 extern int __stt_cb_error(int uid, int reason);
31 extern int __stt_cb_result(int uid, int event, char** data, int data_count, const char* msg);
33 extern int __stt_cb_set_state(int uid, int state);
35 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
37 DBusConnection* conn = (DBusConnection*)data;
38 DBusMessage* msg = NULL;
39 DBusMessage *reply = NULL;
42 return ECORE_CALLBACK_RENEW;
44 dbus_connection_read_write_dispatch(conn, 50);
46 msg = dbus_connection_pop_message(conn);
48 if (true != dbus_connection_get_is_connected(conn)) {
49 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Conn is disconnected");
50 return ECORE_CALLBACK_RENEW;
53 /* loop again if we haven't read a message */
55 return ECORE_CALLBACK_RENEW;
59 dbus_error_init(&err);
62 snprintf(if_name, 64, "%s%d", STT_CLIENT_SERVICE_INTERFACE, getpid());
64 if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_HELLO)) {
65 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Hello");
69 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
70 if (dbus_error_is_set(&err)) {
71 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
72 dbus_error_free(&err);
76 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get hello : uid(%d)", uid);
79 stt_client_s* client = stt_client_get_by_uid(uid);
85 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get hello : invalid uid");
88 reply = dbus_message_new_method_return(msg);
91 dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
93 if (!dbus_connection_send(conn, reply, NULL))
94 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to send reply");
96 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get hello : result(%d)", response);
98 dbus_connection_flush(conn);
99 dbus_message_unref(reply);
101 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to create reply message");
104 SLOG(LOG_DEBUG, TAG_STTC, "=====");
105 SLOG(LOG_DEBUG, TAG_STTC, " ");
106 } /* STTD_METHOD_HELLO */
108 else if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_SET_STATE)) {
109 SLOG(LOG_DEBUG, TAG_STTC, "===== Set State");
114 dbus_message_get_args(msg, &err,
115 DBUS_TYPE_INT32, &uid,
116 DBUS_TYPE_INT32, &state,
119 if (dbus_error_is_set(&err)) {
120 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
121 dbus_error_free(&err);
124 if (uid > 0 && state >= 0) {
125 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set state : uid(%d), state(%d)", uid, state);
127 response = __stt_cb_set_state(uid, state);
129 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set state : invalid uid or state");
132 reply = dbus_message_new_method_return(msg);
135 dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
137 if (!dbus_connection_send(conn, reply, NULL)) {
138 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set state : fail to send reply");
141 dbus_connection_flush(conn);
142 dbus_message_unref(reply);
144 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set state : fail to create reply message");
147 SLOG(LOG_DEBUG, TAG_STTC, "=====");
148 SLOG(LOG_DEBUG, TAG_STTC, " ");
149 } /* STTD_METHOD_SET_STATE */
151 else if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_GET_STATE)) {
152 SLOG(LOG_DEBUG, TAG_STTC, "===== Get state");
156 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
158 if (dbus_error_is_set(&err)) {
159 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
160 dbus_error_free(&err);
164 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get state : uid(%d)", uid);
167 stt_client_s* client = stt_client_get_by_uid(uid);
169 response = client->current_state;
171 SLOG(LOG_ERROR, TAG_STTC, "invalid uid");
174 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get state : invalid uid");
177 reply = dbus_message_new_method_return(msg);
180 dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
182 if (!dbus_connection_send(conn, reply, NULL))
183 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get state : fail to send reply");
185 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get state : result(%d)", response);
187 dbus_connection_flush(conn);
188 dbus_message_unref(reply);
190 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to create reply message");
193 SLOG(LOG_DEBUG, TAG_STTC, "=====");
194 SLOG(LOG_DEBUG, TAG_STTC, " ");
195 } /* STTD_METHOD_GET_STATE */
197 else if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_RESULT)) {
198 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Result");
200 DBusMessageIter args;
202 dbus_message_iter_init(msg, &args);
205 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
206 dbus_message_iter_get_basic(&args, &uid);
207 dbus_message_iter_next(&args);
211 char** temp_result = NULL;
212 char* temp_msg = NULL;
213 char* temp_char = NULL;
217 /* Get recognition type */
218 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
219 dbus_message_iter_get_basic(&args, &temp_event);
220 dbus_message_iter_next(&args);
223 if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&args)) {
224 dbus_message_iter_get_basic(&args, &(temp_msg) );
225 dbus_message_iter_next(&args);
229 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
230 dbus_message_iter_get_basic(&args, &temp_count);
231 dbus_message_iter_next(&args);
234 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get result : uid(%d) event(%d) message(%s) count(%d)",
235 uid, temp_event, temp_msg, temp_count);
237 if (temp_count <= 0) {
238 __stt_cb_result(uid, temp_event, NULL, 0, temp_msg);
240 temp_result = (char**)calloc(temp_count, sizeof(char*));
242 if (NULL == temp_result) {
243 SLOG(LOG_ERROR, TAG_STTC, "Fail : memory allocation error");
246 for (i = 0;i < temp_count;i++) {
247 dbus_message_iter_get_basic(&args, &(temp_char) );
248 dbus_message_iter_next(&args);
250 if (NULL != temp_char) {
251 temp_result[i] = strdup(temp_char);
252 SLOG(LOG_DEBUG, TAG_STTC, "result[%d] : %s", i, temp_result[i]);
256 __stt_cb_result(uid, temp_event, temp_result, temp_count, temp_msg);
258 for (i = 0;i < temp_count;i++) {
259 if (NULL != temp_result[i])
260 free(temp_result[i]);
267 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get result : invalid uid");
270 SLOG(LOG_DEBUG, TAG_STTC, "=====");
271 SLOG(LOG_DEBUG, TAG_STTC, " ");
272 }/* STTD_METHOD_RESULT */
274 else if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_ERROR)) {
275 SLOG(LOG_DEBUG, TAG_STTC, "===== Get Error");
280 dbus_message_get_args(msg, &err,
281 DBUS_TYPE_INT32, &uid,
282 DBUS_TYPE_INT32, &reason,
283 DBUS_TYPE_STRING, &err_msg,
286 if (dbus_error_is_set(&err)) {
287 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt Get Error message : Get arguments error (%s)\n", err.message);
288 dbus_error_free(&err);
290 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt Get Error message : uid(%d), reason(%d), msg(%s)\n", uid, reason, err_msg);
291 __stt_cb_error(uid, reason);
294 reply = dbus_message_new_method_return(msg);
297 if (!dbus_connection_send(conn, reply, NULL))
298 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt Error message : fail to send reply");
300 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt Error message");
302 dbus_connection_flush(conn);
303 dbus_message_unref(reply);
305 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt Error message : fail to create reply message");
308 SLOG(LOG_DEBUG, TAG_STTC, "=====");
309 SLOG(LOG_DEBUG, TAG_STTC, " ");
310 }/* STTD_METHOD_ERROR */
312 /* free the message */
313 dbus_message_unref(msg);
315 return ECORE_CALLBACK_PASS_ON;
318 int stt_dbus_open_connection()
320 if (NULL != g_conn) {
321 SLOG(LOG_WARN, TAG_STTC, "already existed connection ");
328 /* initialise the error value */
329 dbus_error_init(&err);
331 /* connect to the DBUS system bus, and check for errors */
332 g_conn = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
334 if (dbus_error_is_set(&err)) {
335 SLOG(LOG_ERROR, TAG_STTC, "Dbus Connection Error (%s)\n", err.message);
336 dbus_error_free(&err);
339 if (NULL == g_conn) {
340 SLOG(LOG_ERROR, TAG_STTC, "Fail to get dbus connection");
341 return STT_ERROR_OPERATION_FAILED;
346 char service_name[64];
347 memset(service_name, '\0', 64);
348 snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
350 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "service name is %s\n", service_name);
352 /* register our name on the bus, and check for errors */
353 ret = dbus_bus_request_name(g_conn, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
355 if (dbus_error_is_set(&err)) {
356 SLOG(LOG_ERROR, TAG_STTC, "Name Error (%s)\n", err.message);
357 dbus_error_free(&err);
360 if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
361 SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] Fail to be primary owner");
365 if( NULL != g_fd_handler ) {
366 SLOG(LOG_WARN, TAG_STTC, "The handler already exists.");
371 snprintf(rule, 128, "type='signal',interface='%s%d'", STT_CLIENT_SERVICE_INTERFACE, pid);
373 /* add a rule for which messages we want to see */
374 dbus_bus_add_match(g_conn, rule, &err);
375 dbus_connection_flush(g_conn);
377 if (dbus_error_is_set(&err)) {
378 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)\n", err.message);
379 dbus_error_free(&err);
380 return STT_ERROR_OPERATION_FAILED;
384 if (1 != dbus_connection_get_unix_fd(g_conn, &fd)) {
385 SLOG(LOG_ERROR, TAG_STTC, "fail to get fd from dbus");
386 return STT_ERROR_OPERATION_FAILED;
388 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "Get fd from dbus : %d\n", fd);
391 g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn, NULL, NULL);
393 if (NULL == g_fd_handler) {
394 SLOG(LOG_ERROR, TAG_STTC, "fail to get fd handler from ecore");
395 return STT_ERROR_OPERATION_FAILED;
401 int stt_dbus_close_connection()
404 dbus_error_init(&err);
408 char service_name[64];
409 memset(service_name, '\0', 64);
410 snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
412 dbus_bus_release_name (g_conn, service_name, &err);
414 if (dbus_error_is_set(&err)) {
415 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Release name Error (%s)", err.message);
416 dbus_error_free(&err);
419 dbus_connection_close(g_conn);
427 int stt_dbus_reconnect()
429 bool connected = dbus_connection_get_is_connected(g_conn);
430 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] %s", connected ? "Connected" : "Not connected");
432 if (false == connected) {
433 stt_dbus_close_connection();
435 if(0 != stt_dbus_open_connection()) {
436 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to reconnect");
440 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Reconnect");
446 int stt_dbus_request_hello()
450 msg = dbus_message_new_method_call(
451 STT_SERVER_SERVICE_NAME,
452 STT_SERVER_SERVICE_OBJECT_PATH,
453 STT_SERVER_SERVICE_INTERFACE,
457 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request stt hello : Fail to make message");
458 return STT_ERROR_OPERATION_FAILED;
461 if (NULL == g_conn) {
462 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
463 dbus_message_unref(msg);
464 return STT_ERROR_INVALID_STATE;
468 dbus_error_init(&err);
470 DBusMessage* result_msg = NULL;
471 int result = STT_DAEMON_NORMAL;
473 result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_short_time, &err);
474 dbus_message_unref(msg);
475 if (dbus_error_is_set(&err)) {
476 dbus_error_free(&err);
480 if (NULL != result_msg) {
481 dbus_message_get_args(result_msg, &err,
482 DBUS_TYPE_INT32, &status,
485 dbus_message_unref(result_msg);
487 if (dbus_error_is_set(&err)) {
488 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
489 dbus_error_free(&err);
492 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt hello - %d", status);
495 result = STT_ERROR_TIMED_OUT;
502 int stt_dbus_request_initialize(int uid, bool* silence_supported)
506 msg = dbus_message_new_method_call(
507 STT_SERVER_SERVICE_NAME,
508 STT_SERVER_SERVICE_OBJECT_PATH,
509 STT_SERVER_SERVICE_INTERFACE,
510 STT_METHOD_INITIALIZE);
513 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt initialize : Fail to make message");
514 return STT_ERROR_OPERATION_FAILED;
516 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt initialize : uid(%d)", uid);
519 if (NULL == g_conn) {
520 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
521 dbus_message_unref(msg);
522 return STT_ERROR_INVALID_STATE;
526 dbus_message_append_args( msg,
527 DBUS_TYPE_INT32, &pid,
528 DBUS_TYPE_INT32, &uid,
532 dbus_error_init(&err);
534 DBusMessage* result_msg;
535 int result = STT_ERROR_OPERATION_FAILED;
537 result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
538 dbus_message_unref(msg);
539 if (dbus_error_is_set(&err)) {
540 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
541 dbus_error_free(&err);
544 if (NULL != result_msg) {
545 dbus_message_get_args(result_msg, &err,
546 DBUS_TYPE_INT32, &result,
547 DBUS_TYPE_INT32, silence_supported,
550 if (dbus_error_is_set(&err)) {
551 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)\n", err.message);
552 dbus_error_free(&err);
553 result = STT_ERROR_OPERATION_FAILED;
557 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt initialize : result = %d, silence(%d)",
558 result, *silence_supported);
560 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt initialize : result = %d", result);
563 dbus_message_unref(result_msg);
565 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
566 stt_dbus_reconnect();
567 result = STT_ERROR_TIMED_OUT;
573 int stt_dbus_request_finalize(int uid)
577 msg = dbus_message_new_method_call(
578 STT_SERVER_SERVICE_NAME,
579 STT_SERVER_SERVICE_OBJECT_PATH,
580 STT_SERVER_SERVICE_INTERFACE,
581 STT_METHOD_FINALIZE);
584 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt finalize : Fail to make message");
585 return STT_ERROR_OPERATION_FAILED;
587 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt finalize : uid(%d)", uid);
590 if (NULL == g_conn) {
591 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
592 dbus_message_unref(msg);
593 return STT_ERROR_INVALID_STATE;
596 dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
599 dbus_error_init(&err);
601 DBusMessage* result_msg;
602 int result = STT_ERROR_OPERATION_FAILED;
604 result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_short_time, &err);
605 dbus_message_unref(msg);
606 if (dbus_error_is_set(&err)) {
607 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
608 dbus_error_free(&err);
611 if (NULL != result_msg) {
612 dbus_message_get_args(result_msg, &err,
613 DBUS_TYPE_INT32, &result,
616 if (dbus_error_is_set(&err)) {
617 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
618 dbus_error_free(&err);
619 result = STT_ERROR_OPERATION_FAILED;
622 dbus_message_unref(result_msg);
625 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt finalize : result = %d", result);
627 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt finalize : result = %d", result);
630 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
631 stt_dbus_reconnect();
632 result = STT_ERROR_TIMED_OUT;
638 int stt_dbus_request_set_current_engine(int uid, const char* engine_id, bool* silence_supported)
642 msg = dbus_message_new_method_call(
643 STT_SERVER_SERVICE_NAME,
644 STT_SERVER_SERVICE_OBJECT_PATH,
645 STT_SERVER_SERVICE_INTERFACE,
646 STT_METHOD_SET_CURRENT_ENGINE);
649 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set engine : Fail to make message");
650 return STT_ERROR_OPERATION_FAILED;
652 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set engine : uid(%d)", uid);
655 if (NULL == g_conn) {
656 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
657 dbus_message_unref(msg);
658 return STT_ERROR_INVALID_STATE;
661 dbus_message_append_args( msg,
662 DBUS_TYPE_INT32, &uid,
663 DBUS_TYPE_STRING, &engine_id,
667 dbus_error_init(&err);
669 DBusMessage* result_msg;
670 int result = STT_ERROR_OPERATION_FAILED;
672 result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
673 dbus_message_unref(msg);
674 if (dbus_error_is_set(&err)) {
675 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
676 dbus_error_free(&err);
679 if (NULL != result_msg) {
680 dbus_message_get_args(result_msg, &err,
681 DBUS_TYPE_INT32, &result,
682 DBUS_TYPE_INT32, silence_supported,
685 if (dbus_error_is_set(&err)) {
686 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)\n", err.message);
687 dbus_error_free(&err);
688 result = STT_ERROR_OPERATION_FAILED;
691 dbus_message_unref(result_msg);
694 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set engine : result = %d , silence(%d)",
695 result, *silence_supported);
697 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set engine : result = %d", result);
700 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
701 stt_dbus_reconnect();
702 result = STT_ERROR_TIMED_OUT;
708 int stt_dbus_request_check_app_agreed(int uid, const char* appid, bool* value)
710 if (NULL == appid || NULL == value) {
711 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
712 return STT_ERROR_INVALID_PARAMETER;
717 msg = dbus_message_new_method_call(
718 STT_SERVER_SERVICE_NAME,
719 STT_SERVER_SERVICE_OBJECT_PATH,
720 STT_SERVER_SERVICE_INTERFACE,
721 STT_METHOD_CHECK_APP_AGREED);
724 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt check app agreed : Fail to make message");
725 return STT_ERROR_OPERATION_FAILED;
727 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt check app agreed : uid(%d) appid(%s)", uid, appid);
730 if (NULL == g_conn) {
731 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
732 dbus_message_unref(msg);
733 return STT_ERROR_INVALID_STATE;
736 dbus_message_append_args(msg,
737 DBUS_TYPE_INT32, &uid,
738 DBUS_TYPE_STRING, &appid,
742 dbus_error_init(&err);
744 DBusMessage* result_msg;
745 int result = STT_ERROR_OPERATION_FAILED;
748 result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
749 dbus_message_unref(msg);
750 if (dbus_error_is_set(&err)) {
751 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
752 dbus_error_free(&err);
755 if (NULL != result_msg) {
756 dbus_message_get_args(result_msg, &err,
757 DBUS_TYPE_INT32, &result,
758 DBUS_TYPE_INT32, &available,
761 if (dbus_error_is_set(&err)) {
762 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
763 dbus_error_free(&err);
764 result = STT_ERROR_OPERATION_FAILED;
766 dbus_message_unref(result_msg);
769 *value = (bool)available;
770 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt check app agreed : result = %d, available = %d", result, *value);
772 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt check app agreed : result = %d", result);
775 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
776 stt_dbus_reconnect();
777 result = STT_ERROR_TIMED_OUT;
783 int stt_dbus_request_get_support_langs(int uid, stt_h stt, stt_supported_language_cb callback, void* user_data)
785 if (NULL == stt || NULL == callback) {
786 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
787 return STT_ERROR_INVALID_PARAMETER;
792 msg = dbus_message_new_method_call(
793 STT_SERVER_SERVICE_NAME,
794 STT_SERVER_SERVICE_OBJECT_PATH,
795 STT_SERVER_SERVICE_INTERFACE,
796 STT_METHOD_GET_SUPPORT_LANGS);
799 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get supported languages : Fail to make message");
800 return STT_ERROR_OPERATION_FAILED;
802 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get supported languages : uid(%d)", uid);
805 if (NULL == g_conn) {
806 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
807 dbus_message_unref(msg);
808 return STT_ERROR_INVALID_STATE;
811 dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
814 dbus_error_init(&err);
816 DBusMessage* result_msg;
817 DBusMessageIter args;
818 int result = STT_ERROR_OPERATION_FAILED;
820 result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err );
821 dbus_message_unref(msg);
822 if (dbus_error_is_set(&err)) {
823 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
824 dbus_error_free(&err);
827 if (NULL != result_msg) {
828 if (dbus_message_iter_init(result_msg, &args)) {
830 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
831 dbus_message_iter_get_basic(&args, &result);
832 dbus_message_iter_next(&args);
836 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get support languages : result = %d", result);
840 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
841 dbus_message_iter_get_basic(&args, &size);
842 dbus_message_iter_next(&args);
846 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt size of language error : size = %d", size);
851 for (i=0 ; i<size ; i++) {
852 dbus_message_iter_get_basic(&args, &(temp_lang));
853 dbus_message_iter_next(&args);
855 if (true != callback(stt, temp_lang, user_data)) {
861 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result = %d", result);
864 dbus_message_unref(result_msg);
866 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result message is NULL");
867 stt_dbus_reconnect();
868 result = STT_ERROR_TIMED_OUT;
874 int stt_dbus_request_get_default_lang(int uid, char** language)
876 if (NULL == language) {
877 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
878 return STT_ERROR_INVALID_PARAMETER;
883 msg = dbus_message_new_method_call(
884 STT_SERVER_SERVICE_NAME,
885 STT_SERVER_SERVICE_OBJECT_PATH,
886 STT_SERVER_SERVICE_INTERFACE,
887 STT_METHOD_GET_CURRENT_LANG);
890 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get default language : Fail to make message");
891 return STT_ERROR_OPERATION_FAILED;
893 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get default language : uid(%d)", uid);
896 if (NULL == g_conn) {
897 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
898 dbus_message_unref(msg);
899 return STT_ERROR_INVALID_STATE;
902 dbus_message_append_args( msg,
903 DBUS_TYPE_INT32, &uid,
907 dbus_error_init(&err);
909 DBusMessage* result_msg;
910 int result = STT_ERROR_OPERATION_FAILED;
911 char* temp_lang = NULL;
913 result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
914 dbus_message_unref(msg);
915 if (dbus_error_is_set(&err)) {
916 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
917 dbus_error_free(&err);
920 if (NULL != result_msg) {
921 dbus_message_get_args(result_msg, &err,
922 DBUS_TYPE_INT32, &result,
923 DBUS_TYPE_STRING, &temp_lang,
926 if (dbus_error_is_set(&err)) {
927 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
928 dbus_error_free(&err);
929 result = STT_ERROR_OPERATION_FAILED;
931 dbus_message_unref(result_msg);
934 *language = strdup(temp_lang);
935 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get default language : result = %d, language = %s", result, *language);
937 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get default language : result = %d", result);
940 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
941 stt_dbus_reconnect();
942 result = STT_ERROR_TIMED_OUT;
948 int stt_dbus_request_is_recognition_type_supported(int uid, const char* type, bool* support)
950 if (NULL == support || NULL == type) {
951 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
952 return STT_ERROR_INVALID_PARAMETER;
957 msg = dbus_message_new_method_call(
958 STT_SERVER_SERVICE_NAME,
959 STT_SERVER_SERVICE_OBJECT_PATH,
960 STT_SERVER_SERVICE_INTERFACE,
961 STT_METHOD_IS_TYPE_SUPPORTED);
964 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt is partial result supported : Fail to make message");
965 return STT_ERROR_OPERATION_FAILED;
967 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt is recognition type supported : uid(%d) type(%s)", uid, type);
970 if (NULL == g_conn) {
971 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
972 dbus_message_unref(msg);
973 return STT_ERROR_INVALID_STATE;
976 dbus_message_append_args( msg,
977 DBUS_TYPE_INT32, &uid,
978 DBUS_TYPE_STRING, &type,
982 dbus_error_init(&err);
984 DBusMessage* result_msg;
985 int result = STT_ERROR_OPERATION_FAILED;
986 int result_support = -1;
988 result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
989 dbus_message_unref(msg);
990 if (dbus_error_is_set(&err)) {
991 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
992 dbus_error_free(&err);
995 if (NULL != result_msg) {
996 dbus_message_get_args(result_msg, &err,
997 DBUS_TYPE_INT32, &result,
998 DBUS_TYPE_INT32, &result_support,
1001 if (dbus_error_is_set(&err)) {
1002 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1003 dbus_error_free(&err);
1004 result = STT_ERROR_OPERATION_FAILED;
1006 dbus_message_unref(result_msg);
1009 *support = (bool)result_support;
1010 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt is recognition type supported : result = %d, support = %s", result, *support ? "true" : "false");
1012 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt is recognition type supported : result = %d", result);
1015 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1016 stt_dbus_reconnect();
1017 result = STT_ERROR_TIMED_OUT;
1023 int stt_dbus_request_set_start_sound(int uid, const char* file)
1026 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1027 return STT_ERROR_INVALID_PARAMETER;
1032 msg = dbus_message_new_method_call(
1033 STT_SERVER_SERVICE_NAME,
1034 STT_SERVER_SERVICE_OBJECT_PATH,
1035 STT_SERVER_SERVICE_INTERFACE,
1036 STT_METHOD_SET_START_SOUND);
1039 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set start sound : Fail to make message");
1040 return STT_ERROR_OPERATION_FAILED;
1042 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set start sound : uid(%d) file(%s)", uid, file);
1045 if (NULL == g_conn) {
1046 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
1047 dbus_message_unref(msg);
1048 return STT_ERROR_INVALID_STATE;
1051 dbus_message_append_args( msg,
1052 DBUS_TYPE_INT32, &uid,
1053 DBUS_TYPE_STRING, &file,
1057 dbus_error_init(&err);
1059 DBusMessage* result_msg;
1060 int result = STT_ERROR_OPERATION_FAILED;
1062 result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
1063 dbus_message_unref(msg);
1064 if (dbus_error_is_set(&err)) {
1065 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1066 dbus_error_free(&err);
1069 if (NULL != result_msg) {
1070 dbus_message_get_args(result_msg, &err,
1071 DBUS_TYPE_INT32, &result,
1074 if (dbus_error_is_set(&err)) {
1075 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1076 dbus_error_free(&err);
1077 result = STT_ERROR_OPERATION_FAILED;
1079 dbus_message_unref(result_msg);
1082 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1084 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1087 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1088 stt_dbus_reconnect();
1089 result = STT_ERROR_TIMED_OUT;
1095 int stt_dbus_request_unset_start_sound(int uid)
1099 msg = dbus_message_new_method_call(
1100 STT_SERVER_SERVICE_NAME,
1101 STT_SERVER_SERVICE_OBJECT_PATH,
1102 STT_SERVER_SERVICE_INTERFACE,
1103 STT_METHOD_UNSET_START_SOUND);
1106 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset start sound : Fail to make message");
1107 return STT_ERROR_OPERATION_FAILED;
1109 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset start sound : uid(%d)", uid);
1112 if (NULL == g_conn) {
1113 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
1114 dbus_message_unref(msg);
1115 return STT_ERROR_INVALID_STATE;
1118 dbus_message_append_args( msg,
1119 DBUS_TYPE_INT32, &uid,
1123 dbus_error_init(&err);
1125 DBusMessage* result_msg;
1126 int result = STT_ERROR_OPERATION_FAILED;
1128 result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
1129 dbus_message_unref(msg);
1130 if (dbus_error_is_set(&err)) {
1131 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1132 dbus_error_free(&err);
1135 if (NULL != result_msg) {
1136 dbus_message_get_args(result_msg, &err,
1137 DBUS_TYPE_INT32, &result,
1140 if (dbus_error_is_set(&err)) {
1141 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1142 dbus_error_free(&err);
1143 result = STT_ERROR_OPERATION_FAILED;
1145 dbus_message_unref(result_msg);
1148 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1150 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1153 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1154 stt_dbus_reconnect();
1155 result = STT_ERROR_TIMED_OUT;
1161 int stt_dbus_request_set_stop_sound(int uid, const char* file)
1164 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1165 return STT_ERROR_INVALID_PARAMETER;
1170 msg = dbus_message_new_method_call(
1171 STT_SERVER_SERVICE_NAME,
1172 STT_SERVER_SERVICE_OBJECT_PATH,
1173 STT_SERVER_SERVICE_INTERFACE,
1174 STT_METHOD_SET_STOP_SOUND);
1177 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set stop sound : Fail to make message");
1178 return STT_ERROR_OPERATION_FAILED;
1180 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set stop sound : uid(%d) file(%s)", uid, file);
1183 if (NULL == g_conn) {
1184 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
1185 dbus_message_unref(msg);
1186 return STT_ERROR_INVALID_STATE;
1189 dbus_message_append_args( msg,
1190 DBUS_TYPE_INT32, &uid,
1191 DBUS_TYPE_STRING, &file,
1195 dbus_error_init(&err);
1197 DBusMessage* result_msg;
1198 int result = STT_ERROR_OPERATION_FAILED;
1200 result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
1201 dbus_message_unref(msg);
1202 if (dbus_error_is_set(&err)) {
1203 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1204 dbus_error_free(&err);
1207 if (NULL != result_msg) {
1208 dbus_message_get_args(result_msg, &err,
1209 DBUS_TYPE_INT32, &result,
1212 if (dbus_error_is_set(&err)) {
1213 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1214 dbus_error_free(&err);
1215 result = STT_ERROR_OPERATION_FAILED;
1217 dbus_message_unref(result_msg);
1220 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1222 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1225 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1226 stt_dbus_reconnect();
1227 result = STT_ERROR_TIMED_OUT;
1233 int stt_dbus_request_unset_stop_sound(int uid)
1237 msg = dbus_message_new_method_call(
1238 STT_SERVER_SERVICE_NAME,
1239 STT_SERVER_SERVICE_OBJECT_PATH,
1240 STT_SERVER_SERVICE_INTERFACE,
1241 STT_METHOD_UNSET_STOP_SOUND);
1244 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset stop sound : Fail to make message");
1245 return STT_ERROR_OPERATION_FAILED;
1247 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset stop sound : uid(%d)", uid);
1250 if (NULL == g_conn) {
1251 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
1252 dbus_message_unref(msg);
1253 return STT_ERROR_INVALID_STATE;
1256 dbus_message_append_args( msg,
1257 DBUS_TYPE_INT32, &uid,
1261 dbus_error_init(&err);
1263 DBusMessage* result_msg;
1264 int result = STT_ERROR_OPERATION_FAILED;
1266 result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
1267 dbus_message_unref(msg);
1268 if (dbus_error_is_set(&err)) {
1269 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1270 dbus_error_free(&err);
1273 if (NULL != result_msg) {
1274 dbus_message_get_args(result_msg, &err,
1275 DBUS_TYPE_INT32, &result,
1278 if (dbus_error_is_set(&err)) {
1279 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1280 dbus_error_free(&err);
1281 result = STT_ERROR_OPERATION_FAILED;
1283 dbus_message_unref(result_msg);
1286 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1288 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1291 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1292 stt_dbus_reconnect();
1293 result = STT_ERROR_TIMED_OUT;
1299 int stt_dbus_request_start(int uid, const char* lang, const char* type, int silence, const char* appid)
1301 if (NULL == lang || NULL == type || NULL == appid) {
1302 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1303 return STT_ERROR_INVALID_PARAMETER;
1308 /* create a signal & check for errors */
1309 msg = dbus_message_new_method_call(
1310 STT_SERVER_SERVICE_NAME,
1311 STT_SERVER_SERVICE_OBJECT_PATH,
1312 STT_SERVER_SERVICE_INTERFACE,
1316 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start : Fail to make message");
1317 return STT_ERROR_OPERATION_FAILED;
1319 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start : uid(%d), language(%s), type(%s)", uid, lang, type);
1322 if (NULL == g_conn) {
1323 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
1324 dbus_message_unref(msg);
1325 return STT_ERROR_INVALID_STATE;
1328 dbus_message_append_args( msg,
1329 DBUS_TYPE_INT32, &uid,
1330 DBUS_TYPE_STRING, &lang,
1331 DBUS_TYPE_STRING, &type,
1332 DBUS_TYPE_INT32, &silence,
1333 DBUS_TYPE_STRING, &appid,
1337 dbus_error_init(&err);
1339 DBusMessage* result_msg;
1340 int result = STT_ERROR_OPERATION_FAILED;
1342 result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
1343 dbus_message_unref(msg);
1344 if (dbus_error_is_set(&err)) {
1345 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1346 dbus_error_free(&err);
1349 if (NULL != result_msg) {
1350 dbus_message_get_args(result_msg, &err,
1351 DBUS_TYPE_INT32, &result,
1354 if (dbus_error_is_set(&err)) {
1355 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1356 dbus_error_free(&err);
1357 result = STT_ERROR_OPERATION_FAILED;
1359 dbus_message_unref(result_msg);
1362 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt start : result = %d ", result);
1364 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt start : result = %d ", result);
1367 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1368 stt_dbus_reconnect();
1369 result = STT_ERROR_TIMED_OUT;
1375 int stt_dbus_request_stop(int uid)
1379 /* create a signal & check for errors */
1380 msg = dbus_message_new_method_call(
1381 STT_SERVER_SERVICE_NAME,
1382 STT_SERVER_SERVICE_OBJECT_PATH,
1383 STT_SERVER_SERVICE_INTERFACE,
1387 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt stop : Fail to make message");
1388 return STT_ERROR_OPERATION_FAILED;
1390 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt stop : uid(%d)", uid);
1393 if (NULL == g_conn) {
1394 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
1395 dbus_message_unref(msg);
1396 return STT_ERROR_INVALID_STATE;
1399 dbus_message_append_args(msg,
1400 DBUS_TYPE_INT32, &uid,
1404 dbus_error_init(&err);
1406 DBusMessage* result_msg;
1407 int result = STT_ERROR_OPERATION_FAILED;
1409 result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
1410 dbus_message_unref(msg);
1411 if (dbus_error_is_set(&err)) {
1412 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1413 dbus_error_free(&err);
1416 if (NULL != result_msg) {
1417 dbus_message_get_args(result_msg, &err,
1418 DBUS_TYPE_INT32, &result,
1421 if (dbus_error_is_set(&err)) {
1422 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1423 dbus_error_free(&err);
1424 result = STT_ERROR_OPERATION_FAILED;
1426 dbus_message_unref(result_msg);
1429 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt stop : result = %d ", result);
1431 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt stop : result = %d ", result);
1434 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1435 stt_dbus_reconnect();
1436 result = STT_ERROR_TIMED_OUT;
1442 int stt_dbus_request_cancel(int uid)
1446 /* create a signal & check for errors */
1447 msg = dbus_message_new_method_call(
1448 STT_SERVER_SERVICE_NAME,
1449 STT_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
1450 STT_SERVER_SERVICE_INTERFACE, /* interface name of the signal */
1451 STT_METHOD_CANCEL); /* name of the signal */
1454 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel : Fail to make message");
1455 return STT_ERROR_OPERATION_FAILED;
1457 SECURE_SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel : uid(%d)", uid);
1460 if (NULL == g_conn) {
1461 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is NOT valid");
1462 dbus_message_unref(msg);
1463 return STT_ERROR_INVALID_STATE;
1466 dbus_message_append_args(msg,
1467 DBUS_TYPE_INT32, &uid,
1471 dbus_error_init(&err);
1473 DBusMessage* result_msg;
1474 int result = STT_ERROR_OPERATION_FAILED;
1476 result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, g_waiting_time, &err);
1477 dbus_message_unref(msg);
1478 if (dbus_error_is_set(&err)) {
1479 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1480 dbus_error_free(&err);
1483 if (NULL != result_msg) {
1484 dbus_message_get_args(result_msg, &err,
1485 DBUS_TYPE_INT32, &result,
1488 if (dbus_error_is_set(&err)) {
1489 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1490 dbus_error_free(&err);
1491 result = STT_ERROR_OPERATION_FAILED;
1493 dbus_message_unref(result_msg);
1496 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt cancel : result = %d ", result);
1498 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt cancel : result = %d ", result);
1501 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1502 stt_dbus_reconnect();
1503 result = STT_ERROR_TIMED_OUT;