diff options
Diffstat (limited to 'libempathy')
| -rw-r--r-- | libempathy/Makefile.am | 4 | ||||
| -rw-r--r-- | libempathy/empathy-call-factory.c | 12 | ||||
| -rw-r--r-- | libempathy/empathy-call-factory.h | 2 | ||||
| -rw-r--r-- | libempathy/empathy-call-handler.h | 106 | ||||
| -rw-r--r-- | libempathy/empathy-streamed-media-handler.c (renamed from libempathy/empathy-call-handler.c) | 210 | ||||
| -rw-r--r-- | libempathy/empathy-streamed-media-handler.h | 106 |
6 files changed, 220 insertions, 220 deletions
diff --git a/libempathy/Makefile.am b/libempathy/Makefile.am index 497d8d99b..025515604 100644 --- a/libempathy/Makefile.am +++ b/libempathy/Makefile.am @@ -29,7 +29,6 @@ libempathy_headers = \ empathy-account-settings.h \ empathy-auth-factory.h \ empathy-call-factory.h \ - empathy-call-handler.h \ empathy-chatroom-manager.h \ empathy-chatroom.h \ empathy-connection-managers.h \ @@ -54,6 +53,7 @@ libempathy_headers = \ empathy-server-sasl-handler.h \ empathy-server-tls-handler.h \ empathy-status-presets.h \ + empathy-streamed-media-handler.h \ empathy-time.h \ empathy-tls-certificate.h \ empathy-tls-verifier.h \ @@ -71,7 +71,6 @@ libempathy_la_SOURCES = \ empathy-account-settings.c \ empathy-auth-factory.c \ empathy-call-factory.c \ - empathy-call-handler.c \ empathy-chatroom-manager.c \ empathy-chatroom.c \ empathy-connection-managers.c \ @@ -94,6 +93,7 @@ libempathy_la_SOURCES = \ empathy-server-sasl-handler.c \ empathy-server-tls-handler.c \ empathy-status-presets.c \ + empathy-streamed-media-handler.c \ empathy-time.c \ empathy-tls-certificate.c \ empathy-tls-verifier.c \ diff --git a/libempathy/empathy-call-factory.c b/libempathy/empathy-call-factory.c index 6e523aada..4ec3e976b 100644 --- a/libempathy/empathy-call-factory.c +++ b/libempathy/empathy-call-factory.c @@ -49,7 +49,7 @@ static void handle_channels_cb (TpSimpleHandler *handler, /* signal enum */ enum { - NEW_CALL_HANDLER, + NEW_STREAMED_MEDIA_HANDLER, LAST_SIGNAL }; @@ -166,14 +166,14 @@ empathy_call_factory_class_init ( object_class->dispose = empathy_call_factory_dispose; object_class->finalize = empathy_call_factory_finalize; - signals[NEW_CALL_HANDLER] = + signals[NEW_STREAMED_MEDIA_HANDLER] = g_signal_new ("new-call-handler", G_TYPE_FROM_CLASS (empathy_call_factory_class), G_SIGNAL_RUN_LAST, 0, NULL, NULL, _empathy_marshal_VOID__OBJECT_BOOLEAN, G_TYPE_NONE, - 2, EMPATHY_TYPE_CALL_HANDLER, G_TYPE_BOOLEAN); + 2, EMPATHY_TYPE_STREAMED_MEDIA_HANDLER, G_TYPE_BOOLEAN); } EmpathyCallFactory * @@ -263,13 +263,13 @@ static void create_call_handler (EmpathyCallFactory *factory, EmpathyTpStreamedMedia *call) { - EmpathyCallHandler *handler; + EmpathyStreamedMediaHandler *handler; g_return_if_fail (factory != NULL); - handler = empathy_call_handler_new_for_channel (call); + handler = empathy_streamed_media_handler_new_for_channel (call); - g_signal_emit (factory, signals[NEW_CALL_HANDLER], 0, + g_signal_emit (factory, signals[NEW_STREAMED_MEDIA_HANDLER], 0, handler, FALSE); g_object_unref (handler); diff --git a/libempathy/empathy-call-factory.h b/libempathy/empathy-call-factory.h index 7b160dda4..36c08911b 100644 --- a/libempathy/empathy-call-factory.h +++ b/libempathy/empathy-call-factory.h @@ -23,7 +23,7 @@ #include <glib-object.h> -#include <libempathy/empathy-call-handler.h> +#include <libempathy/empathy-streamed-media-handler.h> #include <libempathy/empathy-dispatcher.h> G_BEGIN_DECLS diff --git a/libempathy/empathy-call-handler.h b/libempathy/empathy-call-handler.h deleted file mode 100644 index 1e0fd7165..000000000 --- a/libempathy/empathy-call-handler.h +++ /dev/null @@ -1,106 +0,0 @@ -/* - * empathy-call-handler.h - Header for EmpathyCallHandler - * Copyright (C) 2008-2009 Collabora Ltd. - * @author Sjoerd Simons <sjoerd.simons@collabora.co.uk> - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * 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 - */ - -#ifndef __EMPATHY_CALL_HANDLER_H__ -#define __EMPATHY_CALL_HANDLER_H__ - -#include <glib-object.h> - -#include <gst/gst.h> -#include <gst/farsight/fs-conference-iface.h> - -#include <libempathy/empathy-tp-streamed-media.h> -#include <libempathy/empathy-contact.h> - -G_BEGIN_DECLS - -typedef struct _EmpathyCallHandler EmpathyCallHandler; -typedef struct _EmpathyCallHandlerClass EmpathyCallHandlerClass; - -struct _EmpathyCallHandlerClass { - GObjectClass parent_class; -}; - -struct _EmpathyCallHandler { - GObject parent; - gpointer priv; -}; - -GType empathy_call_handler_get_type (void); - -/* TYPE MACROS */ -#define EMPATHY_TYPE_CALL_HANDLER \ - (empathy_call_handler_get_type ()) -#define EMPATHY_CALL_HANDLER(obj) \ - (G_TYPE_CHECK_INSTANCE_CAST((obj), EMPATHY_TYPE_CALL_HANDLER, \ - EmpathyCallHandler)) -#define EMPATHY_CALL_HANDLER_CLASS(klass) \ - (G_TYPE_CHECK_CLASS_CAST((klass), EMPATHY_TYPE_CALL_HANDLER, \ - EmpathyCallHandlerClass)) -#define EMPATHY_IS_CALL_HANDLER(obj) \ - (G_TYPE_CHECK_INSTANCE_TYPE((obj), EMPATHY_TYPE_CALL_HANDLER)) -#define EMPATHY_IS_CALL_HANDLER_CLASS(klass) \ - (G_TYPE_CHECK_CLASS_TYPE((klass), EMPATHY_TYPE_CALL_HANDLER)) -#define EMPATHY_CALL_HANDLER_GET_CLASS(obj) \ - (G_TYPE_INSTANCE_GET_CLASS ((obj), EMPATHY_TYPE_CALL_HANDLER, \ - EmpathyCallHandlerClass)) - -EmpathyCallHandler * empathy_call_handler_new_for_contact ( - EmpathyContact *contact); - -EmpathyCallHandler * empathy_call_handler_new_for_channel ( - EmpathyTpStreamedMedia *call); - -void empathy_call_handler_start_call (EmpathyCallHandler *handler, - gint64 timestamp); -void empathy_call_handler_stop_call (EmpathyCallHandler *handler); - -gboolean empathy_call_handler_has_initial_video (EmpathyCallHandler *handler); - -void empathy_call_handler_bus_message (EmpathyCallHandler *handler, - GstBus *bus, GstMessage *message); - -FsCodec * empathy_call_handler_get_send_audio_codec ( - EmpathyCallHandler *self); - -FsCodec * empathy_call_handler_get_send_video_codec ( - EmpathyCallHandler *self); - -GList * empathy_call_handler_get_recv_audio_codecs ( - EmpathyCallHandler *self); - -GList * empathy_call_handler_get_recv_video_codecs ( - EmpathyCallHandler *self); - -FsCandidate * empathy_call_handler_get_audio_remote_candidate ( - EmpathyCallHandler *self); - -FsCandidate * empathy_call_handler_get_audio_local_candidate ( - EmpathyCallHandler *self); - -FsCandidate * empathy_call_handler_get_video_remote_candidate ( - EmpathyCallHandler *self); - -FsCandidate * empathy_call_handler_get_video_local_candidate ( - EmpathyCallHandler *self); - -G_END_DECLS - -#endif /* #ifndef __EMPATHY_CALL_HANDLER_H__*/ diff --git a/libempathy/empathy-call-handler.c b/libempathy/empathy-streamed-media-handler.c index c3ce5fed4..7fa49cde7 100644 --- a/libempathy/empathy-call-handler.c +++ b/libempathy/empathy-streamed-media-handler.c @@ -1,5 +1,5 @@ /* - * empathy-call-handler.c - Source for EmpathyCallHandler + * empathy-call-handler.c - Source for EmpathyStreamedMediaHandler * Copyright (C) 2008-2009 Collabora Ltd. * @author Sjoerd Simons <sjoerd.simons@collabora.co.uk> * @@ -29,7 +29,7 @@ #include <telepathy-farsight/channel.h> #include <telepathy-farsight/stream.h> -#include "empathy-call-handler.h" +#include "empathy-streamed-media-handler.h" #include "empathy-call-factory.h" #include "empathy-marshal.h" #include "empathy-utils.h" @@ -37,7 +37,7 @@ #define DEBUG_FLAG EMPATHY_DEBUG_VOIP #include <libempathy/empathy-debug.h> -G_DEFINE_TYPE(EmpathyCallHandler, empathy_call_handler, G_TYPE_OBJECT) +G_DEFINE_TYPE(EmpathyStreamedMediaHandler, empathy_streamed_media_handler, G_TYPE_OBJECT) /* signal enum */ enum { @@ -87,14 +87,14 @@ typedef struct { FsCandidate *video_remote_candidate; FsCandidate *audio_local_candidate; FsCandidate *video_local_candidate; -} EmpathyCallHandlerPriv; +} EmpathyStreamedMediaHandlerPriv; -#define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyCallHandler) +#define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyStreamedMediaHandler) static void -empathy_call_handler_dispose (GObject *object) +empathy_streamed_media_handler_dispose (GObject *object) { - EmpathyCallHandlerPriv *priv = GET_PRIV (object); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (object); if (priv->dispose_has_run) return; @@ -120,14 +120,14 @@ empathy_call_handler_dispose (GObject *object) priv->call = NULL; /* release any references held by the object here */ - if (G_OBJECT_CLASS (empathy_call_handler_parent_class)->dispose) - G_OBJECT_CLASS (empathy_call_handler_parent_class)->dispose (object); + if (G_OBJECT_CLASS (empathy_streamed_media_handler_parent_class)->dispose) + G_OBJECT_CLASS (empathy_streamed_media_handler_parent_class)->dispose (object); } static void -empathy_call_handler_finalize (GObject *object) +empathy_streamed_media_handler_finalize (GObject *object) { - EmpathyCallHandlerPriv *priv = GET_PRIV (object); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (object); fs_codec_destroy (priv->send_audio_codec); fs_codec_destroy (priv->send_video_codec); @@ -138,23 +138,23 @@ empathy_call_handler_finalize (GObject *object) fs_candidate_destroy (priv->audio_local_candidate); fs_candidate_destroy (priv->video_local_candidate); - if (G_OBJECT_CLASS (empathy_call_handler_parent_class)->finalize) - G_OBJECT_CLASS (empathy_call_handler_parent_class)->finalize (object); + if (G_OBJECT_CLASS (empathy_streamed_media_handler_parent_class)->finalize) + G_OBJECT_CLASS (empathy_streamed_media_handler_parent_class)->finalize (object); } static void -empathy_call_handler_init (EmpathyCallHandler *obj) +empathy_streamed_media_handler_init (EmpathyStreamedMediaHandler *obj) { - EmpathyCallHandlerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (obj, - EMPATHY_TYPE_CALL_HANDLER, EmpathyCallHandlerPriv); + EmpathyStreamedMediaHandlerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (obj, + EMPATHY_TYPE_STREAMED_MEDIA_HANDLER, EmpathyStreamedMediaHandlerPriv); obj->priv = priv; } static void -empathy_call_handler_constructed (GObject *object) +empathy_streamed_media_handler_constructed (GObject *object) { - EmpathyCallHandlerPriv *priv = GET_PRIV (object); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (object); if (priv->contact == NULL) { @@ -163,10 +163,10 @@ empathy_call_handler_constructed (GObject *object) } static void -empathy_call_handler_set_property (GObject *object, +empathy_streamed_media_handler_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { - EmpathyCallHandlerPriv *priv = GET_PRIV (object); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (object); switch (property_id) { @@ -188,10 +188,10 @@ empathy_call_handler_set_property (GObject *object, } static void -empathy_call_handler_get_property (GObject *object, +empathy_streamed_media_handler_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { - EmpathyCallHandlerPriv *priv = GET_PRIV (object); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (object); switch (property_id) { @@ -238,18 +238,18 @@ empathy_call_handler_get_property (GObject *object, static void -empathy_call_handler_class_init (EmpathyCallHandlerClass *klass) +empathy_streamed_media_handler_class_init (EmpathyStreamedMediaHandlerClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); GParamSpec *param_spec; - g_type_class_add_private (klass, sizeof (EmpathyCallHandlerPriv)); + g_type_class_add_private (klass, sizeof (EmpathyStreamedMediaHandlerPriv)); - object_class->constructed = empathy_call_handler_constructed; - object_class->set_property = empathy_call_handler_set_property; - object_class->get_property = empathy_call_handler_get_property; - object_class->dispose = empathy_call_handler_dispose; - object_class->finalize = empathy_call_handler_finalize; + object_class->constructed = empathy_streamed_media_handler_constructed; + object_class->set_property = empathy_streamed_media_handler_set_property; + object_class->get_property = empathy_streamed_media_handler_get_property; + object_class->dispose = empathy_streamed_media_handler_dispose; + object_class->finalize = empathy_streamed_media_handler_finalize; param_spec = g_param_spec_object ("contact", "contact", "The remote contact", @@ -386,35 +386,35 @@ empathy_call_handler_class_init (EmpathyCallHandlerClass *klass) } /** - * empathy_call_handler_new_for_contact: + * empathy_streamed_media_handler_new_for_contact: * @contact: an #EmpathyContact * - * Creates a new #EmpathyCallHandler with contact @contact. + * Creates a new #EmpathyStreamedMediaHandler with contact @contact. * - * Return value: a new #EmpathyCallHandler + * Return value: a new #EmpathyStreamedMediaHandler */ -EmpathyCallHandler * -empathy_call_handler_new_for_contact (EmpathyContact *contact) +EmpathyStreamedMediaHandler * +empathy_streamed_media_handler_new_for_contact (EmpathyContact *contact) { - return EMPATHY_CALL_HANDLER (g_object_new (EMPATHY_TYPE_CALL_HANDLER, + return EMPATHY_STREAMED_MEDIA_HANDLER (g_object_new (EMPATHY_TYPE_STREAMED_MEDIA_HANDLER, "contact", contact, NULL)); } -EmpathyCallHandler * -empathy_call_handler_new_for_channel (EmpathyTpStreamedMedia *call) +EmpathyStreamedMediaHandler * +empathy_streamed_media_handler_new_for_channel (EmpathyTpStreamedMedia *call) { - return EMPATHY_CALL_HANDLER (g_object_new (EMPATHY_TYPE_CALL_HANDLER, + return EMPATHY_STREAMED_MEDIA_HANDLER (g_object_new (EMPATHY_TYPE_STREAMED_MEDIA_HANDLER, "tp-call", call, "initial-video", empathy_tp_streamed_media_is_receiving_video (call), NULL)); } static void -update_sending_codec (EmpathyCallHandler *self, +update_sending_codec (EmpathyStreamedMediaHandler *self, FsCodec *codec, FsSession *session) { - EmpathyCallHandlerPriv *priv = GET_PRIV (self); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (self); FsMediaType type; if (codec == NULL || session == NULL) @@ -435,11 +435,11 @@ update_sending_codec (EmpathyCallHandler *self, } static void -update_receiving_codec (EmpathyCallHandler *self, +update_receiving_codec (EmpathyStreamedMediaHandler *self, GList *codecs, FsStream *stream) { - EmpathyCallHandlerPriv *priv = GET_PRIV (self); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (self); FsSession *session; FsMediaType type; @@ -467,12 +467,12 @@ update_receiving_codec (EmpathyCallHandler *self, } static void -update_candidates (EmpathyCallHandler *self, +update_candidates (EmpathyStreamedMediaHandler *self, FsCandidate *remote_candidate, FsCandidate *local_candidate, FsStream *stream) { - EmpathyCallHandlerPriv *priv = GET_PRIV (self); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (self); FsSession *session; FsMediaType type; @@ -528,10 +528,10 @@ update_candidates (EmpathyCallHandler *self, } void -empathy_call_handler_bus_message (EmpathyCallHandler *handler, +empathy_streamed_media_handler_bus_message (EmpathyStreamedMediaHandler *handler, GstBus *bus, GstMessage *message) { - EmpathyCallHandlerPriv *priv = GET_PRIV (handler); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (handler); const GstStructure *s = gst_message_get_structure (message); if (priv->tfchannel == NULL) @@ -590,9 +590,9 @@ empathy_call_handler_bus_message (EmpathyCallHandler *handler, } static void -empathy_call_handler_tf_channel_session_created_cb (TfChannel *tfchannel, +empathy_streamed_media_handler_tf_channel_session_created_cb (TfChannel *tfchannel, FsConference *conference, FsParticipant *participant, - EmpathyCallHandler *self) + EmpathyStreamedMediaHandler *self) { g_signal_emit (G_OBJECT (self), signals[CONFERENCE_ADDED], 0, GST_ELEMENT (conference)); @@ -611,8 +611,8 @@ src_pad_added_error_idle (gpointer data) } static void -empathy_call_handler_tf_stream_src_pad_added_cb (TfStream *stream, - GstPad *pad, FsCodec *codec, EmpathyCallHandler *handler) +empathy_streamed_media_handler_tf_stream_src_pad_added_cb (TfStream *stream, + GstPad *pad, FsCodec *codec, EmpathyStreamedMediaHandler *handler) { guint media_type; gboolean retval; @@ -628,7 +628,7 @@ empathy_call_handler_tf_stream_src_pad_added_cb (TfStream *stream, static gboolean -empathy_call_handler_tf_stream_request_resource_cb (TfStream *stream, +empathy_streamed_media_handler_tf_stream_request_resource_cb (TfStream *stream, guint direction, EmpathyTpStreamedMedia *call) { gboolean ret; @@ -643,15 +643,15 @@ empathy_call_handler_tf_stream_request_resource_cb (TfStream *stream, } static void -empathy_call_handler_tf_stream_closed_cb (TfStream *stream, - EmpathyCallHandler *handler) +empathy_streamed_media_handler_tf_stream_closed_cb (TfStream *stream, + EmpathyStreamedMediaHandler *handler) { g_signal_emit (handler, signals[STREAM_CLOSED], 0, stream); } static void -empathy_call_handler_tf_channel_stream_created_cb (TfChannel *tfchannel, - TfStream *stream, EmpathyCallHandler *handler) +empathy_streamed_media_handler_tf_channel_stream_created_cb (TfChannel *tfchannel, + TfStream *stream, EmpathyStreamedMediaHandler *handler) { guint media_type; GstPad *spad; @@ -662,12 +662,12 @@ empathy_call_handler_tf_channel_stream_created_cb (TfChannel *tfchannel, FsCodec *codec; g_signal_connect (stream, "src-pad-added", - G_CALLBACK (empathy_call_handler_tf_stream_src_pad_added_cb), handler); + G_CALLBACK (empathy_streamed_media_handler_tf_stream_src_pad_added_cb), handler); g_signal_connect (stream, "request-resource", - G_CALLBACK (empathy_call_handler_tf_stream_request_resource_cb), + G_CALLBACK (empathy_streamed_media_handler_tf_stream_request_resource_cb), handler); g_signal_connect (stream, "closed", - G_CALLBACK (empathy_call_handler_tf_stream_closed_cb), handler); + G_CALLBACK (empathy_streamed_media_handler_tf_stream_closed_cb), handler); g_object_get (stream, "media-type", &media_type, "sink-pad", &spad, NULL); @@ -701,14 +701,14 @@ empathy_call_handler_tf_channel_stream_created_cb (TfChannel *tfchannel, } static void -empathy_call_handler_tf_channel_closed_cb (TfChannel *tfchannel, - EmpathyCallHandler *handler) +empathy_streamed_media_handler_tf_channel_closed_cb (TfChannel *tfchannel, + EmpathyStreamedMediaHandler *handler) { g_signal_emit (G_OBJECT (handler), signals[CLOSED], 0); } static GList * -empathy_call_handler_tf_channel_codec_config_cb (TfChannel *channel, +empathy_streamed_media_handler_tf_channel_codec_config_cb (TfChannel *channel, guint stream_id, FsMediaType media_type, guint direction, gpointer user_data) { gchar *filename = empathy_file_lookup ("codec-preferences", "data"); @@ -729,9 +729,9 @@ empathy_call_handler_tf_channel_codec_config_cb (TfChannel *channel, } static void -empathy_call_handler_start_tpfs (EmpathyCallHandler *self) +empathy_streamed_media_handler_start_tpfs (EmpathyStreamedMediaHandler *self) { - EmpathyCallHandlerPriv *priv = GET_PRIV (self); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (self); TpChannel *channel; g_object_get (priv->call, "channel", &channel, NULL); @@ -742,24 +742,24 @@ empathy_call_handler_start_tpfs (EmpathyCallHandler *self) /* Set up the telepathy farsight channel */ g_signal_connect (priv->tfchannel, "session-created", - G_CALLBACK (empathy_call_handler_tf_channel_session_created_cb), self); + G_CALLBACK (empathy_streamed_media_handler_tf_channel_session_created_cb), self); g_signal_connect (priv->tfchannel, "stream-created", - G_CALLBACK (empathy_call_handler_tf_channel_stream_created_cb), self); + G_CALLBACK (empathy_streamed_media_handler_tf_channel_stream_created_cb), self); g_signal_connect (priv->tfchannel, "closed", - G_CALLBACK (empathy_call_handler_tf_channel_closed_cb), self); + G_CALLBACK (empathy_streamed_media_handler_tf_channel_closed_cb), self); g_signal_connect (priv->tfchannel, "stream-get-codec-config", - G_CALLBACK (empathy_call_handler_tf_channel_codec_config_cb), self); + G_CALLBACK (empathy_streamed_media_handler_tf_channel_codec_config_cb), self); g_object_unref (channel); } static void -empathy_call_handler_request_cb (GObject *source, +empathy_streamed_media_handler_request_cb (GObject *source, GAsyncResult *result, gpointer user_data) { - EmpathyCallHandler *self = EMPATHY_CALL_HANDLER (user_data); - EmpathyCallHandlerPriv *priv = GET_PRIV (self); + EmpathyStreamedMediaHandler *self = EMPATHY_STREAMED_MEDIA_HANDLER (user_data); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (self); TpChannel *channel; GError *error = NULL; TpAccountChannelRequest *req = TP_ACCOUNT_CHANNEL_REQUEST (source); @@ -780,23 +780,23 @@ empathy_call_handler_request_cb (GObject *source, g_object_notify (G_OBJECT (self), "tp-call"); - empathy_call_handler_start_tpfs (self); + empathy_streamed_media_handler_start_tpfs (self); g_object_unref (channel); } void -empathy_call_handler_start_call (EmpathyCallHandler *handler, +empathy_streamed_media_handler_start_call (EmpathyStreamedMediaHandler *handler, gint64 timestamp) { - EmpathyCallHandlerPriv *priv = GET_PRIV (handler); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (handler); TpAccountChannelRequest *req; TpAccount *account; GHashTable *request; if (priv->call != NULL) { - empathy_call_handler_start_tpfs (handler); + empathy_streamed_media_handler_start_tpfs (handler); empathy_tp_streamed_media_accept_incoming_call (priv->call); return; } @@ -812,22 +812,22 @@ empathy_call_handler_start_call (EmpathyCallHandler *handler, req = tp_account_channel_request_new (account, request, timestamp); tp_account_channel_request_create_and_handle_channel_async (req, NULL, - empathy_call_handler_request_cb, handler); + empathy_streamed_media_handler_request_cb, handler); g_object_unref (req); g_hash_table_unref (request); } /** - * empathy_call_handler_stop_call: - * @handler: an #EmpathyCallHandler + * empathy_streamed_media_handler_stop_call: + * @handler: an #EmpathyStreamedMediaHandler * - * Closes the #EmpathyCallHandler's call and frees its resources. + * Closes the #EmpathyStreamedMediaHandler's call and frees its resources. */ void -empathy_call_handler_stop_call (EmpathyCallHandler *handler) +empathy_streamed_media_handler_stop_call (EmpathyStreamedMediaHandler *handler) { - EmpathyCallHandlerPriv *priv = GET_PRIV (handler); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (handler); if (priv->call != NULL) { @@ -839,86 +839,86 @@ empathy_call_handler_stop_call (EmpathyCallHandler *handler) } /** - * empathy_call_handler_has_initial_video: - * @handler: an #EmpathyCallHandler + * empathy_streamed_media_handler_has_initial_video: + * @handler: an #EmpathyStreamedMediaHandler * - * Return %TRUE if the call managed by this #EmpathyCallHandler was + * Return %TRUE if the call managed by this #EmpathyStreamedMediaHandler was * created with video enabled * * Return value: %TRUE if the call was created as a video conversation. */ gboolean -empathy_call_handler_has_initial_video (EmpathyCallHandler *handler) +empathy_streamed_media_handler_has_initial_video (EmpathyStreamedMediaHandler *handler) { - EmpathyCallHandlerPriv *priv = GET_PRIV (handler); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (handler); return priv->initial_video; } FsCodec * -empathy_call_handler_get_send_audio_codec (EmpathyCallHandler *self) +empathy_streamed_media_handler_get_send_audio_codec (EmpathyStreamedMediaHandler *self) { - EmpathyCallHandlerPriv *priv = GET_PRIV (self); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (self); return priv->send_audio_codec; } FsCodec * -empathy_call_handler_get_send_video_codec (EmpathyCallHandler *self) +empathy_streamed_media_handler_get_send_video_codec (EmpathyStreamedMediaHandler *self) { - EmpathyCallHandlerPriv *priv = GET_PRIV (self); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (self); return priv->send_video_codec; } GList * -empathy_call_handler_get_recv_audio_codecs (EmpathyCallHandler *self) +empathy_streamed_media_handler_get_recv_audio_codecs (EmpathyStreamedMediaHandler *self) { - EmpathyCallHandlerPriv *priv = GET_PRIV (self); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (self); return priv->recv_audio_codecs; } GList * -empathy_call_handler_get_recv_video_codecs (EmpathyCallHandler *self) +empathy_streamed_media_handler_get_recv_video_codecs (EmpathyStreamedMediaHandler *self) { - EmpathyCallHandlerPriv *priv = GET_PRIV (self); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (self); return priv->recv_video_codecs; } FsCandidate * -empathy_call_handler_get_audio_remote_candidate ( - EmpathyCallHandler *self) +empathy_streamed_media_handler_get_audio_remote_candidate ( + EmpathyStreamedMediaHandler *self) { - EmpathyCallHandlerPriv *priv = GET_PRIV (self); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (self); return priv->audio_remote_candidate; } FsCandidate * -empathy_call_handler_get_audio_local_candidate ( - EmpathyCallHandler *self) +empathy_streamed_media_handler_get_audio_local_candidate ( + EmpathyStreamedMediaHandler *self) { - EmpathyCallHandlerPriv *priv = GET_PRIV (self); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (self); return priv->audio_local_candidate; } FsCandidate * -empathy_call_handler_get_video_remote_candidate ( - EmpathyCallHandler *self) +empathy_streamed_media_handler_get_video_remote_candidate ( + EmpathyStreamedMediaHandler *self) { - EmpathyCallHandlerPriv *priv = GET_PRIV (self); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (self); return priv->video_remote_candidate; } FsCandidate * -empathy_call_handler_get_video_local_candidate ( - EmpathyCallHandler *self) +empathy_streamed_media_handler_get_video_local_candidate ( + EmpathyStreamedMediaHandler *self) { - EmpathyCallHandlerPriv *priv = GET_PRIV (self); + EmpathyStreamedMediaHandlerPriv *priv = GET_PRIV (self); return priv->video_local_candidate; } diff --git a/libempathy/empathy-streamed-media-handler.h b/libempathy/empathy-streamed-media-handler.h new file mode 100644 index 000000000..b6d7049c2 --- /dev/null +++ b/libempathy/empathy-streamed-media-handler.h @@ -0,0 +1,106 @@ +/* + * empathy-call-handler.h - Header for EmpathyStreamedMediaHandler + * Copyright (C) 2008-2009 Collabora Ltd. + * @author Sjoerd Simons <sjoerd.simons@collabora.co.uk> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * 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 + */ + +#ifndef __EMPATHY_STREAMED_MEDIA_HANDLER_H__ +#define __EMPATHY_STREAMED_MEDIA_HANDLER_H__ + +#include <glib-object.h> + +#include <gst/gst.h> +#include <gst/farsight/fs-conference-iface.h> + +#include <libempathy/empathy-tp-streamed-media.h> +#include <libempathy/empathy-contact.h> + +G_BEGIN_DECLS + +typedef struct _EmpathyStreamedMediaHandler EmpathyStreamedMediaHandler; +typedef struct _EmpathyStreamedMediaHandlerClass EmpathyStreamedMediaHandlerClass; + +struct _EmpathyStreamedMediaHandlerClass { + GObjectClass parent_class; +}; + +struct _EmpathyStreamedMediaHandler { + GObject parent; + gpointer priv; +}; + +GType empathy_streamed_media_handler_get_type (void); + +/* TYPE MACROS */ +#define EMPATHY_TYPE_STREAMED_MEDIA_HANDLER \ + (empathy_streamed_media_handler_get_type ()) +#define EMPATHY_STREAMED_MEDIA_HANDLER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), EMPATHY_TYPE_STREAMED_MEDIA_HANDLER, \ + EmpathyStreamedMediaHandler)) +#define EMPATHY_STREAMED_MEDIA_HANDLER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), EMPATHY_TYPE_STREAMED_MEDIA_HANDLER, \ + EmpathyStreamedMediaHandlerClass)) +#define EMPATHY_IS_STREAMED_MEDIA_HANDLER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj), EMPATHY_TYPE_STREAMED_MEDIA_HANDLER)) +#define EMPATHY_IS_STREAMED_MEDIA_HANDLER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), EMPATHY_TYPE_STREAMED_MEDIA_HANDLER)) +#define EMPATHY_STREAMED_MEDIA_HANDLER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), EMPATHY_TYPE_STREAMED_MEDIA_HANDLER, \ + EmpathyStreamedMediaHandlerClass)) + +EmpathyStreamedMediaHandler * empathy_streamed_media_handler_new_for_contact ( + EmpathyContact *contact); + +EmpathyStreamedMediaHandler * empathy_streamed_media_handler_new_for_channel ( + EmpathyTpStreamedMedia *call); + +void empathy_streamed_media_handler_start_call (EmpathyStreamedMediaHandler *handler, + gint64 timestamp); +void empathy_streamed_media_handler_stop_call (EmpathyStreamedMediaHandler *handler); + +gboolean empathy_streamed_media_handler_has_initial_video (EmpathyStreamedMediaHandler *handler); + +void empathy_streamed_media_handler_bus_message (EmpathyStreamedMediaHandler *handler, + GstBus *bus, GstMessage *message); + +FsCodec * empathy_streamed_media_handler_get_send_audio_codec ( + EmpathyStreamedMediaHandler *self); + +FsCodec * empathy_streamed_media_handler_get_send_video_codec ( + EmpathyStreamedMediaHandler *self); + +GList * empathy_streamed_media_handler_get_recv_audio_codecs ( + EmpathyStreamedMediaHandler *self); + +GList * empathy_streamed_media_handler_get_recv_video_codecs ( + EmpathyStreamedMediaHandler *self); + +FsCandidate * empathy_streamed_media_handler_get_audio_remote_candidate ( + EmpathyStreamedMediaHandler *self); + +FsCandidate * empathy_streamed_media_handler_get_audio_local_candidate ( + EmpathyStreamedMediaHandler *self); + +FsCandidate * empathy_streamed_media_handler_get_video_remote_candidate ( + EmpathyStreamedMediaHandler *self); + +FsCandidate * empathy_streamed_media_handler_get_video_local_candidate ( + EmpathyStreamedMediaHandler *self); + +G_END_DECLS + +#endif /* #ifndef __EMPATHY_STREAMED_MEDIA_HANDLER_H__*/ |