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);
37 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
39 if (NULL == g_conn_listener) return ECORE_CALLBACK_RENEW;
41 dbus_connection_read_write_dispatch(g_conn_listener, 50);
44 DBusMessage* msg = NULL;
45 msg = dbus_connection_pop_message(g_conn_listener);
47 /* loop again if we haven't read a message */
53 dbus_error_init(&err);
55 char if_name[64] = {0, };
56 snprintf(if_name, 64, "%s", VC_CLIENT_SERVICE_INTERFACE);
58 if (dbus_message_is_method_call(msg, if_name, VCD_METHOD_HELLO)) {
59 SLOG(LOG_DEBUG, TAG_VCC, "===== Get Hello");
63 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
65 if (dbus_error_is_set(&err)) {
66 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
67 dbus_error_free(&err);
71 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc get hello : pid(%d) ", pid);
74 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc get hello : invalid pid ");
77 DBusMessage* reply = NULL;
78 reply = dbus_message_new_method_return(msg);
81 dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
83 if (!dbus_connection_send(g_conn_listener, reply, NULL))
84 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc get hello : fail to send reply");
86 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc get hello : result(%d)", response);
88 dbus_connection_flush(g_conn_listener);
89 dbus_message_unref(reply);
91 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc get hello : fail to create reply message");
94 SLOG(LOG_DEBUG, TAG_VCC, "=====");
95 SLOG(LOG_DEBUG, TAG_VCC, " ");
96 } /* VCD_METHOD_HELLO */
98 else if (dbus_message_is_signal(msg, if_name, VCD_METHOD_SET_SERVICE_STATE)) {
101 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
102 if (dbus_error_is_set(&err)) {
103 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Get arguments error (%s)", err.message);
104 dbus_error_free(&err);
107 SLOG(LOG_DEBUG, TAG_VCC, "<<<< state changed : %d", state);
109 __vc_cb_service_state(state);
111 } /* VCD_METHOD_SET_SERVICE_STATE */
113 else if (dbus_message_is_method_call(msg, if_name, VCD_METHOD_RESULT)) {
114 SLOG(LOG_DEBUG, TAG_VCC, "===== Get Client Result");
118 SLOG(LOG_DEBUG, TAG_VCC, "=====");
119 SLOG(LOG_DEBUG, TAG_VCC, " ");
121 } /* VCD_METHOD_RESULT */
123 else if (dbus_message_is_signal(msg, if_name, VCD_METHOD_ERROR)) {
124 SLOG(LOG_DEBUG, TAG_VCC, "===== Get Error");
129 dbus_message_get_args(msg, &err,
130 DBUS_TYPE_INT32, &reason,
131 DBUS_TYPE_INT32, &daemon_pid,
132 DBUS_TYPE_STRING, &err_msg,
135 if (dbus_error_is_set(&err)) {
136 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc Get Error message : Get arguments error (%s)", err.message);
137 dbus_error_free(&err);
139 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc Get Error message : reason(%d), daemon_pid(%d), msg(%s)", reason, daemon_pid, err_msg);
140 __vc_cb_error(reason, daemon_pid, err_msg);
143 SLOG(LOG_DEBUG, TAG_VCC, "=====");
144 SLOG(LOG_DEBUG, TAG_VCC, " ");
145 } /* VCD_METHOD_ERROR */
148 SLOG(LOG_DEBUG, TAG_VCC, "Message is NOT valid");
149 dbus_message_unref(msg);
153 /* free the message */
154 dbus_message_unref(msg);
157 return ECORE_CALLBACK_PASS_ON;
160 int vc_dbus_open_connection()
162 if (NULL != g_conn_sender && NULL != g_conn_listener) {
163 SLOG(LOG_WARN, TAG_VCC, "already existed connection ");
170 /* initialise the error value */
171 dbus_error_init(&err);
173 /* connect to the DBUS system bus, and check for errors */
174 g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
176 if (dbus_error_is_set(&err)) {
177 SLOG(LOG_ERROR, TAG_VCC, "Dbus Connection Error (%s)", err.message);
178 dbus_error_free(&err);
181 if (NULL == g_conn_sender) {
182 SLOG(LOG_ERROR, TAG_VCC, "Fail to get dbus connection ");
183 return VC_ERROR_OPERATION_FAILED;
186 g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
188 if (dbus_error_is_set(&err)) {
189 SLOG(LOG_ERROR, TAG_VCC, "Dbus Connection Error (%s)", err.message);
190 dbus_error_free(&err);
193 if (NULL == g_conn_listener) {
194 SLOG(LOG_ERROR, TAG_VCC, "Fail to get dbus connection ");
195 return VC_ERROR_OPERATION_FAILED;
200 char service_name[64];
201 memset(service_name, '\0', 64);
202 snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
204 SLOG(LOG_DEBUG, TAG_VCC, "service name is %s", service_name);
206 /* register our name on the bus, and check for errors */
207 ret = dbus_bus_request_name(g_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
209 if (dbus_error_is_set(&err)) {
210 SLOG(LOG_ERROR, TAG_VCC, "Name Error (%s)", err.message);
211 dbus_error_free(&err);
214 if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
215 SLOG(LOG_ERROR, TAG_VCC, "fail dbus_bus_request_name()");
219 if (NULL != g_fd_handler) {
220 SLOG(LOG_WARN, TAG_VCC, "The handler already exists.");
224 char rule[128] = {0, };
225 snprintf(rule, 128, "type='signal',interface='%s'", VC_CLIENT_SERVICE_INTERFACE);
227 /* add a rule for which messages we want to see */
228 dbus_bus_add_match(g_conn_listener, rule, &err);
229 dbus_connection_flush(g_conn_listener);
231 if (dbus_error_is_set(&err)) {
232 SLOG(LOG_ERROR, TAG_VCC, "Match Error (%s)", err.message);
233 dbus_error_free(&err);
234 return VC_ERROR_OPERATION_FAILED;
238 if (1 != dbus_connection_get_unix_fd(g_conn_listener, &fd)) {
239 SLOG(LOG_ERROR, TAG_VCC, "fail to get fd from dbus ");
240 return VC_ERROR_OPERATION_FAILED;
242 SLOG(LOG_DEBUG, TAG_VCC, "Get fd from dbus : %d", fd);
245 g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
246 if (NULL == g_fd_handler) {
247 SLOG(LOG_ERROR, TAG_VCC, "fail to get fd handler from ecore ");
248 return VC_ERROR_OPERATION_FAILED;
254 int vc_dbus_close_connection()
257 dbus_error_init(&err);
259 if (NULL != g_fd_handler) {
260 ecore_main_fd_handler_del(g_fd_handler);
266 char service_name[64];
267 memset(service_name, '\0', 64);
268 snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
270 dbus_bus_release_name(g_conn_listener, service_name, &err);
272 if (dbus_error_is_set(&err)) {
273 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
274 dbus_error_free(&err);
277 dbus_connection_close(g_conn_sender);
278 dbus_connection_close(g_conn_listener);
280 dbus_connection_unref(g_conn_sender);
281 dbus_connection_unref(g_conn_listener);
283 g_conn_sender = NULL;
284 g_conn_listener = NULL;
289 int vc_dbus_reconnect()
291 bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
292 bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
293 SLOG(LOG_DEBUG, TAG_VCC, "[DBUS] Sender(%s) Listener(%s)",
294 sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
296 if (false == sender_connected || false == listener_connected) {
297 vc_dbus_close_connection();
299 if (0 != vc_dbus_open_connection()) {
300 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to reconnect");
304 SLOG(LOG_DEBUG, TAG_VCC, "[DBUS] Reconnect");
310 static int __dbus_check()
312 if (NULL == g_conn_sender) {
313 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection");
314 return vc_dbus_reconnect();
319 int vc_dbus_request_hello()
321 if (0 != __dbus_check()) {
322 return VC_ERROR_OPERATION_FAILED;
327 msg = dbus_message_new_method_call(
328 VC_SERVER_SERVICE_NAME,
329 VC_SERVER_SERVICE_OBJECT_PATH,
330 VC_SERVER_SERVICE_INTERFACE,
334 SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc hello : Fail to make message");
335 return VC_ERROR_OPERATION_FAILED;
339 dbus_error_init(&err);
341 DBusMessage* result_msg = NULL;
344 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, 500, &err);
346 if (dbus_error_is_set(&err)) {
347 dbus_error_free(&err);
350 dbus_message_unref(msg);
352 if (NULL != result_msg) {
353 dbus_message_unref(result_msg);
356 result = VC_ERROR_TIMED_OUT;
363 int vc_dbus_request_initialize(int pid, int* mgr_pid, int* service_state, int* daemon_pid)
365 if (0 != __dbus_check()) {
366 return VC_ERROR_OPERATION_FAILED;
371 msg = dbus_message_new_method_call(
372 VC_SERVER_SERVICE_NAME,
373 VC_SERVER_SERVICE_OBJECT_PATH,
374 VC_SERVER_SERVICE_INTERFACE,
375 VC_METHOD_INITIALIZE);
378 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc initialize : Fail to make message ");
379 return VC_ERROR_OPERATION_FAILED;
381 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc initialize : pid(%d)", pid);
384 dbus_message_append_args(msg,
385 DBUS_TYPE_INT32, &pid,
389 dbus_error_init(&err);
391 DBusMessage* result_msg;
392 int result = VC_ERROR_OPERATION_FAILED;
394 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
395 dbus_message_unref(msg);
397 if (dbus_error_is_set(&err)) {
398 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
399 dbus_error_free(&err);
402 if (NULL != result_msg) {
404 int tmp_service_state = 0;
405 int tmp_daemon_pid = 0;
406 dbus_message_get_args(result_msg, &err,
407 DBUS_TYPE_INT32, &result,
408 DBUS_TYPE_INT32, &tmp,
409 DBUS_TYPE_INT32, &tmp_service_state,
410 DBUS_TYPE_INT32, &tmp_daemon_pid,
413 if (dbus_error_is_set(&err)) {
414 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
415 dbus_error_free(&err);
416 result = VC_ERROR_OPERATION_FAILED;
419 dbus_message_unref(result_msg);
423 *service_state = tmp_service_state;
424 *daemon_pid = tmp_daemon_pid;
425 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc initialize : result = %d mgr = %d service = %d daemon_pid = %d", result, *mgr_pid, *service_state, *daemon_pid);
427 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc initialize : result = %d", result);
430 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL ");
432 result = VC_ERROR_TIMED_OUT;
438 int vc_dbus_request_finalize(int pid)
440 if (0 != __dbus_check()) {
441 return VC_ERROR_OPERATION_FAILED;
446 msg = dbus_message_new_method_call(
447 VC_SERVER_SERVICE_NAME,
448 VC_SERVER_SERVICE_OBJECT_PATH,
449 VC_SERVER_SERVICE_INTERFACE,
453 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc finalize : Fail to make message ");
454 return VC_ERROR_OPERATION_FAILED;
456 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc finalize : pid(%d)", pid);
459 dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
462 dbus_error_init(&err);
464 DBusMessage* result_msg;
465 int result = VC_ERROR_OPERATION_FAILED;
467 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
468 dbus_message_unref(msg);
470 if (dbus_error_is_set(&err)) {
471 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
472 dbus_error_free(&err);
475 if (NULL != result_msg) {
476 dbus_message_get_args(result_msg, &err,
477 DBUS_TYPE_INT32, &result,
480 if (dbus_error_is_set(&err)) {
481 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
482 dbus_error_free(&err);
483 result = VC_ERROR_OPERATION_FAILED;
486 dbus_message_unref(result_msg);
489 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc finalize : result = %d", result);
491 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc finalize : result = %d", result);
494 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL ");
496 result = VC_ERROR_TIMED_OUT;
502 int vc_dbus_request_set_exclusive_command(int pid, bool value)
504 if (0 != __dbus_check()) {
505 return VC_ERROR_OPERATION_FAILED;
510 msg = dbus_message_new_method_call(
511 VC_SERVER_SERVICE_NAME,
512 VC_SERVER_SERVICE_OBJECT_PATH,
513 VC_SERVER_SERVICE_INTERFACE,
514 VC_METHOD_SET_EXCLUSIVE_CMD);
517 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set exclusive command : Fail to make message");
518 return VC_ERROR_OPERATION_FAILED;
520 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set exclusive command : pid(%d)", pid);
525 dbus_message_append_args(msg,
526 DBUS_TYPE_INT32, &pid,
527 DBUS_TYPE_INT32, &temp,
531 dbus_error_init(&err);
533 DBusMessage* result_msg;
534 int result = VC_ERROR_OPERATION_FAILED;
536 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
537 dbus_message_unref(msg);
539 if (dbus_error_is_set(&err)) {
540 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus 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,
549 if (dbus_error_is_set(&err)) {
550 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
551 dbus_error_free(&err);
552 result = VC_ERROR_OPERATION_FAILED;
554 dbus_message_unref(result_msg);
557 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc set exclusive command : result = %d", result);
559 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc set exclusive command : result = %d", result);
562 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
564 result = VC_ERROR_TIMED_OUT;
570 int vc_dbus_request_set_command(int pid, vc_cmd_type_e cmd_type)
572 if (0 != __dbus_check()) {
573 return VC_ERROR_OPERATION_FAILED;
578 msg = dbus_message_new_method_call(
579 VC_SERVER_SERVICE_NAME,
580 VC_SERVER_SERVICE_OBJECT_PATH,
581 VC_SERVER_SERVICE_INTERFACE,
582 VC_METHOD_SET_COMMAND);
585 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set command : Fail to make message");
586 return VC_ERROR_OPERATION_FAILED;
588 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set command : pid(%d)", pid);
591 dbus_message_append_args(msg,
592 DBUS_TYPE_INT32, &pid,
593 DBUS_TYPE_INT32, &cmd_type,
597 dbus_error_init(&err);
599 DBusMessage* result_msg;
600 int result = VC_ERROR_OPERATION_FAILED;
602 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
603 dbus_message_unref(msg);
605 if (dbus_error_is_set(&err)) {
606 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
607 dbus_error_free(&err);
610 if (NULL != result_msg) {
611 dbus_message_get_args(result_msg, &err,
612 DBUS_TYPE_INT32, &result,
615 if (dbus_error_is_set(&err)) {
616 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
617 dbus_error_free(&err);
618 result = VC_ERROR_OPERATION_FAILED;
620 dbus_message_unref(result_msg);
623 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc set command : result = %d", result);
625 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc set command : result = %d", result);
628 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
630 result = VC_ERROR_TIMED_OUT;
636 int vc_dbus_request_unset_command(int pid, vc_cmd_type_e cmd_type)
638 if (0 != __dbus_check()) {
639 return VC_ERROR_OPERATION_FAILED;
644 msg = dbus_message_new_method_call(
645 VC_SERVER_SERVICE_NAME,
646 VC_SERVER_SERVICE_OBJECT_PATH,
647 VC_SERVER_SERVICE_INTERFACE,
648 VC_METHOD_UNSET_COMMAND);
651 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc unset command : Fail to make message");
652 return VC_ERROR_OPERATION_FAILED;
654 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc unset command : pid(%d), type(%d)", pid, cmd_type);
657 dbus_message_append_args(msg,
658 DBUS_TYPE_INT32, &pid,
659 DBUS_TYPE_INT32, &cmd_type,
663 dbus_error_init(&err);
665 DBusMessage* result_msg;
666 int result = VC_ERROR_OPERATION_FAILED;
668 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
669 dbus_message_unref(msg);
671 if (dbus_error_is_set(&err)) {
672 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
673 dbus_error_free(&err);
676 if (NULL != result_msg) {
677 dbus_message_get_args(result_msg, &err,
678 DBUS_TYPE_INT32, &result,
681 if (dbus_error_is_set(&err)) {
682 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
683 dbus_error_free(&err);
684 result = VC_ERROR_OPERATION_FAILED;
686 dbus_message_unref(result_msg);
689 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc unset command : result = %d", result);
691 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc unset command : result = %d", result);
694 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
696 result = VC_ERROR_TIMED_OUT;
702 int vc_dbus_set_foreground(int pid, bool value)
704 if (0 != __dbus_check()) {
705 return VC_ERROR_OPERATION_FAILED;
708 DBusMessage* msg = NULL;
711 tmp_value = (int)value;
713 msg = dbus_message_new_signal(
714 VC_MANAGER_SERVICE_OBJECT_PATH,
715 VC_MANAGER_SERVICE_INTERFACE,
716 VCC_MANAGER_METHOD_SET_FOREGROUND);
719 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set foreground to manager : Fail to make message");
720 return VC_ERROR_OPERATION_FAILED;
722 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set foreground to manager : client pid(%d), value(%s)", pid, tmp_value ? "true" : "false");
725 dbus_message_append_args(msg,
726 DBUS_TYPE_INT32, &pid,
727 DBUS_TYPE_INT32, &tmp_value,
730 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
731 SLOG(LOG_ERROR, TAG_VCC, "[Dbus ERROR] Fail to Send");
732 return VC_ERROR_OPERATION_FAILED;
735 dbus_message_unref(msg);
738 msg = dbus_message_new_method_call(
739 VC_SERVER_SERVICE_NAME,
740 VC_SERVER_SERVICE_OBJECT_PATH,
741 VC_SERVER_SERVICE_INTERFACE,
742 VC_METHOD_SET_FOREGROUND);
745 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set foreground to daemon : Fail to make message");
746 return VC_ERROR_OPERATION_FAILED;
748 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set foreground to daemon : client pid(%d), value(%s)", pid, tmp_value ? "true" : "false");
751 dbus_message_append_args(msg,
752 DBUS_TYPE_INT32, &pid,
753 DBUS_TYPE_INT32, &tmp_value,
756 dbus_message_set_no_reply(msg, TRUE);
758 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
759 SLOG(LOG_ERROR, TAG_VCC, "[Dbus ERROR] Fail to Send");
760 return VC_ERROR_OPERATION_FAILED;
763 dbus_connection_flush(g_conn_sender);
765 dbus_message_unref(msg);
770 int vc_dbus_request_dialog(int pid, const char* disp_text, const char* utt_text, bool continuous)
772 if (NULL == g_conn_sender) {
773 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection");
774 if (0 != vc_dbus_reconnect()) {
775 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to reconnect");
780 int tmp_continue = 0;
782 tmp_continue = (int)continuous;
784 msg = dbus_message_new_method_call(
785 VC_SERVER_SERVICE_NAME,
786 VC_SERVER_SERVICE_OBJECT_PATH,
787 VC_SERVER_SERVICE_INTERFACE,
791 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc request dialog to manager : Fail to make message");
792 return VC_ERROR_OPERATION_FAILED;
794 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);
797 dbus_message_append_args(msg,
798 DBUS_TYPE_INT32, &pid,
799 DBUS_TYPE_STRING, &disp_text,
800 DBUS_TYPE_STRING, &utt_text,
801 DBUS_TYPE_INT32, &tmp_continue,
805 dbus_error_init(&err);
807 DBusMessage* result_msg;
808 int result = VC_ERROR_OPERATION_FAILED;
810 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
811 dbus_message_unref(msg);
813 if (dbus_error_is_set(&err)) {
814 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
815 dbus_error_free(&err);
818 if (NULL != result_msg) {
819 dbus_message_get_args(result_msg, &err,
820 DBUS_TYPE_INT32, &result,
823 if (dbus_error_is_set(&err)) {
824 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
825 dbus_error_free(&err);
826 result = VC_ERROR_OPERATION_FAILED;
828 dbus_message_unref(result_msg);
831 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc set command : result = %d", result);
833 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc set command : result = %d", result);
836 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
838 result = VC_ERROR_TIMED_OUT;
844 int vc_dbus_request_is_system_command_valid(int pid, bool* is_sys_cmd_valid)
846 if (NULL == g_conn_sender) {
847 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection");
848 if (0 != vc_dbus_reconnect()) {
849 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to reconnect");
855 msg = dbus_message_new_method_call(
856 VC_SERVER_SERVICE_NAME,
857 VC_SERVER_SERVICE_OBJECT_PATH,
858 VC_SERVER_SERVICE_INTERFACE,
859 VC_METHOD_IS_SYS_COMMAND_VALID);
862 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc is system command valid : Fail to make message");
863 return VC_ERROR_OPERATION_FAILED;
865 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc is system command valid : pid(%d)", pid);
868 dbus_message_append_args(msg,
869 DBUS_TYPE_INT32, &pid,
873 dbus_error_init(&err);
876 DBusMessage* result_msg;
877 int result = VC_ERROR_OPERATION_FAILED;
879 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
880 dbus_message_unref(msg);
882 if (dbus_error_is_set(&err)) {
883 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
884 dbus_error_free(&err);
887 if (NULL != result_msg) {
888 dbus_message_get_args(result_msg, &err,
889 DBUS_TYPE_INT32, &result,
890 DBUS_TYPE_INT32, &tmp_sys_cmd,
893 if (dbus_error_is_set(&err)) {
894 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
895 dbus_error_free(&err);
896 result = VC_ERROR_OPERATION_FAILED;
898 dbus_message_unref(result_msg);
901 *is_sys_cmd_valid = (bool)tmp_sys_cmd;
902 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc is system command valid : result = %d, is_sys_cmd_valid = %d", result, *is_sys_cmd_valid);
904 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc is system command valid : result = %d", result);
907 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
909 result = VC_ERROR_TIMED_OUT;
917 int vc_dbus_request_start(int pid, int silence)
921 /* create a signal & check for errors */
922 msg = dbus_message_new_method_call(
923 VC_SERVER_SERVICE_NAME,
924 VC_SERVER_SERVICE_OBJECT_PATH,
925 VC_SERVER_SERVICE_INTERFACE,
926 VC_METHOD_REQUEST_START);
929 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc start : Fail to make message ");
930 return VC_ERROR_OPERATION_FAILED;
932 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc start : pid(%d), silence(%d)", pid, silence);
935 DBusMessageIter args;
936 dbus_message_iter_init_append(msg, &args);
939 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(pid));
940 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(silence));
943 dbus_error_init(&err);
945 DBusMessage* result_msg;
946 int result = VC_ERROR_OPERATION_FAILED;
948 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
949 dbus_message_unref(msg);
951 if (dbus_error_is_set(&err)) {
952 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
953 dbus_error_free(&err);
956 if (NULL != result_msg) {
957 dbus_message_get_args(result_msg, &err,
958 DBUS_TYPE_INT32, &result,
961 if (dbus_error_is_set(&err)) {
962 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
963 dbus_error_free(&err);
964 result = VC_ERROR_OPERATION_FAILED;
966 dbus_message_unref(result_msg);
969 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc start : result = %d", result);
971 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc start : result = %d", result);
974 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
976 result = VC_ERROR_TIMED_OUT;
982 int vc_dbus_request_stop(int pid)
986 /* create a signal & check for errors */
987 msg = dbus_message_new_method_call(
988 VC_SERVER_SERVICE_NAME,
989 VC_SERVER_SERVICE_OBJECT_PATH,
990 VC_SERVER_SERVICE_INTERFACE,
991 VC_METHOD_REQUEST_STOP);
994 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc stop : Fail to make message ");
995 return VC_ERROR_OPERATION_FAILED;
997 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc stop : pid(%d)", pid);
1000 dbus_message_append_args(msg,
1001 DBUS_TYPE_INT32, &pid,
1005 dbus_error_init(&err);
1007 DBusMessage* result_msg;
1008 int result = VC_ERROR_OPERATION_FAILED;
1010 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1011 dbus_message_unref(msg);
1013 if (dbus_error_is_set(&err)) {
1014 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1015 dbus_error_free(&err);
1018 if (NULL != result_msg) {
1019 dbus_message_get_args(result_msg, &err,
1020 DBUS_TYPE_INT32, &result,
1023 if (dbus_error_is_set(&err)) {
1024 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1025 dbus_error_free(&err);
1026 result = VC_ERROR_OPERATION_FAILED;
1028 dbus_message_unref(result_msg);
1031 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc stop : result = %d", result);
1033 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc stop : result = %d", result);
1036 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1037 vc_dbus_reconnect();
1038 result = VC_ERROR_TIMED_OUT;
1044 int vc_dbus_request_cancel(int pid)
1048 /* create a signal & check for errors */
1049 msg = dbus_message_new_method_call(
1050 VC_SERVER_SERVICE_NAME,
1051 VC_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
1052 VC_SERVER_SERVICE_INTERFACE, /* interface name of the signal */
1053 VC_METHOD_REQUEST_CANCEL); /* name of the signal */
1056 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc cancel : Fail to make message ");
1057 return VC_ERROR_OPERATION_FAILED;
1059 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc cancel : pid(%d)", pid);
1062 dbus_message_append_args(msg,
1063 DBUS_TYPE_INT32, &pid,
1067 dbus_error_init(&err);
1069 DBusMessage* result_msg;
1070 int result = VC_ERROR_OPERATION_FAILED;
1072 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1073 dbus_message_unref(msg);
1075 if (dbus_error_is_set(&err)) {
1076 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1077 dbus_error_free(&err);
1080 if (NULL != result_msg) {
1081 dbus_message_get_args(result_msg, &err,
1082 DBUS_TYPE_INT32, &result,
1085 if (dbus_error_is_set(&err)) {
1086 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1087 dbus_error_free(&err);
1088 result = VC_ERROR_OPERATION_FAILED;
1090 dbus_message_unref(result_msg);
1093 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc cancel : result = %d", result);
1095 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc cancel : result = %d", result);
1098 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1099 vc_dbus_reconnect();
1100 result = VC_ERROR_TIMED_OUT;
1108 int vc_dbus_request_auth_enable(int pid, int mgr_pid)
1110 if (0 != __dbus_check()) {
1111 return VC_ERROR_OPERATION_FAILED;
1116 char service_name[64] = {0,};
1117 char object_path[64] = {0,};
1118 char target_if_name[128] = {0,};
1120 snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1121 snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1122 snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1124 /* create a signal & check for errors */
1125 msg = dbus_message_new_method_call(
1127 object_path, /* object name of the signal */
1128 target_if_name, /* interface name of the signal */
1129 VC_METHOD_AUTH_ENABLE); /* name of the signal */
1132 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth enable : Fail to make message ");
1133 return VC_ERROR_OPERATION_FAILED;
1135 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth enable : pid(%d)", pid);
1138 dbus_message_append_args(msg,
1139 DBUS_TYPE_INT32, &pid,
1143 dbus_error_init(&err);
1145 DBusMessage* result_msg;
1146 int result = VC_ERROR_OPERATION_FAILED;
1148 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1149 dbus_message_unref(msg);
1151 if (dbus_error_is_set(&err)) {
1152 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1153 dbus_error_free(&err);
1156 if (NULL != result_msg) {
1157 dbus_message_get_args(result_msg, &err,
1158 DBUS_TYPE_INT32, &result,
1161 if (dbus_error_is_set(&err)) {
1162 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1163 dbus_error_free(&err);
1164 result = VC_ERROR_OPERATION_FAILED;
1166 dbus_message_unref(result_msg);
1169 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth enable : result = %d", result);
1171 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth enable : result = %d", result);
1174 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1175 vc_dbus_reconnect();
1176 result = VC_ERROR_TIMED_OUT;
1182 int vc_dbus_request_auth_disable(int pid, int mgr_pid)
1184 if (0 != __dbus_check()) {
1185 return VC_ERROR_OPERATION_FAILED;
1190 char service_name[64] = {0,};
1191 char object_path[64] = {0,};
1192 char target_if_name[128] = {0,};
1194 snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1195 snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1196 snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1198 /* create a signal & check for errors */
1199 msg = dbus_message_new_method_call(
1201 object_path, /* object name of the signal */
1202 target_if_name, /* interface name of the signal */
1203 VC_METHOD_AUTH_DISABLE); /* name of the signal */
1206 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth disable : Fail to make message ");
1207 return VC_ERROR_OPERATION_FAILED;
1209 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth disable : pid(%d)", pid);
1212 dbus_message_append_args(msg,
1213 DBUS_TYPE_INT32, &pid,
1217 dbus_error_init(&err);
1219 DBusMessage* result_msg;
1220 int result = VC_ERROR_OPERATION_FAILED;
1222 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1223 dbus_message_unref(msg);
1225 if (dbus_error_is_set(&err)) {
1226 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1227 dbus_error_free(&err);
1230 if (NULL != result_msg) {
1231 dbus_message_get_args(result_msg, &err,
1232 DBUS_TYPE_INT32, &result,
1235 if (dbus_error_is_set(&err)) {
1236 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1237 dbus_error_free(&err);
1238 result = VC_ERROR_OPERATION_FAILED;
1240 dbus_message_unref(result_msg);
1243 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth disable : result = %d", result);
1245 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth disable : result = %d", result);
1248 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1249 vc_dbus_reconnect();
1250 result = VC_ERROR_TIMED_OUT;
1256 int vc_dbus_request_auth_start(int pid, int mgr_pid)
1258 if (0 != __dbus_check()) {
1259 return VC_ERROR_OPERATION_FAILED;
1264 char service_name[64] = {0,};
1265 char object_path[64] = {0,};
1266 char target_if_name[128] = {0,};
1268 snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1269 snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1270 snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1272 /* create a signal & check for errors */
1273 msg = dbus_message_new_method_call(
1277 VC_METHOD_AUTH_START);
1280 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth start : Fail to make message ");
1281 return VC_ERROR_OPERATION_FAILED;
1283 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth start : pid(%d)", pid);
1286 DBusMessageIter args;
1287 dbus_message_iter_init_append(msg, &args);
1290 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(pid));
1293 dbus_error_init(&err);
1295 DBusMessage* result_msg;
1296 int result = VC_ERROR_OPERATION_FAILED;
1298 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1299 dbus_message_unref(msg);
1301 if (dbus_error_is_set(&err)) {
1302 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1303 dbus_error_free(&err);
1306 if (NULL != result_msg) {
1307 dbus_message_get_args(result_msg, &err,
1308 DBUS_TYPE_INT32, &result,
1311 if (dbus_error_is_set(&err)) {
1312 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1313 dbus_error_free(&err);
1314 result = VC_ERROR_OPERATION_FAILED;
1316 dbus_message_unref(result_msg);
1319 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth start : result = %d", result);
1321 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth start : result = %d", result);
1324 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1325 vc_dbus_reconnect();
1326 result = VC_ERROR_TIMED_OUT;
1332 int vc_dbus_request_auth_stop(int pid, int mgr_pid)
1334 if (0 != __dbus_check()) {
1335 return VC_ERROR_OPERATION_FAILED;
1340 char service_name[64] = {0,};
1341 char object_path[64] = {0,};
1342 char target_if_name[128] = {0,};
1344 snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1345 snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1346 snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1348 /* create a signal & check for errors */
1349 msg = dbus_message_new_method_call(
1353 VC_METHOD_AUTH_STOP);
1356 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth stop : Fail to make message ");
1357 return VC_ERROR_OPERATION_FAILED;
1359 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth stop : pid(%d)", pid);
1362 dbus_message_append_args(msg,
1363 DBUS_TYPE_INT32, &pid,
1367 dbus_error_init(&err);
1369 DBusMessage* result_msg;
1370 int result = VC_ERROR_OPERATION_FAILED;
1372 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1373 dbus_message_unref(msg);
1375 if (dbus_error_is_set(&err)) {
1376 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1377 dbus_error_free(&err);
1380 if (NULL != result_msg) {
1381 dbus_message_get_args(result_msg, &err,
1382 DBUS_TYPE_INT32, &result,
1385 if (dbus_error_is_set(&err)) {
1386 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1387 dbus_error_free(&err);
1388 result = VC_ERROR_OPERATION_FAILED;
1390 dbus_message_unref(result_msg);
1393 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth stop : result = %d", result);
1395 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth stop : result = %d", result);
1398 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1399 vc_dbus_reconnect();
1400 result = VC_ERROR_TIMED_OUT;
1406 int vc_dbus_request_auth_cancel(int pid, int mgr_pid)
1408 if (0 != __dbus_check()) {
1409 return VC_ERROR_OPERATION_FAILED;
1414 char service_name[64] = {0,};
1415 char object_path[64] = {0,};
1416 char target_if_name[128] = {0,};
1418 snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1419 snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1420 snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1422 /* create a signal & check for errors */
1423 msg = dbus_message_new_method_call(
1425 object_path, /* object name of the signal */
1426 target_if_name, /* interface name of the signal */
1427 VC_METHOD_AUTH_CANCEL); /* name of the signal */
1430 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth cancel : Fail to make message ");
1431 return VC_ERROR_OPERATION_FAILED;
1433 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth cancel : pid(%d)", pid);
1436 dbus_message_append_args(msg,
1437 DBUS_TYPE_INT32, &pid,
1441 dbus_error_init(&err);
1443 DBusMessage* result_msg;
1444 int result = VC_ERROR_OPERATION_FAILED;
1446 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1447 dbus_message_unref(msg);
1449 if (dbus_error_is_set(&err)) {
1450 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1451 dbus_error_free(&err);
1454 if (NULL != result_msg) {
1455 dbus_message_get_args(result_msg, &err,
1456 DBUS_TYPE_INT32, &result,
1459 if (dbus_error_is_set(&err)) {
1460 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1461 dbus_error_free(&err);
1462 result = VC_ERROR_OPERATION_FAILED;
1464 dbus_message_unref(result_msg);
1467 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth cancel : result = %d", result);
1469 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth cancel : result = %d", result);
1472 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1473 vc_dbus_reconnect();
1474 result = VC_ERROR_TIMED_OUT;