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 */
163 else if (dbus_message_is_signal(msg, "org.freedesktop.DBus", "NameOwnerChanged")) {
164 SLOG(LOG_DEBUG, TAG_VCC, "===== Owner Changed");
166 dbus_error_init(&err);
167 /* remove a rule for daemon error */
168 char rule_err[256] = {0, };
169 snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", VC_SERVER_SERVICE_INTERFACE);
170 dbus_bus_remove_match(g_conn_listener, rule_err, &err);
171 dbus_connection_flush(g_conn_listener);
173 if (dbus_error_is_set(&err)) {
174 SLOG(LOG_ERROR, TAG_VCC, "Match Error (%s)", err.message);
175 dbus_error_free(&err);
177 __vc_cb_error(VC_ERROR_SERVICE_RESET, -1, "Daemon Reset");
178 SLOG(LOG_DEBUG, TAG_VCC, "=====");
179 SLOG(LOG_DEBUG, TAG_VCC, " ");
180 } /* NameOwnerChanged */
183 SLOG(LOG_DEBUG, TAG_VCC, "Message is NOT valid");
184 dbus_message_unref(msg);
188 /* free the message */
189 dbus_message_unref(msg);
192 return ECORE_CALLBACK_PASS_ON;
195 static void __vc_dbus_connection_free()
197 if (NULL != g_conn_listener) {
198 dbus_connection_close(g_conn_listener);
199 dbus_connection_unref(g_conn_listener);
200 g_conn_listener = NULL;
202 if (NULL != g_conn_sender) {
203 dbus_connection_close(g_conn_sender);
204 dbus_connection_unref(g_conn_sender);
205 g_conn_sender = NULL;
209 int vc_dbus_open_connection()
211 if (NULL != g_conn_sender && NULL != g_conn_listener) {
212 SLOG(LOG_WARN, TAG_VCC, "already existed connection ");
219 /* initialise the error value */
220 dbus_error_init(&err);
222 /* connect to the DBUS system bus, and check for errors */
223 g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
225 if (dbus_error_is_set(&err)) {
226 SLOG(LOG_ERROR, TAG_VCC, "Dbus Connection Error (%s)", err.message);
227 dbus_error_free(&err);
230 if (NULL == g_conn_sender) {
231 SLOG(LOG_ERROR, TAG_VCC, "Fail to get dbus connection ");
232 return VC_ERROR_OPERATION_FAILED;
235 g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
237 if (dbus_error_is_set(&err)) {
238 SLOG(LOG_ERROR, TAG_VCC, "Dbus Connection Error (%s)", err.message);
239 dbus_error_free(&err);
242 if (NULL == g_conn_listener) {
243 SLOG(LOG_ERROR, TAG_VCC, "Fail to get dbus connection ");
244 __vc_dbus_connection_free();
245 return VC_ERROR_OPERATION_FAILED;
250 char service_name[64];
251 memset(service_name, '\0', 64);
252 snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
254 SLOG(LOG_DEBUG, TAG_VCC, "service name is %s", service_name);
256 /* register our name on the bus, and check for errors */
257 ret = dbus_bus_request_name(g_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
259 if (dbus_error_is_set(&err)) {
260 SLOG(LOG_ERROR, TAG_VCC, "Name Error (%s)", err.message);
261 dbus_error_free(&err);
264 if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
265 SLOG(LOG_ERROR, TAG_VCC, "fail dbus_bus_request_name()");
266 __vc_dbus_connection_free();
270 if (NULL != g_fd_handler) {
271 SLOG(LOG_WARN, TAG_VCC, "The handler already exists.");
272 __vc_dbus_connection_free();
276 char rule[128] = {0, };
277 snprintf(rule, 128, "type='signal',interface='%s'", VC_CLIENT_SERVICE_INTERFACE);
279 /* add a rule for which messages we want to see */
280 dbus_bus_add_match(g_conn_listener, rule, &err);
281 dbus_connection_flush(g_conn_listener);
283 if (dbus_error_is_set(&err)) {
284 SLOG(LOG_ERROR, TAG_VCC, "Match Error (%s)", err.message);
285 dbus_error_free(&err);
286 __vc_dbus_connection_free();
287 return VC_ERROR_OPERATION_FAILED;
291 if (1 != dbus_connection_get_unix_fd(g_conn_listener, &fd)) {
292 SLOG(LOG_ERROR, TAG_VCC, "fail to get fd from dbus ");
293 __vc_dbus_connection_free();
294 return VC_ERROR_OPERATION_FAILED;
296 SLOG(LOG_DEBUG, TAG_VCC, "Get fd from dbus : %d", fd);
299 g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
300 if (NULL == g_fd_handler) {
301 SLOG(LOG_ERROR, TAG_VCC, "fail to get fd handler from ecore ");
302 __vc_dbus_connection_free();
303 return VC_ERROR_OPERATION_FAILED;
309 int vc_dbus_close_connection()
312 dbus_error_init(&err);
314 if (NULL != g_fd_handler) {
315 ecore_main_fd_handler_del(g_fd_handler);
321 char service_name[64];
322 memset(service_name, '\0', 64);
323 snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
325 dbus_bus_release_name(g_conn_listener, service_name, &err);
327 if (dbus_error_is_set(&err)) {
328 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
329 dbus_error_free(&err);
332 __vc_dbus_connection_free();
337 int vc_dbus_reconnect()
339 if (!g_conn_sender || !g_conn_listener) {
340 vc_dbus_close_connection();
342 if (0 != vc_dbus_open_connection()) {
343 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to reconnect");
347 SLOG(LOG_DEBUG, TAG_VCC, "[DBUS] Reconnect");
351 bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
352 bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
353 SLOG(LOG_WARN, TAG_VCC, "[DBUS] Sender(%s) Listener(%s)",
354 sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
356 if (false == sender_connected || false == listener_connected) {
357 vc_dbus_close_connection();
359 if (0 != vc_dbus_open_connection()) {
360 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to reconnect");
364 SLOG(LOG_DEBUG, TAG_VCC, "[DBUS] Reconnect");
370 static int __dbus_check()
372 if (NULL == g_conn_sender) {
373 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection");
374 return vc_dbus_reconnect();
379 int vc_dbus_request_hello()
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,
394 SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc hello : Fail to make message");
395 return VC_ERROR_OPERATION_FAILED;
399 dbus_error_init(&err);
401 DBusMessage* result_msg = NULL;
404 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, 500, &err);
406 if (dbus_error_is_set(&err)) {
407 dbus_error_free(&err);
410 dbus_message_unref(msg);
412 if (NULL != result_msg) {
413 dbus_message_unref(result_msg);
416 result = VC_ERROR_TIMED_OUT;
423 int vc_dbus_request_initialize(int pid, int* mgr_pid, int* service_state, int* daemon_pid)
425 if (0 != __dbus_check()) {
426 return VC_ERROR_OPERATION_FAILED;
431 msg = dbus_message_new_method_call(
432 VC_SERVER_SERVICE_NAME,
433 VC_SERVER_SERVICE_OBJECT_PATH,
434 VC_SERVER_SERVICE_INTERFACE,
435 VC_METHOD_INITIALIZE);
438 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc initialize : Fail to make message ");
439 return VC_ERROR_OPERATION_FAILED;
441 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc initialize : pid(%d)", pid);
444 dbus_message_append_args(msg,
445 DBUS_TYPE_INT32, &pid,
449 dbus_error_init(&err);
451 DBusMessage* result_msg;
452 int result = VC_ERROR_OPERATION_FAILED;
454 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
455 dbus_message_unref(msg);
457 if (dbus_error_is_set(&err)) {
458 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
459 dbus_error_free(&err);
462 if (NULL != result_msg) {
464 int tmp_service_state = 0;
465 int tmp_daemon_pid = 0;
466 dbus_message_get_args(result_msg, &err,
467 DBUS_TYPE_INT32, &result,
468 DBUS_TYPE_INT32, &tmp,
469 DBUS_TYPE_INT32, &tmp_service_state,
470 DBUS_TYPE_INT32, &tmp_daemon_pid,
473 if (dbus_error_is_set(&err)) {
474 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
475 dbus_error_free(&err);
476 result = VC_ERROR_OPERATION_FAILED;
479 dbus_message_unref(result_msg);
483 *service_state = tmp_service_state;
484 *daemon_pid = tmp_daemon_pid;
486 /* add a rule for daemon error */
487 char rule_err[256] = {0, };
488 snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", VC_SERVER_SERVICE_INTERFACE);
489 dbus_bus_add_match(g_conn_listener, rule_err, &err);
490 dbus_connection_flush(g_conn_listener);
492 if (dbus_error_is_set(&err)) {
493 SLOG(LOG_ERROR, TAG_VCC, "Match Error (%s)", err.message);
494 dbus_error_free(&err);
495 return VC_ERROR_OPERATION_FAILED;
498 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc initialize : result = %d mgr = %d service = %d daemon_pid = %d", result, *mgr_pid, *service_state, *daemon_pid);
500 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc initialize : result = %d", result);
503 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL ");
505 result = VC_ERROR_TIMED_OUT;
511 int vc_dbus_request_finalize(int pid)
514 dbus_error_init(&err);
516 if (0 != __dbus_check()) {
517 return VC_ERROR_OPERATION_FAILED;
520 /* remove a rule for daemon error */
521 char rule_err[256] = {0, };
522 snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", VC_SERVER_SERVICE_INTERFACE);
523 dbus_bus_remove_match(g_conn_listener, rule_err, &err);
524 dbus_connection_flush(g_conn_listener);
526 if (dbus_error_is_set(&err)) {
527 SLOG(LOG_ERROR, TAG_VCC, "Match Error (%s)", err.message);
528 dbus_error_free(&err);
533 msg = dbus_message_new_method_call(
534 VC_SERVER_SERVICE_NAME,
535 VC_SERVER_SERVICE_OBJECT_PATH,
536 VC_SERVER_SERVICE_INTERFACE,
540 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc finalize : Fail to make message ");
541 return VC_ERROR_OPERATION_FAILED;
543 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc finalize : pid(%d)", pid);
546 dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
548 DBusMessage* result_msg;
549 int result = VC_ERROR_OPERATION_FAILED;
551 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
552 dbus_message_unref(msg);
554 if (dbus_error_is_set(&err)) {
555 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
556 dbus_error_free(&err);
559 if (NULL != result_msg) {
560 dbus_message_get_args(result_msg, &err,
561 DBUS_TYPE_INT32, &result,
564 if (dbus_error_is_set(&err)) {
565 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
566 dbus_error_free(&err);
567 result = VC_ERROR_OPERATION_FAILED;
570 dbus_message_unref(result_msg);
573 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc finalize : result = %d", result);
575 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc finalize : 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_exclusive_command(int pid, bool value)
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_EXCLUSIVE_CMD);
601 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set exclusive command : Fail to make message");
602 return VC_ERROR_OPERATION_FAILED;
604 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set exclusive command : pid(%d)", pid);
609 dbus_message_append_args(msg,
610 DBUS_TYPE_INT32, &pid,
611 DBUS_TYPE_INT32, &temp,
615 dbus_error_init(&err);
617 DBusMessage* result_msg;
618 int result = VC_ERROR_OPERATION_FAILED;
620 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
621 dbus_message_unref(msg);
623 if (dbus_error_is_set(&err)) {
624 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
625 dbus_error_free(&err);
628 if (NULL != result_msg) {
629 dbus_message_get_args(result_msg, &err,
630 DBUS_TYPE_INT32, &result,
633 if (dbus_error_is_set(&err)) {
634 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
635 dbus_error_free(&err);
636 result = VC_ERROR_OPERATION_FAILED;
638 dbus_message_unref(result_msg);
641 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc set exclusive command : result = %d", result);
643 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc set exclusive command : result = %d", result);
646 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
648 result = VC_ERROR_TIMED_OUT;
654 int vc_dbus_request_set_command(int pid, vc_cmd_type_e cmd_type)
656 if (0 != __dbus_check()) {
657 return VC_ERROR_OPERATION_FAILED;
662 msg = dbus_message_new_method_call(
663 VC_SERVER_SERVICE_NAME,
664 VC_SERVER_SERVICE_OBJECT_PATH,
665 VC_SERVER_SERVICE_INTERFACE,
666 VC_METHOD_SET_COMMAND);
669 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set command : Fail to make message");
670 return VC_ERROR_OPERATION_FAILED;
672 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set command : pid(%d)", pid);
675 dbus_message_append_args(msg,
676 DBUS_TYPE_INT32, &pid,
677 DBUS_TYPE_INT32, &cmd_type,
681 dbus_error_init(&err);
683 DBusMessage* result_msg;
684 int result = VC_ERROR_OPERATION_FAILED;
686 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
687 dbus_message_unref(msg);
689 if (dbus_error_is_set(&err)) {
690 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
691 dbus_error_free(&err);
694 if (NULL != result_msg) {
695 dbus_message_get_args(result_msg, &err,
696 DBUS_TYPE_INT32, &result,
699 if (dbus_error_is_set(&err)) {
700 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
701 dbus_error_free(&err);
702 result = VC_ERROR_OPERATION_FAILED;
704 dbus_message_unref(result_msg);
707 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc set command : result = %d", result);
709 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc set command : result = %d", result);
712 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
714 result = VC_ERROR_TIMED_OUT;
720 int vc_dbus_request_unset_command(int pid, vc_cmd_type_e cmd_type)
722 if (0 != __dbus_check()) {
723 return VC_ERROR_OPERATION_FAILED;
728 msg = dbus_message_new_method_call(
729 VC_SERVER_SERVICE_NAME,
730 VC_SERVER_SERVICE_OBJECT_PATH,
731 VC_SERVER_SERVICE_INTERFACE,
732 VC_METHOD_UNSET_COMMAND);
735 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc unset command : Fail to make message");
736 return VC_ERROR_OPERATION_FAILED;
738 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc unset command : pid(%d), type(%d)", pid, cmd_type);
741 dbus_message_append_args(msg,
742 DBUS_TYPE_INT32, &pid,
743 DBUS_TYPE_INT32, &cmd_type,
747 dbus_error_init(&err);
749 DBusMessage* result_msg;
750 int result = VC_ERROR_OPERATION_FAILED;
752 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
753 dbus_message_unref(msg);
755 if (dbus_error_is_set(&err)) {
756 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
757 dbus_error_free(&err);
760 if (NULL != result_msg) {
761 dbus_message_get_args(result_msg, &err,
762 DBUS_TYPE_INT32, &result,
765 if (dbus_error_is_set(&err)) {
766 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
767 dbus_error_free(&err);
768 result = VC_ERROR_OPERATION_FAILED;
770 dbus_message_unref(result_msg);
773 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc unset command : result = %d", result);
775 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc unset command : result = %d", result);
778 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
780 result = VC_ERROR_TIMED_OUT;
786 int vc_dbus_set_foreground(int pid, bool value)
788 if (0 != __dbus_check()) {
789 return VC_ERROR_OPERATION_FAILED;
792 DBusMessage* msg = NULL;
795 tmp_value = (int)value;
797 msg = dbus_message_new_signal(
798 VC_MANAGER_SERVICE_OBJECT_PATH,
799 VC_MANAGER_SERVICE_INTERFACE,
800 VCC_MANAGER_METHOD_SET_FOREGROUND);
803 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set foreground to manager : Fail to make message");
804 return VC_ERROR_OPERATION_FAILED;
806 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set foreground to manager : client pid(%d), value(%s)", pid, tmp_value ? "true" : "false");
809 dbus_message_append_args(msg,
810 DBUS_TYPE_INT32, &pid,
811 DBUS_TYPE_INT32, &tmp_value,
814 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
815 SLOG(LOG_ERROR, TAG_VCC, "[Dbus ERROR] Fail to Send");
816 return VC_ERROR_OPERATION_FAILED;
819 dbus_message_unref(msg);
822 msg = dbus_message_new_method_call(
823 VC_SERVER_SERVICE_NAME,
824 VC_SERVER_SERVICE_OBJECT_PATH,
825 VC_SERVER_SERVICE_INTERFACE,
826 VC_METHOD_SET_FOREGROUND);
829 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set foreground to daemon : Fail to make message");
830 return VC_ERROR_OPERATION_FAILED;
832 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set foreground to daemon : client pid(%d), value(%s)", pid, tmp_value ? "true" : "false");
835 dbus_message_append_args(msg,
836 DBUS_TYPE_INT32, &pid,
837 DBUS_TYPE_INT32, &tmp_value,
840 dbus_message_set_no_reply(msg, TRUE);
842 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
843 SLOG(LOG_ERROR, TAG_VCC, "[Dbus ERROR] Fail to Send");
844 return VC_ERROR_OPERATION_FAILED;
847 dbus_connection_flush(g_conn_sender);
849 dbus_message_unref(msg);
854 int vc_dbus_request_dialog(int pid, const char* disp_text, const char* utt_text, bool continuous)
856 if (NULL == g_conn_sender) {
857 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection");
858 if (0 != vc_dbus_reconnect()) {
859 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to reconnect");
864 int tmp_continue = 0;
866 tmp_continue = (int)continuous;
868 msg = dbus_message_new_method_call(
869 VC_SERVER_SERVICE_NAME,
870 VC_SERVER_SERVICE_OBJECT_PATH,
871 VC_SERVER_SERVICE_INTERFACE,
875 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc request dialog to manager : Fail to make message");
876 return VC_ERROR_OPERATION_FAILED;
878 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);
881 dbus_message_append_args(msg,
882 DBUS_TYPE_INT32, &pid,
883 DBUS_TYPE_STRING, &disp_text,
884 DBUS_TYPE_STRING, &utt_text,
885 DBUS_TYPE_INT32, &tmp_continue,
888 dbus_message_set_no_reply(msg, TRUE);
890 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
891 SLOG(LOG_ERROR, TAG_VCC, "[Dbus ERROR] Fail to Send");
892 return VC_ERROR_OPERATION_FAILED;
894 SLOG(LOG_DEBUG, TAG_VCC, "[Dbus DEBUG] Success to Send");
895 dbus_connection_flush(g_conn_sender);
898 dbus_message_unref(msg);
904 dbus_error_init(&err);
906 DBusMessage* result_msg;
907 int result = VC_ERROR_OPERATION_FAILED;
909 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
910 dbus_message_unref(msg);
912 if (dbus_error_is_set(&err)) {
913 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
914 dbus_error_free(&err);
917 if (NULL != result_msg) {
918 dbus_message_get_args(result_msg, &err,
919 DBUS_TYPE_INT32, &result,
922 if (dbus_error_is_set(&err)) {
923 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
924 dbus_error_free(&err);
925 result = VC_ERROR_OPERATION_FAILED;
927 dbus_message_unref(result_msg);
930 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc set command : result = %d", result);
932 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc set command : result = %d", result);
935 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
937 result = VC_ERROR_TIMED_OUT;
944 int vc_dbus_request_is_system_command_valid(int pid, bool* is_sys_cmd_valid)
946 if (NULL == g_conn_sender) {
947 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection");
948 if (0 != vc_dbus_reconnect()) {
949 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to reconnect");
955 msg = dbus_message_new_method_call(
956 VC_SERVER_SERVICE_NAME,
957 VC_SERVER_SERVICE_OBJECT_PATH,
958 VC_SERVER_SERVICE_INTERFACE,
959 VC_METHOD_IS_SYS_COMMAND_VALID);
962 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc is system command valid : Fail to make message");
963 return VC_ERROR_OPERATION_FAILED;
965 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc is system command valid : pid(%d)", pid);
968 dbus_message_append_args(msg,
969 DBUS_TYPE_INT32, &pid,
973 dbus_error_init(&err);
976 DBusMessage* result_msg;
977 int result = VC_ERROR_OPERATION_FAILED;
979 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
980 dbus_message_unref(msg);
982 if (dbus_error_is_set(&err)) {
983 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
984 dbus_error_free(&err);
987 if (NULL != result_msg) {
988 dbus_message_get_args(result_msg, &err,
989 DBUS_TYPE_INT32, &result,
990 DBUS_TYPE_INT32, &tmp_sys_cmd,
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 *is_sys_cmd_valid = (bool)tmp_sys_cmd;
1002 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc is system command valid : result = %d, is_sys_cmd_valid = %d", result, *is_sys_cmd_valid);
1004 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc is system command valid : result = %d", result);
1007 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
1008 vc_dbus_reconnect();
1009 result = VC_ERROR_TIMED_OUT;
1017 int vc_dbus_request_start(int pid, int silence)
1021 /* create a signal & check for errors */
1022 msg = dbus_message_new_method_call(
1023 VC_SERVER_SERVICE_NAME,
1024 VC_SERVER_SERVICE_OBJECT_PATH,
1025 VC_SERVER_SERVICE_INTERFACE,
1026 VC_METHOD_REQUEST_START);
1029 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc start : Fail to make message ");
1030 return VC_ERROR_OPERATION_FAILED;
1032 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc start : pid(%d), silence(%d)", pid, silence);
1035 DBusMessageIter args;
1036 dbus_message_iter_init_append(msg, &args);
1039 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(pid));
1040 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(silence));
1043 dbus_error_init(&err);
1045 DBusMessage* result_msg;
1046 int result = VC_ERROR_OPERATION_FAILED;
1048 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1049 dbus_message_unref(msg);
1051 if (dbus_error_is_set(&err)) {
1052 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1053 dbus_error_free(&err);
1056 if (NULL != result_msg) {
1057 dbus_message_get_args(result_msg, &err,
1058 DBUS_TYPE_INT32, &result,
1061 if (dbus_error_is_set(&err)) {
1062 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1063 dbus_error_free(&err);
1064 result = VC_ERROR_OPERATION_FAILED;
1066 dbus_message_unref(result_msg);
1069 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc start : result = %d", result);
1071 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc start : result = %d", result);
1074 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1075 vc_dbus_reconnect();
1076 result = VC_ERROR_TIMED_OUT;
1082 int vc_dbus_request_stop(int pid)
1086 /* create a signal & check for errors */
1087 msg = dbus_message_new_method_call(
1088 VC_SERVER_SERVICE_NAME,
1089 VC_SERVER_SERVICE_OBJECT_PATH,
1090 VC_SERVER_SERVICE_INTERFACE,
1091 VC_METHOD_REQUEST_STOP);
1094 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc stop : Fail to make message ");
1095 return VC_ERROR_OPERATION_FAILED;
1097 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc stop : pid(%d)", pid);
1100 dbus_message_append_args(msg,
1101 DBUS_TYPE_INT32, &pid,
1105 dbus_error_init(&err);
1107 DBusMessage* result_msg;
1108 int result = VC_ERROR_OPERATION_FAILED;
1110 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1111 dbus_message_unref(msg);
1113 if (dbus_error_is_set(&err)) {
1114 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1115 dbus_error_free(&err);
1118 if (NULL != result_msg) {
1119 dbus_message_get_args(result_msg, &err,
1120 DBUS_TYPE_INT32, &result,
1123 if (dbus_error_is_set(&err)) {
1124 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1125 dbus_error_free(&err);
1126 result = VC_ERROR_OPERATION_FAILED;
1128 dbus_message_unref(result_msg);
1131 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc stop : result = %d", result);
1133 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc stop : result = %d", result);
1136 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1137 vc_dbus_reconnect();
1138 result = VC_ERROR_TIMED_OUT;
1144 int vc_dbus_request_cancel(int pid)
1148 /* create a signal & check for errors */
1149 msg = dbus_message_new_method_call(
1150 VC_SERVER_SERVICE_NAME,
1151 VC_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
1152 VC_SERVER_SERVICE_INTERFACE, /* interface name of the signal */
1153 VC_METHOD_REQUEST_CANCEL); /* name of the signal */
1156 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc cancel : Fail to make message ");
1157 return VC_ERROR_OPERATION_FAILED;
1159 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc cancel : pid(%d)", pid);
1162 dbus_message_append_args(msg,
1163 DBUS_TYPE_INT32, &pid,
1167 dbus_error_init(&err);
1169 DBusMessage* result_msg;
1170 int result = VC_ERROR_OPERATION_FAILED;
1172 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1173 dbus_message_unref(msg);
1175 if (dbus_error_is_set(&err)) {
1176 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1177 dbus_error_free(&err);
1180 if (NULL != result_msg) {
1181 dbus_message_get_args(result_msg, &err,
1182 DBUS_TYPE_INT32, &result,
1185 if (dbus_error_is_set(&err)) {
1186 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1187 dbus_error_free(&err);
1188 result = VC_ERROR_OPERATION_FAILED;
1190 dbus_message_unref(result_msg);
1193 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc cancel : result = %d", result);
1195 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc cancel : result = %d", result);
1198 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1199 vc_dbus_reconnect();
1200 result = VC_ERROR_TIMED_OUT;
1208 int vc_dbus_request_auth_enable(int pid, int mgr_pid)
1210 if (0 != __dbus_check()) {
1211 return VC_ERROR_OPERATION_FAILED;
1216 char service_name[64] = {0,};
1217 char object_path[64] = {0,};
1218 char target_if_name[128] = {0,};
1220 snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1221 snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1222 snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1224 /* create a signal & check for errors */
1225 msg = dbus_message_new_method_call(
1227 object_path, /* object name of the signal */
1228 target_if_name, /* interface name of the signal */
1229 VC_METHOD_AUTH_ENABLE); /* name of the signal */
1232 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth enable : Fail to make message ");
1233 return VC_ERROR_OPERATION_FAILED;
1235 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth enable : pid(%d)", pid);
1238 dbus_message_append_args(msg,
1239 DBUS_TYPE_INT32, &pid,
1243 dbus_error_init(&err);
1245 DBusMessage* result_msg;
1246 int result = VC_ERROR_OPERATION_FAILED;
1248 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1249 dbus_message_unref(msg);
1251 if (dbus_error_is_set(&err)) {
1252 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1253 dbus_error_free(&err);
1256 if (NULL != result_msg) {
1257 dbus_message_get_args(result_msg, &err,
1258 DBUS_TYPE_INT32, &result,
1261 if (dbus_error_is_set(&err)) {
1262 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1263 dbus_error_free(&err);
1264 result = VC_ERROR_OPERATION_FAILED;
1266 dbus_message_unref(result_msg);
1269 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth enable : result = %d", result);
1271 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth enable : result = %d", result);
1274 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1275 vc_dbus_reconnect();
1276 result = VC_ERROR_TIMED_OUT;
1282 int vc_dbus_request_auth_disable(int pid, int mgr_pid)
1284 if (0 != __dbus_check()) {
1285 return VC_ERROR_OPERATION_FAILED;
1290 char service_name[64] = {0,};
1291 char object_path[64] = {0,};
1292 char target_if_name[128] = {0,};
1294 snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1295 snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1296 snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1298 /* create a signal & check for errors */
1299 msg = dbus_message_new_method_call(
1301 object_path, /* object name of the signal */
1302 target_if_name, /* interface name of the signal */
1303 VC_METHOD_AUTH_DISABLE); /* name of the signal */
1306 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth disable : Fail to make message ");
1307 return VC_ERROR_OPERATION_FAILED;
1309 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth disable : pid(%d)", pid);
1312 dbus_message_append_args(msg,
1313 DBUS_TYPE_INT32, &pid,
1317 dbus_error_init(&err);
1319 DBusMessage* result_msg;
1320 int result = VC_ERROR_OPERATION_FAILED;
1322 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1323 dbus_message_unref(msg);
1325 if (dbus_error_is_set(&err)) {
1326 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1327 dbus_error_free(&err);
1330 if (NULL != result_msg) {
1331 dbus_message_get_args(result_msg, &err,
1332 DBUS_TYPE_INT32, &result,
1335 if (dbus_error_is_set(&err)) {
1336 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1337 dbus_error_free(&err);
1338 result = VC_ERROR_OPERATION_FAILED;
1340 dbus_message_unref(result_msg);
1343 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth disable : result = %d", result);
1345 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth disable : result = %d", result);
1348 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1349 vc_dbus_reconnect();
1350 result = VC_ERROR_TIMED_OUT;
1356 int vc_dbus_request_auth_start(int pid, int mgr_pid)
1358 if (0 != __dbus_check()) {
1359 return VC_ERROR_OPERATION_FAILED;
1364 char service_name[64] = {0,};
1365 char object_path[64] = {0,};
1366 char target_if_name[128] = {0,};
1368 snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1369 snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1370 snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1372 /* create a signal & check for errors */
1373 msg = dbus_message_new_method_call(
1377 VC_METHOD_AUTH_START);
1380 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth start : Fail to make message ");
1381 return VC_ERROR_OPERATION_FAILED;
1383 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth start : pid(%d)", pid);
1386 DBusMessageIter args;
1387 dbus_message_iter_init_append(msg, &args);
1390 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(pid));
1393 dbus_error_init(&err);
1395 DBusMessage* result_msg;
1396 int result = VC_ERROR_OPERATION_FAILED;
1398 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1399 dbus_message_unref(msg);
1401 if (dbus_error_is_set(&err)) {
1402 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1403 dbus_error_free(&err);
1406 if (NULL != result_msg) {
1407 dbus_message_get_args(result_msg, &err,
1408 DBUS_TYPE_INT32, &result,
1411 if (dbus_error_is_set(&err)) {
1412 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1413 dbus_error_free(&err);
1414 result = VC_ERROR_OPERATION_FAILED;
1416 dbus_message_unref(result_msg);
1419 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth start : result = %d", result);
1421 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth start : result = %d", result);
1424 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1425 vc_dbus_reconnect();
1426 result = VC_ERROR_TIMED_OUT;
1432 int vc_dbus_request_auth_stop(int pid, int mgr_pid)
1434 if (0 != __dbus_check()) {
1435 return VC_ERROR_OPERATION_FAILED;
1440 char service_name[64] = {0,};
1441 char object_path[64] = {0,};
1442 char target_if_name[128] = {0,};
1444 snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1445 snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1446 snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1448 /* create a signal & check for errors */
1449 msg = dbus_message_new_method_call(
1453 VC_METHOD_AUTH_STOP);
1456 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth stop : Fail to make message ");
1457 return VC_ERROR_OPERATION_FAILED;
1459 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth stop : pid(%d)", pid);
1462 dbus_message_append_args(msg,
1463 DBUS_TYPE_INT32, &pid,
1467 dbus_error_init(&err);
1469 DBusMessage* result_msg;
1470 int result = VC_ERROR_OPERATION_FAILED;
1472 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1473 dbus_message_unref(msg);
1475 if (dbus_error_is_set(&err)) {
1476 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1477 dbus_error_free(&err);
1480 if (NULL != result_msg) {
1481 dbus_message_get_args(result_msg, &err,
1482 DBUS_TYPE_INT32, &result,
1485 if (dbus_error_is_set(&err)) {
1486 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1487 dbus_error_free(&err);
1488 result = VC_ERROR_OPERATION_FAILED;
1490 dbus_message_unref(result_msg);
1493 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth stop : result = %d", result);
1495 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth stop : result = %d", result);
1498 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1499 vc_dbus_reconnect();
1500 result = VC_ERROR_TIMED_OUT;
1506 int vc_dbus_request_auth_cancel(int pid, int mgr_pid)
1508 if (0 != __dbus_check()) {
1509 return VC_ERROR_OPERATION_FAILED;
1514 char service_name[64] = {0,};
1515 char object_path[64] = {0,};
1516 char target_if_name[128] = {0,};
1518 snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1519 snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1520 snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1522 /* create a signal & check for errors */
1523 msg = dbus_message_new_method_call(
1525 object_path, /* object name of the signal */
1526 target_if_name, /* interface name of the signal */
1527 VC_METHOD_AUTH_CANCEL); /* name of the signal */
1530 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth cancel : Fail to make message ");
1531 return VC_ERROR_OPERATION_FAILED;
1533 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth cancel : pid(%d)", pid);
1536 dbus_message_append_args(msg,
1537 DBUS_TYPE_INT32, &pid,
1541 dbus_error_init(&err);
1543 DBusMessage* result_msg;
1544 int result = VC_ERROR_OPERATION_FAILED;
1546 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1547 dbus_message_unref(msg);
1549 if (dbus_error_is_set(&err)) {
1550 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1551 dbus_error_free(&err);
1554 if (NULL != result_msg) {
1555 dbus_message_get_args(result_msg, &err,
1556 DBUS_TYPE_INT32, &result,
1559 if (dbus_error_is_set(&err)) {
1560 SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1561 dbus_error_free(&err);
1562 result = VC_ERROR_OPERATION_FAILED;
1564 dbus_message_unref(result_msg);
1567 SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth cancel : result = %d", result);
1569 SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth cancel : result = %d", result);
1572 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1573 vc_dbus_reconnect();
1574 result = VC_ERROR_TIMED_OUT;