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 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 if (NULL == g_conn_sender) {
297 g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
298 if (dbus_error_is_set(&err)) {
299 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Dbus Connection Error (%s)", err.message);
300 dbus_error_free(&err);
304 if (NULL == g_conn_sender) {
305 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to get dbus connection");
306 return STT_ERROR_OPERATION_FAILED;
309 dbus_connection_set_exit_on_disconnect(g_conn_sender, false);
311 /* connect to the DBUS system bus, and check for errors */
312 if (NULL == g_conn_listener) {
313 g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
314 if (dbus_error_is_set(&err)) {
315 SLOG(LOG_ERROR, TAG_STTC, "Dbus Connection Error (%s)", err.message);
316 dbus_error_free(&err);
320 if (NULL == g_conn_listener) {
321 SLOG(LOG_ERROR, TAG_STTC, "Fail to get dbus connection");
322 return STT_ERROR_OPERATION_FAILED;
327 char service_name[64];
328 memset(service_name, '\0', 64);
329 snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
331 SLOG(LOG_DEBUG, TAG_STTC, "service name is %s", service_name);
333 /* register our name on the bus, and check for errors */
334 dbus_bus_request_name(g_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
336 if (dbus_error_is_set(&err)) {
337 SLOG(LOG_ERROR, TAG_STTC, "Name Error (%s)", err.message);
338 dbus_error_free(&err);
341 char rule[128] = {0, };
342 snprintf(rule, 128, "type='signal',interface='%s%d'", STT_CLIENT_SERVICE_INTERFACE, pid);
344 /* add a rule for which messages we want to see */
345 dbus_bus_add_match(g_conn_listener, rule, &err);
346 dbus_connection_flush(g_conn_listener);
348 if (dbus_error_is_set(&err)) {
349 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)", err.message);
350 dbus_error_free(&err);
351 return STT_ERROR_OPERATION_FAILED;
355 if (true != dbus_connection_get_unix_fd(g_conn_listener, &fd)) {
356 SLOG(LOG_ERROR, TAG_STTC, "Fail to get fd from dbus");
357 return STT_ERROR_OPERATION_FAILED;
359 SLOG(LOG_DEBUG, TAG_STTC, "Get fd from dbus : %d", fd);
362 g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
363 if (NULL == g_fd_handler) {
364 SLOG(LOG_ERROR, TAG_STTC, "fail to get fd handler from ecore");
365 return STT_ERROR_OPERATION_FAILED;
371 int stt_dbus_close_connection()
374 dbus_error_init(&err);
376 if (NULL != g_fd_handler) {
377 ecore_main_fd_handler_del(g_fd_handler);
383 char service_name[64];
384 memset(service_name, '\0', 64);
385 snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
387 dbus_bus_release_name(g_conn_listener, service_name, &err);
388 if (dbus_error_is_set(&err)) {
389 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Release name Error (%s)", err.message);
390 dbus_error_free(&err);
393 dbus_connection_close(g_conn_sender);
394 dbus_connection_close(g_conn_listener);
396 dbus_connection_unref(g_conn_sender);
397 dbus_connection_unref(g_conn_listener);
399 g_conn_sender = NULL;
400 g_conn_listener = NULL;
405 int stt_dbus_reconnect()
407 bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
408 bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
409 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Sender(%s) Listener(%s)",
410 sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
412 if (false == sender_connected || false == listener_connected) {
413 stt_dbus_close_connection();
415 if (0 != stt_dbus_open_connection()) {
416 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to reconnect");
420 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Reconnect");
426 int stt_dbus_request_hello()
430 msg = dbus_message_new_method_call(
431 STT_SERVER_SERVICE_NAME,
432 STT_SERVER_SERVICE_OBJECT_PATH,
433 STT_SERVER_SERVICE_INTERFACE,
437 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request stt hello : Fail to make message");
438 return STT_ERROR_OPERATION_FAILED;
442 dbus_error_init(&err);
444 DBusMessage* result_msg = NULL;
448 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
449 dbus_message_unref(msg);
450 if (dbus_error_is_set(&err)) {
451 dbus_error_free(&err);
454 if (NULL != result_msg) {
455 dbus_message_unref(result_msg);
457 if (dbus_error_is_set(&err)) {
458 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
459 dbus_error_free(&err);
462 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt hello");
464 if (dbus_error_is_set(&err)) {
465 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
466 dbus_error_free(&err);
469 SLOG(LOG_ERROR, TAG_STTC, "STT_ERROR_TIME_OUT");
470 result = STT_ERROR_TIMED_OUT;
473 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
474 result = STT_ERROR_OPERATION_FAILED;
481 int stt_dbus_request_initialize(int uid, bool* silence_supported, bool* credential_needed)
485 msg = dbus_message_new_method_call(
486 STT_SERVER_SERVICE_NAME,
487 STT_SERVER_SERVICE_OBJECT_PATH,
488 STT_SERVER_SERVICE_INTERFACE,
489 STT_METHOD_INITIALIZE);
492 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt initialize : Fail to make message");
493 return STT_ERROR_OPERATION_FAILED;
495 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt initialize : uid(%d)", uid);
499 dbus_message_append_args(msg,
500 DBUS_TYPE_INT32, &pid,
501 DBUS_TYPE_INT32, &uid,
505 dbus_error_init(&err);
507 DBusMessage* result_msg;
508 int result = STT_ERROR_OPERATION_FAILED;
511 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
512 dbus_message_unref(msg);
513 if (dbus_error_is_set(&err)) {
514 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
515 dbus_error_free(&err);
518 if (NULL != result_msg) {
519 dbus_message_get_args(result_msg, &err,
520 DBUS_TYPE_INT32, &result,
521 DBUS_TYPE_INT32, silence_supported,
522 DBUS_TYPE_INT32, credential_needed,
525 if (dbus_error_is_set(&err)) {
526 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
527 dbus_error_free(&err);
528 result = STT_ERROR_OPERATION_FAILED;
532 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt initialize : result = %d, silence(%d), credential(%d)",
533 result, *silence_supported, *credential_needed);
535 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt initialize : result = %d", result);
538 dbus_message_unref(result_msg);
540 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
541 stt_dbus_reconnect();
542 result = STT_ERROR_TIMED_OUT;
545 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
546 result = STT_ERROR_OPERATION_FAILED;
552 int stt_dbus_request_finalize(int uid)
556 msg = dbus_message_new_method_call(
557 STT_SERVER_SERVICE_NAME,
558 STT_SERVER_SERVICE_OBJECT_PATH,
559 STT_SERVER_SERVICE_INTERFACE,
560 STT_METHOD_FINALIZE);
563 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt finalize : Fail to make message");
564 return STT_ERROR_OPERATION_FAILED;
566 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt finalize : uid(%d)", uid);
569 dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
572 dbus_error_init(&err);
574 DBusMessage* result_msg;
575 int result = STT_ERROR_OPERATION_FAILED;
577 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
578 dbus_message_unref(msg);
579 if (dbus_error_is_set(&err)) {
580 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
581 dbus_error_free(&err);
584 if (NULL != result_msg) {
585 dbus_message_get_args(result_msg, &err,
586 DBUS_TYPE_INT32, &result,
589 if (dbus_error_is_set(&err)) {
590 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
591 dbus_error_free(&err);
592 result = STT_ERROR_OPERATION_FAILED;
595 dbus_message_unref(result_msg);
598 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt finalize : result = %d", result);
600 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt finalize : result = %d", result);
603 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
604 stt_dbus_reconnect();
605 result = STT_ERROR_TIMED_OUT;
611 int stt_dbus_request_set_current_engine(int uid, const char* engine_id, bool* silence_supported, bool* credential_needed)
615 msg = dbus_message_new_method_call(
616 STT_SERVER_SERVICE_NAME,
617 STT_SERVER_SERVICE_OBJECT_PATH,
618 STT_SERVER_SERVICE_INTERFACE,
619 STT_METHOD_SET_CURRENT_ENGINE);
622 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set engine : Fail to make message");
623 return STT_ERROR_OPERATION_FAILED;
625 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set engine : uid(%d), engine_id(%s)", uid, (NULL == engine_id) ? "NULL" : engine_id);
628 dbus_message_append_args(msg,
629 DBUS_TYPE_INT32, &uid,
630 DBUS_TYPE_STRING, &engine_id,
634 dbus_error_init(&err);
636 DBusMessage* result_msg;
637 int result = STT_ERROR_OPERATION_FAILED;
639 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
640 dbus_message_unref(msg);
641 if (dbus_error_is_set(&err)) {
642 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
643 dbus_error_free(&err);
646 if (NULL != result_msg) {
647 dbus_message_get_args(result_msg, &err,
648 DBUS_TYPE_INT32, &result,
649 DBUS_TYPE_INT32, silence_supported,
650 DBUS_TYPE_INT32, credential_needed,
653 if (dbus_error_is_set(&err)) {
654 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
655 dbus_error_free(&err);
656 result = STT_ERROR_OPERATION_FAILED;
659 dbus_message_unref(result_msg);
662 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set engine : result = %d , silence(%d), credential(%d)",
663 result, *silence_supported, *credential_needed);
665 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set engine : result = %d", result);
668 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
669 stt_dbus_reconnect();
670 result = STT_ERROR_TIMED_OUT;
676 int stt_dbus_request_check_app_agreed(int uid, const char* appid, bool* value)
678 if (NULL == appid || NULL == value) {
679 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
680 return STT_ERROR_INVALID_PARAMETER;
685 msg = dbus_message_new_method_call(
686 STT_SERVER_SERVICE_NAME,
687 STT_SERVER_SERVICE_OBJECT_PATH,
688 STT_SERVER_SERVICE_INTERFACE,
689 STT_METHOD_CHECK_APP_AGREED);
692 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt check app agreed : Fail to make message");
693 return STT_ERROR_OPERATION_FAILED;
695 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt check app agreed : uid(%d) appid(%s)", uid, appid);
698 dbus_message_append_args(msg,
699 DBUS_TYPE_INT32, &uid,
700 DBUS_TYPE_STRING, &appid,
704 dbus_error_init(&err);
706 DBusMessage* result_msg;
707 int result = STT_ERROR_OPERATION_FAILED;
710 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
711 dbus_message_unref(msg);
712 if (dbus_error_is_set(&err)) {
713 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
714 dbus_error_free(&err);
717 if (NULL != result_msg) {
718 dbus_message_get_args(result_msg, &err,
719 DBUS_TYPE_INT32, &result,
720 DBUS_TYPE_INT32, &available,
723 if (dbus_error_is_set(&err)) {
724 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
725 dbus_error_free(&err);
726 result = STT_ERROR_OPERATION_FAILED;
728 dbus_message_unref(result_msg);
731 *value = (bool)available;
732 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt check app agreed : result = %d, available = %d", result, *value);
734 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt check app agreed : result = %d", result);
737 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
738 stt_dbus_reconnect();
739 result = STT_ERROR_TIMED_OUT;
745 int stt_dbus_request_get_support_langs(int uid, stt_h stt, stt_supported_language_cb callback, void* user_data)
747 if (NULL == stt || NULL == callback) {
748 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
749 return STT_ERROR_INVALID_PARAMETER;
754 msg = dbus_message_new_method_call(
755 STT_SERVER_SERVICE_NAME,
756 STT_SERVER_SERVICE_OBJECT_PATH,
757 STT_SERVER_SERVICE_INTERFACE,
758 STT_METHOD_GET_SUPPORT_LANGS);
761 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get supported languages : Fail to make message");
762 return STT_ERROR_OPERATION_FAILED;
764 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get supported languages : uid(%d)", uid);
767 dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
770 dbus_error_init(&err);
772 DBusMessage* result_msg;
773 DBusMessageIter args;
774 int result = STT_ERROR_OPERATION_FAILED;
776 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
777 dbus_message_unref(msg);
778 if (dbus_error_is_set(&err)) {
779 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
780 dbus_error_free(&err);
783 if (NULL != result_msg) {
784 if (dbus_message_iter_init(result_msg, &args)) {
786 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
787 dbus_message_iter_get_basic(&args, &result);
788 dbus_message_iter_next(&args);
792 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get support languages : result = %d", result);
796 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
797 dbus_message_iter_get_basic(&args, &size);
798 dbus_message_iter_next(&args);
802 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt size of language error : size = %d", size);
807 for (i = 0; i < size; i++) {
808 dbus_message_iter_get_basic(&args, &(temp_lang));
809 dbus_message_iter_next(&args);
811 if (true != callback(stt, temp_lang, user_data)) {
817 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result = %d", result);
820 dbus_message_unref(result_msg);
822 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result message is NULL");
823 stt_dbus_reconnect();
824 result = STT_ERROR_TIMED_OUT;
830 int stt_dbus_request_get_default_lang(int uid, char** language)
832 if (NULL == language) {
833 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
834 return STT_ERROR_INVALID_PARAMETER;
839 msg = dbus_message_new_method_call(
840 STT_SERVER_SERVICE_NAME,
841 STT_SERVER_SERVICE_OBJECT_PATH,
842 STT_SERVER_SERVICE_INTERFACE,
843 STT_METHOD_GET_CURRENT_LANG);
846 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get default language : Fail to make message");
847 return STT_ERROR_OPERATION_FAILED;
849 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get default language : uid(%d)", uid);
852 dbus_message_append_args(msg,
853 DBUS_TYPE_INT32, &uid,
857 dbus_error_init(&err);
859 DBusMessage* result_msg;
860 int result = STT_ERROR_OPERATION_FAILED;
861 char* temp_lang = NULL;
863 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
864 dbus_message_unref(msg);
865 if (dbus_error_is_set(&err)) {
866 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
867 dbus_error_free(&err);
870 if (NULL != result_msg) {
871 dbus_message_get_args(result_msg, &err,
872 DBUS_TYPE_INT32, &result,
873 DBUS_TYPE_STRING, &temp_lang,
876 if (dbus_error_is_set(&err)) {
877 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
878 dbus_error_free(&err);
879 result = STT_ERROR_OPERATION_FAILED;
881 dbus_message_unref(result_msg);
884 *language = strdup(temp_lang);
885 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get default language : result = %d, language = %s", result, *language);
887 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get default language : result = %d", result);
890 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
891 stt_dbus_reconnect();
892 result = STT_ERROR_TIMED_OUT;
898 int stt_dbus_request_set_private_data(int uid, const char* key, const char* data)
900 if (NULL == key || NULL == data) {
901 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
902 return STT_ERROR_INVALID_PARAMETER;
907 msg = dbus_message_new_method_call(
908 STT_SERVER_SERVICE_NAME,
909 STT_SERVER_SERVICE_OBJECT_PATH,
910 STT_SERVER_SERVICE_INTERFACE,
911 STT_METHOD_SET_PRIVATE_DATA);
914 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set private data : Fail to make message");
915 return STT_ERROR_OPERATION_FAILED;
917 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set private data : uid(%d)", uid);
920 if (true != dbus_message_append_args(msg,
921 DBUS_TYPE_INT32, &uid,
922 DBUS_TYPE_STRING, &key,
923 DBUS_TYPE_STRING, &data,
924 DBUS_TYPE_INVALID)) {
925 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to append args");
926 return STT_ERROR_OPERATION_FAILED;
930 dbus_error_init(&err);
932 DBusMessage* result_msg;
933 int result = STT_ERROR_OPERATION_FAILED;
935 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
936 dbus_message_unref(msg);
937 if (dbus_error_is_set(&err)) {
938 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
939 dbus_error_free(&err);
942 if (NULL != result_msg) {
943 dbus_message_get_args(result_msg, &err,
944 DBUS_TYPE_INT32, &result,
947 if (dbus_error_is_set(&err)) {
948 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
949 dbus_error_free(&err);
950 result = STT_ERROR_OPERATION_FAILED;
952 dbus_message_unref(result_msg);
955 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set private data : result = %d", result);
957 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set private data : result = %d", result);
960 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
961 stt_dbus_reconnect();
962 result = STT_ERROR_TIMED_OUT;
968 int stt_dbus_request_get_private_data(int uid, const char* key, char** data)
970 if (NULL == key || NULL == data) {
971 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
972 return STT_ERROR_INVALID_PARAMETER;
977 msg = dbus_message_new_method_call(
978 STT_SERVER_SERVICE_NAME,
979 STT_SERVER_SERVICE_OBJECT_PATH,
980 STT_SERVER_SERVICE_INTERFACE,
981 STT_METHOD_GET_PRIVATE_DATA);
984 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get private data : Fail to make message");
985 return STT_ERROR_OPERATION_FAILED;
987 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get private data : uid(%d)", uid);
990 if (true != dbus_message_append_args(msg,
991 DBUS_TYPE_INT32, &uid,
992 DBUS_TYPE_STRING, &key,
993 DBUS_TYPE_INVALID)) {
994 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to append args");
995 return STT_ERROR_OPERATION_FAILED;
999 dbus_error_init(&err);
1001 DBusMessage* result_msg;
1002 int result = STT_ERROR_OPERATION_FAILED;
1004 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1005 dbus_message_unref(msg);
1006 if (dbus_error_is_set(&err)) {
1007 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1008 dbus_error_free(&err);
1012 if (NULL != result_msg) {
1013 dbus_message_get_args(result_msg, &err,
1014 DBUS_TYPE_INT32, &result,
1015 DBUS_TYPE_STRING, &temp,
1018 if (dbus_error_is_set(&err)) {
1019 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1020 dbus_error_free(&err);
1021 result = STT_ERROR_OPERATION_FAILED;
1023 dbus_message_unref(result_msg);
1026 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get private data : result = %d", result);
1028 *data = strdup(temp);
1031 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get private data : result = %d", result);
1034 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1035 stt_dbus_reconnect();
1036 result = STT_ERROR_TIMED_OUT;
1044 int stt_dbus_request_is_recognition_type_supported(int uid, const char* type, bool* support)
1046 if (NULL == support || NULL == type) {
1047 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1048 return STT_ERROR_INVALID_PARAMETER;
1053 msg = dbus_message_new_method_call(
1054 STT_SERVER_SERVICE_NAME,
1055 STT_SERVER_SERVICE_OBJECT_PATH,
1056 STT_SERVER_SERVICE_INTERFACE,
1057 STT_METHOD_IS_TYPE_SUPPORTED);
1060 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt is partial result supported : Fail to make message");
1061 return STT_ERROR_OPERATION_FAILED;
1063 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt is recognition type supported : uid(%d) type(%s)", uid, type);
1066 dbus_message_append_args(msg,
1067 DBUS_TYPE_INT32, &uid,
1068 DBUS_TYPE_STRING, &type,
1072 dbus_error_init(&err);
1074 DBusMessage* result_msg;
1075 int result = STT_ERROR_OPERATION_FAILED;
1076 int result_support = -1;
1078 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1079 dbus_message_unref(msg);
1080 if (dbus_error_is_set(&err)) {
1081 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1082 dbus_error_free(&err);
1085 if (NULL != result_msg) {
1086 dbus_message_get_args(result_msg, &err,
1087 DBUS_TYPE_INT32, &result,
1088 DBUS_TYPE_INT32, &result_support,
1091 if (dbus_error_is_set(&err)) {
1092 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1093 dbus_error_free(&err);
1094 result = STT_ERROR_OPERATION_FAILED;
1096 dbus_message_unref(result_msg);
1099 *support = (bool)result_support;
1100 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt is recognition type supported : result = %d, support = %s", result, *support ? "true" : "false");
1102 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt is recognition type supported : result = %d", result);
1105 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1106 stt_dbus_reconnect();
1107 result = STT_ERROR_TIMED_OUT;
1113 int stt_dbus_request_set_start_sound(int uid, const char* file)
1116 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1117 return STT_ERROR_INVALID_PARAMETER;
1122 msg = dbus_message_new_method_call(
1123 STT_SERVER_SERVICE_NAME,
1124 STT_SERVER_SERVICE_OBJECT_PATH,
1125 STT_SERVER_SERVICE_INTERFACE,
1126 STT_METHOD_SET_START_SOUND);
1129 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set start sound : Fail to make message");
1130 return STT_ERROR_OPERATION_FAILED;
1132 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set start sound : uid(%d) file(%s)", uid, file);
1135 dbus_message_append_args(msg,
1136 DBUS_TYPE_INT32, &uid,
1137 DBUS_TYPE_STRING, &file,
1141 dbus_error_init(&err);
1143 DBusMessage* result_msg;
1144 int result = STT_ERROR_OPERATION_FAILED;
1146 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1147 dbus_message_unref(msg);
1148 if (dbus_error_is_set(&err)) {
1149 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1150 dbus_error_free(&err);
1153 if (NULL != result_msg) {
1154 dbus_message_get_args(result_msg, &err,
1155 DBUS_TYPE_INT32, &result,
1158 if (dbus_error_is_set(&err)) {
1159 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1160 dbus_error_free(&err);
1161 result = STT_ERROR_OPERATION_FAILED;
1163 dbus_message_unref(result_msg);
1166 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1168 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1171 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1172 stt_dbus_reconnect();
1173 result = STT_ERROR_TIMED_OUT;
1179 int stt_dbus_request_unset_start_sound(int uid)
1183 msg = dbus_message_new_method_call(
1184 STT_SERVER_SERVICE_NAME,
1185 STT_SERVER_SERVICE_OBJECT_PATH,
1186 STT_SERVER_SERVICE_INTERFACE,
1187 STT_METHOD_UNSET_START_SOUND);
1190 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset start sound : Fail to make message");
1191 return STT_ERROR_OPERATION_FAILED;
1193 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset start sound : uid(%d)", uid);
1196 dbus_message_append_args(msg,
1197 DBUS_TYPE_INT32, &uid,
1201 dbus_error_init(&err);
1203 DBusMessage* result_msg;
1204 int result = STT_ERROR_OPERATION_FAILED;
1206 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1207 dbus_message_unref(msg);
1208 if (dbus_error_is_set(&err)) {
1209 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1210 dbus_error_free(&err);
1213 if (NULL != result_msg) {
1214 dbus_message_get_args(result_msg, &err,
1215 DBUS_TYPE_INT32, &result,
1218 if (dbus_error_is_set(&err)) {
1219 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1220 dbus_error_free(&err);
1221 result = STT_ERROR_OPERATION_FAILED;
1223 dbus_message_unref(result_msg);
1226 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1228 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1231 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1232 stt_dbus_reconnect();
1233 result = STT_ERROR_TIMED_OUT;
1239 int stt_dbus_request_set_stop_sound(int uid, const char* file)
1242 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1243 return STT_ERROR_INVALID_PARAMETER;
1248 msg = dbus_message_new_method_call(
1249 STT_SERVER_SERVICE_NAME,
1250 STT_SERVER_SERVICE_OBJECT_PATH,
1251 STT_SERVER_SERVICE_INTERFACE,
1252 STT_METHOD_SET_STOP_SOUND);
1255 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set stop sound : Fail to make message");
1256 return STT_ERROR_OPERATION_FAILED;
1258 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set stop sound : uid(%d) file(%s)", uid, file);
1261 dbus_message_append_args(msg,
1262 DBUS_TYPE_INT32, &uid,
1263 DBUS_TYPE_STRING, &file,
1267 dbus_error_init(&err);
1269 DBusMessage* result_msg;
1270 int result = STT_ERROR_OPERATION_FAILED;
1272 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1273 dbus_message_unref(msg);
1274 if (dbus_error_is_set(&err)) {
1275 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1276 dbus_error_free(&err);
1279 if (NULL != result_msg) {
1280 dbus_message_get_args(result_msg, &err,
1281 DBUS_TYPE_INT32, &result,
1284 if (dbus_error_is_set(&err)) {
1285 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1286 dbus_error_free(&err);
1287 result = STT_ERROR_OPERATION_FAILED;
1289 dbus_message_unref(result_msg);
1292 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1294 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1297 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1298 stt_dbus_reconnect();
1299 result = STT_ERROR_TIMED_OUT;
1305 int stt_dbus_request_unset_stop_sound(int uid)
1309 msg = dbus_message_new_method_call(
1310 STT_SERVER_SERVICE_NAME,
1311 STT_SERVER_SERVICE_OBJECT_PATH,
1312 STT_SERVER_SERVICE_INTERFACE,
1313 STT_METHOD_UNSET_STOP_SOUND);
1316 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset stop sound : Fail to make message");
1317 return STT_ERROR_OPERATION_FAILED;
1319 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset stop sound : uid(%d)", uid);
1322 dbus_message_append_args(msg,
1323 DBUS_TYPE_INT32, &uid,
1327 dbus_error_init(&err);
1329 DBusMessage* result_msg;
1330 int result = STT_ERROR_OPERATION_FAILED;
1332 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1333 dbus_message_unref(msg);
1334 if (dbus_error_is_set(&err)) {
1335 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1336 dbus_error_free(&err);
1339 if (NULL != result_msg) {
1340 dbus_message_get_args(result_msg, &err,
1341 DBUS_TYPE_INT32, &result,
1344 if (dbus_error_is_set(&err)) {
1345 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1346 dbus_error_free(&err);
1347 result = STT_ERROR_OPERATION_FAILED;
1349 dbus_message_unref(result_msg);
1352 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1354 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1357 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1358 stt_dbus_reconnect();
1359 result = STT_ERROR_TIMED_OUT;
1365 int stt_dbus_request_start(int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential)
1367 if (NULL == lang || NULL == type || NULL == appid) {
1368 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1369 return STT_ERROR_INVALID_PARAMETER;
1374 /* create a signal & check for errors */
1375 msg = dbus_message_new_method_call(
1376 STT_SERVER_SERVICE_NAME,
1377 STT_SERVER_SERVICE_OBJECT_PATH,
1378 STT_SERVER_SERVICE_INTERFACE,
1382 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start : Fail to make message");
1383 return STT_ERROR_OPERATION_FAILED;
1385 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start : uid(%d), language(%s), type(%s)", uid, lang, type);
1389 if (NULL == credential) {
1390 temp = strdup("NULL");
1392 temp = strdup(credential);
1395 dbus_message_append_args(msg,
1396 DBUS_TYPE_INT32, &uid,
1397 DBUS_TYPE_STRING, &lang,
1398 DBUS_TYPE_STRING, &type,
1399 DBUS_TYPE_INT32, &silence,
1400 DBUS_TYPE_STRING, &appid,
1401 DBUS_TYPE_STRING, &temp,
1404 if (g_conn_sender) {
1405 dbus_message_set_no_reply(msg, TRUE);
1407 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1408 SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt start message : Out Of Memory !");
1413 return STT_ERROR_OUT_OF_MEMORY;
1415 dbus_connection_flush(g_conn_sender);
1418 dbus_message_unref(msg);
1421 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1426 return STT_ERROR_OPERATION_FAILED;
1436 dbus_error_init(&err);
1438 DBusMessage* result_msg;
1439 int result = STT_ERROR_OPERATION_FAILED;
1441 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1442 dbus_message_unref(msg);
1443 if (dbus_error_is_set(&err)) {
1444 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1445 dbus_error_free(&err);
1448 if (NULL != result_msg) {
1449 dbus_message_get_args(result_msg, &err,
1450 DBUS_TYPE_INT32, &result,
1453 if (dbus_error_is_set(&err)) {
1454 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1455 dbus_error_free(&err);
1456 result = STT_ERROR_OPERATION_FAILED;
1458 dbus_message_unref(result_msg);
1461 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt start : result = %d ", result);
1463 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt start : result = %d ", result);
1466 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1467 stt_dbus_reconnect();
1468 result = STT_ERROR_TIMED_OUT;
1475 int stt_dbus_request_stop(int uid)
1479 /* create a signal & check for errors */
1480 msg = dbus_message_new_method_call(
1481 STT_SERVER_SERVICE_NAME,
1482 STT_SERVER_SERVICE_OBJECT_PATH,
1483 STT_SERVER_SERVICE_INTERFACE,
1487 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt stop : Fail to make message");
1488 return STT_ERROR_OPERATION_FAILED;
1490 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt stop : uid(%d)", uid);
1493 dbus_message_append_args(msg,
1494 DBUS_TYPE_INT32, &uid,
1497 if (g_conn_sender) {
1498 dbus_message_set_no_reply(msg, TRUE);
1500 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1501 SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
1502 return STT_ERROR_OUT_OF_MEMORY;
1504 dbus_connection_flush(g_conn_sender);
1507 dbus_message_unref(msg);
1509 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1510 return STT_ERROR_OPERATION_FAILED;
1516 dbus_error_init(&err);
1518 DBusMessage* result_msg;
1519 int result = STT_ERROR_OPERATION_FAILED;
1521 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1522 dbus_message_unref(msg);
1523 if (dbus_error_is_set(&err)) {
1524 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1525 dbus_error_free(&err);
1528 if (NULL != result_msg) {
1529 dbus_message_get_args(result_msg, &err,
1530 DBUS_TYPE_INT32, &result,
1533 if (dbus_error_is_set(&err)) {
1534 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1535 dbus_error_free(&err);
1536 result = STT_ERROR_OPERATION_FAILED;
1538 dbus_message_unref(result_msg);
1541 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt stop : result = %d ", result);
1543 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt stop : result = %d ", result);
1546 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1547 stt_dbus_reconnect();
1548 result = STT_ERROR_TIMED_OUT;
1555 int stt_dbus_request_cancel(int uid)
1559 /* create a signal & check for errors */
1560 msg = dbus_message_new_method_call(
1561 STT_SERVER_SERVICE_NAME,
1562 STT_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
1563 STT_SERVER_SERVICE_INTERFACE, /* interface name of the signal */
1564 STT_METHOD_CANCEL); /* name of the signal */
1567 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel : Fail to make message");
1568 return STT_ERROR_OPERATION_FAILED;
1570 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel : uid(%d)", uid);
1573 dbus_message_append_args(msg,
1574 DBUS_TYPE_INT32, &uid,
1577 if (g_conn_sender) {
1578 dbus_message_set_no_reply(msg, TRUE);
1580 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1581 SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
1582 return STT_ERROR_OUT_OF_MEMORY;
1584 dbus_connection_flush(g_conn_sender);
1587 dbus_message_unref(msg);
1589 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1590 return STT_ERROR_OPERATION_FAILED;
1596 dbus_error_init(&err);
1598 DBusMessage* result_msg;
1599 int result = STT_ERROR_OPERATION_FAILED;
1601 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1602 dbus_message_unref(msg);
1603 if (dbus_error_is_set(&err)) {
1604 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1605 dbus_error_free(&err);
1608 if (NULL != result_msg) {
1609 dbus_message_get_args(result_msg, &err,
1610 DBUS_TYPE_INT32, &result,
1613 if (dbus_error_is_set(&err)) {
1614 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1615 dbus_error_free(&err);
1616 result = STT_ERROR_OPERATION_FAILED;
1618 dbus_message_unref(result_msg);
1621 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt cancel : result = %d ", result);
1623 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt cancel : result = %d ", result);
1626 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1627 stt_dbus_reconnect();
1628 result = STT_ERROR_TIMED_OUT;