* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- *
+ *
* Authors: Xavier Claessens <xclaesse@gmail.com>
* Sjoerd Simons <sjoerd.simons@collabora.co.uk>
*/
#include <glib/gi18n.h>
#include <telepathy-glib/util.h>
+#include <telepathy-glib/interfaces.h>
+#include <libempathy/empathy-account-manager.h>
#include <libempathy/empathy-dispatcher.h>
#include <libempathy/empathy-tp-contact-factory.h>
#include <libempathy/empathy-contact-manager.h>
#include <extensions/extensions.h>
+#include <libempathy-gtk/empathy-conf.h>
#include <libempathy-gtk/empathy-images.h>
#include <libempathy-gtk/empathy-contact-dialogs.h>
-#include <libempathy-gtk/empathy-ui-utils.h>
+#include <libempathy-gtk/empathy-sound.h>
#include "empathy-event-manager.h"
#include "empathy-main-window.h"
#define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyEventManager)
+#define NOTIFICATION_TIMEOUT 2 /* seconds */
+
+/* The time interval in milliseconds between 2 incoming rings */
+#define MS_BETWEEN_RING 500
+
typedef struct {
EmpathyEventManager *manager;
EmpathyDispatchOperation *operation;
/* Ongoing approvals */
GSList *approvals;
- /* voip ringing sound */
- guint voip_timeout;
gint ringing;
} EmpathyEventManagerPriv;
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)
{
event_free (event);
}
+static gboolean
+autoremove_event_timeout_cb (EventPriv *event)
+{
+ event_remove (event);
+ return FALSE;
+}
+
static void
event_manager_add (EmpathyEventManager *manager, EmpathyContact *contact,
const gchar *icon_name, const gchar *header, const gchar *message,
event->public.icon_name = g_strdup (icon_name);
event->public.header = g_strdup (header);
event->public.message = g_strdup (message);
+ event->public.must_ack = (func != NULL);
event->inhibit = FALSE;
event->func = func;
event->user_data = user_data;
DEBUG ("Adding event %p", event);
priv->events = g_slist_prepend (priv->events, event);
g_signal_emit (event->manager, signals[EVENT_ADDED], 0, event);
+
+ if (!event->public.must_ack)
+ {
+ g_timeout_add_seconds (NOTIFICATION_TIMEOUT,
+ (GSourceFunc) autoremove_event_timeout_cb, event);
+ }
}
static void
return;
}
- dialog = gtk_message_dialog_new (GTK_WINDOW (empathy_main_window_get()),
- GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+ 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),
EmpathyMessage *message, EventManagerApproval *approval)
{
EmpathyContact *sender;
- gchar *header;
+ const gchar *header;
const gchar *msg;
TpChannel *channel;
EventPriv *event;
}
sender = empathy_message_get_sender (message);
- header = g_strdup_printf (_("New message from %s"),
- empathy_contact_get_name (sender));
+ header = 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, header,
msg, approval, event_text_channel_process_func, NULL);
- g_free (header);
empathy_sound_play (empathy_main_window_get (),
EMPATHY_SOUND_CONVERSATION_NEW);
}
approval->operation);
if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_STREAMED_MEDIA)
{
- event_manager_stop_ringing (approval->manager);
+ priv->ringing--;
+ if (priv->ringing == 0)
+ empathy_sound_stop (EMPATHY_SOUND_PHONE_INCOMING);
}
}
static void
event_manager_media_channel_got_contact (EventManagerApproval *approval)
{
+ EmpathyEventManagerPriv *priv = GET_PRIV (approval->manager);
gchar *header;
header = g_strdup_printf (_("Incoming call from %s"),
approval, event_channel_process_voip_func, NULL);
g_free (header);
- event_manager_start_ringing (approval->manager);
+
+ priv->ringing++;
+ if (priv->ringing == 1)
+ empathy_sound_start_playing (empathy_main_window_get (),
+ EMPATHY_SOUND_PHONE_INCOMING, MS_BETWEEN_RING);
}
static void
event_manager_tube_dispatch_ability_cb (GObject *object,
GParamSpec *spec, gpointer user_data)
{
- EventManagerApproval *approval = (EventManagerApproval *)user_data;
+ EventManagerApproval *approval = (EventManagerApproval *) user_data;
EmpathyTubeDispatchAbility dispatchability;
dispatchability =
gpointer user_data,
GObject *object)
{
- EventManagerApproval *approval = (EventManagerApproval *)user_data;
+ EventManagerApproval *approval = (EventManagerApproval *) user_data;
EmpathyTubeDispatchAbility dispatchability;
if (error != NULL)
g_free (msg);
}
+static void
+event_manager_ft_got_contact_cb (EmpathyTpContactFactory *factory,
+ EmpathyContact *contact,
+ const GError *error,
+ gpointer user_data,
+ GObject *object)
+{
+ EventManagerApproval *approval = (EventManagerApproval *) user_data;
+ char *header;
+
+ approval->contact = contact;
+
+ header = g_strdup_printf (_("Incoming file transfer from %s"),
+ empathy_contact_get_name (approval->contact));
+
+ event_manager_add (approval->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_free (header);
+}
+
static void
event_manager_approve_channel_cb (EmpathyDispatcher *dispatcher,
EmpathyDispatchOperation *operation, EmpathyEventManager *manager)
}
else if (!tp_strdiff (channel_type, TP_IFACE_CHANNEL_TYPE_FILE_TRANSFER))
{
- EmpathyTpFile *file;
- gchar *header;
-
- 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 (approval->contact));
+ TpChannel *channel;
+ TpConnection *connection;
+ TpHandle handle;
+ EmpathyTpContactFactory *factory;
- event_manager_add (manager, approval->contact, EMPATHY_IMAGE_DOCUMENT_SEND,
- header, NULL, approval, event_channel_process_func, NULL);
+ channel = empathy_dispatch_operation_get_channel (operation);
+ handle = tp_channel_get_handle (channel, NULL);
- /* FIXME better sound for incoming file transfers ?*/
- empathy_sound_play (empathy_main_window_get (),
- EMPATHY_SOUND_CONVERSATION_NEW);
+ 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_ft_got_contact_cb, approval, NULL, G_OBJECT (manager));
- g_free (header);
+ g_object_unref (factory);
}
- else if (!tp_strdiff (channel_type, EMP_IFACE_CHANNEL_TYPE_STREAM_TUBE) ||
- !tp_strdiff (channel_type, EMP_IFACE_CHANNEL_TYPE_DBUS_TUBE))
+ else if (!tp_strdiff (channel_type, TP_IFACE_CHANNEL_TYPE_STREAM_TUBE) ||
+ !tp_strdiff (channel_type, TP_IFACE_CHANNEL_TYPE_DBUS_TUBE))
{
TpChannel *channel;
TpHandle handle;
}
else
{
- DEBUG ("Unknown channel type, ignoring..");
+ DEBUG ("Unknown channel type (%s), ignoring..", channel_type);
}
}
g_free (header);
}
+static void
+event_manager_presence_changed_cb (EmpathyContactMonitor *monitor,
+ EmpathyContact *contact,
+ TpConnectionPresenceType current,
+ TpConnectionPresenceType previous,
+ EmpathyEventManager *manager)
+{
+ EmpathyAccount *account;
+ gchar *header = NULL;
+ gboolean preference = FALSE;
+
+ account = empathy_contact_get_account (contact);
+ if (empathy_account_is_just_connected (account))
+ return;
+
+ if (tp_connection_presence_type_cmp_availability (previous,
+ TP_CONNECTION_PRESENCE_TYPE_OFFLINE) > 0)
+ {
+ /* contact was online */
+ empathy_conf_get_bool (empathy_conf_get (),
+ EMPATHY_PREFS_NOTIFICATIONS_CONTACT_SIGNOUT, &preference);
+ if (preference && tp_connection_presence_type_cmp_availability (current,
+ TP_CONNECTION_PRESENCE_TYPE_OFFLINE) <= 0)
+ {
+ /* someone is logging off */
+ header = g_strdup_printf (_("%s is now offline."),
+ empathy_contact_get_name (contact));
+
+ event_manager_add (manager, contact, GTK_STOCK_DIALOG_INFO, header,
+ NULL, NULL, NULL, NULL);
+ }
+ }
+ else
+ {
+ /* contact was offline */
+ empathy_conf_get_bool (empathy_conf_get (),
+ EMPATHY_PREFS_NOTIFICATIONS_CONTACT_SIGNIN, &preference);
+ if (preference && tp_connection_presence_type_cmp_availability (current,
+ TP_CONNECTION_PRESENCE_TYPE_OFFLINE) > 0)
+ {
+ /* someone is logging in */
+ header = g_strdup_printf (_("%s is now online."),
+ empathy_contact_get_name (contact));
+
+ event_manager_add (manager, contact, GTK_STOCK_DIALOG_INFO, header,
+ NULL, NULL, NULL, NULL);
+ }
+ }
+ g_free (header);
+}
+
+
static GObject *
event_manager_constructor (GType type,
guint n_props,
{
EmpathyEventManagerPriv *priv = GET_PRIV (object);
+ if (priv->ringing > 0)
+ empathy_sound_stop (EMPATHY_SOUND_PHONE_INCOMING);
+
g_slist_foreach (priv->events, (GFunc) event_free, NULL);
g_slist_free (priv->events);
g_slist_foreach (priv->approvals, (GFunc) event_manager_approval_free, NULL);
{
EmpathyEventManagerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (manager,
EMPATHY_TYPE_EVENT_MANAGER, EmpathyEventManagerPriv);
+ EmpathyContactMonitor *monitor;
+ EmpathyContactList *list_iface;
+
+ list_iface = EMPATHY_CONTACT_LIST (empathy_contact_manager_dup_singleton ());
+ monitor = empathy_contact_list_get_monitor (list_iface);
+ g_object_unref (list_iface);
manager->priv = priv;
G_CALLBACK (event_manager_approve_channel_cb), manager);
g_signal_connect (priv->contact_manager, "pendings-changed",
G_CALLBACK (event_manager_pendings_changed_cb), manager);
+ g_signal_connect (monitor, "contact-presence-changed",
+ G_CALLBACK (event_manager_presence_changed_cb), manager);
}
EmpathyEventManager *
void
empathy_event_activate (EmpathyEvent *event_public)
{
- EventPriv *event = (EventPriv*) event_public;
+ EventPriv *event = (EventPriv *) event_public;
g_return_if_fail (event_public != NULL);
event->inhibit = TRUE;
}
-
projects / empathy.git / blobdiff