aboutsummaryrefslogtreecommitdiffstats
path: root/libempathy
diff options
context:
space:
mode:
Diffstat (limited to 'libempathy')
-rw-r--r--libempathy/Makefile.am4
-rw-r--r--libempathy/empathy-call-factory.c12
-rw-r--r--libempathy/empathy-call-factory.h2
-rw-r--r--libempathy/empathy-call-handler.h106
-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.h106
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__*/