#include <telepathy-glib/interfaces.h>
#include <telepathy-glib/simple-approver.h>
+#include <telepathy-yell/telepathy-yell.h>
+
+#include <libempathy/empathy-channel-factory.h>
#include <libempathy/empathy-presence-manager.h>
#include <libempathy/empathy-tp-contact-factory.h>
#include <libempathy/empathy-contact-manager.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"
#define NOTIFICATION_TIMEOUT 2 /* seconds */
+#define ACCEPT_WITHOUT_VIDEO 1
+
/* The time interval in milliseconds between 2 incoming rings */
#define MS_BETWEEN_RING 500
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;
}
else
{
- timestamp = tp_user_action_time_from_x11 (gtk_get_current_event_time ());
+ timestamp = empathy_get_current_action_time ();
}
g_assert (approval->operation != NULL);
event_text_channel_process_func (EventPriv *event)
{
EmpathyTpChat *tp_chat;
- gint64 timestamp;
-
- timestamp = tp_user_action_time_from_x11 (gtk_get_current_event_time ());
if (event->approval->handler != 0)
{
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);
{
empathy_tp_streamed_media_close (user_data);
}
+ else if (TPY_IS_CALL_CHANNEL (user_data))
+ {
+ tpy_call_channel_hangup_async (user_data,
+ TPY_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, "");
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)
{
+ tpy_call_channel_send_video (TPY_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_VOIP)
+ {
+ EmpathyTpStreamedMedia *call;
+ call = EMPATHY_TP_STREAMED_MEDIA (event->approval->handler_instance);
+ video = empathy_tp_streamed_media_has_initial_video (call);
+ }
+ else if (etype == EMPATHY_EVENT_TYPE_CALL)
+ {
+ TpyCallChannel *call;
+ call = TPY_CALL_CHANNEL (event->approval->handler_instance);
+ g_object_get (G_OBJECT (call), "initial-video", &video, 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 = empathy_main_window_dup ();
+ GtkWidget *window;
EmpathyContact *sender;
const gchar *header;
const gchar *msg;
- TpChannel *channel;
EventPriv *event;
EmpathyEventManagerPriv *priv = GET_PRIV (approval->manager);
event = event_lookup_by_approval (approval->manager, approval);
sender = empathy_message_get_sender (message);
+
+ /* We only want to show incoming messages */
+ if (empathy_contact_is_user (sender))
+ return;
+
header = empathy_contact_get_alias (sender);
msg = empathy_message_get_body (message);
- channel = empathy_tp_chat_get_channel (tp_chat);
-
if (event != NULL)
event_update (approval->manager, event, EMPATHY_IMAGE_NEW_MESSAGE, header,
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_CONVERSATION_NEW);
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_STREAMED_MEDIA ||
+ channel_type == TPY_IFACE_QUARK_CHANNEL_TYPE_CALL)
{
priv->ringing--;
if (priv->ringing == 0)
event_manager_approval_done (approval);
}
+static void
+event_manager_call_state_changed_cb (TpyCallChannel *call,
+ TpyCallState state,
+ TpyCallFlags flags,
+ const GValueArray *call_state_reason,
+ GHashTable *call_state_details,
+ EventManagerApproval *approval)
+{
+ if (state == TPY_CALL_STATE_ENDED)
+ {
+ DEBUG ("Call ended, seems we missed it :/");
+ reject_approval (approval);
+ }
+}
+
+static void
+event_manager_call_channel_got_contact_cb (TpConnection *connection,
+ EmpathyContact *contact,
+ const GError *error,
+ gpointer user_data,
+ GObject *object)
+{
+ EventManagerApproval *approval = (EventManagerApproval *) user_data;
+ EmpathyEventManagerPriv *priv = GET_PRIV (approval->manager);
+ GtkWidget *window;
+ TpyCallChannel *call;
+ gchar *header;
+ gboolean video;
+
+ call = TPY_CALL_CHANNEL (approval->handler_instance);
+
+ if (error != NULL)
+ {
+ DEBUG ("Can't get the contact for the call.. Rejecting?");
+ reject_approval (approval);
+ return;
+ }
+
+ if (tpy_call_channel_get_state (call, NULL, NULL) == TPY_CALL_STATE_ENDED)
+ {
+ DEBUG ("Call already ended, seems we missed it :/");
+ reject_approval (approval);
+ return;
+ }
+
+ approval->handler = g_signal_connect (call, "state-changed",
+ G_CALLBACK (event_manager_call_state_changed_cb), approval);
+
+ window = empathy_main_window_dup ();
+ approval->contact = g_object_ref (contact);
+
+ 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)
+ 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_got_contact (EventManagerApproval *approval)
{
gint response,
EventManagerApproval *approval)
{
- EmpathyTpChat *tp_chat;
-
gtk_widget_destroy (GTK_WIDGET (approval->dialog));
approval->dialog = NULL;
- tp_chat = EMPATHY_TP_CHAT (approval->handler_instance);
-
if (response != GTK_RESPONSE_OK)
{
/* close channel */
channel_type = tp_channel_get_channel_type_id (channel);
if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_STREAMED_MEDIA ||
+ channel_type == TPY_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;
channel_type = tp_channel_get_channel_type_id (channel);
- if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_TEXT)
+ if (TP_IS_TEXT_CHANNEL (channel))
{
- EmpathyTpChat *tp_chat;
+ EmpathyTpChat *tp_chat = EMPATHY_TP_CHAT (channel);
+ GList *messages, *l;
- tp_chat = empathy_tp_chat_new (account, channel);
- approval->handler_instance = G_OBJECT (tp_chat);
+ approval->handler_instance = g_object_ref (tp_chat);
if (tp_proxy_has_interface (channel, TP_IFACE_CHANNEL_INTERFACE_GROUP))
{
}
/* 1-1 text channel, wait for the first message */
- approval->handler = g_signal_connect (tp_chat, "message-received",
+ 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);
+ }
}
else if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_STREAMED_MEDIA)
{
EmpathyContact *contact;
- EmpathyTpStreamedMedia *call = empathy_tp_streamed_media_new (account, channel);
+ EmpathyTpStreamedMedia *call = empathy_tp_streamed_media_new (account,
+ channel);
approval->handler_instance = G_OBJECT (call);
}
}
+ else if (channel_type == TPY_IFACE_QUARK_CHANNEL_TYPE_CALL)
+ {
+ TpyCallChannel *call = TPY_CALL_CHANNEL (channel);
+ const gchar *id;
+
+ approval->handler_instance = g_object_ref (call);
+
+ id = tp_channel_get_identifier (channel);
+
+ empathy_tp_contact_factory_get_from_id (connection, id,
+ event_manager_call_channel_got_contact_cb,
+ approval, NULL, G_OBJECT (self));
+ }
else if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_FILE_TRANSFER)
{
TpHandle handle;
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));
}
{
EmpathyEventManagerPriv *priv = GET_PRIV (manager);
TpAccount *account;
- gchar *header = NULL;
EmpathyPresenceManager *presence_mgr;
GtkWidget *window = empathy_main_window_dup ();
if (g_settings_get_boolean (priv->gsettings_notif,
EMPATHY_PREFS_NOTIFICATIONS_CONTACT_SIGNOUT))
{
- header = g_strdup_printf ("<b>%s</b>",
- empathy_contact_get_alias (contact));
-
event_manager_add (manager, NULL, contact,
- EMPATHY_EVENT_TYPE_PRESENCE, EMPATHY_IMAGE_AVATAR_DEFAULT,
- header, _("Disconnected"), NULL, NULL, NULL);
+ EMPATHY_EVENT_TYPE_PRESENCE_OFFLINE,
+ EMPATHY_IMAGE_AVATAR_DEFAULT,
+ empathy_contact_get_alias (contact), _("Disconnected"),
+ NULL, NULL, NULL);
}
}
}
if (g_settings_get_boolean (priv->gsettings_notif,
EMPATHY_PREFS_NOTIFICATIONS_CONTACT_SIGNIN))
{
- header = g_strdup_printf ("<b>%s</b>",
- empathy_contact_get_alias (contact));
-
event_manager_add (manager, NULL, contact,
- EMPATHY_EVENT_TYPE_PRESENCE, EMPATHY_IMAGE_AVATAR_DEFAULT,
- header, _("Connected"), NULL, NULL, NULL);
+ EMPATHY_EVENT_TYPE_PRESENCE_ONLINE,
+ EMPATHY_IMAGE_AVATAR_DEFAULT,
+ empathy_contact_get_alias (contact), _("Connected"),
+ NULL, NULL, NULL);
}
}
}
- g_free (header);
out:
g_object_unref (presence_mgr);
EMPATHY_TYPE_EVENT_MANAGER, EmpathyEventManagerPriv);
TpDBusDaemon *dbus;
GError *error = NULL;
+ EmpathyChannelFactory *factory;
manager->priv = priv;
TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA,
TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, G_TYPE_UINT, TP_HANDLE_TYPE_CONTACT,
NULL));
+ tp_base_client_take_approver_filter (priv->approver,
+ tp_asv_new (
+ TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
+ TPY_IFACE_CHANNEL_TYPE_CALL,
+ TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, G_TYPE_UINT, TP_HANDLE_TYPE_CONTACT,
+ NULL));
/* I don't feel good about doing this, and I'm sorry, but the
* capabilities connection feature is added earlier because it's
TP_IFACE_CHANNEL_INTERFACE_SASL_AUTHENTICATION,
NULL));
+ factory = empathy_channel_factory_dup ();
+
+ tp_base_client_set_channel_factory (priv->approver,
+ TP_CLIENT_CHANNEL_FACTORY (factory));
+
if (!tp_base_client_register (priv->approver, &error))
{
DEBUG ("Failed to register Approver: %s", error->message);
g_error_free (error);
}
+ g_object_unref (factory);
g_object_unref (dbus);
}