X-Git-Url: https://git.0d.be/?p=empathy.git;a=blobdiff_plain;f=src%2Fempathy-event-manager.c;h=0b4fa775a73157045907cb52d2017d89011daf28;hp=4b5cfc5051f2d610f8f6a6a1bd722c99ad60871d;hb=24a7e1a69082dceea87e4f2a4c70667f17b19637;hpb=cf97caca295b0484e866a8b5e328a9a0c649e6c8 diff --git a/src/empathy-event-manager.c b/src/empathy-event-manager.c index 4b5cfc50..0b4fa775 100644 --- a/src/empathy-event-manager.c +++ b/src/empathy-event-manager.c @@ -1,4 +1,3 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ /* * Copyright (C) 2007-2008 Collabora Ltd. * @@ -17,6 +16,7 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * * Authors: Xavier Claessens + * Sjoerd Simons */ #include @@ -27,477 +27,1049 @@ #include #include -#include +#include #include #include -#include +#include +#include #include +#include #include #include #include +#include #include "empathy-event-manager.h" +#include "empathy-main-window.h" +#include "empathy-tube-dispatch.h" #define DEBUG_FLAG EMPATHY_DEBUG_DISPATCHER #include #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyEventManager) + +typedef struct { + EmpathyEventManager *manager; + EmpathyDispatchOperation *operation; + gulong approved_handler; + gulong claimed_handler; + gulong invalidated_handler; + /* Remove contact if applicable */ + EmpathyContact *contact; + /* Tube dispatcher if applicable */ + EmpathyTubeDispatch *tube_dispatch; + /* option signal handler and it's instance */ + gulong handler; + GObject *handler_instance; + /* optional accept widget */ + GtkWidget *dialog; +} EventManagerApproval; + typedef struct { - EmpathyDispatcher *dispatcher; - EmpathyContactManager *contact_manager; - GSList *events; + EmpathyDispatcher *dispatcher; + EmpathyContactManager *contact_manager; + GSList *events; + /* Ongoing approvals */ + GSList *approvals; + + /* voip ringing sound */ + guint voip_timeout; + gint ringing; } EmpathyEventManagerPriv; typedef struct _EventPriv EventPriv; typedef void (*EventFunc) (EventPriv *event); struct _EventPriv { - EmpathyEvent public; - TpChannel *channel; - EmpathyEventManager *manager; - EventFunc func; - gpointer user_data; + EmpathyEvent public; + EmpathyEventManager *manager; + EventManagerApproval *approval; + EventFunc func; + gboolean inhibit; + gpointer user_data; }; enum { - EVENT_ADDED, - EVENT_REMOVED, - LAST_SIGNAL + EVENT_ADDED, + EVENT_REMOVED, + EVENT_UPDATED, + LAST_SIGNAL }; static guint signals[LAST_SIGNAL]; G_DEFINE_TYPE (EmpathyEventManager, empathy_event_manager, G_TYPE_OBJECT); +static EmpathyEventManager * manager_singleton = NULL; + +static EventManagerApproval * +event_manager_approval_new (EmpathyEventManager *manager, + EmpathyDispatchOperation *operation) +{ + EventManagerApproval *result = g_slice_new0 (EventManagerApproval); + result->operation = g_object_ref (operation); + result->manager = manager; + + return result; +} + +static void +event_manager_approval_free (EventManagerApproval *approval) +{ + g_signal_handler_disconnect (approval->operation, + approval->approved_handler); + g_signal_handler_disconnect (approval->operation, + approval->claimed_handler); + g_signal_handler_disconnect (approval->operation, + approval->invalidated_handler); + g_object_unref (approval->operation); + + if (approval->handler != 0) + g_signal_handler_disconnect (approval->handler_instance, + approval->handler); + + if (approval->contact != NULL) + g_object_unref (approval->contact); + + if (approval->tube_dispatch != NULL) + g_object_unref (approval->tube_dispatch); + + if (approval->dialog != NULL) + { + gtk_widget_destroy (approval->dialog); + } + + g_slice_free (EventManagerApproval, approval); +} + static void event_remove (EventPriv *event); static void event_free (EventPriv *event) { - g_free (event->public.icon_name); - g_free (event->public.message); + g_free (event->public.icon_name); + g_free (event->public.header); + g_free (event->public.message); - if (event->public.contact) { - g_object_unref (event->public.contact); - } + if (event->public.contact) + { + g_object_unref (event->public.contact); + } - if (event->channel) { - g_signal_handlers_disconnect_by_func (event->channel, - event_remove, - event); - g_object_unref (event->channel); - } - g_slice_free (EventPriv, event); + g_slice_free (EventPriv, event); +} + +static void event_manager_ringing_finished_cb (ca_context *c, guint id, + int error_code, gpointer user_data); + +static gboolean +event_manager_ringing_timeout_cb (gpointer data) +{ + EmpathyEventManager *manager = EMPATHY_EVENT_MANAGER (data); + EmpathyEventManagerPriv *priv = GET_PRIV (manager); + + priv->voip_timeout = 0; + + empathy_sound_play_full (empathy_main_window_get (), + EMPATHY_SOUND_PHONE_INCOMING, event_manager_ringing_finished_cb, + manager); + + return FALSE; +} + +static gboolean +event_manager_ringing_idle_cb (gpointer data) +{ + EmpathyEventManager *manager = EMPATHY_EVENT_MANAGER (data); + EmpathyEventManagerPriv *priv = GET_PRIV (manager); + + if (priv->ringing > 0) + priv->voip_timeout = g_timeout_add (500, event_manager_ringing_timeout_cb, + data); + + return FALSE; } static void -event_remove (EventPriv *event) +event_manager_ringing_finished_cb (ca_context *c, guint id, int error_code, + gpointer user_data) { - EmpathyEventManagerPriv *priv = GET_PRIV (event->manager); + if (error_code == CA_ERROR_CANCELED) + return; - DEBUG ("Removing event %p", event); - priv->events = g_slist_remove (priv->events, event); - g_signal_emit (event->manager, signals[EVENT_REMOVED], 0, event); - event_free (event); + g_idle_add (event_manager_ringing_idle_cb, user_data); } static void -event_manager_add (EmpathyEventManager *manager, - EmpathyContact *contact, - const gchar *icon_name, - const gchar *message, - TpChannel *channel, - EventFunc func, - gpointer user_data) +event_manager_start_ringing (EmpathyEventManager *manager) { - EmpathyEventManagerPriv *priv = GET_PRIV (manager); - EventPriv *event; + EmpathyEventManagerPriv *priv = GET_PRIV (manager); - event = g_slice_new0 (EventPriv); - event->public.contact = contact ? g_object_ref (contact) : NULL; - event->public.icon_name = g_strdup (icon_name); - event->public.message = g_strdup (message); - event->manager = manager; - event->func = func; - event->user_data = user_data; + priv->ringing++; - if (channel) { - event->channel = g_object_ref (channel); - g_signal_connect_swapped (channel, "invalidated", - G_CALLBACK (event_remove), - event); - } + if (priv->ringing == 1) + { + empathy_sound_play_full (empathy_main_window_get (), + EMPATHY_SOUND_PHONE_INCOMING, event_manager_ringing_finished_cb, + manager); + } +} - DEBUG ("Adding event %p", event); - priv->events = g_slist_prepend (priv->events, event); - g_signal_emit (event->manager, signals[EVENT_ADDED], 0, event); +static void +event_manager_stop_ringing (EmpathyEventManager *manager) +{ + EmpathyEventManagerPriv *priv = GET_PRIV (manager); + + priv->ringing--; + + if (priv->ringing > 0) + return; + + empathy_sound_stop (EMPATHY_SOUND_PHONE_INCOMING); + + if (priv->voip_timeout != 0) + { + g_source_remove (priv->voip_timeout); + priv->voip_timeout = 0; + } } static void -event_channel_process_func (EventPriv *event) +event_remove (EventPriv *event) { - EmpathyEventManagerPriv *priv = GET_PRIV (event->manager); + EmpathyEventManagerPriv *priv = GET_PRIV (event->manager); - /* This will emit "dispatch-channel" and the event will be removed - * in the callback of that signal, no need to remove the event here. */ - empathy_dispatcher_channel_process (priv->dispatcher, event->channel); + DEBUG ("Removing event %p", event); + priv->events = g_slist_remove (priv->events, event); + g_signal_emit (event->manager, signals[EVENT_REMOVED], 0, event); + event_free (event); } -static gboolean -event_manager_chat_unref_idle (gpointer user_data) +static void +event_manager_add (EmpathyEventManager *manager, EmpathyContact *contact, + const gchar *icon_name, const gchar *header, const gchar *message, + EventManagerApproval *approval, EventFunc func, gpointer user_data) { - g_object_unref (user_data); - return FALSE; + EmpathyEventManagerPriv *priv = GET_PRIV (manager); + EventPriv *event; + + event = g_slice_new0 (EventPriv); + event->public.contact = contact ? g_object_ref (contact) : NULL; + event->public.icon_name = g_strdup (icon_name); + event->public.header = g_strdup (header); + event->public.message = g_strdup (message); + event->inhibit = FALSE; + event->func = func; + event->user_data = user_data; + event->manager = manager; + event->approval = approval; + + DEBUG ("Adding event %p", event); + priv->events = g_slist_prepend (priv->events, event); + g_signal_emit (event->manager, signals[EVENT_ADDED], 0, event); } static void -event_manager_chat_message_received_cb (EmpathyTpChat *tp_chat, - EmpathyMessage *message, - EmpathyEventManager *manager) +event_channel_process_func (EventPriv *event) { - EmpathyContact *sender; - gchar *msg; - TpChannel *channel; + empathy_dispatch_operation_approve (event->approval->operation); +} - g_idle_add (event_manager_chat_unref_idle, tp_chat); - g_signal_handlers_disconnect_by_func (tp_chat, - event_manager_chat_message_received_cb, - manager); +static void +event_text_channel_process_func (EventPriv *event) +{ + EmpathyTpChat *tp_chat; - sender = empathy_message_get_sender (message); - msg = g_strdup_printf (_("New message from %s:\n%s"), - empathy_contact_get_name (sender), - empathy_message_get_body (message)); + if (event->approval->handler != 0) + { + tp_chat = EMPATHY_TP_CHAT + (empathy_dispatch_operation_get_channel_wrapper (event->approval->operation)); - channel = empathy_tp_chat_get_channel (tp_chat); - event_manager_add (manager, sender, EMPATHY_IMAGE_NEW_MESSAGE, msg, - channel, event_channel_process_func, NULL); + g_signal_handler_disconnect (tp_chat, event->approval->handler); + event->approval->handler = 0; + } - g_free (msg); + empathy_dispatch_operation_approve (event->approval->operation); +} + +static EventPriv * +event_lookup_by_approval (EmpathyEventManager *manager, + EventManagerApproval *approval) +{ + EmpathyEventManagerPriv *priv = GET_PRIV (manager); + GSList *l; + EventPriv *retval = NULL; + + for (l = priv->events; l; l = l->next) + { + EventPriv *event = l->data; + + if (event->approval == approval) + { + retval = event; + break; + } + } + + return retval; } static void -event_manager_filter_channel_cb (EmpathyDispatcher *dispatcher, - TpChannel *channel, - EmpathyEventManager *manager) +event_update (EmpathyEventManager *manager, EventPriv *event, + const char *icon_name, const char *header, const char *msg) { - gchar *channel_type; + g_free (event->public.icon_name); + g_free (event->public.header); + g_free (event->public.message); - g_object_get (channel, "channel-type", &channel_type, NULL); - if (!tp_strdiff (channel_type, TP_IFACE_CHANNEL_TYPE_TEXT)) { - EmpathyTpChat *tp_chat; + event->public.icon_name = g_strdup (icon_name); + event->public.header = g_strdup (header); + event->public.message = g_strdup (msg); - tp_chat = empathy_tp_chat_new (channel); - g_signal_connect (tp_chat, "message-received", - G_CALLBACK (event_manager_chat_message_received_cb), - manager); - } - else if (!tp_strdiff (channel_type, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA)) { - EmpathyTpGroup *tp_group; - EmpathyContact *contact; - gchar *msg; - - tp_group = empathy_tp_group_new (channel); - empathy_run_until_ready (tp_group); - empathy_tp_group_get_invitation (tp_group, &contact); - empathy_contact_run_until_ready (contact, - EMPATHY_CONTACT_READY_NAME, - NULL); - - msg = g_strdup_printf (_("Incoming call from %s"), - empathy_contact_get_name (contact)); - - event_manager_add (manager, contact, EMPATHY_IMAGE_VOIP, msg, - channel, event_channel_process_func, NULL); - - g_free (msg); - g_object_unref (contact); - g_object_unref (tp_group); - } - else if (!tp_strdiff (channel_type, EMP_IFACE_CHANNEL_TYPE_FILE_TRANSFER)) { - EmpathyContact *contact; - gchar *msg; - TpHandle handle; - McAccount *account; - EmpathyContactFactory *factory; - - factory = empathy_contact_factory_new (); - handle = tp_channel_get_handle (channel, NULL); - account = empathy_channel_get_account (channel); - - contact = empathy_contact_factory_get_from_handle (factory, - account, - handle); - - empathy_contact_run_until_ready (contact, - EMPATHY_CONTACT_READY_NAME, NULL); - - msg = g_strdup_printf (_("Incoming file transfer from %s"), - empathy_contact_get_name (contact)); - - event_manager_add (manager, contact, - EMPATHY_IMAGE_DOCUMENT_SEND, - msg, channel, - event_channel_process_func, NULL); - - g_object_unref (factory); - g_object_unref (account); - } + g_signal_emit (manager, signals[EVENT_UPDATED], 0, event); +} - g_free (channel_type); +static void +event_manager_call_window_confirmation_dialog_response_cb (GtkDialog *dialog, + gint response, gpointer user_data) +{ + EventManagerApproval *approval = user_data; + + gtk_widget_destroy (approval->dialog); + approval->dialog = NULL; + + if (response != GTK_RESPONSE_ACCEPT) + { + EmpathyTpCall *call = + EMPATHY_TP_CALL ( + empathy_dispatch_operation_get_channel_wrapper ( + approval->operation)); + + g_object_ref (call); + if (empathy_dispatch_operation_claim (approval->operation)) + empathy_tp_call_close (call); + g_object_unref (call); + + } + else + { + EmpathyCallFactory *factory = empathy_call_factory_get (); + empathy_call_factory_claim_channel (factory, approval->operation); + } } static void -event_manager_dispatch_channel_cb (EmpathyDispatcher *dispatcher, - TpChannel *channel, - EmpathyEventManager *manager) +event_channel_process_voip_func (EventPriv *event) { - EmpathyEventManagerPriv *priv = GET_PRIV (manager); - GSList *l; + GtkWidget *dialog; + GtkWidget *button; + GtkWidget *image; - for (l = priv->events; l; l = l->next) { - EventPriv *event = l->data; + if (event->approval->dialog != NULL) + { + gtk_window_present (GTK_WINDOW (event->approval->dialog)); + return; + } - if (event->channel && - empathy_proxy_equal (channel, event->channel)) { - event_remove (event); - break; - } - } + dialog = gtk_message_dialog_new (NULL, 0, + GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, _("Incoming call")); + gtk_message_dialog_format_secondary_text ( + GTK_MESSAGE_DIALOG (dialog), + _("%s is calling you, do you want to answer?"), + empathy_contact_get_name (event->approval->contact)); + + gtk_dialog_set_default_response (GTK_DIALOG (dialog), + GTK_RESPONSE_OK); + + button = gtk_dialog_add_button (GTK_DIALOG (dialog), + _("_Reject"), GTK_RESPONSE_REJECT); + image = gtk_image_new_from_icon_name (GTK_STOCK_CANCEL, + GTK_ICON_SIZE_BUTTON); + gtk_button_set_image (GTK_BUTTON (button), image); + + button = gtk_dialog_add_button (GTK_DIALOG (dialog), + _("_Answer"), GTK_RESPONSE_ACCEPT); + + image = gtk_image_new_from_icon_name (GTK_STOCK_APPLY, GTK_ICON_SIZE_BUTTON); + gtk_button_set_image (GTK_BUTTON (button), image); + + g_signal_connect (dialog, "response", + G_CALLBACK (event_manager_call_window_confirmation_dialog_response_cb), + event->approval); + + gtk_widget_show (dialog); + + event->approval->dialog = dialog; } -#define TUBE_NO_APP_MESSAGE _("%s is offering you an invitation, but " \ - "you don't have the needed external " \ - "application to handle it.") +static void +event_manager_chat_message_received_cb (EmpathyTpChat *tp_chat, + EmpathyMessage *message, EventManagerApproval *approval) +{ + EmpathyContact *sender; + gchar *header; + const gchar *msg; + TpChannel *channel; + EventPriv *event; + + /* try to update the event if it's referring to a chat which is already in the + * queue. */ + event = event_lookup_by_approval (approval->manager, approval); + + if (event != NULL && event->inhibit && approval->handler != 0) + { + g_signal_handler_disconnect (tp_chat, approval->handler); + approval->handler = 0; + return; + } + + sender = empathy_message_get_sender (message); + header = g_strdup_printf (_("New message from %s"), + empathy_contact_get_name (sender)); + msg = empathy_message_get_body (message); + + channel = empathy_tp_chat_get_channel (tp_chat); + + if (event != NULL) + event_update (approval->manager, event, EMPATHY_IMAGE_NEW_MESSAGE, header, msg); + else + event_manager_add (approval->manager, sender, EMPATHY_IMAGE_NEW_MESSAGE, header, + msg, approval, event_text_channel_process_func, NULL); + + g_free (header); + empathy_sound_play (empathy_main_window_get (), + EMPATHY_SOUND_CONVERSATION_NEW); +} static void -event_tube_process_func (EventPriv *event) +event_manager_approval_done (EventManagerApproval *approval) { - EmpathyEventManagerPriv *priv = GET_PRIV (event->manager); - EmpathyDispatcherTube *tube = (EmpathyDispatcherTube*) event->user_data; + EmpathyEventManagerPriv *priv = GET_PRIV (approval->manager); + GSList *l; + + if (approval->operation != NULL) + { + GQuark channel_type; + + channel_type = empathy_dispatch_operation_get_channel_type_id ( + approval->operation); + if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_STREAMED_MEDIA) + { + event_manager_stop_ringing (approval->manager); + } + } + + priv->approvals = g_slist_remove (priv->approvals, approval); + + for (l = priv->events; l; l = l->next) + { + EventPriv *event = l->data; + + if (event->approval == approval) + { + event_remove (event); + break; + } + } + + event_manager_approval_free (approval); +} - if (tube->activatable) { - empathy_dispatcher_tube_process (priv->dispatcher, tube); - } else { - GtkWidget *dialog; - gchar *str; - - /* Tell the user that the tube can't be handled */ - str = g_strdup_printf (TUBE_NO_APP_MESSAGE, - empathy_contact_get_name (tube->initiator)); - - dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, - GTK_MESSAGE_ERROR, - GTK_BUTTONS_OK, - "%s", str); - gtk_window_set_title (GTK_WINDOW (dialog), - _("Invitation Error")); - g_free (str); - - gtk_widget_show (dialog); - g_signal_connect (dialog, "response", - G_CALLBACK (gtk_widget_destroy), - NULL); - } +static void +event_manager_operation_approved_cb (EmpathyDispatchOperation *operation, + EventManagerApproval *approval) +{ + event_manager_approval_done (approval); +} - empathy_dispatcher_tube_unref (tube); - event_remove (event); +static void +event_manager_operation_claimed_cb (EmpathyDispatchOperation *operation, + EventManagerApproval *approval) +{ + event_manager_approval_done (approval); } static void -event_manager_filter_tube_cb (EmpathyDispatcher *dispatcher, - EmpathyDispatcherTube *tube, - EmpathyEventManager *manager) +event_manager_operation_invalidated_cb (EmpathyDispatchOperation *operation, + guint domain, gint code, gchar *message, + EventManagerApproval *approval) { - const gchar *icon_name; - gchar *msg; + event_manager_approval_done (approval); +} - empathy_contact_run_until_ready (tube->initiator, - EMPATHY_CONTACT_READY_NAME, NULL); +static void +event_manager_media_channel_got_contact (EventManagerApproval *approval) +{ + gchar *header; - if (tube->activatable) { - icon_name = GTK_STOCK_EXECUTE; - msg = g_strdup_printf (_("%s is offering you an invitation. An external " - "application will be started to handle it."), - empathy_contact_get_name (tube->initiator)); - } else { - icon_name = GTK_STOCK_DIALOG_ERROR; - msg = g_strdup_printf (TUBE_NO_APP_MESSAGE, - empathy_contact_get_name (tube->initiator)); - } + header = g_strdup_printf (_("Incoming call from %s"), + empathy_contact_get_name (approval->contact)); - event_manager_add (manager, tube->initiator, icon_name, msg, - tube->channel, event_tube_process_func, - empathy_dispatcher_tube_ref (tube)); + event_manager_add (approval->manager, + approval->contact, EMPATHY_IMAGE_VOIP, header, NULL, + approval, event_channel_process_voip_func, NULL); - g_free (msg); + g_free (header); + event_manager_start_ringing (approval->manager); } static void -event_pending_subscribe_func (EventPriv *event) +event_manager_media_channel_contact_changed_cb (EmpathyTpCall *call, + GParamSpec *param, EventManagerApproval *approval) { - empathy_subscription_dialog_show (event->public.contact, NULL); - event_remove (event); + EmpathyContact *contact; + + g_object_get (G_OBJECT (call), "contact", &contact, NULL); + + if (contact == NULL) + return; + + approval->contact = contact; + event_manager_media_channel_got_contact (approval); } static void -event_manager_pendings_changed_cb (EmpathyContactList *list, - EmpathyContact *contact, - EmpathyContact *actor, - guint reason, - gchar *message, - gboolean is_pending, - EmpathyEventManager *manager) -{ - EmpathyEventManagerPriv *priv = GET_PRIV (manager); - GString *str; - - if (!is_pending) { - GSList *l; - - for (l = priv->events; l; l = l->next) { - EventPriv *event = l->data; - - if (event->public.contact == contact && - event->func == event_pending_subscribe_func) { - event_remove (event); - break; - } - } - - return; - } - - empathy_contact_run_until_ready (contact, - EMPATHY_CONTACT_READY_NAME, - NULL); +event_manager_tube_approved_cb (EventPriv *event) +{ + empathy_tube_dispatch_handle (event->approval->tube_dispatch); +} - str = g_string_new (NULL); - g_string_printf (str, _("Subscription requested by %s"), - empathy_contact_get_name (contact)); - if (!G_STR_EMPTY (message)) { - g_string_append_printf (str, _("\nMessage: %s"), message); - } +static void +event_manager_add_tube_approval (EventManagerApproval *approval, + EmpathyTubeDispatchAbility ability) +{ + const gchar *icon_name; + gchar *header; + const gchar *msg; + + header = g_strdup_printf (_("%s is offering you an invitation"), + empathy_contact_get_name (approval->contact)); + + if (ability == EMPATHY_TUBE_DISPATCHABILITY_POSSIBLE) + { + icon_name = GTK_STOCK_EXECUTE; + msg = _("An external application will be started to handle it."); + } + else + { + icon_name = GTK_STOCK_DIALOG_ERROR; + msg = _("You don't have the needed external " + "application to handle it."); + } + + event_manager_add (approval->manager, approval->contact, icon_name, header, + msg, approval, event_manager_tube_approved_cb, approval); + + g_free (header); + /* FIXME better sound for incoming tubes ? */ + empathy_sound_play (empathy_main_window_get (), + EMPATHY_SOUND_CONVERSATION_NEW); +} - event_manager_add (manager, contact, GTK_STOCK_DIALOG_QUESTION, str->str, - NULL, event_pending_subscribe_func, NULL); +static void +event_manager_tube_dispatch_ability_cb (GObject *object, + GParamSpec *spec, gpointer user_data) +{ + EventManagerApproval *approval = (EventManagerApproval *)user_data; + EmpathyTubeDispatchAbility dispatchability; + + dispatchability = + empathy_tube_dispatch_is_dispatchable (approval->tube_dispatch); + + if (dispatchability != EMPATHY_TUBE_DISPATCHABILITY_UNKNOWN) + { + event_manager_add_tube_approval (approval, dispatchability); + g_signal_handler_disconnect (object, approval->handler); + approval->handler = 0; + } +} - g_string_free (str, TRUE); +static void +event_manager_tube_got_contact_cb (EmpathyTpContactFactory *factory, + EmpathyContact *contact, + const GError *error, + gpointer user_data, + GObject *object) +{ + EventManagerApproval *approval = (EventManagerApproval *)user_data; + EmpathyTubeDispatchAbility dispatchability; + + if (error != NULL) + { + /* FIXME: We should probably still display the event */ + DEBUG ("Error: %s", error->message); + return; + } + + approval->contact = g_object_ref (contact); + + dispatchability = empathy_tube_dispatch_is_dispatchable + (approval->tube_dispatch); + + switch (dispatchability) + { + case EMPATHY_TUBE_DISPATCHABILITY_UNKNOWN: + approval->handler = g_signal_connect (approval->tube_dispatch, + "notify::dispatchability", + G_CALLBACK (event_manager_tube_dispatch_ability_cb), approval); + approval->handler_instance = G_OBJECT (approval->tube_dispatch); + break; + case EMPATHY_TUBE_DISPATCHABILITY_POSSIBLE: + /* fallthrough */ + case EMPATHY_TUBE_DISPATCHABILITY_IMPOSSIBLE: + event_manager_add_tube_approval (approval, dispatchability); + break; + } } static void -event_manager_finalize (GObject *object) +invite_dialog_response_cb (GtkDialog *dialog, + gint response, + EventManagerApproval *approval) { - EmpathyEventManagerPriv *priv = GET_PRIV (object); + EmpathyTpChat *tp_chat; + TpChannel *channel; + TpHandle self_handle; + GArray *members; + + gtk_widget_destroy (GTK_WIDGET (approval->dialog)); + approval->dialog = NULL; + + tp_chat = EMPATHY_TP_CHAT (empathy_dispatch_operation_get_channel_wrapper ( + approval->operation)); + + if (response != GTK_RESPONSE_OK) + { + /* close channel */ + DEBUG ("Muc invitation rejected"); + + if (empathy_dispatch_operation_claim (approval->operation)) + empathy_tp_chat_close (tp_chat); + return; + } + + DEBUG ("Muc invitation accepted"); + + /* join the room */ + channel = empathy_tp_chat_get_channel (tp_chat); - g_slist_foreach (priv->events, (GFunc) event_free, NULL); - g_slist_free (priv->events); - g_object_unref (priv->contact_manager); - g_object_unref (priv->dispatcher); + self_handle = tp_channel_group_get_self_handle (channel); + members = g_array_sized_new (FALSE, FALSE, sizeof (TpHandle), 1); + g_array_append_val (members, self_handle); + + tp_cli_channel_interface_group_call_add_members (channel, -1, members, + "", NULL, NULL, NULL, NULL); + + empathy_dispatch_operation_approve (approval->operation); + + g_array_free (members, TRUE); } static void -empathy_event_manager_class_init (EmpathyEventManagerClass *klass) +event_room_channel_process_func (EventPriv *event) { - GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkWidget *dialog, *button, *image; + TpChannel *channel = empathy_dispatch_operation_get_channel ( + event->approval->operation); + + if (event->approval->dialog != NULL) + { + gtk_window_present (GTK_WINDOW (event->approval->dialog)); + return; + } - object_class->finalize = event_manager_finalize; + /* create dialog */ + dialog = gtk_message_dialog_new (NULL, 0, + GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, _("Room invitation")); - signals[EVENT_ADDED] = - g_signal_new ("event-added", - G_TYPE_FROM_CLASS (klass), - G_SIGNAL_RUN_LAST, - 0, - NULL, NULL, - g_cclosure_marshal_VOID__POINTER, - G_TYPE_NONE, - 1, G_TYPE_POINTER); + gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), + _("%s is inviting you to join %s"), + empathy_contact_get_name (event->approval->contact), + tp_channel_get_identifier (channel)); - signals[EVENT_REMOVED] = - g_signal_new ("event-removed", - G_TYPE_FROM_CLASS (klass), - G_SIGNAL_RUN_LAST, - 0, - NULL, NULL, - g_cclosure_marshal_VOID__POINTER, - G_TYPE_NONE, - 1, G_TYPE_POINTER); + gtk_dialog_set_default_response (GTK_DIALOG (dialog), + GTK_RESPONSE_OK); - g_type_class_add_private (object_class, sizeof (EmpathyEventManagerPriv)); + button = gtk_dialog_add_button (GTK_DIALOG (dialog), + _("_Decline"), GTK_RESPONSE_CANCEL); + image = gtk_image_new_from_icon_name (GTK_STOCK_CANCEL, GTK_ICON_SIZE_BUTTON); + gtk_button_set_image (GTK_BUTTON (button), image); + + button = gtk_dialog_add_button (GTK_DIALOG (dialog), + _("_Join"), GTK_RESPONSE_OK); + image = gtk_image_new_from_icon_name (GTK_STOCK_APPLY, GTK_ICON_SIZE_BUTTON); + gtk_button_set_image (GTK_BUTTON (button), image); + + g_signal_connect (dialog, "response", + G_CALLBACK (invite_dialog_response_cb), event->approval); + + gtk_widget_show (dialog); + + event->approval->dialog = dialog; } static void -empathy_event_manager_init (EmpathyEventManager *manager) +event_manager_muc_invite_got_contact_cb (EmpathyTpContactFactory *factory, + EmpathyContact *contact, + const GError *error, + gpointer user_data, + GObject *object) { - EmpathyEventManagerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (manager, - EMPATHY_TYPE_EVENT_MANAGER, EmpathyEventManagerPriv); + EventManagerApproval *approval = (EventManagerApproval *) user_data; + TpChannel *channel; + const gchar *invite_msg; + gchar *msg; + TpHandle self_handle; + + if (error != NULL) + { + /* FIXME: We should probably still display the event */ + DEBUG ("Error: %s", error->message); + return; + } + + approval->contact = g_object_ref (contact); + channel = empathy_dispatch_operation_get_channel (approval->operation); + + self_handle = tp_channel_group_get_self_handle (channel); + tp_channel_group_get_local_pending_info (channel, self_handle, NULL, NULL, + &invite_msg); + + msg = g_strdup_printf (_("%s invited you to join %s"), + empathy_contact_get_name (approval->contact), + tp_channel_get_identifier (channel)); + + event_manager_add (approval->manager, + approval->contact, EMPATHY_IMAGE_GROUP_MESSAGE, msg, invite_msg, + approval, event_room_channel_process_func, NULL); + + empathy_sound_play (empathy_main_window_get (), + EMPATHY_SOUND_CONVERSATION_NEW); + + g_free (msg); +} - manager->priv = priv; +static void +event_manager_approve_channel_cb (EmpathyDispatcher *dispatcher, + EmpathyDispatchOperation *operation, EmpathyEventManager *manager) +{ + const gchar *channel_type; + EventManagerApproval *approval; + EmpathyEventManagerPriv *priv = GET_PRIV (manager); + + channel_type = empathy_dispatch_operation_get_channel_type (operation); + + approval = event_manager_approval_new (manager, operation); + priv->approvals = g_slist_prepend (priv->approvals, approval); + + approval->approved_handler = g_signal_connect (operation, "approved", + G_CALLBACK (event_manager_operation_approved_cb), approval); + + approval->claimed_handler = g_signal_connect (operation, "claimed", + G_CALLBACK (event_manager_operation_claimed_cb), approval); + + approval->invalidated_handler = g_signal_connect (operation, "invalidated", + G_CALLBACK (event_manager_operation_invalidated_cb), approval); + + if (!tp_strdiff (channel_type, TP_IFACE_CHANNEL_TYPE_TEXT)) + { + EmpathyTpChat *tp_chat = + EMPATHY_TP_CHAT ( + empathy_dispatch_operation_get_channel_wrapper (operation)); + TpChannel *channel = empathy_tp_chat_get_channel (tp_chat); + + if (tp_proxy_has_interface (channel, TP_IFACE_CHANNEL_INTERFACE_GROUP)) + { + /* Are we in local-pending ? */ + TpHandle self_handle, inviter; + + self_handle = tp_channel_group_get_self_handle (channel); + + if (self_handle != 0 && tp_channel_group_get_local_pending_info ( + channel, self_handle, &inviter, NULL, NULL)) + { + /* We are invited to a room */ + EmpathyTpContactFactory *factory; + TpConnection *connection; + + DEBUG ("Have been invited to %s. Ask user if he wants to accept", + tp_channel_get_identifier (channel)); + + connection = empathy_tp_chat_get_connection (tp_chat); + factory = empathy_tp_contact_factory_dup_singleton (connection); + + empathy_tp_contact_factory_get_from_handle (factory, + inviter, event_manager_muc_invite_got_contact_cb, + approval, NULL, G_OBJECT (manager)); + + g_object_unref (factory); + return; + } + + /* if we are not invited, let's wait for the first message */ + } + + /* 1-1 text channel, wait for the first message */ + approval->handler = g_signal_connect (tp_chat, "message-received", + G_CALLBACK (event_manager_chat_message_received_cb), approval); + approval->handler_instance = G_OBJECT (tp_chat); + } + else if (!tp_strdiff (channel_type, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA)) + { + EmpathyContact *contact; + EmpathyTpCall *call = EMPATHY_TP_CALL ( + empathy_dispatch_operation_get_channel_wrapper (operation)); + + g_object_get (G_OBJECT (call), "contact", &contact, NULL); + + if (contact == NULL) + { + g_signal_connect (call, "notify::contact", + G_CALLBACK (event_manager_media_channel_contact_changed_cb), + approval); + } + else + { + approval->contact = contact; + event_manager_media_channel_got_contact (approval); + } + + } + else if (!tp_strdiff (channel_type, TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER)) + { + EmpathyTpFile *file; + gchar *header; + + file = EMPATHY_TP_FILE (empathy_dispatch_operation_get_channel_wrapper (operation)); + approval->contact = g_object_ref (empathy_tp_file_get_contact (file)); + + header = g_strdup_printf (_("Incoming file transfer from %s"), + empathy_contact_get_name (approval->contact)); + + event_manager_add (manager, approval->contact, EMPATHY_IMAGE_DOCUMENT_SEND, + header, NULL, approval, event_channel_process_func, NULL); + + /* FIXME better sound for incoming file transfers ?*/ + empathy_sound_play (empathy_main_window_get (), + EMPATHY_SOUND_CONVERSATION_NEW); + + g_free (header); + } + else if (!tp_strdiff (channel_type, EMP_IFACE_CHANNEL_TYPE_STREAM_TUBE) || + !tp_strdiff (channel_type, EMP_IFACE_CHANNEL_TYPE_DBUS_TUBE)) + { + TpChannel *channel; + TpHandle handle; + TpHandleType handle_type; + TpConnection *connection; + EmpathyTpContactFactory *factory; + + channel = empathy_dispatch_operation_get_channel (operation); + handle = tp_channel_get_handle (channel, &handle_type); + + /* Only understand p2p tubes */ + if (handle_type != TP_HANDLE_TYPE_CONTACT) + return; + + approval->tube_dispatch = empathy_tube_dispatch_new (operation); + connection = tp_channel_borrow_connection (channel); + factory = empathy_tp_contact_factory_dup_singleton (connection); + empathy_tp_contact_factory_get_from_handle (factory, handle, + event_manager_tube_got_contact_cb, approval, NULL, G_OBJECT (manager)); + } + else + { + DEBUG ("Unknown channel type, ignoring.."); + } +} - priv->dispatcher = empathy_dispatcher_new (); - priv->contact_manager = empathy_contact_manager_new (); - g_signal_connect (priv->dispatcher, "filter-channel", - G_CALLBACK (event_manager_filter_channel_cb), - manager); - g_signal_connect (priv->dispatcher, "dispatch-channel", - G_CALLBACK (event_manager_dispatch_channel_cb), - manager); - g_signal_connect (priv->dispatcher, "filter-tube", - G_CALLBACK (event_manager_filter_tube_cb), - manager); - g_signal_connect (priv->contact_manager, "pendings-changed", - G_CALLBACK (event_manager_pendings_changed_cb), - manager); +static void +event_pending_subscribe_func (EventPriv *event) +{ + empathy_subscription_dialog_show (event->public.contact, NULL); + event_remove (event); } -EmpathyEventManager * -empathy_event_manager_new (void) +static void +event_manager_pendings_changed_cb (EmpathyContactList *list, + EmpathyContact *contact, EmpathyContact *actor, + guint reason, gchar *message, gboolean is_pending, + EmpathyEventManager *manager) { - static EmpathyEventManager *manager = NULL; + EmpathyEventManagerPriv *priv = GET_PRIV (manager); + gchar *header, *event_msg; - if (!manager) { - manager = g_object_new (EMPATHY_TYPE_EVENT_MANAGER, NULL); - g_object_add_weak_pointer (G_OBJECT (manager), (gpointer) &manager); + if (!is_pending) + { + GSList *l; + + for (l = priv->events; l; l = l->next) + { + EventPriv *event = l->data; + + if (event->public.contact == contact && + event->func == event_pending_subscribe_func) + { + event_remove (event); + break; + } + } + + return; + } + + header = g_strdup_printf (_("Subscription requested by %s"), + empathy_contact_get_name (contact)); + + if (!EMP_STR_EMPTY (message)) + event_msg = g_strdup_printf (_("\nMessage: %s"), message); + else + event_msg = NULL; + + event_manager_add (manager, contact, GTK_STOCK_DIALOG_QUESTION, header, + event_msg, NULL, event_pending_subscribe_func, NULL); + + g_free (event_msg); + g_free (header); +} + +static GObject * +event_manager_constructor (GType type, + guint n_props, + GObjectConstructParam *props) +{ + GObject *retval; + + if (manager_singleton) { + retval = g_object_ref (manager_singleton); } else { - g_object_ref (manager); + retval = G_OBJECT_CLASS (empathy_event_manager_parent_class)->constructor + (type, n_props, props); + + manager_singleton = EMPATHY_EVENT_MANAGER (retval); + g_object_add_weak_pointer (retval, (gpointer) &manager_singleton); } - return manager; + return retval; +} + +static void +event_manager_finalize (GObject *object) +{ + EmpathyEventManagerPriv *priv = GET_PRIV (object); + + g_slist_foreach (priv->events, (GFunc) event_free, NULL); + g_slist_free (priv->events); + g_slist_foreach (priv->approvals, (GFunc) event_manager_approval_free, NULL); + g_slist_free (priv->approvals); + g_object_unref (priv->contact_manager); + g_object_unref (priv->dispatcher); +} + +static void +empathy_event_manager_class_init (EmpathyEventManagerClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = event_manager_finalize; + object_class->constructor = event_manager_constructor; + + signals[EVENT_ADDED] = + g_signal_new ("event-added", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, + 0, + NULL, NULL, + g_cclosure_marshal_VOID__POINTER, + G_TYPE_NONE, + 1, G_TYPE_POINTER); + + signals[EVENT_REMOVED] = + g_signal_new ("event-removed", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, + 0, + NULL, NULL, + g_cclosure_marshal_VOID__POINTER, + G_TYPE_NONE, 1, G_TYPE_POINTER); + + signals[EVENT_UPDATED] = + g_signal_new ("event-updated", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, + 0, + NULL, NULL, + g_cclosure_marshal_VOID__POINTER, + G_TYPE_NONE, 1, G_TYPE_POINTER); + + + g_type_class_add_private (object_class, sizeof (EmpathyEventManagerPriv)); +} + +static void +empathy_event_manager_init (EmpathyEventManager *manager) +{ + EmpathyEventManagerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (manager, + EMPATHY_TYPE_EVENT_MANAGER, EmpathyEventManagerPriv); + + manager->priv = priv; + + priv->dispatcher = empathy_dispatcher_dup_singleton (); + priv->contact_manager = empathy_contact_manager_dup_singleton (); + g_signal_connect (priv->dispatcher, "approve", + G_CALLBACK (event_manager_approve_channel_cb), manager); + g_signal_connect (priv->contact_manager, "pendings-changed", + G_CALLBACK (event_manager_pendings_changed_cb), manager); +} + +EmpathyEventManager * +empathy_event_manager_dup_singleton (void) +{ + return g_object_new (EMPATHY_TYPE_EVENT_MANAGER, NULL); } GSList * empathy_event_manager_get_events (EmpathyEventManager *manager) { - EmpathyEventManagerPriv *priv = GET_PRIV (manager); + EmpathyEventManagerPriv *priv = GET_PRIV (manager); - g_return_val_if_fail (EMPATHY_IS_EVENT_MANAGER (manager), NULL); + g_return_val_if_fail (EMPATHY_IS_EVENT_MANAGER (manager), NULL); - return priv->events; + return priv->events; } EmpathyEvent * empathy_event_manager_get_top_event (EmpathyEventManager *manager) { - EmpathyEventManagerPriv *priv = GET_PRIV (manager); + EmpathyEventManagerPriv *priv = GET_PRIV (manager); - g_return_val_if_fail (EMPATHY_IS_EVENT_MANAGER (manager), NULL); + g_return_val_if_fail (EMPATHY_IS_EVENT_MANAGER (manager), NULL); - return priv->events ? priv->events->data : NULL; + return priv->events ? priv->events->data : NULL; } void empathy_event_activate (EmpathyEvent *event_public) { - EventPriv *event = (EventPriv*) event_public; + EventPriv *event = (EventPriv*) event_public; - g_return_if_fail (event_public != NULL); + g_return_if_fail (event_public != NULL); - if (event->func) { - event->func (event); - } else { - event_remove (event); - } + if (event->func) + event->func (event); + else + event_remove (event); +} + +void +empathy_event_inhibit_updates (EmpathyEvent *event_public) +{ + EventPriv *event = (EventPriv *) event_public; + + g_return_if_fail (event_public != NULL); + + event->inhibit = TRUE; }