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

diff --git a/src/empathy-event-manager.c b/src/empathy-event-manager.c
index f4e774b8..ef924864 100644
--- a/src/empathy-event-manager.c
+++ b/src/empathy-event-manager.c
@@ -31,14 +31,18 @@
 #include <libempathy/empathy-contact-manager.h>
 #include <libempathy/empathy-tp-chat.h>
 #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
@@ -58,6 +62,8 @@ typedef struct {
   EmpathyTubeDispatch *tube_dispatch;
   /* option signal handler */
   gulong handler;
+  /* optional accept widget */
+  GtkWidget *dialog;
 } EventManagerApproval;
 
 typedef struct {
@@ -66,6 +72,10 @@ typedef struct {
   GSList *events;
   /* Ongoing approvals */
   GSList *approvals;
+
+  /* voip ringing sound */
+  guint voip_timeout;
+  gint ringing;
 } EmpathyEventManagerPriv;
 
 typedef struct _EventPriv EventPriv;
@@ -121,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);
 }
 
@@ -141,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)
 {
@@ -182,6 +272,23 @@ event_channel_process_func (EventPriv *event)
   empathy_dispatch_operation_approve (event->approval->operation);
 }
 
+static void
+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)
@@ -197,6 +304,7 @@ event_lookup_by_approval (EmpathyEventManager *manager,
       if (event->approval == approval)
         {
           retval = event;
+          break;
         }
     }
 
@@ -218,6 +326,80 @@ event_update (EmpathyEventManager *manager, EventPriv *event,
   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)
@@ -232,10 +414,10 @@ event_manager_chat_message_received_cb (EmpathyTpChat *tp_chat,
    * queue. */
   event = event_lookup_by_approval (approval->manager, approval);
 
-  if (event != NULL && event->inhibit)
+  if (event != NULL && event->inhibit && approval->handler != 0)
     {
-      g_signal_handlers_disconnect_by_func (tp_chat,
-        event_manager_chat_message_received_cb, approval);
+      g_signal_handler_disconnect (tp_chat, approval->handler);
+      approval->handler = 0;
       return;
     }
 
@@ -250,9 +432,11 @@ event_manager_chat_message_received_cb (EmpathyTpChat *tp_chat,
     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_channel_process_func, NULL);
+      msg, approval, event_text_channel_process_func, NULL);
 
   g_free (header);
+  empathy_sound_play (empathy_main_window_get (),
+    EMPATHY_SOUND_CONVERSATION_NEW);
 }
 
 static void
@@ -261,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)
@@ -318,9 +514,10 @@ event_manager_media_channel_got_name_cb (EmpathyContact *contact,
 
   event_manager_add (approval->manager,
     approval->contact, EMPATHY_IMAGE_VOIP, header, NULL,
-    approval, event_channel_process_func, NULL);
+    approval, event_channel_process_voip_func, NULL);
 
   g_free (header);
+  event_manager_start_ringing (approval->manager);
 }
 
 static void
@@ -379,6 +576,9 @@ event_manager_add_tube_approval (EventManagerApproval *approval,
     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);
 }
 
 static void
@@ -432,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)
@@ -459,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))
     {
@@ -510,6 +868,10 @@ event_manager_approve_channel_cb (EmpathyDispatcher *dispatcher,
       event_manager_add (manager, 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_object_unref (factory);
       g_object_unref (account);
       g_free (header);
@@ -623,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;