2 * Copyright (c) 2011-2015 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the License);
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an AS IS BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 #include "vc_client.h"
23 static int g_waiting_time = 3000;
25 static Ecore_Fd_Handler* g_fd_handler = NULL;
27 static DBusConnection* g_conn_sender = NULL;
28 static DBusConnection* g_conn_listener = NULL;
30 extern int __vc_cb_error(int reason, int daemon_pid, char* msg);
32 extern void __vc_cb_result();
34 extern int __vc_cb_service_state(int state);
36 extern int __vc_cb_manager_pid(int manager_pid);
39 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
41 if (NULL == g_conn_listener) return ECORE_CALLBACK_RENEW;
43 dbus_connection_read_write_dispatch(g_conn_listener, 50);
46 DBusMessage* msg = NULL;
47 msg = dbus_connection_pop_message(g_conn_listener);
49 /* loop again if we haven't read a message */
55 dbus_error_init(&err);
57 char if_name[64] = {0, };
58 snprintf(if_name, 64, "%s", VC_CLIENT_SERVICE_INTERFACE);
60 if (dbus_message_is_method_call(msg, if_name, VCD_METHOD_HELLO)) {
61 SLOG(LOG_DEBUG, TAG_VCC, "===== Get Hello");
65 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
67 if (dbus_error_is_set(&err)) {
68 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
69 dbus_error_free(&err);
73 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc get hello : pid(%d) ", pid);
76 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc get hello : invalid pid ");
79 DBusMessage* reply = NULL;
80 reply = dbus_message_new_method_return(msg);
83 dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
85 if (!dbus_connection_send(g_conn_listener, reply, NULL))
86 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc get hello : fail to send reply");
88 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc get hello : result(%d)", response);
90 dbus_connection_flush(g_conn_listener);
91 dbus_message_unref(reply);
93 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc get hello : fail to create reply message");
96 SLOG(LOG_DEBUG, TAG_VCC, "=====");
97 SLOG(LOG_DEBUG, TAG_VCC, " ");
98 } /* VCD_METHOD_HELLO */
100 else if (dbus_message_is_signal(msg, if_name, VCD_METHOD_SET_SERVICE_STATE)) {
103 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
104 if (dbus_error_is_set(&err)) {
105 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Get arguments error (%s)", err.message);
106 dbus_error_free(&err);
109 SLOG(LOG_DEBUG, TAG_VCC, "<<<< state changed : %d", state);
111 __vc_cb_service_state(state);
113 } /* VCD_METHOD_SET_SERVICE_STATE */
115 else if (dbus_message_is_method_call(msg, if_name, VCD_METHOD_RESULT)) {
116 SLOG(LOG_DEBUG, TAG_VCC, "===== Get Client Result");
120 SLOG(LOG_DEBUG, TAG_VCC, "=====");
121 SLOG(LOG_DEBUG, TAG_VCC, " ");
123 } /* VCD_METHOD_RESULT */
124 else if (dbus_message_is_signal(msg, if_name, VCD_METHOD_SEND_MANAGER_PID)) {
127 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &manager_pid, DBUS_TYPE_INVALID);
128 if (dbus_error_is_set(&err)) {
129 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Get arguments error (%s)", err.message);
130 dbus_error_free(&err);
133 SLOG(LOG_DEBUG, TAG_VCC, "<<<< manager pid is changed : %d", manager_pid);
135 __vc_cb_manager_pid(manager_pid);
137 } /* VCD_METHOD_SEND_MANAGER_PID */
139 else if (dbus_message_is_signal(msg, if_name, VCD_METHOD_ERROR)) {
140 SLOG(LOG_DEBUG, TAG_VCC, "===== Get Error");
145 dbus_message_get_args(msg, &err,
146 DBUS_TYPE_INT32, &reason,
147 DBUS_TYPE_INT32, &daemon_pid,
148 DBUS_TYPE_STRING, &err_msg,
151 if (dbus_error_is_set(&err)) {
152 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc Get Error message : Get arguments error (%s)", err.message);
153 dbus_error_free(&err);
155 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc Get Error message : reason(%d), daemon_pid(%d), msg(%s)", reason, daemon_pid, err_msg);
156 __vc_cb_error(reason, daemon_pid, err_msg);
159 SLOG(LOG_DEBUG, TAG_VCC, "=====");
160 SLOG(LOG_DEBUG, TAG_VCC, " ");
161 } /* VCD_METHOD_ERROR */
164 SLOG(LOG_DEBUG, TAG_VCC, "Message is NOT valid");
165 dbus_message_unref(msg);
169 /* free the message */
170 dbus_message_unref(msg);
173 return ECORE_CALLBACK_PASS_ON;
176 int vc_dbus_open_connection()
178 if (NULL != g_conn_sender && NULL != g_conn_listener) {
179 SLOG(LOG_WARN, TAG_VCC, "already existed connection ");
186 /* initialise the error value */
187 dbus_error_init(&err);
189 /* connect to the DBUS system bus, and check for errors */
190 g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
192 if (dbus_error_is_set(&err)) {
193 SLOG(LOG_ERROR, TAG_VCC, "Dbus Connection Error (%s)", err.message);
194 dbus_error_free(&err);
197 if (NULL == g_conn_sender) {
198 SLOG(LOG_ERROR, TAG_VCC, "Fail to get dbus connection ");
199 return VC_ERROR_OPERATION_FAILED;
202 g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
204 if (dbus_error_is_set(&err)) {
205 SLOG(LOG_ERROR, TAG_VCC, "Dbus Connection Error (%s)", err.message);
206 dbus_error_free(&err);
209 if (NULL == g_conn_listener) {
210 SLOG(LOG_ERROR, TAG_VCC, "Fail to get dbus connection ");
211 return VC_ERROR_OPERATION_FAILED;
216 char service_name[64];
217 memset(service_name, '\0', 64);
218 snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
220 SLOG(LOG_DEBUG, TAG_VCC, "service name is %s", service_name);
222 /* register our name on the bus, and check for errors */
223 ret = dbus_bus_request_name(g_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
225 if (dbus_error_is_set(&err)) {
226 SLOG(LOG_ERROR, TAG_VCC, "Name Error (%s)", err.message);
227 dbus_error_free(&err);
230 if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
231 SLOG(LOG_ERROR, TAG_VCC, "fail dbus_bus_request_name()");
235 if (NULL != g_fd_handler) {
236 SLOG(LOG_WARN, TAG_VCC, "The handler already exists.");
240 char rule[128] = {0, };
241 snprintf(rule, 128, "type='signal',interface='%s'", VC_CLIENT_SERVICE_INTERFACE);
243 /* add a rule for which messages we want to see */
244 dbus_bus_add_match(g_conn_listener, rule, &err);
245 dbus_connection_flush(g_conn_listener);
247 if (dbus_error_is_set(&err)) {
248 SLOG(LOG_ERROR, TAG_VCC, "Match Error (%s)", err.message);
249 dbus_error_free(&err);
250 return VC_ERROR_OPERATION_FAILED;
254 if (1 != dbus_connection_get_unix_fd(g_conn_listener, &fd)) {
255 SLOG(LOG_ERROR, TAG_VCC, "fail to get fd from dbus ");
256 return VC_ERROR_OPERATION_FAILED;
258 SLOG(LOG_DEBUG, TAG_VCC, "Get fd from dbus : %d", fd);
261 g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
262 if (NULL == g_fd_handler) {
263 SLOG(LOG_ERROR, TAG_VCC, "fail to get fd handler from ecore ");
264 return VC_ERROR_OPERATION_FAILED;
270 int vc_dbus_close_connection()
273 dbus_error_init(&err);
275 if (NULL != g_fd_handler) {
276 ecore_main_fd_handler_del(g_fd_handler);
282 char service_name[64];
283 memset(service_name, '\0', 64);
284 snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
286 dbus_bus_release_name(g_conn_listener, service_name, &err);
288 if (dbus_error_is_set(&err)) {
289 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
290 dbus_error_free(&err);
293 dbus_connection_close(g_conn_sender);
294 dbus_connection_close(g_conn_listener);
296 dbus_connection_unref(g_conn_sender);
297 dbus_connection_unref(g_conn_listener);
299 g_conn_sender = NULL;
300 g_conn_listener = NULL;
305 int vc_dbus_reconnect()
307 bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
308 bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
309 SLOG(LOG_WARN, TAG_VCC, "[DBUS] Sender(%s) Listener(%s)",
310 sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
312 if (false == sender_connected || false == listener_connected) {
313 vc_dbus_close_connection();
315 if (0 != vc_dbus_open_connection()) {
316 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to reconnect");
320 SLOG(LOG_DEBUG, TAG_VCC, "[DBUS] Reconnect");
326 static int __dbus_check()
328 if (NULL == g_conn_sender) {
329 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection");
330 return vc_dbus_reconnect();
335 int vc_dbus_request_hello()
337 if (0 != __dbus_check()) {
338 return VC_ERROR_OPERATION_FAILED;
343 msg = dbus_message_new_method_call(
344 VC_SERVER_SERVICE_NAME,
345 VC_SERVER_SERVICE_OBJECT_PATH,
346 VC_SERVER_SERVICE_INTERFACE,
350 SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc hello : Fail to make message");
351 return VC_ERROR_OPERATION_FAILED;
355 dbus_error_init(&err);
357 DBusMessage* result_msg = NULL;
360 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, 500, &err);
362 if (dbus_error_is_set(&err)) {
363 dbus_error_free(&err);
366 dbus_message_unref(msg);
368 if (NULL != result_msg) {
369 dbus_message_unref(result_msg);
372 result = VC_ERROR_TIMED_OUT;
379 int vc_dbus_request_initialize(int pid, int* mgr_pid, int* service_state, int* daemon_pid)
381 if (0 != __dbus_check()) {
382 return VC_ERROR_OPERATION_FAILED;
387 msg = dbus_message_new_method_call(
388 VC_SERVER_SERVICE_NAME,
389 VC_SERVER_SERVICE_OBJECT_PATH,
390 VC_SERVER_SERVICE_INTERFACE,
391 VC_METHOD_INITIALIZE);
394 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc initialize : Fail to make message ");
395 return VC_ERROR_OPERATION_FAILED;
397 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc initialize : pid(%d)", pid);
400 dbus_message_append_args(msg,
401 DBUS_TYPE_INT32, &pid,
405 dbus_error_init(&err);
407 DBusMessage* result_msg;
408 int result = VC_ERROR_OPERATION_FAILED;
410 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
411 dbus_message_unref(msg);
413 if (dbus_error_is_set(&err)) {
414 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
415 dbus_error_free(&err);
418 if (NULL != result_msg) {
420 int tmp_service_state = 0;
421 int tmp_daemon_pid = 0;
422 dbus_message_get_args(result_msg, &err,
423 DBUS_TYPE_INT32, &result,
424 DBUS_TYPE_INT32, &tmp,
425 DBUS_TYPE_INT32, &tmp_service_state,
426 DBUS_TYPE_INT32, &tmp_daemon_pid,
429 if (dbus_error_is_set(&err)) {
430 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
431 dbus_error_free(&err);
432 result = VC_ERROR_OPERATION_FAILED;
435 dbus_message_unref(result_msg);
439 *service_state = tmp_service_state;
440 *daemon_pid = tmp_daemon_pid;
441 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc initialize : result = %d mgr = %d service = %d daemon_pid = %d", result, *mgr_pid, *service_state, *daemon_pid);
443 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc initialize : result = %d", result);
446 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL ");
448 result = VC_ERROR_TIMED_OUT;
454 int vc_dbus_request_finalize(int pid)
456 if (0 != __dbus_check()) {
457 return VC_ERROR_OPERATION_FAILED;
462 msg = dbus_message_new_method_call(
463 VC_SERVER_SERVICE_NAME,
464 VC_SERVER_SERVICE_OBJECT_PATH,
465 VC_SERVER_SERVICE_INTERFACE,
469 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc finalize : Fail to make message ");
470 return VC_ERROR_OPERATION_FAILED;
472 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc finalize : pid(%d)", pid);
475 dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
478 dbus_error_init(&err);
480 DBusMessage* result_msg;
481 int result = VC_ERROR_OPERATION_FAILED;
483 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
484 dbus_message_unref(msg);
486 if (dbus_error_is_set(&err)) {
487 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
488 dbus_error_free(&err);
491 if (NULL != result_msg) {
492 dbus_message_get_args(result_msg, &err,
493 DBUS_TYPE_INT32, &result,
496 if (dbus_error_is_set(&err)) {
497 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
498 dbus_error_free(&err);
499 result = VC_ERROR_OPERATION_FAILED;
502 dbus_message_unref(result_msg);
505 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc finalize : result = %d", result);
507 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc finalize : result = %d", result);
510 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL ");
512 result = VC_ERROR_TIMED_OUT;
518 int vc_dbus_request_set_exclusive_command(int pid, bool value)
520 if (0 != __dbus_check()) {
521 return VC_ERROR_OPERATION_FAILED;
526 msg = dbus_message_new_method_call(
527 VC_SERVER_SERVICE_NAME,
528 VC_SERVER_SERVICE_OBJECT_PATH,
529 VC_SERVER_SERVICE_INTERFACE,
530 VC_METHOD_SET_EXCLUSIVE_CMD);
533 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set exclusive command : Fail to make message");
534 return VC_ERROR_OPERATION_FAILED;
536 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set exclusive command : pid(%d)", pid);
541 dbus_message_append_args(msg,
542 DBUS_TYPE_INT32, &pid,
543 DBUS_TYPE_INT32, &temp,
547 dbus_error_init(&err);
549 DBusMessage* result_msg;
550 int result = VC_ERROR_OPERATION_FAILED;
552 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
553 dbus_message_unref(msg);
555 if (dbus_error_is_set(&err)) {
556 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
557 dbus_error_free(&err);
560 if (NULL != result_msg) {
561 dbus_message_get_args(result_msg, &err,
562 DBUS_TYPE_INT32, &result,
565 if (dbus_error_is_set(&err)) {
566 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
567 dbus_error_free(&err);
568 result = VC_ERROR_OPERATION_FAILED;
570 dbus_message_unref(result_msg);
573 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc set exclusive command : result = %d", result);
575 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc set exclusive command : result = %d", result);
578 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
580 result = VC_ERROR_TIMED_OUT;
586 int vc_dbus_request_set_command(int pid, vc_cmd_type_e cmd_type)
588 if (0 != __dbus_check()) {
589 return VC_ERROR_OPERATION_FAILED;
594 msg = dbus_message_new_method_call(
595 VC_SERVER_SERVICE_NAME,
596 VC_SERVER_SERVICE_OBJECT_PATH,
597 VC_SERVER_SERVICE_INTERFACE,
598 VC_METHOD_SET_COMMAND);
601 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set command : Fail to make message");
602 return VC_ERROR_OPERATION_FAILED;
604 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set command : pid(%d)", pid);
607 dbus_message_append_args(msg,
608 DBUS_TYPE_INT32, &pid,
609 DBUS_TYPE_INT32, &cmd_type,
613 dbus_error_init(&err);
615 DBusMessage* result_msg;
616 int result = VC_ERROR_OPERATION_FAILED;
618 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
619 dbus_message_unref(msg);
621 if (dbus_error_is_set(&err)) {
622 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
623 dbus_error_free(&err);
626 if (NULL != result_msg) {
627 dbus_message_get_args(result_msg, &err,
628 DBUS_TYPE_INT32, &result,
631 if (dbus_error_is_set(&err)) {
632 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
633 dbus_error_free(&err);
634 result = VC_ERROR_OPERATION_FAILED;
636 dbus_message_unref(result_msg);
639 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc set command : result = %d", result);
641 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc set command : result = %d", result);
644 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
646 result = VC_ERROR_TIMED_OUT;
652 int vc_dbus_request_unset_command(int pid, vc_cmd_type_e cmd_type)
654 if (0 != __dbus_check()) {
655 return VC_ERROR_OPERATION_FAILED;
660 msg = dbus_message_new_method_call(
661 VC_SERVER_SERVICE_NAME,
662 VC_SERVER_SERVICE_OBJECT_PATH,
663 VC_SERVER_SERVICE_INTERFACE,
664 VC_METHOD_UNSET_COMMAND);
667 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc unset command : Fail to make message");
668 return VC_ERROR_OPERATION_FAILED;
670 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc unset command : pid(%d), type(%d)", pid, cmd_type);
673 dbus_message_append_args(msg,
674 DBUS_TYPE_INT32, &pid,
675 DBUS_TYPE_INT32, &cmd_type,
679 dbus_error_init(&err);
681 DBusMessage* result_msg;
682 int result = VC_ERROR_OPERATION_FAILED;
684 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
685 dbus_message_unref(msg);
687 if (dbus_error_is_set(&err)) {
688 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
689 dbus_error_free(&err);
692 if (NULL != result_msg) {
693 dbus_message_get_args(result_msg, &err,
694 DBUS_TYPE_INT32, &result,
697 if (dbus_error_is_set(&err)) {
698 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
699 dbus_error_free(&err);
700 result = VC_ERROR_OPERATION_FAILED;
702 dbus_message_unref(result_msg);
705 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc unset command : result = %d", result);
707 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc unset command : result = %d", result);
710 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
712 result = VC_ERROR_TIMED_OUT;
718 int vc_dbus_set_foreground(int pid, bool value)
720 if (0 != __dbus_check()) {
721 return VC_ERROR_OPERATION_FAILED;
724 DBusMessage* msg = NULL;
727 tmp_value = (int)value;
729 msg = dbus_message_new_signal(
730 VC_MANAGER_SERVICE_OBJECT_PATH,
731 VC_MANAGER_SERVICE_INTERFACE,
732 VCC_MANAGER_METHOD_SET_FOREGROUND);
735 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set foreground to manager : Fail to make message");
736 return VC_ERROR_OPERATION_FAILED;
738 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set foreground to manager : client pid(%d), value(%s)", pid, tmp_value ? "true" : "false");
741 dbus_message_append_args(msg,
742 DBUS_TYPE_INT32, &pid,
743 DBUS_TYPE_INT32, &tmp_value,
746 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
747 SLOG(LOG_ERROR, TAG_VCC, "[Dbus ERROR] Fail to Send");
748 return VC_ERROR_OPERATION_FAILED;
751 dbus_message_unref(msg);
754 msg = dbus_message_new_method_call(
755 VC_SERVER_SERVICE_NAME,
756 VC_SERVER_SERVICE_OBJECT_PATH,
757 VC_SERVER_SERVICE_INTERFACE,
758 VC_METHOD_SET_FOREGROUND);
761 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set foreground to daemon : Fail to make message");
762 return VC_ERROR_OPERATION_FAILED;
764 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set foreground to daemon : client pid(%d), value(%s)", pid, tmp_value ? "true" : "false");
767 dbus_message_append_args(msg,
768 DBUS_TYPE_INT32, &pid,
769 DBUS_TYPE_INT32, &tmp_value,
772 dbus_message_set_no_reply(msg, TRUE);
774 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
775 SLOG(LOG_ERROR, TAG_VCC, "[Dbus ERROR] Fail to Send");
776 return VC_ERROR_OPERATION_FAILED;
779 dbus_connection_flush(g_conn_sender);
781 dbus_message_unref(msg);
786 int vc_dbus_request_dialog(int pid, const char* disp_text, const char* utt_text, bool continuous)
788 if (NULL == g_conn_sender) {
789 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection");
790 if (0 != vc_dbus_reconnect()) {
791 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to reconnect");
796 int tmp_continue = 0;
798 tmp_continue = (int)continuous;
800 msg = dbus_message_new_method_call(
801 VC_SERVER_SERVICE_NAME,
802 VC_SERVER_SERVICE_OBJECT_PATH,
803 VC_SERVER_SERVICE_INTERFACE,
807 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc request dialog to manager : Fail to make message");
808 return VC_ERROR_OPERATION_FAILED;
810 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc request dialog to manager : client pid(%d), disp_text(%s), utt_text(%s), continuous(%d)", getpid(), disp_text, utt_text, continuous);
813 dbus_message_append_args(msg,
814 DBUS_TYPE_INT32, &pid,
815 DBUS_TYPE_STRING, &disp_text,
816 DBUS_TYPE_STRING, &utt_text,
817 DBUS_TYPE_INT32, &tmp_continue,
820 dbus_message_set_no_reply(msg, TRUE);
822 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
823 SLOG(LOG_ERROR, TAG_VCC, "[Dbus ERROR] Fail to Send");
824 return VC_ERROR_OPERATION_FAILED;
826 SLOG(LOG_DEBUG, TAG_VCC, "[Dbus DEBUG] Success to Send");
827 dbus_connection_flush(g_conn_sender);
830 dbus_message_unref(msg);
836 dbus_error_init(&err);
838 DBusMessage* result_msg;
839 int result = VC_ERROR_OPERATION_FAILED;
841 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
842 dbus_message_unref(msg);
844 if (dbus_error_is_set(&err)) {
845 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
846 dbus_error_free(&err);
849 if (NULL != result_msg) {
850 dbus_message_get_args(result_msg, &err,
851 DBUS_TYPE_INT32, &result,
854 if (dbus_error_is_set(&err)) {
855 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
856 dbus_error_free(&err);
857 result = VC_ERROR_OPERATION_FAILED;
859 dbus_message_unref(result_msg);
862 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc set command : result = %d", result);
864 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc set command : result = %d", result);
867 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
869 result = VC_ERROR_TIMED_OUT;
876 int vc_dbus_request_is_system_command_valid(int pid, bool* is_sys_cmd_valid)
878 if (NULL == g_conn_sender) {
879 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection");
880 if (0 != vc_dbus_reconnect()) {
881 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to reconnect");
887 msg = dbus_message_new_method_call(
888 VC_SERVER_SERVICE_NAME,
889 VC_SERVER_SERVICE_OBJECT_PATH,
890 VC_SERVER_SERVICE_INTERFACE,
891 VC_METHOD_IS_SYS_COMMAND_VALID);
894 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc is system command valid : Fail to make message");
895 return VC_ERROR_OPERATION_FAILED;
897 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc is system command valid : pid(%d)", pid);
900 dbus_message_append_args(msg,
901 DBUS_TYPE_INT32, &pid,
905 dbus_error_init(&err);
908 DBusMessage* result_msg;
909 int result = VC_ERROR_OPERATION_FAILED;
911 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
912 dbus_message_unref(msg);
914 if (dbus_error_is_set(&err)) {
915 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
916 dbus_error_free(&err);
919 if (NULL != result_msg) {
920 dbus_message_get_args(result_msg, &err,
921 DBUS_TYPE_INT32, &result,
922 DBUS_TYPE_INT32, &tmp_sys_cmd,
925 if (dbus_error_is_set(&err)) {
926 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
927 dbus_error_free(&err);
928 result = VC_ERROR_OPERATION_FAILED;
930 dbus_message_unref(result_msg);
933 *is_sys_cmd_valid = (bool)tmp_sys_cmd;
934 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc is system command valid : result = %d, is_sys_cmd_valid = %d", result, *is_sys_cmd_valid);
936 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc is system command valid : result = %d", result);
939 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
941 result = VC_ERROR_TIMED_OUT;
949 int vc_dbus_request_start(int pid, int silence)
953 /* create a signal & check for errors */
954 msg = dbus_message_new_method_call(
955 VC_SERVER_SERVICE_NAME,
956 VC_SERVER_SERVICE_OBJECT_PATH,
957 VC_SERVER_SERVICE_INTERFACE,
958 VC_METHOD_REQUEST_START);
961 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc start : Fail to make message ");
962 return VC_ERROR_OPERATION_FAILED;
964 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc start : pid(%d), silence(%d)", pid, silence);
967 DBusMessageIter args;
968 dbus_message_iter_init_append(msg, &args);
971 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(pid));
972 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(silence));
975 dbus_error_init(&err);
977 DBusMessage* result_msg;
978 int result = VC_ERROR_OPERATION_FAILED;
980 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
981 dbus_message_unref(msg);
983 if (dbus_error_is_set(&err)) {
984 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
985 dbus_error_free(&err);
988 if (NULL != result_msg) {
989 dbus_message_get_args(result_msg, &err,
990 DBUS_TYPE_INT32, &result,
993 if (dbus_error_is_set(&err)) {
994 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
995 dbus_error_free(&err);
996 result = VC_ERROR_OPERATION_FAILED;
998 dbus_message_unref(result_msg);
1001 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc start : result = %d", result);
1003 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc start : result = %d", result);
1006 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1007 vc_dbus_reconnect();
1008 result = VC_ERROR_TIMED_OUT;
1014 int vc_dbus_request_stop(int pid)
1018 /* create a signal & check for errors */
1019 msg = dbus_message_new_method_call(
1020 VC_SERVER_SERVICE_NAME,
1021 VC_SERVER_SERVICE_OBJECT_PATH,
1022 VC_SERVER_SERVICE_INTERFACE,
1023 VC_METHOD_REQUEST_STOP);
1026 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc stop : Fail to make message ");
1027 return VC_ERROR_OPERATION_FAILED;
1029 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc stop : pid(%d)", pid);
1032 dbus_message_append_args(msg,
1033 DBUS_TYPE_INT32, &pid,
1037 dbus_error_init(&err);
1039 DBusMessage* result_msg;
1040 int result = VC_ERROR_OPERATION_FAILED;
1042 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1043 dbus_message_unref(msg);
1045 if (dbus_error_is_set(&err)) {
1046 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1047 dbus_error_free(&err);
1050 if (NULL != result_msg) {
1051 dbus_message_get_args(result_msg, &err,
1052 DBUS_TYPE_INT32, &result,
1055 if (dbus_error_is_set(&err)) {
1056 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1057 dbus_error_free(&err);
1058 result = VC_ERROR_OPERATION_FAILED;
1060 dbus_message_unref(result_msg);
1063 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc stop : result = %d", result);
1065 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc stop : result = %d", result);
1068 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1069 vc_dbus_reconnect();
1070 result = VC_ERROR_TIMED_OUT;
1076 int vc_dbus_request_cancel(int pid)
1080 /* create a signal & check for errors */
1081 msg = dbus_message_new_method_call(
1082 VC_SERVER_SERVICE_NAME,
1083 VC_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
1084 VC_SERVER_SERVICE_INTERFACE, /* interface name of the signal */
1085 VC_METHOD_REQUEST_CANCEL); /* name of the signal */
1088 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc cancel : Fail to make message ");
1089 return VC_ERROR_OPERATION_FAILED;
1091 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc cancel : pid(%d)", pid);
1094 dbus_message_append_args(msg,
1095 DBUS_TYPE_INT32, &pid,
1099 dbus_error_init(&err);
1101 DBusMessage* result_msg;
1102 int result = VC_ERROR_OPERATION_FAILED;
1104 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1105 dbus_message_unref(msg);
1107 if (dbus_error_is_set(&err)) {
1108 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1109 dbus_error_free(&err);
1112 if (NULL != result_msg) {
1113 dbus_message_get_args(result_msg, &err,
1114 DBUS_TYPE_INT32, &result,
1117 if (dbus_error_is_set(&err)) {
1118 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1119 dbus_error_free(&err);
1120 result = VC_ERROR_OPERATION_FAILED;
1122 dbus_message_unref(result_msg);
1125 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc cancel : result = %d", result);
1127 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc cancel : result = %d", result);
1130 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1131 vc_dbus_reconnect();
1132 result = VC_ERROR_TIMED_OUT;
1140 int vc_dbus_request_auth_enable(int pid, int mgr_pid)
1142 if (0 != __dbus_check()) {
1143 return VC_ERROR_OPERATION_FAILED;
1148 char service_name[64] = {0,};
1149 char object_path[64] = {0,};
1150 char target_if_name[128] = {0,};
1152 snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1153 snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1154 snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1156 /* create a signal & check for errors */
1157 msg = dbus_message_new_method_call(
1159 object_path, /* object name of the signal */
1160 target_if_name, /* interface name of the signal */
1161 VC_METHOD_AUTH_ENABLE); /* name of the signal */
1164 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth enable : Fail to make message ");
1165 return VC_ERROR_OPERATION_FAILED;
1167 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth enable : pid(%d)", pid);
1170 dbus_message_append_args(msg,
1171 DBUS_TYPE_INT32, &pid,
1175 dbus_error_init(&err);
1177 DBusMessage* result_msg;
1178 int result = VC_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);
1183 if (dbus_error_is_set(&err)) {
1184 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1185 dbus_error_free(&err);
1188 if (NULL != result_msg) {
1189 dbus_message_get_args(result_msg, &err,
1190 DBUS_TYPE_INT32, &result,
1193 if (dbus_error_is_set(&err)) {
1194 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1195 dbus_error_free(&err);
1196 result = VC_ERROR_OPERATION_FAILED;
1198 dbus_message_unref(result_msg);
1201 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth enable : result = %d", result);
1203 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth enable : result = %d", result);
1206 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1207 vc_dbus_reconnect();
1208 result = VC_ERROR_TIMED_OUT;
1214 int vc_dbus_request_auth_disable(int pid, int mgr_pid)
1216 if (0 != __dbus_check()) {
1217 return VC_ERROR_OPERATION_FAILED;
1222 char service_name[64] = {0,};
1223 char object_path[64] = {0,};
1224 char target_if_name[128] = {0,};
1226 snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1227 snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1228 snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1230 /* create a signal & check for errors */
1231 msg = dbus_message_new_method_call(
1233 object_path, /* object name of the signal */
1234 target_if_name, /* interface name of the signal */
1235 VC_METHOD_AUTH_DISABLE); /* name of the signal */
1238 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth disable : Fail to make message ");
1239 return VC_ERROR_OPERATION_FAILED;
1241 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth disable : pid(%d)", pid);
1244 dbus_message_append_args(msg,
1245 DBUS_TYPE_INT32, &pid,
1249 dbus_error_init(&err);
1251 DBusMessage* result_msg;
1252 int result = VC_ERROR_OPERATION_FAILED;
1254 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1255 dbus_message_unref(msg);
1257 if (dbus_error_is_set(&err)) {
1258 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1259 dbus_error_free(&err);
1262 if (NULL != result_msg) {
1263 dbus_message_get_args(result_msg, &err,
1264 DBUS_TYPE_INT32, &result,
1267 if (dbus_error_is_set(&err)) {
1268 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1269 dbus_error_free(&err);
1270 result = VC_ERROR_OPERATION_FAILED;
1272 dbus_message_unref(result_msg);
1275 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth disable : result = %d", result);
1277 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth disable : result = %d", result);
1280 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1281 vc_dbus_reconnect();
1282 result = VC_ERROR_TIMED_OUT;
1288 int vc_dbus_request_auth_start(int pid, int mgr_pid)
1290 if (0 != __dbus_check()) {
1291 return VC_ERROR_OPERATION_FAILED;
1296 char service_name[64] = {0,};
1297 char object_path[64] = {0,};
1298 char target_if_name[128] = {0,};
1300 snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1301 snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1302 snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1304 /* create a signal & check for errors */
1305 msg = dbus_message_new_method_call(
1309 VC_METHOD_AUTH_START);
1312 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth start : Fail to make message ");
1313 return VC_ERROR_OPERATION_FAILED;
1315 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth start : pid(%d)", pid);
1318 DBusMessageIter args;
1319 dbus_message_iter_init_append(msg, &args);
1322 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(pid));
1325 dbus_error_init(&err);
1327 DBusMessage* result_msg;
1328 int result = VC_ERROR_OPERATION_FAILED;
1330 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1331 dbus_message_unref(msg);
1333 if (dbus_error_is_set(&err)) {
1334 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1335 dbus_error_free(&err);
1338 if (NULL != result_msg) {
1339 dbus_message_get_args(result_msg, &err,
1340 DBUS_TYPE_INT32, &result,
1343 if (dbus_error_is_set(&err)) {
1344 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1345 dbus_error_free(&err);
1346 result = VC_ERROR_OPERATION_FAILED;
1348 dbus_message_unref(result_msg);
1351 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth start : result = %d", result);
1353 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth start : result = %d", result);
1356 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1357 vc_dbus_reconnect();
1358 result = VC_ERROR_TIMED_OUT;
1364 int vc_dbus_request_auth_stop(int pid, int mgr_pid)
1366 if (0 != __dbus_check()) {
1367 return VC_ERROR_OPERATION_FAILED;
1372 char service_name[64] = {0,};
1373 char object_path[64] = {0,};
1374 char target_if_name[128] = {0,};
1376 snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1377 snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1378 snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1380 /* create a signal & check for errors */
1381 msg = dbus_message_new_method_call(
1385 VC_METHOD_AUTH_STOP);
1388 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth stop : Fail to make message ");
1389 return VC_ERROR_OPERATION_FAILED;
1391 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth stop : pid(%d)", pid);
1394 dbus_message_append_args(msg,
1395 DBUS_TYPE_INT32, &pid,
1399 dbus_error_init(&err);
1401 DBusMessage* result_msg;
1402 int result = VC_ERROR_OPERATION_FAILED;
1404 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1405 dbus_message_unref(msg);
1407 if (dbus_error_is_set(&err)) {
1408 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1409 dbus_error_free(&err);
1412 if (NULL != result_msg) {
1413 dbus_message_get_args(result_msg, &err,
1414 DBUS_TYPE_INT32, &result,
1417 if (dbus_error_is_set(&err)) {
1418 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1419 dbus_error_free(&err);
1420 result = VC_ERROR_OPERATION_FAILED;
1422 dbus_message_unref(result_msg);
1425 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth stop : result = %d", result);
1427 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth stop : result = %d", result);
1430 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1431 vc_dbus_reconnect();
1432 result = VC_ERROR_TIMED_OUT;
1438 int vc_dbus_request_auth_cancel(int pid, int mgr_pid)
1440 if (0 != __dbus_check()) {
1441 return VC_ERROR_OPERATION_FAILED;
1446 char service_name[64] = {0,};
1447 char object_path[64] = {0,};
1448 char target_if_name[128] = {0,};
1450 snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1451 snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1452 snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1454 /* create a signal & check for errors */
1455 msg = dbus_message_new_method_call(
1457 object_path, /* object name of the signal */
1458 target_if_name, /* interface name of the signal */
1459 VC_METHOD_AUTH_CANCEL); /* name of the signal */
1462 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth cancel : Fail to make message ");
1463 return VC_ERROR_OPERATION_FAILED;
1465 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth cancel : pid(%d)", pid);
1468 dbus_message_append_args(msg,
1469 DBUS_TYPE_INT32, &pid,
1473 dbus_error_init(&err);
1475 DBusMessage* result_msg;
1476 int result = VC_ERROR_OPERATION_FAILED;
1478 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1479 dbus_message_unref(msg);
1481 if (dbus_error_is_set(&err)) {
1482 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1483 dbus_error_free(&err);
1486 if (NULL != result_msg) {
1487 dbus_message_get_args(result_msg, &err,
1488 DBUS_TYPE_INT32, &result,
1491 if (dbus_error_is_set(&err)) {
1492 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1493 dbus_error_free(&err);
1494 result = VC_ERROR_OPERATION_FAILED;
1496 dbus_message_unref(result_msg);
1499 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth cancel : result = %d", result);
1501 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth cancel : result = %d", result);
1504 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1505 vc_dbus_reconnect();
1506 result = VC_ERROR_TIMED_OUT;