#include <telepathy-glib/util.h>
#include <libempathy/empathy-dispatcher.h>
-#include <libempathy/empathy-contact-factory.h>
+#include <libempathy/empathy-tp-contact-factory.h>
#include <libempathy/empathy-contact-manager.h>
#include <libempathy/empathy-tp-chat.h>
#include <libempathy/empathy-tp-call.h>
+#include <libempathy/empathy-tp-file.h>
#include <libempathy/empathy-utils.h>
+#include <libempathy/empathy-call-factory.h>
#include <extensions/extensions.h>
EmpathyContact *contact;
/* Tube dispatcher if applicable */
EmpathyTubeDispatch *tube_dispatch;
- /* option signal handler */
+ /* option signal handler and it's instance */
gulong handler;
+ GObject *handler_instance;
+ /* optional accept widget */
+ GtkWidget *dialog;
} EventManagerApproval;
typedef struct {
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);
}
{
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;
}
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 (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;
+}
+
static void
event_manager_chat_message_received_cb (EmpathyTpChat *tp_chat,
EmpathyMessage *message, EventManagerApproval *approval)
g_free (header);
empathy_sound_play (empathy_main_window_get (),
EMPATHY_SOUND_CONVERSATION_NEW);
-
- g_free (msg);
}
static void
}
static void
-event_manager_media_channel_got_name_cb (EmpathyContact *contact,
- const GError *error, gpointer user_data, GObject *object)
+event_manager_media_channel_got_contact (EventManagerApproval *approval)
{
- EventManagerApproval *approval = user_data;
gchar *header;
- if (error != NULL)
- {
- /* FIXME just returning assuming the operation will be invalidated as
- * well */
- return;
- }
-
header = g_strdup_printf (_("Incoming call from %s"),
- empathy_contact_get_name (contact));
+ empathy_contact_get_name (approval->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);
-
- g_free (msg);
-}
-
-static void
-event_manager_media_channel_got_contact (EventManagerApproval *approval)
-{
- empathy_contact_call_when_ready (approval->contact,
- EMPATHY_CONTACT_READY_NAME, event_manager_media_channel_got_name_cb,
- approval, NULL, G_OBJECT (approval->manager));
}
static void
/* FIXME better sound for incoming tubes ? */
empathy_sound_play (empathy_main_window_get (),
EMPATHY_SOUND_CONVERSATION_NEW);
-
- g_free (msg);
}
static void
}
static void
-event_manager_tube_got_contact_name_cb (EmpathyContact *contact,
- const GError *error, gpointer user_data, GObject *object)
+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 assume that the operation gets invalidated as well (if it
- * didn't already */
- return;
+ /* 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 */
}
}
+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);
+ 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_cb (EmpathyTpContactFactory *factory,
+ 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;
+
+ 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);
+}
+
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);
+
+ 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))
{
}
}
- else if (!tp_strdiff (channel_type, EMP_IFACE_CHANNEL_TYPE_FILE_TRANSFER))
+ else if (!tp_strdiff (channel_type, TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER))
{
- EmpathyContact *contact;
- gchar *header;
- TpHandle handle;
- McAccount *account;
- EmpathyContactFactory *factory;
- TpChannel *channel = empathy_dispatch_operation_get_channel (operation);
+ EmpathyTpFile *file;
+ gchar *header;
- factory = empathy_contact_factory_dup_singleton ();
- 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);
+ 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 (contact));
+ empathy_contact_get_name (approval->contact));
- event_manager_add (manager, contact, EMPATHY_IMAGE_DOCUMENT_SEND,
+ 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_object_unref (factory);
- g_object_unref (account);
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))
{
- EmpathyContact *contact;
- TpHandle handle;
- TpHandleType handle_type;
- McAccount *account;
- EmpathyContactFactory *factory;
- EmpathyTubeDispatch *tube_dispatch;
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;
- factory = empathy_contact_factory_dup_singleton ();
- account = empathy_channel_get_account (channel);
-
- contact = empathy_contact_factory_get_from_handle (factory, account,
- handle);
-
- tube_dispatch = empathy_tube_dispatch_new (operation);
-
- approval->contact = contact;
- approval->tube_dispatch = tube_dispatch;
-
- empathy_contact_call_when_ready (contact,
- EMPATHY_CONTACT_READY_NAME, event_manager_tube_got_contact_name_cb,
- approval, NULL, G_OBJECT (manager));
-
- g_object_unref (factory);
- g_object_unref (account);
+ 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
{
{
EventPriv *event = l->data;
- if (event->public.contact == contact &&
- event->func == event_pending_subscribe_func)
- {
- event_remove (event);
- break;
+ 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);
-
header = g_strdup_printf (_("Subscription requested by %s"),
empathy_contact_get_name (contact));
(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;