#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
EmpathyTubeDispatch *tube_dispatch;
/* option signal handler */
gulong handler;
+ /* optional accept widget */
+ GtkWidget *dialog;
} EventManagerApproval;
typedef struct {
GSList *events;
/* Ongoing approvals */
GSList *approvals;
+
+ /* voip ringing sound */
+ guint voip_timeout;
+ gint ringing;
} EmpathyEventManagerPriv;
typedef struct _EventPriv EventPriv;
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);
}
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)
{
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)
msg, approval, event_text_channel_process_func, NULL);
g_free (header);
+ empathy_sound_play (empathy_main_window_get (),
+ EMPATHY_SOUND_CONVERSATION_NEW);
}
static void
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)
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
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
}
}
+static void
+invite_dialog_response_cb (GtkDialog *dialog,
+ gint response,
+ EventManagerApproval *approval)
+{
+ EmpathyTpChat *tp_chat;
+ TpChannel *channel;
+ EmpathyTpGroup *group;
+ EmpathyContact *self_contact;
+
+ 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);
+
+ group = empathy_tp_group_new (channel);
+ empathy_run_until_ready (group);
+
+ self_contact = empathy_tp_group_get_self_contact (group);
+ empathy_tp_group_add_member (group, self_contact, NULL);
+
+ empathy_dispatch_operation_approve (approval->operation);
+
+ g_object_unref (group);
+ g_object_unref (self_contact);
+}
+
+static void
+event_room_channel_process_func (EventPriv *event)
+{
+ GtkWidget *dialog, *button, *image;
+ TpHandle room_handle;
+ GArray *handles;
+ gchar **names;
+ TpChannel *channel = empathy_dispatch_operation_get_channel (
+ event->approval->operation);
+
+ if (event->approval->dialog != NULL)
+ {
+ gtk_window_present (GTK_WINDOW (event->approval->dialog));
+ return;
+ }
+
+ /* get room name */
+ room_handle = tp_channel_get_handle (channel, NULL);
+
+ handles = g_array_new (FALSE, FALSE, sizeof (guint));
+ g_array_append_val (handles, room_handle);
+
+ tp_cli_connection_run_inspect_handles (
+ tp_channel_borrow_connection (channel), -1,
+ TP_HANDLE_TYPE_ROOM, handles, &names, NULL, NULL);
+
+ /* 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),
+ *names);
+
+ 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);
+
+ g_array_free (handles, TRUE);
+ g_free (names);
+
+ event->approval->dialog = dialog;
+}
+
static void
event_manager_approve_channel_cb (EmpathyDispatcher *dispatcher,
EmpathyDispatchOperation *operation, EmpathyEventManager *manager)
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)
+ {
+ EmpathyTpGroup *group;
+ EmpathyPendingInfo *info;
+ gchar *msg;
+
+ group = empathy_tp_group_new (channel);
+ empathy_run_until_ready (group);
+ info = empathy_tp_group_get_invitation (group, NULL);
- approval->handler = g_signal_connect (tp_chat, "message-received",
- G_CALLBACK (event_manager_chat_message_received_cb), approval);
+ if (info == 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);
+
+ g_object_unref (group);
+ return;
+ }
+
+ /* We are invited to a room */
+ msg = g_strdup_printf ("%s invited you to join %s",
+ empathy_contact_get_name (info->actor),
+ tp_channel_get_identifier (channel));
+
+ approval->contact = g_object_ref (info->actor);
+
+ event_manager_add (approval->manager,
+ info->actor, EMPATHY_IMAGE_GROUP_MESSAGE, msg, info->message,
+ approval, event_room_channel_process_func, NULL);
+
+ empathy_sound_play (empathy_main_window_get (),
+ EMPATHY_SOUND_CONVERSATION_NEW);
+
+ g_object_unref (group);
+ }
}
else if (!tp_strdiff (channel_type, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA))
{
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);
(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;