X-Git-Url: https://git.0d.be/?p=empathy.git;a=blobdiff_plain;f=src%2Fempathy-event-manager.c;h=ef9248647d6fd3bb234c094c3a4625446c77f211;hp=7643ad7351c3b3101f9a47ae70bb1f9a5eb45ccf;hb=bea67ada3dc8e5cfe415dface5c98858d875677d;hpb=500751eb56f36006b7bf02cd4a2da8b2ff3dc2a4

diff --git a/src/empathy-event-manager.c b/src/empathy-event-manager.c
index 7643ad73..ef924864 100644
--- a/src/empathy-event-manager.c
+++ b/src/empathy-event-manager.c
@@ -33,13 +33,16 @@
 #include <libempathy/empathy-tp-call.h>
 #include <libempathy/empathy-tp-group.h>
 #include <libempathy/empathy-utils.h>
+#include <libempathy/empathy-call-factory.h>
 
 #include <extensions/extensions.h>
 
 #include <libempathy-gtk/empathy-images.h>
 #include <libempathy-gtk/empathy-contact-dialogs.h>
+#include <libempathy-gtk/empathy-ui-utils.h>
 
 #include "empathy-event-manager.h"
+#include "empathy-main-window.h"
 #include "empathy-tube-dispatch.h"
 
 #define DEBUG_FLAG EMPATHY_DEBUG_DISPATCHER
@@ -59,6 +62,8 @@ typedef struct {
   EmpathyTubeDispatch *tube_dispatch;
   /* option signal handler */
   gulong handler;
+  /* optional accept widget */
+  GtkWidget *dialog;
 } EventManagerApproval;
 
 typedef struct {
@@ -67,6 +72,10 @@ typedef struct {
   GSList *events;
   /* Ongoing approvals */
   GSList *approvals;
+
+  /* voip ringing sound */
+  guint voip_timeout;
+  gint ringing;
 } EmpathyEventManagerPriv;
 
 typedef struct _EventPriv EventPriv;
@@ -77,12 +86,14 @@ struct _EventPriv {
   EmpathyEventManager *manager;
   EventManagerApproval *approval;
   EventFunc func;
+  gboolean inhibit;
   gpointer user_data;
 };
 
 enum {
   EVENT_ADDED,
   EVENT_REMOVED,
+  EVENT_UPDATED,
   LAST_SIGNAL
 };
 
@@ -120,6 +131,11 @@ event_manager_approval_free (EventManagerApproval *approval)
   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);
 }
 
@@ -129,6 +145,7 @@ static void
 event_free (EventPriv *event)
 {
   g_free (event->public.icon_name);
+  g_free (event->public.header);
   g_free (event->public.message);
 
   if (event->public.contact)
@@ -139,6 +156,81 @@ event_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_manager_ringing_finished_cb (ca_context *c, guint id, int error_code,
+  gpointer user_data)
+{
+  if (error_code == CA_ERROR_CANCELED)
+    return;
+
+  g_idle_add (event_manager_ringing_idle_cb, user_data);
+}
+
+static void
+event_manager_start_ringing (EmpathyEventManager *manager)
+{
+  EmpathyEventManagerPriv *priv = GET_PRIV (manager);
+
+  priv->ringing++;
+
+  if (priv->ringing == 1)
+    {
+      empathy_sound_play_full (empathy_main_window_get (),
+        EMPATHY_SOUND_PHONE_INCOMING, event_manager_ringing_finished_cb,
+        manager);
+    }
+}
+
+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_remove (EventPriv *event)
 {
@@ -151,10 +243,9 @@ event_remove (EventPriv *event)
 }
 
 static void
-event_manager_add (EmpathyEventManager *manager, EmpathyContact      *contact,
-  const gchar         *icon_name, const gchar         *message,
-  EventManagerApproval *approval, EventFunc            func,
-  gpointer             user_data)
+event_manager_add (EmpathyEventManager *manager, EmpathyContact *contact,
+  const gchar *icon_name, const gchar *header, const gchar *message,
+  EventManagerApproval *approval, EventFunc func, gpointer user_data)
 {
   EmpathyEventManagerPriv *priv = GET_PRIV (manager);
   EventPriv               *event;
@@ -162,13 +253,13 @@ event_manager_add (EmpathyEventManager *manager, EmpathyContact      *contact,
   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;
-
-  if (approval)
-    event->approval = approval;
+  event->approval = approval;
 
   DEBUG ("Adding event %p", event);
   priv->events = g_slist_prepend (priv->events, event);
@@ -182,25 +273,170 @@ event_channel_process_func (EventPriv *event)
 }
 
 static void
-event_manager_chat_message_received_cb (EmpathyTpChat       *tp_chat,
-  EmpathyMessage      *message, EventManagerApproval *approval)
+event_text_channel_process_func (EventPriv *event)
+{
+  EmpathyTpChat *tp_chat;
+
+  if (event->approval->handler != 0)
+    {
+      tp_chat = EMPATHY_TP_CHAT
+        (empathy_dispatch_operation_get_channel_wrapper (event->approval->operation));
+  
+      g_signal_handler_disconnect (tp_chat, event->approval->handler);
+      event->approval->handler = 0;
+    }
+
+  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_update (EmpathyEventManager *manager, EventPriv *event,
+  const char *icon_name, const char *header, const char *msg)
+{
+  g_free (event->public.icon_name);
+  g_free (event->public.header);
+  g_free (event->public.message);
+
+  event->public.icon_name = g_strdup (icon_name);
+  event->public.header = g_strdup (header);
+  event->public.message = g_strdup (msg);
+
+  g_signal_emit (manager, signals[EVENT_UPDATED], 0, event);
+}
+
+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_channel_process_voip_func (EventPriv *event)
+{
+  GtkWidget *dialog;
+  GtkWidget *button;
+  GtkWidget *image;
+
+  if (event->approval->dialog != NULL)
+    {
+      gtk_window_present (GTK_WINDOW (event->approval->dialog));
+      return;
+    }
+
+  dialog = gtk_message_dialog_new (GTK_WINDOW (empathy_main_window_get()),
+      GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+      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;
+}
+
+static void
+event_manager_chat_message_received_cb (EmpathyTpChat *tp_chat,
+  EmpathyMessage *message, EventManagerApproval *approval)
 {
   EmpathyContact  *sender;
-  gchar           *msg;
+  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);
 
-  g_signal_handlers_disconnect_by_func (tp_chat,
-    event_manager_chat_message_received_cb, 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);
-  msg = g_strdup_printf (_("New message from %s:\n%s"),
-    empathy_contact_get_name (sender), empathy_message_get_body (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);
-  event_manager_add (approval->manager, sender, EMPATHY_IMAGE_NEW_MESSAGE, msg,
-    approval, event_channel_process_func, NULL);
 
-  g_free (msg);
+  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
@@ -209,6 +445,18 @@ event_manager_approval_done (EventManagerApproval *approval)
   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)
@@ -252,7 +500,7 @@ event_manager_media_channel_got_name_cb (EmpathyContact *contact,
   const GError *error, gpointer user_data, GObject *object)
 {
   EventManagerApproval *approval = user_data;
-  gchar *msg;
+  gchar *header;
 
   if (error != NULL)
     {
@@ -261,14 +509,15 @@ event_manager_media_channel_got_name_cb (EmpathyContact *contact,
       return;
     }
 
-  msg = g_strdup_printf (_("Incoming call from %s"),
+  header = g_strdup_printf (_("Incoming call from %s"),
     empathy_contact_get_name (contact));
 
   event_manager_add (approval->manager,
-    approval->contact, EMPATHY_IMAGE_VOIP, msg,
-    approval, event_channel_process_func, NULL);
+    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
@@ -305,28 +554,31 @@ event_manager_add_tube_approval (EventManagerApproval *approval,
   EmpathyTubeDispatchAbility ability)
 {
   const gchar *icon_name;
-  gchar       *msg;
+  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 = g_strdup_printf (_("%s is offering you an invitation."
-        " An external application will be started to handle it."),
-      empathy_contact_get_name (approval->contact));
+      msg = _("An external application will be started to handle it.");
     }
   else
     {
       icon_name = GTK_STOCK_DIALOG_ERROR;
-      msg = g_strdup_printf (_("%s is offering you an invitation, but "
-        "you don't have the needed external "
-        "application to handle it."),
-        empathy_contact_get_name (approval->contact));
+      msg = _("You don't have the needed external "
+              "application to handle it.");
     }
 
-  event_manager_add (approval->manager, approval->contact, icon_name, msg,
-    approval, event_manager_tube_approved_cb, approval);
+  event_manager_add (approval->manager, approval->contact, icon_name, header,
+    msg, approval, event_manager_tube_approved_cb, approval);
 
-  g_free (msg);
+  g_free (header);
+  /* FIXME better sound for incoming tubes ? */
+  empathy_sound_play (empathy_main_window_get (),
+    EMPATHY_SOUND_CONVERSATION_NEW);
 }
 
 static void
@@ -380,6 +632,123 @@ event_manager_tube_got_contact_name_cb (EmpathyContact *contact,
     }
 }
 
+static void
+invite_dialog_response_cb (GtkDialog *dialog,
+                           gint response,
+                           EventManagerApproval *approval)
+{
+  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);
+      empathy_tp_chat_close (tp_chat);
+      return;
+    }
+
+  DEBUG ("Muc invitation accepted");
+
+  /* join the room */
+  channel = empathy_tp_chat_get_channel (tp_chat);
+
+  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
+event_room_channel_process_func (EventPriv *event)
+{
+  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;
+    }
+
+  /* create dialog */
+  dialog = gtk_message_dialog_new (NULL, 0,
+      GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, _("Room invitation"));
+
+  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));
+
+  gtk_dialog_set_default_response (GTK_DIALOG (dialog),
+      GTK_RESPONSE_OK);
+
+  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
+event_manager_muc_invite_got_contact_name_cb (EmpathyContact *contact,
+                                              const GError *error,
+                                              gpointer user_data,
+                                              GObject *object)
+{
+  EventManagerApproval *approval = (EventManagerApproval *) user_data;
+  TpChannel *channel;
+  const gchar *invite_msg;
+  gchar *msg;
+  TpHandle self_handle;
+
+  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);
+}
+
 static void
 event_manager_approve_channel_cb (EmpathyDispatcher *dispatcher,
   EmpathyDispatchOperation  *operation, EmpathyEventManager *manager)
@@ -407,10 +776,51 @@ event_manager_approve_channel_cb (EmpathyDispatcher *dispatcher,
       EmpathyTpChat *tp_chat =
         EMPATHY_TP_CHAT (
           empathy_dispatch_operation_get_channel_wrapper (operation));
+      TpChannel *channel = empathy_tp_chat_get_channel (tp_chat);
+      TpHandle handle;
+      TpHandleType handle_type;
+
+      handle = tp_channel_get_handle (channel, &handle_type);
+
+      if (handle_type == TP_HANDLE_TYPE_CONTACT)
+        {
+          /* 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);
+        }
+      else if (handle_type == TP_HANDLE_TYPE_ROOM)
+        {
+          TpHandle self_handle, inviter;
+          EmpathyContactFactory *contact_factory;
+          McAccount *account;
+
+          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))
+            {
+              DEBUG ("can't handle a incoming muc to which we have not been "
+                  "invited");
+
+              if (empathy_dispatch_operation_claim (approval->operation))
+                empathy_tp_chat_close (tp_chat);
+              return;
+            }
 
-      g_signal_connect (tp_chat, "message-received",
-        G_CALLBACK (event_manager_chat_message_received_cb), approval);
+          /* We are invited to a room */
+          account = empathy_tp_chat_get_account (tp_chat);
+          contact_factory = empathy_contact_factory_dup_singleton ();
 
+          approval->contact = empathy_contact_factory_get_from_handle (
+              contact_factory, account, inviter);
+
+          empathy_contact_call_when_ready (approval->contact,
+            EMPATHY_CONTACT_READY_NAME,
+            event_manager_muc_invite_got_contact_name_cb, approval, NULL,
+            G_OBJECT (manager));
+
+          g_object_unref (contact_factory);
+        }
     }
   else if (!tp_strdiff (channel_type, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA))
     {
@@ -436,7 +846,7 @@ event_manager_approve_channel_cb (EmpathyDispatcher *dispatcher,
   else if (!tp_strdiff (channel_type, EMP_IFACE_CHANNEL_TYPE_FILE_TRANSFER))
     {
       EmpathyContact        *contact;
-      gchar                 *msg;
+      gchar                 *header;
       TpHandle               handle;
       McAccount             *account;
       EmpathyContactFactory *factory;
@@ -452,19 +862,26 @@ event_manager_approve_channel_cb (EmpathyDispatcher *dispatcher,
       empathy_contact_run_until_ready (contact,
         EMPATHY_CONTACT_READY_NAME, NULL);
 
-      msg = g_strdup_printf (_("Incoming file transfer from %s"),
+      header = g_strdup_printf (_("Incoming file transfer from %s"),
         empathy_contact_get_name (contact));
 
       event_manager_add (manager, contact, EMPATHY_IMAGE_DOCUMENT_SEND,
-        msg, approval, event_channel_process_func, NULL);
+        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_object_unref (factory);
       g_object_unref (account);
+      g_free (header);
     }
-  else if (!tp_strdiff (channel_type, EMP_IFACE_CHANNEL_TYPE_STREAM_TUBE))
+  else if (!tp_strdiff (channel_type, EMP_IFACE_CHANNEL_TYPE_STREAM_TUBE) ||
+      !tp_strdiff (channel_type, EMP_IFACE_CHANNEL_TYPE_DBUS_TUBE))
     {
       EmpathyContact        *contact;
       TpHandle               handle;
+      TpHandleType           handle_type;
       McAccount             *account;
       EmpathyContactFactory *factory;
       EmpathyTubeDispatch *tube_dispatch;
@@ -472,8 +889,13 @@ event_manager_approve_channel_cb (EmpathyDispatcher *dispatcher,
 
       channel = empathy_dispatch_operation_get_channel (operation);
 
-      factory = empathy_contact_factory_new ();
-      handle = tp_channel_get_handle (channel, NULL);
+      handle = tp_channel_get_handle (channel, &handle_type);
+
+      /* Only understand p2p tubes */
+      if (handle_type != TP_HANDLE_TYPE_CONTACT)
+        return;
+
+      factory = empathy_contact_factory_dup_singleton ();
       account = empathy_channel_get_account (channel);
 
       contact = empathy_contact_factory_get_from_handle (factory, account,
@@ -511,7 +933,7 @@ event_manager_pendings_changed_cb (EmpathyContactList  *list,
   EmpathyEventManager *manager)
 {
   EmpathyEventManagerPriv *priv = GET_PRIV (manager);
-  GString                 *str;
+  gchar                   *header, *event_msg;
 
   if (!is_pending)
     {
@@ -534,17 +956,19 @@ event_manager_pendings_changed_cb (EmpathyContactList  *list,
 
   empathy_contact_run_until_ready (contact, EMPATHY_CONTACT_READY_NAME, NULL);
 
-  str = g_string_new (NULL);
-  g_string_printf (str, _("Subscription requested by %s"),
+  header = g_strdup_printf (_("Subscription requested by %s"),
     empathy_contact_get_name (contact));
 
-  if (!G_STR_EMPTY (message))
-    g_string_append_printf (str, _("\nMessage: %s"), message);
+  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, str->str,
-    NULL, event_pending_subscribe_func, NULL);
+  event_manager_add (manager, contact, GTK_STOCK_DIALOG_QUESTION, header,
+    event_msg, NULL, event_pending_subscribe_func, NULL);
 
-  g_string_free (str, TRUE);
+  g_free (event_msg);
+  g_free (header);
 }
 
 static GObject *
@@ -561,7 +985,7 @@ event_manager_constructor (GType type,
 			(type, n_props, props);
 
 		manager_singleton = EMPATHY_EVENT_MANAGER (retval);
-		g_object_add_weak_pointer (retval, (gpointer *) &manager_singleton);
+		g_object_add_weak_pointer (retval, (gpointer) &manager_singleton);
 	}
 
 	return retval;
@@ -607,6 +1031,16 @@ empathy_event_manager_class_init (EmpathyEventManagerClass *klass)
       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));
 }
 
@@ -664,3 +1098,14 @@ empathy_event_activate (EmpathyEvent *event_public)
   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;
+}
+