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.
17 #include <dbus/dbus.h>
18 #include "vcd_client_data.h"
20 #include "vcd_dbus_server.h"
24 static DBusConnection* g_conn_sender = NULL;
25 static DBusConnection* g_conn_listener = NULL;
27 static Ecore_Fd_Handler* g_dbus_fd_handler = NULL;
29 static int g_waiting_time = 3000;
31 static int g_volume_count = 0;
34 static DBusMessage* __get_message(int pid, const char* method, vcd_client_type_e type)
36 char service_name[64] = {0,};
37 char object_path[64] = {0,};
38 char target_if_name[128] = {0,};
40 if (VCD_CLIENT_TYPE_NORMAL == type) {
41 snprintf(service_name, 64, "%s%d", VC_CLIENT_SERVICE_NAME, pid);
42 snprintf(object_path, 64, "%s", VC_CLIENT_SERVICE_OBJECT_PATH);
43 snprintf(target_if_name, 128, "%s", VC_CLIENT_SERVICE_INTERFACE);
44 } else if (VCD_CLIENT_TYPE_WIDGET == type) {
45 snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
46 snprintf(object_path, 64, "%s", VC_WIDGET_SERVICE_OBJECT_PATH);
47 snprintf(target_if_name, 128, "%s", VC_WIDGET_SERVICE_INTERFACE);
48 } else if (VCD_CLIENT_TYPE_MANAGER == type) {
49 snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
50 snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
51 snprintf(target_if_name, 128, "%s", VC_MANAGER_SERVICE_INTERFACE);
56 return dbus_message_new_method_call(service_name, object_path, target_if_name, method);
59 int vcd_dbus_reconnect()
61 bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
62 bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
63 SLOG(LOG_WARN, TAG_VCD, "[DBUS] Sender(%s) Listener(%s)",
64 sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
66 if (false == sender_connected || false == listener_connected) {
67 vcd_dbus_close_connection();
69 if (0 != vcd_dbus_open_connection()) {
70 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to reconnect");
74 SLOG(LOG_DEBUG, TAG_VCD, "[DBUS] Reconnect");
80 static int __dbus_check()
82 if (NULL == g_conn_sender || NULL == g_conn_listener) {
83 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] NULL connection");
84 return vcd_dbus_reconnect();
89 int vcd_check_dbus_connection()
91 if (NULL == g_conn_sender || NULL == g_conn_listener) {
92 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] NULL connection sender(%p), listener(%p)", g_conn_sender, g_conn_listener);
98 int vcdc_send_hello(int pid, vcd_client_type_e type)
100 if (0 != __dbus_check()) {
101 return VCD_ERROR_OPERATION_FAILED;
104 DBusMessage* msg = NULL;
106 if (VCD_CLIENT_TYPE_NORMAL == type) {
107 msg = __get_message(pid, VCD_METHOD_HELLO, VCD_CLIENT_TYPE_NORMAL);
108 } else if (VCD_CLIENT_TYPE_WIDGET == type) {
109 msg = __get_message(pid, VCD_WIDGET_METHOD_HELLO, VCD_CLIENT_TYPE_WIDGET);
110 } else if (VCD_CLIENT_TYPE_MANAGER == type) {
111 msg = __get_message(pid, VCD_MANAGER_METHOD_HELLO, VCD_CLIENT_TYPE_MANAGER);
113 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Client type is NOT valid");
118 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
119 return VCD_ERROR_OUT_OF_MEMORY;
122 dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
125 dbus_error_init(&err);
127 DBusMessage* result_msg;
130 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
131 dbus_message_unref(msg);
133 if (dbus_error_is_set(&err)) {
134 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] %s", err.message);
135 if (NULL != err.name) {
136 if (!strcmp(err.name, DBUS_ERROR_SERVICE_UNKNOWN)) {
137 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Unknown service. Client is not available");
138 dbus_error_free(&err);
142 dbus_error_free(&err);
145 if (NULL != result_msg) {
146 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
148 if (dbus_error_is_set(&err)) {
149 SLOG(LOG_ERROR, TAG_VCD, "[Dbus] Get arguments error (%s)", err.message);
150 dbus_error_free(&err);
151 result = VCD_ERROR_OPERATION_FAILED;
154 dbus_message_unref(result_msg);
156 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result message is NULL. Client is not available");
162 int vcdc_send_show_tooltip(int pid, bool show)
164 if (0 != __dbus_check()) {
165 return VCD_ERROR_OPERATION_FAILED;
169 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] widget pid is NOT valid");
173 char service_name[64] = {0, };
174 memset(service_name, 0, 64);
175 snprintf(service_name, 64, "%s%d", VC_WIDGET_SERVICE_NAME, pid);
177 char target_if_name[128] = {0, };
178 snprintf(target_if_name, sizeof(target_if_name), "%s", VC_WIDGET_SERVICE_INTERFACE);
182 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send widget show tooltip signal : pid(%d) show(%d)", pid, show);
184 msg = dbus_message_new_method_call(
186 VC_WIDGET_SERVICE_OBJECT_PATH,
188 VCD_WIDGET_METHOD_SHOW_TOOLTIP);
191 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
192 return VCD_ERROR_OUT_OF_MEMORY;
195 int temp = (int)show;
197 DBusMessageIter args;
198 dbus_message_iter_init_append(msg, &args);
200 /* Append pid & type */
201 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &pid);
202 dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(temp));
204 dbus_message_set_no_reply(msg, TRUE);
206 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
207 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
208 return VCD_ERROR_OPERATION_FAILED;
210 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
211 dbus_connection_flush(g_conn_sender);
214 dbus_message_unref(msg);
219 int vcdc_send_set_volume(int manger_pid, float volume)
221 if (0 != __dbus_check()) {
222 return VCD_ERROR_OPERATION_FAILED;
225 DBusMessage* msg = NULL;
227 /* SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Set volume (%f)", volume); */
229 msg = dbus_message_new_signal(
230 VC_MANAGER_SERVICE_OBJECT_PATH,
231 VC_MANAGER_SERVICE_INTERFACE,
232 VCD_MANAGER_METHOD_SET_VOLUME);
235 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
236 return VCD_ERROR_OUT_OF_MEMORY;
239 dbus_message_append_args(msg, DBUS_TYPE_INT32, &volume, DBUS_TYPE_INVALID);
241 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
242 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
243 dbus_message_unref(msg);
246 if (10 == g_volume_count) {
247 SLOG(LOG_DEBUG, TAG_VCD, "@@ Send set volume : pid(%d), volume(%f)", manger_pid, volume);
251 dbus_connection_flush(g_conn_sender);
256 dbus_message_unref(msg);
261 int vcdc_send_result(int pid, int manager_pid, int cmd_type)
263 if (0 != __dbus_check()) {
264 return VCD_ERROR_OPERATION_FAILED;
267 DBusMessage* msg = NULL;
269 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result command type(%d)", cmd_type);
272 case VC_COMMAND_TYPE_FOREGROUND:
273 case VC_COMMAND_TYPE_BACKGROUND:
274 if (pid == manager_pid) {
275 msg = __get_message(pid, VCD_MANAGER_METHOD_RESULT, VCD_CLIENT_TYPE_MANAGER);
277 msg = __get_message(pid, VCD_METHOD_RESULT, VCD_CLIENT_TYPE_NORMAL);
280 case VC_COMMAND_TYPE_WIDGET:
281 msg = __get_message(pid, VCD_WIDGET_METHOD_RESULT, VCD_CLIENT_TYPE_WIDGET);
283 case VC_COMMAND_TYPE_SYSTEM:
284 case VC_COMMAND_TYPE_SYSTEM_BACKGROUND:
285 case VC_COMMAND_TYPE_EXCLUSIVE:
286 msg = __get_message(pid, VCD_MANAGER_METHOD_RESULT, VCD_CLIENT_TYPE_MANAGER);
290 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Command type is NOT valid(%d)", cmd_type);
295 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
296 return VCD_ERROR_OUT_OF_MEMORY;
299 dbus_message_set_no_reply(msg, TRUE);
301 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
302 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
303 return VCD_ERROR_OPERATION_FAILED;
305 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
306 dbus_connection_flush(g_conn_sender);
309 dbus_message_unref(msg);
314 int vcdc_send_asr_result(int pid, int event, const char* asr_result, int cmd_type, bool* is_consumed)
316 if (0 != __dbus_check()) {
317 return VCD_ERROR_OPERATION_FAILED;
320 DBusMessage* msg = NULL;
322 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result command type(%d)", cmd_type);
325 case VC_COMMAND_TYPE_WIDGET:
326 msg = __get_message(pid, VCD_WIDGET_METHOD_ASR_RESULT, VCD_CLIENT_TYPE_WIDGET);
329 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Command type is NOT valid(%d)", cmd_type);
330 return VCD_ERROR_INVALID_PARAMETER;
334 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
335 return VCD_ERROR_OUT_OF_MEMORY;
338 dbus_message_append_args(msg, DBUS_TYPE_INT32, &event, DBUS_TYPE_STRING, &asr_result, DBUS_TYPE_INVALID);
341 dbus_error_init(&err);
343 DBusMessage* result_msg;
346 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, 5000, &err);
347 dbus_message_unref(msg);
349 if (dbus_error_is_set(&err)) {
350 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Dbus Error (%s)", err.message);
351 dbus_error_free(&err);
354 if (NULL != result_msg) {
355 dbus_message_get_args(result_msg, &err,
356 DBUS_TYPE_INT32, &result,
359 if (dbus_error_is_set(&err)) {
360 SLOG(LOG_ERROR, TAG_VCD, "@@ Get arguments error (%s)", err.message);
361 dbus_error_free(&err);
362 result = VCD_ERROR_OPERATION_FAILED;
365 dbus_message_unref(result_msg);
366 SLOG(LOG_DEBUG, TAG_VCD, "@@ vc send asr result : result = %d", result);
367 *is_consumed = result;
368 return VCD_ERROR_NONE;
370 SLOG(LOG_ERROR, TAG_VCD, "@@ Result message is NULL ");
371 return VCD_ERROR_OPERATION_FAILED;
375 int vcdc_send_pre_result_to_manager(int manager_pid, int event, const char* pre_result)
377 if (0 != __dbus_check()) {
378 return VCD_ERROR_OPERATION_FAILED;
382 dbus_error_init(&err);
384 DBusMessage* msg = NULL;
386 msg = __get_message(manager_pid, VCD_MANAGER_METHOD_PRE_RESULT, VCD_CLIENT_TYPE_MANAGER);
389 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
390 return VCD_ERROR_OUT_OF_MEMORY;
393 dbus_message_append_args(msg, DBUS_TYPE_INT32, &event, DBUS_TYPE_STRING, &pre_result, DBUS_TYPE_INVALID);
395 dbus_message_set_no_reply(msg, TRUE);
397 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
398 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
399 return VCD_ERROR_OPERATION_FAILED;
401 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
402 dbus_connection_flush(g_conn_sender);
408 int vcdc_send_result_to_manager(int manger_pid, int result_type)
410 if (0 != __dbus_check()) {
411 return VCD_ERROR_OPERATION_FAILED;
415 dbus_error_init(&err);
417 DBusMessage* msg = NULL;
419 msg = __get_message(manger_pid, VCD_MANAGER_METHOD_ALL_RESULT, VCD_CLIENT_TYPE_MANAGER);
422 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
423 return VCD_ERROR_OUT_OF_MEMORY;
426 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send result : result type(%d)", result_type);
428 dbus_message_append_args(msg, DBUS_TYPE_INT32, &result_type, DBUS_TYPE_INVALID);
430 dbus_message_set_no_reply(msg, TRUE);
432 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
433 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
434 return VCD_ERROR_OPERATION_FAILED;
436 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
437 dbus_connection_flush(g_conn_sender);
440 dbus_message_unref(msg);
445 int vcdc_send_speech_detected(int manger_pid)
447 if (0 != __dbus_check()) {
448 return VCD_ERROR_OPERATION_FAILED;
452 dbus_error_init(&err);
454 /* Send to manager */
455 DBusMessage* msg = NULL;
457 msg = __get_message(manger_pid, VCD_MANAGER_METHOD_SPEECH_DETECTED, VCD_CLIENT_TYPE_MANAGER);
460 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
461 return VCD_ERROR_OUT_OF_MEMORY;
464 dbus_message_set_no_reply(msg, TRUE);
466 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
467 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
468 return VCD_ERROR_OPERATION_FAILED;
470 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
471 dbus_connection_flush(g_conn_sender);
474 dbus_message_unref(msg);
479 int vcdc_send_service_state(vcd_state_e state)
481 if (0 != __dbus_check()) {
482 return VCD_ERROR_OPERATION_FAILED;
486 dbus_error_init(&err);
488 DBusMessage* msg = NULL;
490 msg = __get_message(vcd_client_manager_get_pid(), VCD_MANAGER_METHOD_SET_SERVICE_STATE, VCD_CLIENT_TYPE_MANAGER);
493 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
494 return VCD_ERROR_OUT_OF_MEMORY;
497 dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
499 dbus_message_set_no_reply(msg, TRUE);
501 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
502 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
503 return VCD_ERROR_OPERATION_FAILED;
505 SLOG(LOG_DEBUG, TAG_VCD, "@@ Send service state message to manager : state(%d)", state);
506 dbus_connection_flush(g_conn_sender);
509 dbus_message_unref(msg);
514 msg = dbus_message_new_signal(
515 VC_CLIENT_SERVICE_OBJECT_PATH,
516 VC_CLIENT_SERVICE_INTERFACE,
517 VCD_METHOD_SET_SERVICE_STATE);
520 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
521 return VCD_ERROR_OUT_OF_MEMORY;
524 dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
526 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
527 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
528 return VCD_ERROR_OPERATION_FAILED;
530 SLOG(LOG_DEBUG, TAG_VCD, "@@ Send service state message to client : state(%d)", state);
531 dbus_connection_flush(g_conn_sender);
534 dbus_message_unref(msg);
538 /* Send to widget client */
539 msg = dbus_message_new_signal(
540 VC_WIDGET_SERVICE_OBJECT_PATH,
541 VC_WIDGET_SERVICE_INTERFACE,
542 VCD_WIDGET_METHOD_SET_SERVICE_STATE);
545 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
546 return VCD_ERROR_OUT_OF_MEMORY;
549 dbus_message_append_args(msg, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
551 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
552 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
553 return VCD_ERROR_OPERATION_FAILED;
555 SLOG(LOG_DEBUG, TAG_VCD, "@@ Send service state message to widget client : state(%d)", state);
556 dbus_connection_flush(g_conn_sender);
559 dbus_message_unref(msg);
564 int vcdc_send_manager_pid(int manager_pid)
567 dbus_error_init(&err);
569 DBusMessage* msg = NULL;
572 msg = dbus_message_new_signal(
573 VC_CLIENT_SERVICE_OBJECT_PATH,
574 VC_CLIENT_SERVICE_INTERFACE,
575 VCD_METHOD_SEND_MANAGER_PID);
578 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
579 return VCD_ERROR_OUT_OF_MEMORY;
582 dbus_message_append_args(msg, DBUS_TYPE_INT32, &manager_pid, DBUS_TYPE_INVALID);
584 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
585 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
586 return VCD_ERROR_OPERATION_FAILED;
588 SLOG(LOG_DEBUG, TAG_VCD, "@@ Send manager pid to client : pid(%d)", manager_pid);
589 dbus_connection_flush(g_conn_sender);
592 dbus_message_unref(msg);
597 int vcdc_send_dialog(int manger_pid, int pid, const char* disp_text, const char* utt_text, int continuous)
599 if (0 != __dbus_check()) {
600 return VCD_ERROR_OPERATION_FAILED;
604 dbus_error_init(&err);
606 DBusMessage* msg = NULL;
608 msg = __get_message(manger_pid, VCD_MANAGER_METHOD_DIALOG, VCD_CLIENT_TYPE_MANAGER);
611 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
612 return VCD_ERROR_OUT_OF_MEMORY;
615 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] send dialog : pid(%d), disp_text(%s), utt_text(%s), continue(%d)", pid, disp_text, utt_text, continuous);
617 char* disp_null = NULL;
618 char* utt_null = NULL;
619 int ret = VCD_ERROR_NONE;
620 if (NULL == disp_text) {
621 disp_null = strdup("#NULL");
622 disp_text = disp_null;
625 if (NULL == utt_text) {
626 utt_null = strdup("#NULL");
630 dbus_message_append_args(msg,
631 DBUS_TYPE_INT32, &pid,
632 DBUS_TYPE_STRING, &disp_text,
633 DBUS_TYPE_STRING, &utt_text,
634 DBUS_TYPE_INT32, &continuous,
637 dbus_message_set_no_reply(msg, TRUE);
639 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
640 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
641 ret = VCD_ERROR_OPERATION_FAILED;
643 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send");
644 dbus_connection_flush(g_conn_sender);
647 dbus_message_unref(msg);
649 if (NULL != disp_null) {
654 if (NULL != utt_null) {
662 int vcdc_send_error_signal_to_manager(int manager_pid, int reason, char *err_msg)
664 SLOG(LOG_ERROR, TAG_VCD, "@@ Send error signal to manager");
666 if (0 != __dbus_check()) {
667 return VCD_ERROR_OPERATION_FAILED;
672 dbus_error_init(&err);
674 DBusMessage* msg = NULL;
676 msg = dbus_message_new_signal(
677 VC_MANAGER_SERVICE_OBJECT_PATH,
678 VC_MANAGER_SERVICE_INTERFACE,
679 VCD_MANAGER_METHOD_ERROR);
682 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
683 return VCD_ERROR_OUT_OF_MEMORY;
686 char *temp_msg = NULL;
687 if (NULL == err_msg) {
688 SLOG(LOG_WARN, TAG_VCD, "[Dbus ERROR] Input parameter is NULL");
689 temp_msg = strdup("#NULL");
691 temp_msg = strdup(err_msg);
694 daemon_pid = getpid();
695 dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &temp_msg, DBUS_TYPE_INVALID);
697 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
698 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
699 if (NULL != temp_msg) {
703 return VCD_ERROR_OPERATION_FAILED;
705 SLOG(LOG_DEBUG, TAG_VCD, "@@ Send error signal to manager : reason(%d), Error Msg(%s)", reason, temp_msg);
706 dbus_connection_flush(g_conn_sender);
709 dbus_message_unref(msg);
710 if (NULL != temp_msg) {
718 int vcdc_send_error_signal(int reason, char *err_msg)
720 SLOG(LOG_ERROR, TAG_VCD, "@@ Send error signal");
722 if (NULL == err_msg) {
723 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Input parameter is NULL");
724 return VCD_ERROR_INVALID_PARAMETER;
727 if (0 != __dbus_check()) {
728 return VCD_ERROR_OPERATION_FAILED;
733 dbus_error_init(&err);
735 DBusMessage* msg = NULL;
737 msg = dbus_message_new_signal(
738 VC_MANAGER_SERVICE_OBJECT_PATH,
739 VC_MANAGER_SERVICE_INTERFACE,
740 VCD_MANAGER_METHOD_ERROR);
743 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
744 return VCD_ERROR_OUT_OF_MEMORY;
747 daemon_pid = getpid();
748 dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
750 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
751 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
752 return VCD_ERROR_OPERATION_FAILED;
754 SLOG(LOG_DEBUG, TAG_VCD, "@@ Send error signal to manager: reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
755 dbus_connection_flush(g_conn_sender);
758 dbus_message_unref(msg);
761 msg = dbus_message_new_signal(
762 VC_CLIENT_SERVICE_OBJECT_PATH,
763 VC_CLIENT_SERVICE_INTERFACE,
767 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
768 return VCD_ERROR_OUT_OF_MEMORY;
771 dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
773 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
774 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
775 return VCD_ERROR_OPERATION_FAILED;
777 SLOG(LOG_DEBUG, TAG_VCD, "@@ Send error signal : reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
778 dbus_connection_flush(g_conn_sender);
781 dbus_message_unref(msg);
784 msg = dbus_message_new_signal(
785 VC_WIDGET_SERVICE_OBJECT_PATH,
786 VC_WIDGET_SERVICE_INTERFACE,
787 VCD_WIDGET_METHOD_ERROR);
790 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Message is NULL");
791 return VCD_ERROR_OUT_OF_MEMORY;
794 dbus_message_append_args(msg, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INT32, &daemon_pid, DBUS_TYPE_STRING, &err_msg, DBUS_TYPE_INVALID);
796 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
797 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send");
798 return VCD_ERROR_OPERATION_FAILED;
800 SLOG(LOG_DEBUG, TAG_VCD, "@@ Send error signal to widget : reason(%d), daemon_pid(%d), Error Msg(%s)", reason, daemon_pid, err_msg);
801 dbus_connection_flush(g_conn_sender);
804 dbus_message_unref(msg);
809 int vcdc_send_request_set_private_data(int pid, const char* key, const char* data)
811 if (0 != __dbus_check()) {
812 return VCD_ERROR_OPERATION_FAILED;
815 DBusMessage* msg = NULL;
816 msg = __get_message(pid, VCD_MANAGER_METHOD_SET_PRIVATE_DATA, VCD_CLIENT_TYPE_MANAGER);
818 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
819 return VCD_ERROR_OUT_OF_MEMORY;
822 dbus_message_append_args(msg,
823 DBUS_TYPE_INT32, &pid,
824 DBUS_TYPE_STRING, &key,
825 DBUS_TYPE_STRING, &data,
828 dbus_message_set_no_reply(msg, TRUE);
830 if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
831 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to Send request set private data");
832 dbus_message_unref(msg);
833 return VCD_ERROR_OPERATION_FAILED;
835 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] SUCCESS Send request set private data");
836 dbus_connection_flush(g_conn_sender);
839 dbus_message_unref(msg);
841 return VCD_ERROR_NONE;
844 int vcdc_send_request_get_private_data(int pid, const char* key, char** data)
846 if (0 != __dbus_check()) {
847 return VCD_ERROR_OPERATION_FAILED;
850 DBusMessage* msg = NULL;
851 msg = __get_message(pid, VCD_MANAGER_METHOD_GET_PRIVATE_DATA, VCD_CLIENT_TYPE_MANAGER);
853 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to create message");
854 return VCD_ERROR_OUT_OF_MEMORY;
857 dbus_message_append_args(msg,
858 DBUS_TYPE_INT32, &pid,
859 DBUS_TYPE_STRING, &key,
863 dbus_error_init(&err);
865 DBusMessage* result_msg;
869 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
870 dbus_message_unref(msg);
872 if (dbus_error_is_set(&err)) {
873 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] %s", err.message);
874 if (NULL != err.name) {
875 if (!strcmp(err.name, DBUS_ERROR_SERVICE_UNKNOWN)) {
876 SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Unknown service. Client is not available");
877 dbus_error_free(&err);
881 dbus_error_free(&err);
884 if (NULL != result_msg) {
885 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_STRING, &temp, DBUS_TYPE_INVALID);
887 if (dbus_error_is_set(&err)) {
888 SLOG(LOG_ERROR, TAG_VCD, "[Dbus] Get arguments error (%s)", err.message);
889 dbus_error_free(&err);
890 result = VCD_ERROR_OPERATION_FAILED;
893 dbus_message_unref(result_msg);
895 SLOG(LOG_DEBUG, TAG_VCD, "[Dbus] Result message is NULL. Client is not available");
898 if (NULL != data && NULL != temp) {
899 *data = strdup(temp);
905 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
907 if (NULL == g_conn_listener) return ECORE_CALLBACK_RENEW;
909 dbus_connection_read_write_dispatch(g_conn_listener, 50);
912 DBusMessage* msg = NULL;
913 msg = dbus_connection_pop_message(g_conn_listener);
915 /* loop again if we haven't read a message */
921 if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_HELLO))
922 vcd_dbus_server_hello(g_conn_listener, msg);
925 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_INITIALIZE))
926 vcd_dbus_server_mgr_initialize(g_conn_listener, msg);
928 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_FINALIZE))
929 vcd_dbus_server_mgr_finalize(g_conn_listener, msg);
931 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_COMMAND))
932 vcd_dbus_server_mgr_set_command(g_conn_listener, msg);
934 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_UNSET_COMMAND))
935 vcd_dbus_server_mgr_unset_command(g_conn_listener, msg);
937 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_DEMANDABLE))
938 vcd_dbus_server_mgr_set_demandable_client(g_conn_listener, msg);
940 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_AUDIO_TYPE))
941 vcd_dbus_server_mgr_set_audio_type(g_conn_listener, msg);
943 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_GET_AUDIO_TYPE))
944 vcd_dbus_server_mgr_get_audio_type(g_conn_listener, msg);
946 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_CLIENT_INFO))
947 vcd_dbus_server_mgr_set_client_info(g_conn_listener, msg);
949 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_PRIVATE_DATA))
950 vcd_dbus_server_mgr_set_private_data(g_conn_listener, msg);
952 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_GET_PRIVATE_DATA))
953 vcd_dbus_server_mgr_get_private_data(g_conn_listener, msg);
955 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_START))
956 vcd_dbus_server_mgr_start(g_conn_listener, msg);
958 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_STOP))
959 vcd_dbus_server_mgr_stop(g_conn_listener, msg);
961 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_CANCEL))
962 vcd_dbus_server_mgr_cancel(g_conn_listener, msg);
964 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_RESULT_SELECTION))
965 vcd_dbus_server_mgr_result_selection(g_conn_listener, msg);
967 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SET_DOMAIN))
968 vcd_dbus_server_mgr_set_domain(g_conn_listener, msg);
970 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_DO_ACTION))
971 vcd_dbus_server_mgr_do_action(g_conn_listener, msg);
973 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_ENABLE_COMMAND_TYPE))
974 vcd_dbus_server_mgr_enable_command_type(g_conn_listener, msg);
976 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_DISABLE_COMMAND_TYPE))
977 vcd_dbus_server_mgr_disable_command_type(g_conn_listener, msg);
980 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_INITIALIZE))
981 vcd_dbus_server_initialize(g_conn_listener, msg);
983 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_FINALIZE))
984 vcd_dbus_server_finalize(g_conn_listener, msg);
986 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_EXCLUSIVE_CMD))
987 vcd_dbus_server_set_exclusive_command(g_conn_listener, msg);
989 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_COMMAND))
990 vcd_dbus_server_set_command(g_conn_listener, msg);
992 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_UNSET_COMMAND))
993 vcd_dbus_server_unset_command(g_conn_listener, msg);
995 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_SET_FOREGROUND))
996 vcd_dbus_server_set_foreground(g_conn_listener, msg);
998 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_DIALOG))
999 vcd_dbus_server_dialog(g_conn_listener, msg);
1001 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_IS_SYS_COMMAND_VALID))
1002 vcd_dbus_server_is_system_command_valid(g_conn_listener, msg);
1005 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_START))
1006 vcd_dbus_server_start_request(g_conn_listener, msg);
1008 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_STOP))
1009 vcd_dbus_server_stop_request(g_conn_listener, msg);
1011 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_REQUEST_CANCEL))
1012 vcd_dbus_server_cancel_request(g_conn_listener, msg);
1015 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_INITIALIZE))
1016 vcd_dbus_server_widget_initialize(g_conn_listener, msg);
1018 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_FINALIZE))
1019 vcd_dbus_server_widget_finalize(g_conn_listener, msg);
1021 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_START_RECORDING))
1022 vcd_dbus_server_widget_start_recording(g_conn_listener, msg);
1024 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_START))
1025 vcd_dbus_server_widget_start(g_conn_listener, msg);
1027 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_STOP))
1028 vcd_dbus_server_widget_stop(g_conn_listener, msg);
1030 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_CANCEL))
1031 vcd_dbus_server_widget_cancel(g_conn_listener, msg);
1033 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_WIDGET_METHOD_ENABLE_ASR_RESULT))
1034 vcd_dbus_server_widget_enable_asr_result(g_conn_listener, msg);
1036 else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_SETTING_METHOD_SET_LANGUAGE))
1037 vcd_dbus_server_set_language(g_conn_listener, msg);
1040 SLOG(LOG_DEBUG, TAG_VCD, "Message is NOT valid");
1041 dbus_message_unref(msg);
1045 /* free the message */
1046 dbus_message_unref(msg);
1049 return ECORE_CALLBACK_RENEW;
1052 int vcd_dbus_open_connection()
1055 dbus_error_init(&err);
1059 /* Create connection for sender */
1060 g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
1062 if (dbus_error_is_set(&err)) {
1063 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail dbus_bus_get : %s", err.message);
1064 dbus_error_free(&err);
1067 if (NULL == g_conn_sender) {
1068 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to get dbus connection");
1069 return VCD_ERROR_OPERATION_FAILED;
1072 dbus_connection_set_exit_on_disconnect(g_conn_sender, false);
1074 /* connect to the bus and check for errors */
1075 g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
1077 if (dbus_error_is_set(&err)) {
1078 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail dbus_bus_get : %s", err.message);
1079 dbus_error_free(&err);
1082 if (NULL == g_conn_listener) {
1083 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to get dbus connection");
1084 return VCD_ERROR_OPERATION_FAILED;
1087 dbus_connection_set_exit_on_disconnect(g_conn_listener, false);
1089 /* request our name on the bus and check for errors */
1090 ret = dbus_bus_request_name(g_conn_listener, VC_SERVER_SERVICE_NAME, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
1092 if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
1093 printf("Fail to be primary owner in dbus request.");
1094 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to be primary owner");
1095 return VCD_ERROR_OPERATION_FAILED;
1098 if (dbus_error_is_set(&err)) {
1099 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] dbus_bus_request_name() : %s", err.message);
1100 dbus_error_free(&err);
1101 return VCD_ERROR_OPERATION_FAILED;
1104 /* add a rule for getting signal */
1106 snprintf(rule, 128, "type='signal',interface='%s'", VC_SERVER_SERVICE_INTERFACE);
1108 /* add a rule for which messages we want to see */
1109 dbus_bus_add_match(g_conn_listener, rule, &err);/* see signals from the given interface */
1110 dbus_connection_flush(g_conn_listener);
1112 if (dbus_error_is_set(&err)) {
1113 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] dbus_bus_add_match() : %s", err.message);
1114 dbus_error_free(&err);
1115 return VCD_ERROR_OPERATION_FAILED;
1119 dbus_connection_get_unix_fd(g_conn_listener, &fd);
1121 g_dbus_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
1123 if (NULL == g_dbus_fd_handler) {
1124 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] Fail to get fd handler");
1125 return VCD_ERROR_OPERATION_FAILED;
1131 int vcd_dbus_close_connection()
1134 dbus_error_init(&err);
1136 if (NULL != g_dbus_fd_handler) {
1137 ecore_main_fd_handler_del(g_dbus_fd_handler);
1138 g_dbus_fd_handler = NULL;
1141 dbus_bus_release_name(g_conn_listener, VC_SERVER_SERVICE_NAME, &err);
1143 if (dbus_error_is_set(&err)) {
1144 SLOG(LOG_ERROR, TAG_VCD, "[Dbus ERROR] dbus_bus_release_name() : %s", err.message);
1145 dbus_error_free(&err);
1148 dbus_connection_close(g_conn_listener);
1149 dbus_connection_unref(g_conn_listener);
1150 dbus_connection_close(g_conn_sender);
1151 dbus_connection_unref(g_conn_sender);
1153 g_conn_listener = NULL;
1154 g_conn_sender = NULL;