* Sjoerd Simons <sjoerd.simons@collabora.co.uk>
*/
-#include <config.h>
+#include "config.h"
+#include "empathy-event-manager.h"
-#include <string.h>
#include <glib/gi18n.h>
-
-#include <telepathy-glib/account-manager.h>
-#include <telepathy-glib/util.h>
-#include <telepathy-glib/interfaces.h>
-#include <telepathy-glib/simple-approver.h>
-
-#include <libempathy/empathy-presence-manager.h>
-#include <libempathy/empathy-tp-contact-factory.h>
-#include <libempathy/empathy-contact-manager.h>
-#include <libempathy/empathy-tp-chat.h>
-#include <libempathy/empathy-tp-streamed-media.h>
-#include <libempathy/empathy-tp-file.h>
-#include <libempathy/empathy-utils.h>
-#include <libempathy/empathy-gsettings.h>
-
-#include <extensions/extensions.h>
-
-#include <libempathy-gtk/empathy-images.h>
-#include <libempathy-gtk/empathy-contact-dialogs.h>
-#include <libempathy-gtk/empathy-sound-manager.h>
-#include <libempathy-gtk/empathy-ui-utils.h>
-
-#include "empathy-event-manager.h"
-#include "empathy-main-window.h"
+#include <tp-account-widgets/tpaw-images.h>
+#include <tp-account-widgets/tpaw-utils.h>
+#include <telepathy-glib/telepathy-glib-dbus.h>
+
+#include "empathy-call-utils.h"
+#include "empathy-connection-aggregator.h"
+#include "empathy-gsettings.h"
+#include "empathy-images.h"
+#include "empathy-presence-manager.h"
+#include "empathy-sasl-mechanisms.h"
+#include "empathy-sound-manager.h"
+#include "empathy-subscription-dialog.h"
+#include "empathy-tp-chat.h"
+#include "empathy-ui-utils.h"
+#include "empathy-utils.h"
#define DEBUG_FLAG EMPATHY_DEBUG_DISPATCHER
-#include <libempathy/empathy-debug.h>
+#include "empathy-debug.h"
#define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyEventManager)
#define NOTIFICATION_TIMEOUT 2 /* seconds */
+#define ACCEPT_WITHOUT_VIDEO 1
+
/* The time interval in milliseconds between 2 incoming rings */
#define MS_BETWEEN_RING 500
typedef struct {
TpBaseClient *approver;
TpBaseClient *auth_approver;
- EmpathyContactManager *contact_manager;
+ EmpathyConnectionAggregator *conn_aggregator;
GSList *events;
/* Ongoing approvals */
GSList *approvals;
GSettings *gsettings_ui;
EmpathySoundManager *sound_mgr;
+
+ /* TpContact -> EmpathyContact */
+ GHashTable *contacts;
} EmpathyEventManagerPriv;
typedef struct _EventPriv EventPriv;
event->public.header = g_strdup (header);
event->public.message = g_strdup (message);
event->public.must_ack = (func != NULL);
+ if (approval != NULL)
+ event->public.handler_instance = approval->handler_instance;
event->inhibit = FALSE;
event->func = func;
event->user_data = user_data;
}
}
-static void
-handle_with_cb (GObject *source,
- GAsyncResult *result,
- gpointer user_data)
-{
- TpChannelDispatchOperation *cdo = TP_CHANNEL_DISPATCH_OPERATION (source);
- GError *error = NULL;
-
- if (!tp_channel_dispatch_operation_handle_with_finish (cdo, result, &error))
- {
- DEBUG ("HandleWith failed: %s\n", error->message);
- g_error_free (error);
- }
-}
-
static void
handle_with_time_cb (GObject *source,
GAsyncResult *result,
if (!tp_channel_dispatch_operation_handle_with_time_finish (cdo, result,
&error))
{
- if (g_error_matches (error, TP_ERRORS, TP_ERROR_NOT_IMPLEMENTED))
- {
- EventManagerApproval *approval = user_data;
-
- DEBUG ("HandleWithTime() is not implemented, falling back to "
- "HandleWith(). Please upgrade to telepathy-mission-control "
- "5.5.0 or later");
-
- tp_channel_dispatch_operation_handle_with_async (approval->operation,
- NULL, handle_with_cb, approval);
- }
- else
- {
- DEBUG ("HandleWithTime failed: %s\n", error->message);
- }
+ DEBUG ("HandleWithTime failed: %s\n", error->message);
g_error_free (error);
}
}
TpChannelDispatchOperation *cdo = TP_CHANNEL_DISPATCH_OPERATION (source);
GError *error = NULL;
- if (!tp_channel_dispatch_operation_claim_finish (cdo, result, &error))
+ if (!tp_channel_dispatch_operation_claim_with_finish (cdo, result, &error))
{
DEBUG ("Failed to claim channel: %s", error->message);
goto out;
}
- if (EMPATHY_IS_TP_STREAMED_MEDIA (user_data))
+ if (TP_IS_CALL_CHANNEL (user_data))
{
- empathy_tp_streamed_media_close (user_data);
+ tp_call_channel_hangup_async (user_data,
+ TP_CALL_STATE_CHANGE_REASON_USER_REQUESTED,
+ "", "", NULL, NULL);
+ tp_channel_close_async (user_data, NULL, NULL);
}
else if (EMPATHY_IS_TP_CHAT (user_data))
{
empathy_tp_chat_leave (user_data, "");
}
- else if (EMPATHY_IS_TP_FILE (user_data))
+ else if (TP_IS_FILE_TRANSFER_CHANNEL (user_data))
{
- empathy_tp_file_close (user_data);
+ tp_channel_close_async (user_data, NULL, NULL);
}
out:
g_object_unref (user_data);
}
-static void
-reject_auth_channel_claim_cb (GObject *source,
- GAsyncResult *result,
- gpointer user_data)
-{
- TpChannelDispatchOperation *cdo = TP_CHANNEL_DISPATCH_OPERATION (source);
- GError *error = NULL;
-
- if (!tp_channel_dispatch_operation_claim_finish (cdo, result, &error))
- {
- DEBUG ("Failed to claim channel: %s", error->message);
-
- g_error_free (error);
- return;
- }
-
- tp_cli_channel_call_close (TP_CHANNEL (user_data), -1,
- NULL, NULL, NULL, NULL);
-}
-
static void
reject_approval (EventManagerApproval *approval)
{
+ EmpathyEventManagerPriv *priv = GET_PRIV (approval->manager);
+
/* We have to claim the channel before closing it */
/* Unfortunately, we need to special case the auth channels for the
* directly. */
if (approval->handler_instance != NULL)
{
- tp_channel_dispatch_operation_claim_async (approval->operation,
- reject_channel_claim_cb, g_object_ref (approval->handler_instance));
+ tp_channel_dispatch_operation_claim_with_async (approval->operation,
+ priv->approver, reject_channel_claim_cb,
+ g_object_ref (approval->handler_instance));
}
else if (tp_channel_get_channel_type_id (approval->main_channel)
== TP_IFACE_QUARK_CHANNEL_TYPE_SERVER_AUTHENTICATION)
{
- tp_channel_dispatch_operation_claim_async (approval->operation,
- reject_auth_channel_claim_cb, approval->main_channel);
+ tp_channel_dispatch_operation_close_channels_async (approval->operation,
+ NULL, NULL);
}
}
gtk_widget_destroy (approval->dialog);
approval->dialog = NULL;
- if (response != GTK_RESPONSE_ACCEPT)
+ if (response == GTK_RESPONSE_ACCEPT)
{
- reject_approval (approval);
+ event_manager_approval_approve (approval);
}
- else
+ else if (response == ACCEPT_WITHOUT_VIDEO)
{
+ empathy_call_channel_send_video (TP_CALL_CHANNEL (approval->main_channel),
+ FALSE);
event_manager_approval_approve (approval);
}
+ else
+ {
+ reject_approval (approval);
+ }
}
static void
GtkWidget *dialog;
GtkWidget *button;
GtkWidget *image;
- EmpathyTpStreamedMedia *call;
gboolean video;
gchar *title;
+ EmpathyEventType etype = event->public.type;
if (event->approval->dialog != NULL)
{
return;
}
- call = EMPATHY_TP_STREAMED_MEDIA (event->approval->handler_instance);
-
- video = empathy_tp_streamed_media_has_initial_video (call);
+ if (etype == EMPATHY_EVENT_TYPE_CALL)
+ {
+ TpCallChannel *call;
+ call = TP_CALL_CHANNEL (event->approval->handler_instance);
+ video = tp_call_channel_has_initial_video (call, NULL);
+ }
+ else
+ {
+ g_warning ("Unknown event type: %d", event->public.type);
+ return;
+ }
dialog = gtk_message_dialog_new (NULL, 0,
GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE,
GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON (button), image);
+ if (video && etype == EMPATHY_EVENT_TYPE_CALL)
+ {
+ button = gtk_dialog_add_button (GTK_DIALOG (dialog),
+ _("_Answer"), ACCEPT_WITHOUT_VIDEO);
+
+ image = gtk_image_new_from_icon_name ("call-start",
+ GTK_ICON_SIZE_BUTTON);
+ gtk_button_set_image (GTK_BUTTON (button), image);
+ }
+
button = gtk_dialog_add_button (GTK_DIALOG (dialog),
- _("_Answer"), GTK_RESPONSE_ACCEPT);
+ video ? _("_Answer with video") : _("_Answer"), GTK_RESPONSE_ACCEPT);
- image = gtk_image_new_from_icon_name ("call-start", GTK_ICON_SIZE_BUTTON);
+ image = gtk_image_new_from_icon_name ("call-start",
+ 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);
+ G_CALLBACK (event_manager_call_window_confirmation_dialog_response_cb),
+ event->approval);
gtk_widget_show (dialog);
EmpathyMessage *message,
EventManagerApproval *approval)
{
- GtkWidget *window;
EmpathyContact *sender;
const gchar *header;
const gchar *msg;
EMPATHY_EVENT_TYPE_CHAT, EMPATHY_IMAGE_NEW_MESSAGE, header, msg,
approval, event_text_channel_process_func, NULL);
- window = empathy_main_window_dup ();
-
- empathy_sound_manager_play (priv->sound_mgr, window,
+ empathy_sound_manager_play (priv->sound_mgr, NULL,
EMPATHY_SOUND_CONVERSATION_NEW);
-
- g_object_unref (window);
}
static void
channel_type = tp_channel_get_channel_type_id (approval->main_channel);
- if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_STREAMED_MEDIA)
+ if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_CALL)
{
priv->ringing--;
if (priv->ringing == 0)
}
static void
-event_manager_media_channel_got_contact (EventManagerApproval *approval)
-{
- EmpathyEventManagerPriv *priv = GET_PRIV (approval->manager);
- GtkWidget *window = empathy_main_window_dup ();
- gchar *header;
- EmpathyTpStreamedMedia *call;
- gboolean video;
-
- call = EMPATHY_TP_STREAMED_MEDIA (approval->handler_instance);
-
- video = empathy_tp_streamed_media_has_initial_video (call);
-
- header = g_strdup_printf (
- video ? _("Incoming video call from %s") :_("Incoming call from %s"),
- empathy_contact_get_alias (approval->contact));
-
- event_manager_add (approval->manager, NULL,
- approval->contact, EMPATHY_EVENT_TYPE_VOIP,
- video ? EMPATHY_IMAGE_VIDEO_CALL : EMPATHY_IMAGE_VOIP,
- header, NULL, approval,
- event_channel_process_voip_func, NULL);
-
- g_free (header);
-
- priv->ringing++;
- if (priv->ringing == 1)
- empathy_sound_manager_start_playing (priv->sound_mgr, window,
- EMPATHY_SOUND_PHONE_INCOMING, MS_BETWEEN_RING);
-
- g_object_unref (window);
-}
-
-static void
-event_manager_media_channel_contact_changed_cb (EmpathyTpStreamedMedia *call,
- GParamSpec *param, EventManagerApproval *approval)
+event_manager_call_state_changed_cb (TpCallChannel *call,
+ TpCallState state,
+ TpCallFlags flags,
+ TpCallStateReason *reason,
+ GHashTable *details,
+ EventManagerApproval *approval)
{
- 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);
+ if (state == TP_CALL_STATE_ENDED)
+ {
+ DEBUG ("Call ended, seems we missed it :/");
+ reject_approval (approval);
+ }
}
static void
static void
display_invite_room_dialog (EventManagerApproval *approval)
{
- GtkWidget *window = empathy_main_window_dup ();
const gchar *invite_msg;
gchar *msg;
- TpHandle self_handle;
+ TpContact *self_contact;
EmpathyEventManagerPriv *priv = GET_PRIV (approval->manager);
- self_handle = tp_channel_group_get_self_handle (approval->main_channel);
- tp_channel_group_get_local_pending_info (approval->main_channel, self_handle,
- NULL, NULL, &invite_msg);
+ self_contact = tp_channel_group_get_self_contact (approval->main_channel);
+ tp_channel_group_get_local_pending_contact_info (approval->main_channel,
+ self_contact, NULL, NULL, &invite_msg);
if (approval->contact != NULL)
{
EMPATHY_IMAGE_GROUP_MESSAGE, msg, invite_msg, approval,
event_room_channel_process_func, NULL);
- empathy_sound_manager_play (priv->sound_mgr, window,
+ empathy_sound_manager_play (priv->sound_mgr, NULL,
EMPATHY_SOUND_CONVERSATION_NEW);
g_free (msg);
- g_object_unref (window);
}
static void
-event_manager_muc_invite_got_contact_cb (TpConnection *connection,
- EmpathyContact *contact,
- const GError *error,
- gpointer user_data,
- GObject *object)
+event_manager_auth_process_func (EventPriv *event)
+{
+ empathy_event_approve ((EmpathyEvent *) event);
+}
+
+/* If there is a file-transfer, media, or auth channel consider it as
+ * the main one. */
+static TpChannel *
+find_main_channel (GList *channels)
{
- EventManagerApproval *approval = (EventManagerApproval *) user_data;
+ GList *l;
+ TpChannel *text = NULL;
- if (error != NULL)
+ for (l = channels; l != NULL; l = g_list_next (l))
{
- DEBUG ("Error: %s", error->message);
+ TpChannel *channel = l->data;
+ GQuark channel_type;
+
+ if (tp_proxy_get_invalidated (channel) != NULL)
+ continue;
+
+ channel_type = tp_channel_get_channel_type_id (channel);
+
+ if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_CALL ||
+ channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_FILE_TRANSFER ||
+ channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_SERVER_AUTHENTICATION)
+ return channel;
+
+ else if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_TEXT)
+ text = channel;
}
- else
+
+ return text;
+}
+
+static void
+approve_text_channel (EmpathyEventManager *self,
+ EventManagerApproval *approval,
+ TpAddDispatchOperationContext *context,
+ EmpathyTpChat *tp_chat)
+{
+ GList *messages, *l;
+
+ approval->handler_instance = g_object_ref (tp_chat);
+
+ if (tp_proxy_has_interface (tp_chat, TP_IFACE_CHANNEL_INTERFACE_GROUP))
+ {
+ /* Are we in local-pending ? */
+ TpContact *inviter;
+
+ if (empathy_tp_chat_is_invited (tp_chat, &inviter))
+ {
+ /* We are invited to a room */
+ DEBUG ("Have been invited to %s. Ask user if he wants to accept",
+ tp_channel_get_identifier (TP_CHANNEL_GROUP_CHANGE_REASON_NONE));
+
+ if (inviter != NULL)
+ {
+ approval->contact = empathy_contact_dup_from_tp_contact (
+ inviter);
+ }
+
+ display_invite_room_dialog (approval);
+ tp_add_dispatch_operation_context_accept (context);
+
+ return;
+ }
+
+ /* We are not invited, approve the channel right now */
+ tp_add_dispatch_operation_context_accept (context);
+
+ approval->auto_approved = TRUE;
+ event_manager_approval_approve (approval);
+ return;
+ }
+
+ /* 1-1 text channel, wait for the first message */
+ approval->handler = g_signal_connect (tp_chat, "message-received-empathy",
+ G_CALLBACK (event_manager_chat_message_received_cb), approval);
+
+ messages = (GList *) empathy_tp_chat_get_pending_messages (tp_chat);
+ for (l = messages; l != NULL; l = g_list_next (l))
+ {
+ EmpathyMessage *msg = l->data;
+
+ event_manager_chat_message_received_cb (tp_chat, msg, approval);
+ }
+
+ tp_add_dispatch_operation_context_accept (context);
+}
+
+static void
+approval_set_target_contact (EventManagerApproval *approval,
+ TpChannel *channel)
+{
+ TpContact *contact;
+
+ contact = tp_channel_get_target_contact (channel);
+ approval->contact = empathy_contact_dup_from_tp_contact (contact);
+}
+
+static void
+approve_call_channel (EmpathyEventManager *self,
+ EventManagerApproval *approval,
+ TpAddDispatchOperationContext *context,
+ TpCallChannel *call)
+{
+ TpChannel *channel = TP_CHANNEL (call);
+ EmpathyEventManagerPriv *priv = GET_PRIV (approval->manager);
+ gchar *header;
+ gboolean video;
+
+ approval->handler_instance = g_object_ref (call);
+ approval_set_target_contact (approval, channel);
+
+ tp_add_dispatch_operation_context_accept (context);
+
+ if (tp_call_channel_get_state (call, NULL, NULL, NULL) == TP_CALL_STATE_ENDED)
{
- approval->contact = g_object_ref (contact);
+ DEBUG ("Call already ended, seems we missed it :/");
+ reject_approval (approval);
+ return;
}
- display_invite_room_dialog (approval);
+ approval->handler = g_signal_connect (call, "state-changed",
+ G_CALLBACK (event_manager_call_state_changed_cb), approval);
+
+ g_object_get (G_OBJECT (call), "initial-video", &video, NULL);
+
+ header = g_strdup_printf (
+ video ? _("Incoming video call from %s") :_("Incoming call from %s"),
+ empathy_contact_get_alias (approval->contact));
+
+ event_manager_add (approval->manager, NULL,
+ approval->contact, EMPATHY_EVENT_TYPE_CALL,
+ video ? EMPATHY_IMAGE_VIDEO_CALL : EMPATHY_IMAGE_VOIP,
+ header, NULL, approval,
+ event_channel_process_voip_func, NULL);
+
+ g_free (header);
+
+ priv->ringing++;
+ if (priv->ringing == 1)
+ {
+ TpAccountManager *am = tp_account_manager_dup ();
+ TpConnectionPresenceType presence;
+
+ presence = tp_account_manager_get_most_available_presence (am,
+ NULL, NULL);
+
+ if (presence != TP_CONNECTION_PRESENCE_TYPE_BUSY)
+ empathy_sound_manager_start_playing (priv->sound_mgr, NULL,
+ EMPATHY_SOUND_PHONE_INCOMING, MS_BETWEEN_RING);
+
+ g_object_unref (am);
+ }
}
static void
-event_manager_ft_got_contact_cb (TpConnection *connection,
- EmpathyContact *contact,
- const GError *error,
- gpointer user_data,
- GObject *object)
+approve_ft_channel (EmpathyEventManager *self,
+ EventManagerApproval *approval,
+ TpAddDispatchOperationContext *context,
+ TpFileTransferChannel *ft)
{
- EventManagerApproval *approval = (EventManagerApproval *) user_data;
- GtkWidget *window = empathy_main_window_dup ();
- char *header;
+ TpChannel *channel = TP_CHANNEL (ft);
EmpathyEventManagerPriv *priv = GET_PRIV (approval->manager);
+ gchar *header;
+
+ approval->handler_instance = g_object_ref (ft);
+ approval_set_target_contact (approval, channel);
- approval->contact = g_object_ref (contact);
+ tp_add_dispatch_operation_context_accept (context);
header = g_strdup_printf (_("Incoming file transfer from %s"),
- empathy_contact_get_alias (approval->contact));
+ empathy_contact_get_alias (approval->contact));
event_manager_add (approval->manager, NULL,
approval->contact, EMPATHY_EVENT_TYPE_TRANSFER,
approval, event_channel_process_func, NULL);
/* FIXME better sound for incoming file transfers ?*/
- empathy_sound_manager_play (priv->sound_mgr, window,
+ empathy_sound_manager_play (priv->sound_mgr, NULL,
EMPATHY_SOUND_CONVERSATION_NEW);
g_free (header);
- g_object_unref (window);
}
static void
-event_manager_auth_process_func (EventPriv *event)
-{
- empathy_event_approve ((EmpathyEvent *) event);
-}
-
-/* If there is a file-transfer, media, or auth channel consider it as
- * the main one. */
-static TpChannel *
-find_main_channel (GList *channels)
+approve_sasl_channel (EmpathyEventManager *self,
+ TpAccount *account,
+ EventManagerApproval *approval,
+ TpAddDispatchOperationContext *context,
+ TpChannel *channel)
{
- GList *l;
- TpChannel *text = NULL;
-
- for (l = channels; l != NULL; l = g_list_next (l))
+ if (empathy_sasl_channel_supports_mechanism (channel, "X-TELEPATHY-PASSWORD"))
{
- TpChannel *channel = l->data;
- GQuark channel_type;
-
- if (tp_proxy_get_invalidated (channel) != NULL)
- continue;
-
- channel_type = tp_channel_get_channel_type_id (channel);
-
- if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_STREAMED_MEDIA ||
- channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_FILE_TRANSFER ||
- channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_SERVER_AUTHENTICATION)
- return channel;
+ event_manager_add (approval->manager, account, NULL,
+ EMPATHY_EVENT_TYPE_AUTH,
+ GTK_STOCK_DIALOG_AUTHENTICATION,
+ tp_account_get_display_name (account),
+ _("Password required"), approval,
+ event_manager_auth_process_func, NULL);
+ }
+ else
+ {
+ GError error = { TP_ERROR, TP_ERROR_NOT_IMPLEMENTED,
+ "Support only X-TELEPATHY-PASSWORD auth method" };
- else if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_TEXT)
- text = channel;
+ tp_add_dispatch_operation_context_fail (context, &error);
+ return;
}
- return text;
+ tp_add_dispatch_operation_context_accept (context);
}
static void
channel = find_main_channel (channels);
if (channel == NULL)
{
- GError error = { TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+ GError error = { TP_ERROR, TP_ERROR_INVALID_ARGUMENT,
"Unknown channel type" };
DEBUG ("Failed to find the main channel; ignoring");
channel_type = tp_channel_get_channel_type_id (channel);
- if (TP_IS_TEXT_CHANNEL (channel))
+ if (EMPATHY_IS_TP_CHAT (channel))
{
- EmpathyTpChat *tp_chat;
-
- tp_chat = empathy_tp_chat_new (account, channel);
- approval->handler_instance = G_OBJECT (tp_chat);
-
- if (tp_proxy_has_interface (channel, TP_IFACE_CHANNEL_INTERFACE_GROUP))
- {
- /* Are we in local-pending ? */
- TpHandle inviter;
-
- if (empathy_tp_chat_is_invited (tp_chat, &inviter))
- {
- /* We are invited to a room */
- DEBUG ("Have been invited to %s. Ask user if he wants to accept",
- tp_channel_get_identifier (channel));
-
- if (inviter != 0)
- {
- empathy_tp_contact_factory_get_from_handle (connection,
- inviter, event_manager_muc_invite_got_contact_cb,
- approval, NULL, G_OBJECT (self));
- }
- else
- {
- display_invite_room_dialog (approval);
- }
-
- goto out;
- }
-
- /* We are not invited, approve the channel right now */
- tp_add_dispatch_operation_context_accept (context);
-
- approval->auto_approved = TRUE;
- event_manager_approval_approve (approval);
- return;
- }
-
- /* 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);
+ approve_text_channel (self, approval, context, EMPATHY_TP_CHAT (channel));
}
- else if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_STREAMED_MEDIA)
+ else if (TP_IS_CALL_CHANNEL (channel))
{
- EmpathyContact *contact;
- EmpathyTpStreamedMedia *call = empathy_tp_streamed_media_new (account, channel);
-
- approval->handler_instance = G_OBJECT (call);
-
- 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);
- }
-
+ approve_call_channel (self, approval, context, TP_CALL_CHANNEL (channel));
}
- else if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_FILE_TRANSFER)
+ else if (TP_IS_FILE_TRANSFER_CHANNEL (channel))
{
- TpHandle handle;
- EmpathyTpFile *tp_file = empathy_tp_file_new (channel);
-
- approval->handler_instance = G_OBJECT (tp_file);
-
- handle = tp_channel_get_handle (channel, NULL);
-
- connection = tp_channel_borrow_connection (channel);
- empathy_tp_contact_factory_get_from_handle (connection, handle,
- event_manager_ft_got_contact_cb, approval, NULL, G_OBJECT (self));
+ approve_ft_channel (self, approval, context,
+ TP_FILE_TRANSFER_CHANNEL (channel));
}
else if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_SERVER_AUTHENTICATION)
{
- event_manager_add (approval->manager, account, NULL, EMPATHY_EVENT_TYPE_AUTH,
- GTK_STOCK_DIALOG_AUTHENTICATION, tp_account_get_display_name (account),
- _("Password required"), approval,
- event_manager_auth_process_func, NULL);
+ approve_sasl_channel (self, account, approval, context, channel);
}
else
{
- GError error = { TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
+ GError error = { TP_ERROR, TP_ERROR_INVALID_ARGUMENT,
"Invalid channel type" };
DEBUG ("Unknown channel type (%s), ignoring..",
tp_add_dispatch_operation_context_fail (context, &error);
return;
}
-
-out:
- tp_add_dispatch_operation_context_accept (context);
}
static void
event_pending_subscribe_func (EventPriv *event)
{
- empathy_subscription_dialog_show (event->public.contact, event->public.header,
- NULL);
+ GtkWidget *dialog;
+ FolksIndividual *individual;
+
+ individual = empathy_ensure_individual_from_tp_contact (
+ empathy_contact_get_tp_contact (event->public.contact));
+
+ dialog = empathy_subscription_dialog_new (individual, event->public.message);
+ gtk_window_present (GTK_WINDOW (dialog));
+
event_remove (event);
+
+ g_object_unref (individual);
}
static void
-event_manager_pendings_changed_cb (EmpathyContactList *list,
- EmpathyContact *contact, EmpathyContact *actor,
- guint reason, gchar *message, gboolean is_pending,
- EmpathyEventManager *manager)
+check_publish_state (EmpathyEventManager *self,
+ TpContact *tp_contact)
{
- EmpathyEventManagerPriv *priv = GET_PRIV (manager);
- gchar *header, *event_msg;
+ EmpathyEventManagerPriv *priv = GET_PRIV (self);
+ gchar *header, *event_msg;
+ TpSubscriptionState state;
+ EmpathyContact *contact;
+ const gchar *message;
+
+ state = tp_contact_get_publish_state (tp_contact);
+
+ contact = empathy_contact_dup_from_tp_contact (tp_contact);
- if (!is_pending)
+ if (state != TP_SUBSCRIPTION_STATE_ASK)
{
GSList *l;
}
}
- return;
+ goto out;
}
header = g_strdup_printf (
_("%s would like permission to see when you are online"),
empathy_contact_get_alias (contact));
- if (!EMP_STR_EMPTY (message))
+ message = tp_contact_get_publish_request (tp_contact);
+
+ if (!TPAW_STR_EMPTY (message))
event_msg = g_strdup_printf (_("\nMessage: %s"), message);
else
event_msg = NULL;
- event_manager_add (manager, NULL, contact, EMPATHY_EVENT_TYPE_SUBSCRIPTION,
+ event_manager_add (self, NULL, contact, EMPATHY_EVENT_TYPE_SUBSCRIPTION,
GTK_STOCK_DIALOG_QUESTION, header, event_msg, NULL,
event_pending_subscribe_func, NULL);
g_free (event_msg);
g_free (header);
+
+out:
+ g_object_unref (contact);
}
static void
-event_manager_presence_changed_cb (EmpathyContact *contact,
+event_manager_publish_state_changed_cb (TpContact *contact,
+ GParamSpec *spec,
+ EmpathyEventManager *self)
+{
+ check_publish_state (self, contact);
+}
+
+static void
+check_presence (EmpathyEventManager *manager,
+ EmpathyContact *contact,
TpConnectionPresenceType current,
- TpConnectionPresenceType previous,
- EmpathyEventManager *manager)
+ TpConnectionPresenceType previous)
{
EmpathyEventManagerPriv *priv = GET_PRIV (manager);
TpAccount *account;
EmpathyPresenceManager *presence_mgr;
- GtkWidget *window = empathy_main_window_dup ();
account = empathy_contact_get_account (contact);
presence_mgr = empathy_presence_manager_dup_singleton ();
TP_CONNECTION_PRESENCE_TYPE_OFFLINE) <= 0)
{
/* someone is logging off */
- empathy_sound_manager_play (priv->sound_mgr, window,
+ empathy_sound_manager_play (priv->sound_mgr, NULL,
EMPATHY_SOUND_CONTACT_DISCONNECTED);
if (g_settings_get_boolean (priv->gsettings_notif,
{
event_manager_add (manager, NULL, contact,
EMPATHY_EVENT_TYPE_PRESENCE_OFFLINE,
- EMPATHY_IMAGE_AVATAR_DEFAULT,
+ TPAW_IMAGE_AVATAR_DEFAULT,
empathy_contact_get_alias (contact), _("Disconnected"),
NULL, NULL, NULL);
}
TP_CONNECTION_PRESENCE_TYPE_OFFLINE) > 0)
{
/* someone is logging in */
- empathy_sound_manager_play (priv->sound_mgr, window,
+ empathy_sound_manager_play (priv->sound_mgr, NULL,
EMPATHY_SOUND_CONTACT_CONNECTED);
if (g_settings_get_boolean (priv->gsettings_notif,
{
event_manager_add (manager, NULL, contact,
EMPATHY_EVENT_TYPE_PRESENCE_ONLINE,
- EMPATHY_IMAGE_AVATAR_DEFAULT,
+ TPAW_IMAGE_AVATAR_DEFAULT,
empathy_contact_get_alias (contact), _("Connected"),
NULL, NULL, NULL);
}
out:
g_object_unref (presence_mgr);
- g_object_unref (window);
}
static void
-event_manager_members_changed_cb (EmpathyContactList *list,
- EmpathyContact *contact,
- EmpathyContact *actor,
- guint reason,
- gchar *message,
- gboolean is_member,
+event_manager_presence_changed_cb (EmpathyContact *contact,
+ TpConnectionPresenceType current,
+ TpConnectionPresenceType previous,
EmpathyEventManager *manager)
{
- if (is_member)
- g_signal_connect (contact, "presence-changed",
- G_CALLBACK (event_manager_presence_changed_cb), manager);
- else
- g_signal_handlers_disconnect_by_func (contact,
- event_manager_presence_changed_cb, manager);
+ check_presence (manager, contact, current, previous);
}
static GObject *
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->conn_aggregator);
g_object_unref (priv->approver);
g_object_unref (priv->auth_approver);
g_object_unref (priv->gsettings_notif);
g_object_unref (priv->gsettings_ui);
g_object_unref (priv->sound_mgr);
+ g_hash_table_unref (priv->contacts);
}
static void
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
- g_cclosure_marshal_VOID__POINTER,
+ g_cclosure_marshal_generic,
G_TYPE_NONE,
1, G_TYPE_POINTER);
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
- g_cclosure_marshal_VOID__POINTER,
+ g_cclosure_marshal_generic,
G_TYPE_NONE, 1, G_TYPE_POINTER);
signals[EVENT_UPDATED] =
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
- g_cclosure_marshal_VOID__POINTER,
+ g_cclosure_marshal_generic,
G_TYPE_NONE, 1, G_TYPE_POINTER);
g_type_class_add_private (object_class, sizeof (EmpathyEventManagerPriv));
}
+static void
+contact_list_changed_cb (EmpathyConnectionAggregator *aggregator,
+ GPtrArray *added,
+ GPtrArray *removed,
+ EmpathyEventManager *self)
+{
+ EmpathyEventManagerPriv *priv = GET_PRIV (self);
+ guint i;
+
+ for (i = 0; i < added->len; i++)
+ {
+ TpContact *tp_contact = g_ptr_array_index (added, i);
+ EmpathyContact *contact;
+
+ if (g_hash_table_lookup (priv->contacts, tp_contact) != NULL)
+ continue;
+
+ contact = empathy_contact_dup_from_tp_contact (tp_contact);
+
+ tp_g_signal_connect_object (contact, "presence-changed",
+ G_CALLBACK (event_manager_presence_changed_cb), self, 0);
+
+ check_presence (self, contact,
+ empathy_contact_get_presence (contact),
+ TP_CONNECTION_PRESENCE_TYPE_OFFLINE);
+
+ tp_g_signal_connect_object (tp_contact, "notify::publish-state",
+ G_CALLBACK (event_manager_publish_state_changed_cb), self, 0);
+
+ check_publish_state (self, tp_contact);
+
+ /* Pass ownership to the hash table */
+ g_hash_table_insert (priv->contacts, g_object_ref (tp_contact), contact);
+ }
+
+ for (i = 0; i < removed->len; i++)
+ {
+ TpContact *tp_contact = g_ptr_array_index (removed, i);
+ EmpathyContact *contact;
+
+ contact = g_hash_table_lookup (priv->contacts, tp_contact);
+ if (contact == NULL)
+ continue;
+
+ g_signal_handlers_disconnect_by_func (contact,
+ event_manager_presence_changed_cb, self);
+
+ g_signal_handlers_disconnect_by_func (tp_contact,
+ event_manager_publish_state_changed_cb, self);
+
+ g_hash_table_remove (priv->contacts, tp_contact);
+ }
+}
+
static void
empathy_event_manager_init (EmpathyEventManager *manager)
{
EmpathyEventManagerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (manager,
EMPATHY_TYPE_EVENT_MANAGER, EmpathyEventManagerPriv);
- TpDBusDaemon *dbus;
GError *error = NULL;
+ TpAccountManager *am;
+ GPtrArray *contacts, *empty;
manager->priv = priv;
priv->sound_mgr = empathy_sound_manager_dup_singleton ();
- priv->contact_manager = empathy_contact_manager_dup_singleton ();
- g_signal_connect (priv->contact_manager, "pendings-changed",
- G_CALLBACK (event_manager_pendings_changed_cb), manager);
+ priv->contacts = g_hash_table_new_full (NULL, NULL, g_object_unref,
+ g_object_unref);
- g_signal_connect (priv->contact_manager, "members-changed",
- G_CALLBACK (event_manager_members_changed_cb), manager);
+ priv->conn_aggregator = empathy_connection_aggregator_dup_singleton ();
- dbus = tp_dbus_daemon_dup (&error);
- if (dbus == NULL)
- {
- DEBUG ("Failed to get TpDBusDaemon: %s", error->message);
- g_error_free (error);
- return;
- }
+ tp_g_signal_connect_object (priv->conn_aggregator, "contact-list-changed",
+ G_CALLBACK (contact_list_changed_cb), manager, 0);
+
+ contacts = empathy_connection_aggregator_dup_all_contacts (
+ priv->conn_aggregator);
+
+ empty = g_ptr_array_new ();
+
+ contact_list_changed_cb (priv->conn_aggregator, contacts, empty, manager);
+
+ g_ptr_array_unref (contacts);
+ g_ptr_array_unref (empty);
- priv->approver = tp_simple_approver_new (dbus, "Empathy.EventManager", FALSE,
- approve_channels, manager, NULL);
+ am = tp_account_manager_dup ();
- /* EmpathyTpChat relies on this feature being prepared */
- tp_base_client_add_connection_features_varargs (priv->approver,
- TP_CONNECTION_FEATURE_CAPABILITIES, 0);
+ priv->approver = tp_simple_approver_new_with_am (am, "Empathy.EventManager",
+ FALSE, approve_channels, manager, NULL);
/* Private text channels */
tp_base_client_take_approver_filter (priv->approver,
tp_base_client_take_approver_filter (priv->approver,
tp_asv_new (
TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
- TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA,
+ TP_IFACE_CHANNEL_TYPE_CALL,
TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, G_TYPE_UINT, TP_HANDLE_TYPE_CONTACT,
NULL));
* EmpathyTpChat and its users to not depend on the connection being
* prepared with capabilities. I chose the former, obviously. :-) */
- priv->auth_approver = tp_simple_approver_new (dbus,
+ priv->auth_approver = tp_simple_approver_new_with_am (am,
"Empathy.AuthEventManager", FALSE, approve_channels, manager,
NULL);
g_error_free (error);
}
- g_object_unref (dbus);
+ g_object_unref (am);
}
EmpathyEventManager *
projects / empathy.git / blobdiff