diff options
| -rw-r--r-- | src/Makefile.am | 1 | ||||
| -rw-r--r-- | src/ring-streamed-media-mixin.c | 699 | ||||
| -rw-r--r-- | src/ring-streamed-media-mixin.h | 108 |
3 files changed, 808 insertions, 0 deletions
diff --git a/src/Makefile.am b/src/Makefile.am index 7a65dae..9c4b157 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -51,6 +51,7 @@ libtpring_la_SOURCES = \ ring-media-manager.h ring-media-manager.c \ ring-media-channel.h ring-media-channel.c \ ring-call-channel.h ring-call-channel.c \ + ring-streamed-media-mixin.h ring-streamed-media-mixin.c \ ring-member-channel.h ring-member-channel.c \ ring-conference-manager.h ring-conference-manager.c \ ring-conference-channel.h ring-conference-channel.c \ diff --git a/src/ring-streamed-media-mixin.c b/src/ring-streamed-media-mixin.c new file mode 100644 index 0000000..68d9dfa --- /dev/null +++ b/src/ring-streamed-media-mixin.c @@ -0,0 +1,699 @@ +/* + * ring-streamed-media-mixin.c - Source for RingStreamedMediaMixin + * Copyright © 2011 Nokia Corporation + * + * 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 + */ + +#include "config.h" + +#define DEBUG_FLAG RING_DEBUG_MEDIA +#include "ring-debug.h" + +#include <ring-streamed-media-mixin.h> +#include "ring-util.h" + +#include <dbus/dbus-glib-lowlevel.h> +#include <dbus/dbus-glib.h> + +#include <telepathy-glib/dbus.h> +#include <telepathy-glib/enums.h> +#include <telepathy-glib/errors.h> +#include <telepathy-glib/gtypes.h> +#include <telepathy-glib/svc-channel.h> +#include <telepathy-glib/interfaces.h> + +#include <string.h> + +struct _RingStreamedMediaMixinPrivate +{ + struct stream_state { + guint id; /* nonzero when active, 0 otherwise */ + TpHandle handle; + TpMediaStreamType type; + TpMediaStreamState state; + TpMediaStreamDirection direction; + TpMediaStreamPendingSend pending; + } audio[1], video[1]; +}; + +enum { + RING_MEDIA_STREAM_ID_AUDIO = 1, + RING_MEDIA_STREAM_ID_VIDEO = 2 +}; + +static TpDBusPropertiesMixinPropImpl streamed_media_properties[] = { + { "InitialAudio", "initial-audio", NULL }, + { "InitialVideo", "initial-video", NULL }, + { "ImmutableStreams", "immutable-streams", NULL }, + { NULL } +}; + +void +ring_streamed_media_mixin_fill_immutable_properties (gpointer iface, + GHashTable *properties) +{ + tp_dbus_properties_mixin_fill_properties_hash (G_OBJECT (iface), + properties, + TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA, "InitialAudio", + TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA, "InitialVideo", + TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA, "ImmutableStreams", + NULL); +} + +GQuark +ring_streamed_media_mixin_class_get_offset_quark (void) +{ + static GQuark quark = 0; + + if (G_UNLIKELY (quark == 0)) + quark = g_quark_from_static_string ("RingStreamedMediaMixinClassOffset"); + + return quark; +} + +GQuark +ring_streamed_media_mixin_get_offset_quark (void) +{ + static GQuark quark = 0; + + if (G_UNLIKELY (quark == 0)) + quark = g_quark_from_static_string ("RingStreamedMediaMixinOffset"); + + return quark; +} + +RingStreamedMediaMixinClass * +ring_streamed_media_mixin_class (GObjectClass *object_class) +{ + return RING_STREAMED_MEDIA_MIXIN_CLASS (object_class); +} + +void +ring_streamed_media_mixin_class_init (GObjectClass *object_class, glong offset, + RingStreamedMediaMixinValidateMediaHandle validate_handle, + RingStreamedMediaMixinCreateStreams create_streams) +{ + RingStreamedMediaMixinClass *mixin_class; + + g_assert (G_IS_OBJECT_CLASS (object_class)); + g_assert (create_streams != NULL); + g_assert (validate_handle != NULL); + + g_type_set_qdata (G_OBJECT_CLASS_TYPE (object_class), + RING_STREAMED_MEDIA_MIXIN_CLASS_OFFSET_QUARK, + GINT_TO_POINTER (offset)); + + tp_dbus_properties_mixin_implement_interface (object_class, + TP_IFACE_QUARK_CHANNEL_TYPE_STREAMED_MEDIA, + tp_dbus_properties_mixin_getter_gobject_properties, + NULL, + streamed_media_properties); + + mixin_class = RING_STREAMED_MEDIA_MIXIN_CLASS (object_class); + + mixin_class->validate_handle = validate_handle; + mixin_class->create_streams = create_streams; +} + +void +ring_streamed_media_mixin_init (GObject *object, gsize offset) +{ + RingStreamedMediaMixin *mixin; + + g_type_set_qdata (G_OBJECT_TYPE (object), + RING_STREAMED_MEDIA_MIXIN_OFFSET_QUARK, + GSIZE_TO_POINTER (offset)); + + mixin = RING_STREAMED_MEDIA_MIXIN (object); + + mixin->priv = g_slice_new0 (RingStreamedMediaMixinPrivate); +} + +/** + * ring_streamed_media_mixin_finalize: (skip) + * @obj: An object with this mixin. + * + * Free resources held by the contacts mixin. + * + * Since: 0.7.14 + * + */ +void +ring_streamed_media_mixin_finalize (GObject *object) +{ + RingStreamedMediaMixin *mixin = RING_STREAMED_MEDIA_MIXIN (object); + RingStreamedMediaMixinPrivate *priv = mixin->priv; + + DEBUG ("%p", object); + + /* free any data held directly by the object here */ + + memset (priv->audio, 0, sizeof *priv->audio); + memset (priv->video, 0, sizeof *priv->video); + + g_slice_free (RingStreamedMediaMixinPrivate, priv); +} + +/** + * Telepathy.Channel.Type.StreamedMedia DBus interface - version 0.15 + * + * Methods: + * ListStreams ( ) -> a(uuuuuu) + * + * Returns an array of structs representing the streams currently active + * within this channel. Each stream is identified by an unsigned integer + * which is unique for each stream within the channel. + * + * Returns + * + * a(uuuuuu) + * An array of structs containing: + * + * * the stream identifier + * * the contact handle who the stream is with + * (or 0 if the stream represents more than a single member) + * * the type of the stream + * * the current stream state + * * the current direction of the stream + * * the current pending send flags + * + * + * RemoveStreams ( au: streams ) -> nothing + * + * Request that the given streams are removed. + * + * Parameters + * + * streams - au + * An array of stream identifiers (as defined in ListStreams) + * + * Possible errors + * + * org.freedesktop.Telepathy.Error.InvalidArgument + * Raised when one of the provided arguments is invalid. + * + * RequestStreamDirection ( u: stream_id, u: stream_direction ) -> nothing + * + * Request a change in the direction of an existing stream. In particular, + * this might be useful to stop sending media of a particular type, or + * inform the peer that you are no longer using media that is being sent to + * you. + * + * Depending on the protocol, streams which are no longer sending in either + * direction should be removed and a StreamRemoved signal emitted. Some + * direction changes can be enforced locally (for example, BIDIRECTIONAL -> + * RECEIVE can be achieved by merely stopping sending), others may not be + * possible on some protocols, and some need agreement from the remote end. + * In this case, the MEDIA_STREAM_PENDING_REMOTE_SEND flag will be set in + * the StreamDirectionChanged signal, and the signal emitted again without + * the flag to indicate the resulting direction when the remote end has + * accepted or rejected the change. Parameters + * + * stream_id - u + * The stream identifier (as defined in ListStreams) + * stream_direction - u + * The desired stream direction (a value of MediaStreamDirection) + * + * Possible errors + * + * org.freedesktop.Telepathy.Error.InvalidArgument + * Raised when one of the provided arguments is invalid. + * org.freedesktop.Telepathy.Error.NotAvailable + * Raised when the requested functionality is temporarily + * unavailable. (generic description) + * + * RequestStreams ( u: contact_handle, au: types ) -> a(uuuuuu) + * + * Request that streams be established to exchange the given types of media + * with the given member. In general this will try and establish a + * bidirectional stream, but on some protocols it may not be possible to + * indicate to the peer that you would like to receive media, so a send-only + * stream will be created initially. In the cases where the stream requires + * remote agreement (eg you wish to receive media from them), the + * StreamDirectionChanged signal will be emitted with the + * MEDIA_STREAM_PENDING_REMOTE_SEND flag set, and the signal emitted again + * with the flag cleared when the remote end has replied. Parameters + * + * contact_handle - u + * A contact handle with whom to establish the streams + * types - au + * An array of stream types (values of MediaStreamType) + * + * Returns + * + * a(uuuuuu) + * An array of structs (in the same order as the given stream types) + * containing: + * + * * the stream identifier + * * the contact handle who the stream is with + * (or 0 if the stream represents more than a single member) + * * the type of the stream + * * the current stream state + * * the current direction of the stream + * * the current pending send flags + * + * Possible errors + * + * org.freedesktop.Telepathy.Error.InvalidHandle + * The contact name specified is unknown on this channel or + * connection. (generic description) + * org.freedesktop.Telepathy.Error.InvalidArgument + * Raised when one of the provided arguments is invalid. (generic + * description) + * org.freedesktop.Telepathy.Error.NotAvailable + * Raised when the requested functionality is temporarily + * unavailable. (generic description) + * + * Signals: + * -> StreamAdded ( u: stream_id, u: contact_handle, u: stream_type ) + * + * Emitted when a new stream has been added to this channel. + * + * Parameters + * + * stream_id - u + * The stream identifier (as defined in ListStreams) + * contact_handle - u + * The contact handle who the stream is with (or 0 if it represents more than a single member) + * stream_type - u + * The stream type (a value from MediaStreamType) + * + * -> StreamDirectionChanged ( u: stream_id, u: stream_direction, u: pending_flags ) + * + * Emitted when the direction or pending flags of a stream are changed. If + * the MEDIA_STREAM_PENDING_LOCAL_SEND flag is set, the remote user has + * requested that we begin sending on this stream. RequestStreamDirection + * should be called to indicate whether or not this change is acceptable. + * Parameters + * + * stream_id - u + * The stream identifier (as defined in ListStreams) + * stream_direction - u + * The new stream direction (as defined in ListStreams) + * pending_flags - u + * The new pending send flags (as defined in ListStreams) + * + * StreamError ( u: stream_id, u: errno, s: message ) + * + * Emitted when a stream encounters an error. + * + * Parameters + * + * stream_id - u + * The stream identifier (as defined in ListStreams) + * errno - u + * A stream error number, one of the values of MediaStreamError + * message - s + * A string describing the error (for debugging purposes only) + * + * StreamRemoved ( u: stream_id ) + * + * Emitted when a stream has been removed from this channel. + * + * Parameters + * + * stream_id - u + * stream_id - the stream identifier (as defined in ListStreams) + * + * StreamStateChanged ( u: stream_id, u: stream_state ) + * + * Emitted when a member's stream's state changes. + * + * Parameters + * + * stream_id - u + * The stream identifier (as defined in ListStreams) + * stream_state - u + * The new stream state (as defined in ListStreams) + */ + +#define TP_CHANNEL_STREAM_TYPE \ + (dbus_g_type_get_struct("GValueArray", \ + G_TYPE_UINT, \ + G_TYPE_UINT, \ + G_TYPE_UINT, \ + G_TYPE_UINT, \ + G_TYPE_UINT, \ + G_TYPE_UINT, \ + G_TYPE_INVALID)) + +/* Return a pointer to GValue with boxed stream struct */ +static gpointer +describe_stream (struct stream_state *ss) +{ + const GType ElementType = TP_CHANNEL_STREAM_TYPE; + GValue element[1] = {{ 0 }}; + + g_value_init (element, ElementType); + g_value_take_boxed (element, dbus_g_type_specialized_construct (ElementType)); + + dbus_g_type_struct_set (element, + 0, ss->id, + 1, ss->handle, + 2, ss->type, + 3, ss->state, + 4, ss->direction, + 5, ss->pending, + G_MAXUINT); + + return g_value_get_boxed (element); +} + +static gpointer +describe_null_media (TpMediaStreamType tptype) +{ + struct stream_state ss[1] = {{ 0 }}; + + ss->type = tptype; + + return describe_stream (ss); +} + +static GPtrArray * +list_media_streams (TpSvcChannelTypeStreamedMedia *iface) +{ + RingStreamedMediaMixin *mixin = RING_STREAMED_MEDIA_MIXIN (iface); + RingStreamedMediaMixinPrivate *priv = mixin->priv; + GPtrArray *list; + size_t size; + + size = (priv->audio->id != 0) + (priv->video->id != 0); + + list = g_ptr_array_sized_new(size); + + if (priv->audio->id) + g_ptr_array_add(list, describe_stream(priv->audio)); + if (priv->video->id) + g_ptr_array_add(list, describe_stream(priv->video)); + + return list; +} + +static void +free_media_stream_list (GPtrArray *list) +{ + const GType ElementType = TP_CHANNEL_STREAM_TYPE; + guint i; + + if (list) + { + for (i = list->len; i-- > 0;) + g_boxed_free(ElementType, g_ptr_array_index(list, i)); + + g_ptr_array_free(list, TRUE); + } +} + +/** DBus method ListStreams ( ) -> a(uuuuuu) + * + * Returns an array of structs representing the streams currently active + * within this channel. Each stream is identified by an unsigned integer + * which is unique for each stream within the channel. + * + * Returns + * + * a(uuuuuu) + * An array of structs containing: + * + * * the stream identifier + * * the contact handle who the stream is with + * (or 0 if the stream represents more than a single member) + * * the type of the stream + * * the current stream state + * * the current direction of the stream + * * the current pending send flags + */ +static void +ring_streamed_media_list_streams (TpSvcChannelTypeStreamedMedia *iface, + DBusGMethodInvocation *context) +{ + GPtrArray *list = list_media_streams (iface); + + tp_svc_channel_type_streamed_media_return_from_list_streams (context, list); + + free_media_stream_list (list); +} + +/** Update media stream state. + * + * @retval 0 if nothing changed + * @retval 1 (or nonzero) if state changed + */ +static int +update_media_stream (TpSvcChannelTypeStreamedMedia *iface, + TpHandle handle, + guint id, + TpMediaStreamType type, + TpMediaStreamState state, + TpMediaStreamDirection direction, + TpMediaStreamPendingSend pending) +{ + RingStreamedMediaMixin *mixin = RING_STREAMED_MEDIA_MIXIN (iface); + RingStreamedMediaMixinPrivate *priv = mixin->priv; + struct stream_state *ss; + int changed = 0; + + if (id == TP_MEDIA_STREAM_TYPE_AUDIO) + ss = priv->audio; + else if (id == TP_MEDIA_STREAM_TYPE_VIDEO) + ss = priv->video; + else + return 0; + + if (state == TP_MEDIA_STREAM_STATE_DISCONNECTED) + { + if (ss->id != id) + return 0; + + /* emit StreamRemoved */ + tp_svc_channel_type_streamed_media_emit_stream_removed (iface, id); + memset (ss, 0, sizeof ss); + + return 1; + } + + /* emit StreamAdded */ + if (ss->id != id) + { + changed = 1; + + if (handle == 0) + { + g_object_get (iface, "peer", &handle, NULL); + } + + ss->id = id; + ss->handle = handle; + ss->type = type; + + DEBUG ("emitting StreamAdded(%u, %d, %s)", + id, handle, + type == TP_MEDIA_STREAM_TYPE_AUDIO ? "AUDIO" : + type == TP_MEDIA_STREAM_TYPE_VIDEO ? "VIDEO" : "???"); + + tp_svc_channel_type_streamed_media_emit_stream_added (iface, + id, handle, type); + } + + /* emit StreamStateChanged */ + if (ss->state != state) + { + changed = 1; + ss->state = state; + + DEBUG("emitting StreamStateChanged(%u, %s)", + ss->id, + state == TP_MEDIA_STREAM_STATE_DISCONNECTED ? "DISCONNECTED" : + state == TP_MEDIA_STREAM_STATE_CONNECTING ? "CONNECTING" : + state == TP_MEDIA_STREAM_STATE_CONNECTED ? "CONNECTED" : "???"); + + tp_svc_channel_type_streamed_media_emit_stream_state_changed (iface, + ss->id, state); + } + + /* emit StreamDirectionChanged */ + if (ss->direction != direction || ss->pending != pending) + { + changed = 1; + ss->direction = direction; + ss->pending = pending; + + DEBUG("emitting StreamDirectionChanged(%u, %s,%s%s%s)", + ss->id, + direction == TP_MEDIA_STREAM_DIRECTION_BIDIRECTIONAL + ? "BIDIRECTIONAL" : + direction == TP_MEDIA_STREAM_DIRECTION_SEND ? "SEND" : + direction == TP_MEDIA_STREAM_DIRECTION_RECEIVE ? "RECV" : "NONE", + pending & TP_MEDIA_STREAM_PENDING_REMOTE_SEND ? " remote" : "", + pending & TP_MEDIA_STREAM_PENDING_LOCAL_SEND ? " local" : "", + pending == 0 ? " 0" : ""); + + tp_svc_channel_type_streamed_media_emit_stream_direction_changed (iface, + ss->id, ss->direction, ss->pending); + } + + return changed; +} + +/** DBus method RequestStreams ( u: contact_handle, au: types ) -> a(uuuuuu) + * + * Request that streams be established to exchange the given types of media + * with the given member. In general this will try and establish a + * bidirectional stream, but on some protocols it may not be possible to + * indicate to the peer that you would like to receive media, so a send-only + * stream will be created initially. In the cases where the stream requires + * remote agreement (eg you wish to receive media from them), the + * StreamDirectionChanged signal will be emitted with the + * MEDIA_STREAM_PENDING_REMOTE_SEND flag set, and the signal emitted again + * with the flag cleared when the remote end has replied. + * + */ +static void +ring_streamed_media_request_streams (TpSvcChannelTypeStreamedMedia *iface, + guint handle, + const GArray *media_types, + DBusGMethodInvocation *context) +{ + RingStreamedMediaMixin *mixin = RING_STREAMED_MEDIA_MIXIN (iface); + RingStreamedMediaMixinPrivate *priv = mixin->priv; + RingStreamedMediaMixinClass *klass; + GError *error = NULL; + GPtrArray *list; + guint i, create_audio_stream = 0, create_video_stream = 0; + + DEBUG("()"); + + klass = RING_STREAMED_MEDIA_MIXIN_GET_CLASS (iface); + g_assert (klass->validate_handle != NULL); + g_assert (klass->create_streams != NULL); + + if (!klass->validate_handle (iface, &handle, &error)) + { + dbus_g_method_return_error (context, error); + g_clear_error (&error); + return; + } + + /* We can create media only when call has not been initiated */ + for (i = 0; i < media_types->len; i++) + { + guint media_type = g_array_index(media_types, guint, i); + + if (media_type == TP_MEDIA_STREAM_TYPE_AUDIO) + { + if (priv->audio->id == 0) + continue; + + if (!klass->create_streams (iface, handle, TRUE, FALSE, &error)) + { + dbus_g_method_return_error(context, error); + g_clear_error(&error); + return; + } + + create_audio_stream = TRUE; + + update_media_stream (iface, handle, + RING_MEDIA_STREAM_ID_AUDIO, TP_MEDIA_STREAM_TYPE_AUDIO, + TP_MEDIA_STREAM_STATE_CONNECTING, + TP_MEDIA_STREAM_DIRECTION_NONE, + TP_MEDIA_STREAM_PENDING_LOCAL_SEND | + TP_MEDIA_STREAM_PENDING_REMOTE_SEND); + } + } + + list = g_ptr_array_sized_new (media_types->len); + + for (i = 0; i < media_types->len; i++) { + guint media_type = g_array_index(media_types, guint, i); + gpointer element; + + if (media_type == TP_MEDIA_STREAM_TYPE_AUDIO && create_audio_stream) + element = describe_stream(priv->audio), create_audio_stream = 0; + else if (media_type == TP_MEDIA_STREAM_TYPE_VIDEO && create_video_stream) + element = describe_stream(priv->video), create_video_stream = 0; + else + element = describe_null_media(media_type); + + g_ptr_array_add(list, element); + } + + tp_svc_channel_type_streamed_media_return_from_request_streams (context, + list); + + free_media_stream_list (list); + + DEBUG("exit"); +} + +void +ring_streamed_media_mixin_iface_init (gpointer g_iface, gpointer iface_data) +{ + TpSvcChannelTypeStreamedMediaClass *klass = + (TpSvcChannelTypeStreamedMediaClass *)g_iface; + +#define IMPLEMENT(x) tp_svc_channel_type_streamed_media_implement_##x (klass, \ + ring_streamed_media_##x) + IMPLEMENT (list_streams); + IMPLEMENT (request_streams); +#undef IMPLEMENT +} + +/** Update audio state. + * + * @retval 0 if nothing changed + * @retval 1 (or nonzero) if state changed + */ +int +ring_streamed_media_mixin_update_audio (gpointer _self, + TpHandle handle, + TpMediaStreamState state, + TpMediaStreamDirection direction, + TpMediaStreamPendingSend pending) +{ + return update_media_stream (TP_SVC_CHANNEL_TYPE_STREAMED_MEDIA (_self), + handle, RING_MEDIA_STREAM_ID_AUDIO, + TP_MEDIA_STREAM_TYPE_AUDIO, state, direction, pending); +} + +gboolean +ring_streamed_media_mixin_is_audio_stream (gpointer iface, + guint stream_id) +{ + RingStreamedMediaMixin *mixin = RING_STREAMED_MEDIA_MIXIN (iface); + + return stream_id != 0 && stream_id == mixin->priv->audio->id; +} + +gboolean +ring_streamed_media_mixin_is_stream_connected (gpointer iface, + guint stream_id) +{ + RingStreamedMediaMixin *mixin = RING_STREAMED_MEDIA_MIXIN (iface); + + if (stream_id == 0) + return FALSE; + + if (stream_id == mixin->priv->audio->id) + return mixin->priv->audio->state == TP_MEDIA_STREAM_STATE_CONNECTED; + + if (stream_id == mixin->priv->video->id) + return mixin->priv->video->state == TP_MEDIA_STREAM_STATE_CONNECTED; + + return FALSE; +} diff --git a/src/ring-streamed-media-mixin.h b/src/ring-streamed-media-mixin.h new file mode 100644 index 0000000..4f73b33 --- /dev/null +++ b/src/ring-streamed-media-mixin.h @@ -0,0 +1,108 @@ +/* + * ring-streamed-media-mixin.h - Header for RingStreamedMediaMixin + * + * Copyright (C) 2011 Nokia Corporation + * + * 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 RING_STREAMED_MEDIA_MIXIN_H +#define RING_STREAMED_MEDIA_MIXIN_H + +#include <telepathy-glib/svc-connection.h> +#include <telepathy-glib/handle-repo.h> + +G_BEGIN_DECLS + +typedef struct _RingStreamedMediaMixinClass RingStreamedMediaMixinClass; +typedef struct _RingStreamedMediaMixin RingStreamedMediaMixin; +typedef struct _RingStreamedMediaMixinPrivate RingStreamedMediaMixinPrivate; + +typedef gboolean (*RingStreamedMediaMixinValidateMediaHandle) (gpointer, + guint *handle, GError **); +typedef gboolean (*RingStreamedMediaMixinCreateStreams) (gpointer, + guint handle, gboolean audio, gboolean video, GError **); + +struct _RingStreamedMediaMixinClass { + RingStreamedMediaMixinValidateMediaHandle validate_handle; + RingStreamedMediaMixinCreateStreams create_streams; +}; + +struct _RingStreamedMediaMixin { + RingStreamedMediaMixinPrivate *priv; +}; + +/* TYPE MACROS */ + +#define RING_STREAMED_MEDIA_MIXIN_CLASS_OFFSET_QUARK \ + (ring_streamed_media_mixin_class_get_offset_quark ()) + +#define RING_STREAMED_MEDIA_MIXIN_CLASS_OFFSET(klass) \ + (tp_mixin_class_get_offset (klass, \ + RING_STREAMED_MEDIA_MIXIN_CLASS_OFFSET_QUARK)) + +#define RING_STREAMED_MEDIA_MIXIN_CLASS(klass) \ + ((RingStreamedMediaMixinClass *) \ + tp_mixin_offset_cast (klass, \ + RING_STREAMED_MEDIA_MIXIN_CLASS_OFFSET (klass))) + +#define RING_STREAMED_MEDIA_MIXIN_GET_CLASS(object) \ + ring_streamed_media_mixin_class (G_OBJECT_GET_CLASS (object)) + +GQuark ring_streamed_media_mixin_class_get_offset_quark (void); +void ring_streamed_media_mixin_class_init (GObjectClass *klass, glong offset, + RingStreamedMediaMixinValidateMediaHandle validate_handle, + RingStreamedMediaMixinCreateStreams create_streams); + +#define RING_STREAMED_MEDIA_MIXIN_OFFSET_QUARK \ + (ring_streamed_media_mixin_get_offset_quark ()) + +#define RING_STREAMED_MEDIA_MIXIN_OFFSET(object) \ + (tp_mixin_instance_get_offset (object, \ + RING_STREAMED_MEDIA_MIXIN_OFFSET_QUARK)) + +#define RING_STREAMED_MEDIA_MIXIN(object) \ + ((RingStreamedMediaMixin *) \ + tp_mixin_offset_cast (object, \ + RING_STREAMED_MEDIA_MIXIN_OFFSET (object))) + +GQuark ring_streamed_media_mixin_get_offset_quark (void); + +void ring_streamed_media_mixin_init (GObject *object, gsize offset); +void ring_streamed_media_mixin_finalize (GObject *object); + +void ring_streamed_media_mixin_iface_init (gpointer iface, gpointer data); + +/* RingStreamedMediaMixin interface */ + +void ring_streamed_media_mixin_fill_immutable_properties (gpointer iface, + GHashTable *properties); + +int ring_streamed_media_mixin_update_audio (gpointer iface, + TpHandle handle, + TpMediaStreamState state, + TpMediaStreamDirection direction, + TpMediaStreamPendingSend pending); + +gboolean ring_streamed_media_mixin_is_audio_stream (gpointer iface, + guint stream_id); + +gboolean ring_streamed_media_mixin_is_stream_connected (gpointer iface, + guint stream_id); + +G_END_DECLS + +#endif /* #ifndef RING_STREAMED_MEDIA_MIXIN_H */ |