## Media channels

Media channels — client-side wrappers for the Streamed Media channel type, and the Call State, DTMF and Media Signalling interfaces

## Synopsis

    #include <telepathy-glib/channel.h>

    TpProxyPendingCall * tp_cli_channel_type_streamed_media_call_list_streams
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             tp_cli_channel_type_streamed_media_callback_for_list_streams callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    TpProxyPendingCall * tp_cli_channel_type_streamed_media_call_remove_streams
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             const GArray *in_Streams,
                                                             tp_cli_channel_type_streamed_media_callback_for_remove_streams callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    TpProxyPendingCall * tp_cli_channel_type_streamed_media_call_request_stream_direction
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_Stream_ID,
                                                             guint in_Stream_Direction,
                                                             tp_cli_channel_type_streamed_media_callback_for_request_stream_direction callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    TpProxyPendingCall * tp_cli_channel_type_streamed_media_call_request_streams
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_Contact_Handle,
                                                             const GArray *in_Types,
                                                             tp_cli_channel_type_streamed_media_callback_for_request_streams callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_streamed_media_callback_for_list_streams)
                                                            (TpChannel *proxy,
                                                             const GPtrArray *out_Streams,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_streamed_media_callback_for_remove_streams)
                                                            (TpChannel *proxy,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_streamed_media_callback_for_request_stream_direction)
                                                            (TpChannel *proxy,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_streamed_media_callback_for_request_streams)
                                                            (TpChannel *proxy,
                                                             const GPtrArray *out_Streams,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    gboolean            tp_cli_channel_type_streamed_media_run_list_streams
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             GPtrArray **out_Streams,
                                                             GError **error,
                                                             GMainLoop **loop);
    gboolean            tp_cli_channel_type_streamed_media_run_remove_streams
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             const GArray *in_Streams,
                                                             GError **error,
                                                             GMainLoop **loop);
    gboolean            tp_cli_channel_type_streamed_media_run_request_stream_direction
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_Stream_ID,
                                                             guint in_Stream_Direction,
                                                             GError **error,
                                                             GMainLoop **loop);
    gboolean            tp_cli_channel_type_streamed_media_run_request_streams
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_Contact_Handle,
                                                             const GArray *in_Types,
                                                             GPtrArray **out_Streams,
                                                             GError **error,
                                                             GMainLoop **loop);
    TpProxySignalConnection * tp_cli_channel_type_streamed_media_connect_to_stream_added
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_type_streamed_media_signal_callback_stream_added callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);
    TpProxySignalConnection * tp_cli_channel_type_streamed_media_connect_to_stream_direction_changed
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_type_streamed_media_signal_callback_stream_direction_changed callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);
    TpProxySignalConnection * tp_cli_channel_type_streamed_media_connect_to_stream_error
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_type_streamed_media_signal_callback_stream_error callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);
    TpProxySignalConnection * tp_cli_channel_type_streamed_media_connect_to_stream_removed
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_type_streamed_media_signal_callback_stream_removed callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);
    TpProxySignalConnection * tp_cli_channel_type_streamed_media_connect_to_stream_state_changed
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_type_streamed_media_signal_callback_stream_state_changed callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);
    void                (*tp_cli_channel_type_streamed_media_signal_callback_stream_added)
                                                            (TpChannel *proxy,
                                                             guint arg_Stream_ID,
                                                             guint arg_Contact_Handle,
                                                             guint arg_Stream_Type,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_streamed_media_signal_callback_stream_direction_changed)
                                                            (TpChannel *proxy,
                                                             guint arg_Stream_ID,
                                                             guint arg_Stream_Direction,
                                                             guint arg_Pending_Flags,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_streamed_media_signal_callback_stream_error)
                                                            (TpChannel *proxy,
                                                             guint arg_Stream_ID,
                                                             guint arg_Error_Code,
                                                             const gchar *arg_Message,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_streamed_media_signal_callback_stream_removed)
                                                            (TpChannel *proxy,
                                                             guint arg_Stream_ID,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_streamed_media_signal_callback_stream_state_changed)
                                                            (TpChannel *proxy,
                                                             guint arg_Stream_ID,
                                                             guint arg_Stream_State,
                                                             gpointer user_data,
                                                             GObject *weak_object);

    TpProxyPendingCall * tp_cli_channel_interface_call_state_call_get_call_states
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             tp_cli_channel_interface_call_state_callback_for_get_call_states callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_interface_call_state_callback_for_get_call_states)
                                                            (TpChannel *proxy,
                                                             GHashTable *out_States,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    TpProxySignalConnection * tp_cli_channel_interface_call_state_connect_to_call_state_changed
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_interface_call_state_signal_callback_call_state_changed callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);
    gboolean            tp_cli_channel_interface_call_state_run_get_call_states
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             GHashTable **out_States,
                                                             GError **error,
                                                             GMainLoop **loop);
    void                (*tp_cli_channel_interface_call_state_signal_callback_call_state_changed)
                                                            (TpChannel *proxy,
                                                             guint arg_Contact,
                                                             guint arg_State,
                                                             gpointer user_data,
                                                             GObject *weak_object);

    gboolean            tp_cli_channel_interface_dtmf_run_start_tone
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_Stream_ID,
                                                             guchar in_Event,
                                                             GError **error,
                                                             GMainLoop **loop);
    gboolean            tp_cli_channel_interface_dtmf_run_stop_tone
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_Stream_ID,
                                                             GError **error,
                                                             GMainLoop **loop);
    TpProxyPendingCall * tp_cli_channel_interface_dtmf_call_start_tone
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_Stream_ID,
                                                             guchar in_Event,
                                                             tp_cli_channel_interface_dtmf_callback_for_start_tone callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    TpProxyPendingCall * tp_cli_channel_interface_dtmf_call_stop_tone
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_Stream_ID,
                                                             tp_cli_channel_interface_dtmf_callback_for_stop_tone callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_interface_dtmf_callback_for_start_tone)
                                                            (TpChannel *proxy,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_interface_dtmf_callback_for_stop_tone)
                                                            (TpChannel *proxy,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

    void                (*tp_cli_channel_interface_hold_callback_for_get_hold_state)
                                                            (TpChannel *proxy,
                                                             guint out_HoldState,
                                                             guint out_Reason,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    TpProxyPendingCall * tp_cli_channel_interface_hold_call_get_hold_state
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             tp_cli_channel_interface_hold_callback_for_get_hold_state callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    gboolean            tp_cli_channel_interface_hold_run_get_hold_state
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint *out_HoldState,
                                                             guint *out_Reason,
                                                             GError **error,
                                                             GMainLoop **loop);
    void                (*tp_cli_channel_interface_hold_callback_for_request_hold)
                                                            (TpChannel *proxy,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    TpProxyPendingCall * tp_cli_channel_interface_hold_call_request_hold
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             gboolean in_Hold,
                                                             tp_cli_channel_interface_hold_callback_for_request_hold callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    gboolean            tp_cli_channel_interface_hold_run_request_hold
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             gboolean in_Hold,
                                                             GError **error,
                                                             GMainLoop **loop);
    void                (*tp_cli_channel_interface_hold_signal_callback_hold_state_changed)
                                                            (TpChannel *proxy,
                                                             guint arg_HoldState,
                                                             guint arg_Reason,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    TpProxySignalConnection * tp_cli_channel_interface_hold_connect_to_hold_state_changed
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_interface_hold_signal_callback_hold_state_changed callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);

    gboolean            tp_cli_channel_interface_media_signalling_run_get_session_handlers
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             GPtrArray **out_Session_Handlers,
                                                             GError **error,
                                                             GMainLoop **loop);
    TpProxyPendingCall * tp_cli_channel_interface_media_signalling_call_get_session_handlers
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             tp_cli_channel_interface_media_signalling_callback_for_get_session_handlers callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_interface_media_signalling_callback_for_get_session_handlers)
                                                            (TpChannel *proxy,
                                                             const GPtrArray *out_Session_Handlers,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    TpProxySignalConnection * tp_cli_channel_interface_media_signalling_connect_to_new_session_handler
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_interface_media_signalling_signal_callback_new_session_handler callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);
    void                (*tp_cli_channel_interface_media_signalling_signal_callback_new_session_handler)
                                                            (TpChannel *proxy,
                                                             const gchar *arg_Session_Handler,
                                                             const gchar *arg_Session_Type,
                                                             gpointer user_data,
                                                             GObject *weak_object);

## Description

This section documents the auto-generated C wrappers for the Streamed Media channel type, and the DTMF and Media Signalling interfaces which are optionally supported by channels of this type.

Streamed Media channels represent real-time audio or video streaming, including voice over IP, webcams, and telephony.

Channels of type Streamed Media may support the Media Signalling interface. If not, the connection manager is assumed to be presenting the media streams to the user automatically (for instance, in a connection manager like gnome-phone-manager or telepathy-snom that remotely controls a telephone, the phone's own speaker and microphone will probably be used directly).

If Media Signalling is supported, the Telepathy client is responsible for actually streaming the media, using the Media Signalling interface to provide signalling (connection managers might implement this interface in terms of Jingle or SDP, for instance). The Telepathy project suggests that client authors use the Farsight library for this; the glue between Media Signalling and Farsight is currently done in telepathy-stream-engine, an additional D-Bus service, but it will be provided as a library in future.

Channels of type Streamed Media may also support the DTMF and CallState interfaces.

## Details

### tp_cli_channel_type_streamed_media_call_list_streams ()

    TpProxyPendingCall * tp_cli_channel_type_streamed_media_call_list_streams
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             tp_cli_channel_type_streamed_media_callback_for_list_streams callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a ListStreams method call.

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.

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_type_streamed_media_call_remove_streams ()

    TpProxyPendingCall * tp_cli_channel_type_streamed_media_call_remove_streams
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             const GArray *in_Streams,
                                                             tp_cli_channel_type_streamed_media_callback_for_remove_streams callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a RemoveStreams method call.

<tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>Request that the given streams are removed. If all streams are removed, the channel MAY close.</p> <p>Clients SHOULD NOT attempt to terminate calls by removing all the streams; instead, clients SHOULD terminate calls by removing the <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">Group.SelfHandle</tp:dbus-ref> from the channel, using either <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface.Group">RemoveMembers</tp:dbus-ref> or <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface.Group">RemoveMembersWithReason</tp:dbus-ref>. </p>

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`in_Streams` : | Used to pass an 'in' argument: An array of stream identifiers (as defined in <tp:member-ref>ListStreams</tp:member-ref>)
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_type_streamed_media_call_request_stream_direction ()

    TpProxyPendingCall * tp_cli_channel_type_streamed_media_call_request_stream_direction
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_Stream_ID,
                                                             guint in_Stream_Direction,
                                                             tp_cli_channel_type_streamed_media_callback_for_request_stream_direction callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a RequestStreamDirection method call.

<tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>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.</p> <p>Depending on the protocol, streams which are no longer sending in either direction should be removed and a <tp:member-ref>StreamRemoved</tp:member-ref> signal emitted. Some direction changes can be enforced locally (for example, BIDIRECTIONAL -&gt; 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 <tp:member-ref>StreamDirectionChanged</tp:member-ref> signal, and the signal emitted again without the flag to indicate the resulting direction when the remote end has accepted or rejected the change.</p>

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`in_Stream_ID` : | Used to pass an 'in' argument: The stream identifier (as defined in <tp:member-ref>ListStreams</tp:member-ref>)
`in_Stream_Direction` : | Used to pass an 'in' argument: The desired stream direction (a value of MediaStreamDirection)
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_type_streamed_media_call_request_streams ()

    TpProxyPendingCall * tp_cli_channel_type_streamed_media_call_request_streams
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_Contact_Handle,
                                                             const GArray *in_Types,
                                                             tp_cli_channel_type_streamed_media_callback_for_request_streams callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a RequestStreams method call.

<tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>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 <tp:member-ref>StreamDirectionChanged</tp:member-ref> 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.</p> <p>If streams of the requested types already exist, calling this method results in the creation of additional streams. Accordingly, clients wishing to have exactly one audio stream or exactly one video stream SHOULD check for the current streams using <tp:member-ref>ListStreams</tp:member-ref> before calling this method.</p>

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`in_Contact_Handle` : | Used to pass an 'in' argument: A contact handle with whom to establish the streams
`in_Types` : | Used to pass an 'in' argument: An array of stream types (values of MediaStreamType)
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_type_streamed_media_callback_for_list_streams ()

    void                (*tp_cli_channel_type_streamed_media_callback_for_list_streams)
                                                            (TpChannel *proxy,
                                                             const GPtrArray *out_Streams,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a ListStreams method call succeeds or fails.

`proxy` : | the proxy on which the call was made

`out_Streams` :

Used to return an 'out' argument if `error` is `NULL`: <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> An array of structs containing: <ul> <li>the stream identifier</li> <li>the contact handle who the stream is with (or 0 if the stream represents more than a single member)</li> <li>the type of the stream</li> <li>the current stream state</li> <li>the current direction of the stream</li> <li>the current pending send flags</li> </ul>

`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_type_streamed_media_callback_for_remove_streams ()

    void                (*tp_cli_channel_type_streamed_media_callback_for_remove_streams)
                                                            (TpChannel *proxy,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a RemoveStreams method call succeeds or fails.

`proxy` : | the proxy on which the call was made
`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_type_streamed_media_callback_for_request_stream_direction ()

    void                (*tp_cli_channel_type_streamed_media_callback_for_request_stream_direction)
                                                            (TpChannel *proxy,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a RequestStreamDirection method call succeeds or fails.

`proxy` : | the proxy on which the call was made
`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_type_streamed_media_callback_for_request_streams ()

    void                (*tp_cli_channel_type_streamed_media_callback_for_request_streams)
                                                            (TpChannel *proxy,
                                                             const GPtrArray *out_Streams,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a RequestStreams method call succeeds or fails.

`proxy` : | the proxy on which the call was made

`out_Streams` :

Used to return an 'out' argument if `error` is `NULL`: <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> An array of structs (in the same order as the given stream types) containing: <ul> <li>the stream identifier</li> <li>the contact handle who the stream is with (or 0 if the stream represents more than a single member)</li> <li>the type of the stream</li> <li>the current stream state</li> <li>the current direction of the stream</li> <li>the current pending send flags</li> </ul>

`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_type_streamed_media_run_list_streams ()

    gboolean            tp_cli_channel_type_streamed_media_run_list_streams
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             GPtrArray **out_Streams,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method ListStreams and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

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.

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default

`out_Streams` :

Used to return an 'out' argument if `TRUE` is returned: <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> An array of structs containing: <ul> <li>the stream identifier</li> <li>the contact handle who the stream is with (or 0 if the stream represents more than a single member)</li> <li>the type of the stream</li> <li>the current stream state</li> <li>the current direction of the stream</li> <li>the current pending send flags</li> </ul>

`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_type_streamed_media_run_remove_streams ()

    gboolean            tp_cli_channel_type_streamed_media_run_remove_streams
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             const GArray *in_Streams,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method RemoveStreams and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

<tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>Request that the given streams are removed. If all streams are removed, the channel MAY close.</p> <p>Clients SHOULD NOT attempt to terminate calls by removing all the streams; instead, clients SHOULD terminate calls by removing the <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">Group.SelfHandle</tp:dbus-ref> from the channel, using either <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface.Group">RemoveMembers</tp:dbus-ref> or <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface.Group">RemoveMembersWithReason</tp:dbus-ref>. </p>

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default
`in_Streams` : | Used to pass an 'in' argument: An array of stream identifiers (as defined in <tp:member-ref>ListStreams</tp:member-ref>)
`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_type_streamed_media_run_request_stream_direction ()

    gboolean            tp_cli_channel_type_streamed_media_run_request_stream_direction
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_Stream_ID,
                                                             guint in_Stream_Direction,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method RequestStreamDirection and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

<tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>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.</p> <p>Depending on the protocol, streams which are no longer sending in either direction should be removed and a <tp:member-ref>StreamRemoved</tp:member-ref> signal emitted. Some direction changes can be enforced locally (for example, BIDIRECTIONAL -&gt; 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 <tp:member-ref>StreamDirectionChanged</tp:member-ref> signal, and the signal emitted again without the flag to indicate the resulting direction when the remote end has accepted or rejected the change.</p>

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default
`in_Stream_ID` : | Used to pass an 'in' argument: The stream identifier (as defined in <tp:member-ref>ListStreams</tp:member-ref>)
`in_Stream_Direction` : | Used to pass an 'in' argument: The desired stream direction (a value of MediaStreamDirection)
`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_type_streamed_media_run_request_streams ()

    gboolean            tp_cli_channel_type_streamed_media_run_request_streams
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_Contact_Handle,
                                                             const GArray *in_Types,
                                                             GPtrArray **out_Streams,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method RequestStreams and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

<tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>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 <tp:member-ref>StreamDirectionChanged</tp:member-ref> 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.</p> <p>If streams of the requested types already exist, calling this method results in the creation of additional streams. Accordingly, clients wishing to have exactly one audio stream or exactly one video stream SHOULD check for the current streams using <tp:member-ref>ListStreams</tp:member-ref> before calling this method.</p>

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default
`in_Contact_Handle` : | Used to pass an 'in' argument: A contact handle with whom to establish the streams
`in_Types` : | Used to pass an 'in' argument: An array of stream types (values of MediaStreamType)

`out_Streams` :

Used to return an 'out' argument if `TRUE` is returned: <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> An array of structs (in the same order as the given stream types) containing: <ul> <li>the stream identifier</li> <li>the contact handle who the stream is with (or 0 if the stream represents more than a single member)</li> <li>the type of the stream</li> <li>the current stream state</li> <li>the current direction of the stream</li> <li>the current pending send flags</li> </ul>

`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_type_streamed_media_connect_to_stream_added ()

    TpProxySignalConnection * tp_cli_channel_type_streamed_media_connect_to_stream_added
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_type_streamed_media_signal_callback_stream_added callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);

Connect a handler to the signal StreamAdded.

<tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>Emitted when a new stream has been added to this channel. Clients SHOULD assume that the stream's <tp:type>Media_Stream_State</tp:type> is initially Disconnected.</p> <p>If a connection manager needs to represent the addition of a stream whose state is already Connecting or Connected, it MUST do this by emitting StreamAdded, closely followed by <tp:member-ref>StreamStateChanged</tp:member-ref> indicating a change to the appropriate state.</p> <tp:rationale> <p>Historically, it was not clear from the StreamAdded signal what the state of the stream was. telepathy-spec 0.17.22 clarified this.</p> </tp:rationale> <p>Similarly, clients SHOULD assume that the initial <tp:type>Media_Stream_Direction</tp:type> of a newly added stream is Receive, and that the initial <tp:type>Media_Stream_Pending_Send</tp:type> is Pending_Local_Send.</p> <p>If a connection manager needs to represent the addition of a stream whose direction or pending-send differs from those initial values, it MUST do so by emitting StreamAdded, closely followed by <tp:member-ref>StreamDirectionChanged</tp:member-ref> indicating a change to the appropriate direction and pending-send state.</p> <tp:rationale> <p>StreamAdded doesn't itself indicate the stream's direction; this is unfortunate, but is preserved for compatibility.</p> <p>This is the appropriate direction for streams added by a remote contact on existing connection managers, and does not violate user privacy by automatically sending audio or video (audio streams start off muted, video streams start off not sending). For streams added by the local user using the client receiving the signal, the true direction can also be determined from the return value of the <tp:member-ref>RequestStreams</tp:member-ref> method.</p> <p>Existing clients typically operate by maintaining a separate idea of the directions that they would like the streams to have, and enforcing these intended directions by calling <tp:member-ref>RequestStreamDirection</tp:member-ref> whenever needed.</p> </tp:rationale>

`proxy` : | A TpChannel or subclass
`callback` : | Callback to be called when the signal is received
`user_data` : | User-supplied data for the callback
`destroy` : | Destructor for the user-supplied data, which will be called when this signal is disconnected, or before this function returns `NULL`
`weak_object` : | A GObject which will be weakly referenced; if it is destroyed, this callback will automatically be disconnected
`error` : | If not `NULL`, used to raise an error if `NULL` is returned
Returns : | a TpProxySignalConnection containing all of the above, which can be used to disconnect the signal; or `NULL` if the proxy does not have the desired interface or has become invalid.

### tp_cli_channel_type_streamed_media_connect_to_stream_direction_changed ()

    TpProxySignalConnection * tp_cli_channel_type_streamed_media_connect_to_stream_direction_changed
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_type_streamed_media_signal_callback_stream_direction_changed callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);

Connect a handler to the signal StreamDirectionChanged.

<tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>Emitted when the direction or pending flags of a stream are changed.</p> <p>If the MEDIA_STREAM_PENDING_LOCAL_SEND flag is set, the remote user has requested that we begin sending on this stream. <tp:member-ref>RequestStreamDirection</tp:member-ref> should be called to indicate whether or not this change is acceptable.</p> <tp:rationale> <p>This allows for a MSN-style user interface, &quot;Fred has asked you to enable your webcam. (Accept | Reject)&quot;, if desired.</p> </tp:rationale>

`proxy` : | A TpChannel or subclass
`callback` : | Callback to be called when the signal is received
`user_data` : | User-supplied data for the callback
`destroy` : | Destructor for the user-supplied data, which will be called when this signal is disconnected, or before this function returns `NULL`
`weak_object` : | A GObject which will be weakly referenced; if it is destroyed, this callback will automatically be disconnected
`error` : | If not `NULL`, used to raise an error if `NULL` is returned
Returns : | a TpProxySignalConnection containing all of the above, which can be used to disconnect the signal; or `NULL` if the proxy does not have the desired interface or has become invalid.

### tp_cli_channel_type_streamed_media_connect_to_stream_error ()

    TpProxySignalConnection * tp_cli_channel_type_streamed_media_connect_to_stream_error
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_type_streamed_media_signal_callback_stream_error callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);

Connect a handler to the signal StreamError.

Emitted when a stream encounters an error.

`proxy` : | A TpChannel or subclass
`callback` : | Callback to be called when the signal is received
`user_data` : | User-supplied data for the callback
`destroy` : | Destructor for the user-supplied data, which will be called when this signal is disconnected, or before this function returns `NULL`
`weak_object` : | A GObject which will be weakly referenced; if it is destroyed, this callback will automatically be disconnected
`error` : | If not `NULL`, used to raise an error if `NULL` is returned
Returns : | a TpProxySignalConnection containing all of the above, which can be used to disconnect the signal; or `NULL` if the proxy does not have the desired interface or has become invalid.

### tp_cli_channel_type_streamed_media_connect_to_stream_removed ()

    TpProxySignalConnection * tp_cli_channel_type_streamed_media_connect_to_stream_removed
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_type_streamed_media_signal_callback_stream_removed callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);

Connect a handler to the signal StreamRemoved.

Emitted when a stream has been removed from this channel.

`proxy` : | A TpChannel or subclass
`callback` : | Callback to be called when the signal is received
`user_data` : | User-supplied data for the callback
`destroy` : | Destructor for the user-supplied data, which will be called when this signal is disconnected, or before this function returns `NULL`
`weak_object` : | A GObject which will be weakly referenced; if it is destroyed, this callback will automatically be disconnected
`error` : | If not `NULL`, used to raise an error if `NULL` is returned
Returns : | a TpProxySignalConnection containing all of the above, which can be used to disconnect the signal; or `NULL` if the proxy does not have the desired interface or has become invalid.

### tp_cli_channel_type_streamed_media_connect_to_stream_state_changed ()

    TpProxySignalConnection * tp_cli_channel_type_streamed_media_connect_to_stream_state_changed
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_type_streamed_media_signal_callback_stream_state_changed callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);

Connect a handler to the signal StreamStateChanged.

Emitted when a member's stream's state changes.

`proxy` : | A TpChannel or subclass
`callback` : | Callback to be called when the signal is received
`user_data` : | User-supplied data for the callback
`destroy` : | Destructor for the user-supplied data, which will be called when this signal is disconnected, or before this function returns `NULL`
`weak_object` : | A GObject which will be weakly referenced; if it is destroyed, this callback will automatically be disconnected
`error` : | If not `NULL`, used to raise an error if `NULL` is returned
Returns : | a TpProxySignalConnection containing all of the above, which can be used to disconnect the signal; or `NULL` if the proxy does not have the desired interface or has become invalid.

### tp_cli_channel_type_streamed_media_signal_callback_stream_added ()

    void                (*tp_cli_channel_type_streamed_media_signal_callback_stream_added)
                                                            (TpChannel *proxy,
                                                             guint arg_Stream_ID,
                                                             guint arg_Contact_Handle,
                                                             guint arg_Stream_Type,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Represents the signature of a callback for the signal StreamAdded.

`proxy` : | The proxy on which `tp_cli_channel_type_streamed_media_connect_to_stream_added()` was called
`arg_Stream_ID` : | The stream identifier (as defined in <tp:member-ref>ListStreams</tp:member-ref>)
`arg_Contact_Handle` : | The contact handle who the stream is with (or 0 if it represents more than a single member)
`arg_Stream_Type` : | The stream type (a value from MediaStreamType)
`user_data` : | User-supplied data
`weak_object` : | User-supplied weakly referenced object

### tp_cli_channel_type_streamed_media_signal_callback_stream_direction_changed ()

    void                (*tp_cli_channel_type_streamed_media_signal_callback_stream_direction_changed)
                                                            (TpChannel *proxy,
                                                             guint arg_Stream_ID,
                                                             guint arg_Stream_Direction,
                                                             guint arg_Pending_Flags,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Represents the signature of a callback for the signal StreamDirectionChanged.

`proxy` : | The proxy on which `tp_cli_channel_type_streamed_media_connect_to_stream_direction_changed()` was called
`arg_Stream_ID` : | The stream identifier (as defined in <tp:member-ref>ListStreams</tp:member-ref>)
`arg_Stream_Direction` : | The new stream direction (as defined in ListStreams)
`arg_Pending_Flags` : | The new pending send flags (as defined in ListStreams)
`user_data` : | User-supplied data
`weak_object` : | User-supplied weakly referenced object

### tp_cli_channel_type_streamed_media_signal_callback_stream_error ()

    void                (*tp_cli_channel_type_streamed_media_signal_callback_stream_error)
                                                            (TpChannel *proxy,
                                                             guint arg_Stream_ID,
                                                             guint arg_Error_Code,
                                                             const gchar *arg_Message,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Represents the signature of a callback for the signal StreamError.

`proxy` : | The proxy on which `tp_cli_channel_type_streamed_media_connect_to_stream_error()` was called
`arg_Stream_ID` : | The stream identifier (as defined in <tp:member-ref>ListStreams</tp:member-ref>)
`arg_Error_Code` : | A stream error number, one of the values of MediaStreamError
`arg_Message` : | A string describing the error (for debugging purposes only)
`user_data` : | User-supplied data
`weak_object` : | User-supplied weakly referenced object

### tp_cli_channel_type_streamed_media_signal_callback_stream_removed ()

    void                (*tp_cli_channel_type_streamed_media_signal_callback_stream_removed)
                                                            (TpChannel *proxy,
                                                             guint arg_Stream_ID,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Represents the signature of a callback for the signal StreamRemoved.

`proxy` : | The proxy on which `tp_cli_channel_type_streamed_media_connect_to_stream_removed()` was called
`arg_Stream_ID` : | stream_id - the stream identifier (as defined in <tp:member-ref>ListStreams</tp:member-ref>)
`user_data` : | User-supplied data
`weak_object` : | User-supplied weakly referenced object

### tp_cli_channel_type_streamed_media_signal_callback_stream_state_changed ()

    void                (*tp_cli_channel_type_streamed_media_signal_callback_stream_state_changed)
                                                            (TpChannel *proxy,
                                                             guint arg_Stream_ID,
                                                             guint arg_Stream_State,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Represents the signature of a callback for the signal StreamStateChanged.

`proxy` : | The proxy on which `tp_cli_channel_type_streamed_media_connect_to_stream_state_changed()` was called
`arg_Stream_ID` : | The stream identifier (as defined in <tp:member-ref>ListStreams</tp:member-ref>)
`arg_Stream_State` : | The new stream state (as defined in ListStreams)
`user_data` : | User-supplied data
`weak_object` : | User-supplied weakly referenced object

### tp_cli_channel_interface_call_state_call_get_call_states ()

    TpProxyPendingCall * tp_cli_channel_interface_call_state_call_get_call_states
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             tp_cli_channel_interface_call_state_callback_for_get_call_states callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a GetCallStates method call.

Get the current call states for all contacts involved in this call.

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_interface_call_state_callback_for_get_call_states ()

    void                (*tp_cli_channel_interface_call_state_callback_for_get_call_states)
                                                            (TpChannel *proxy,
                                                             GHashTable *out_States,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a GetCallStates method call succeeds or fails.

`proxy` : | the proxy on which the call was made
`out_States` : | Used to return an 'out' argument if `error` is `NULL`: The current call states. Participants where the call state flags would be 0 (all unset) may be omitted from this mapping.
`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_interface_call_state_connect_to_call_state_changed ()

    TpProxySignalConnection * tp_cli_channel_interface_call_state_connect_to_call_state_changed
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_interface_call_state_signal_callback_call_state_changed callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);

Connect a handler to the signal CallStateChanged.

Emitted when the state of a member of the channel has changed.

`proxy` : | A TpChannel or subclass
`callback` : | Callback to be called when the signal is received
`user_data` : | User-supplied data for the callback
`destroy` : | Destructor for the user-supplied data, which will be called when this signal is disconnected, or before this function returns `NULL`
`weak_object` : | A GObject which will be weakly referenced; if it is destroyed, this callback will automatically be disconnected
`error` : | If not `NULL`, used to raise an error if `NULL` is returned
Returns : | a TpProxySignalConnection containing all of the above, which can be used to disconnect the signal; or `NULL` if the proxy does not have the desired interface or has become invalid.

### tp_cli_channel_interface_call_state_run_get_call_states ()

    gboolean            tp_cli_channel_interface_call_state_run_get_call_states
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             GHashTable **out_States,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method GetCallStates and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

Get the current call states for all contacts involved in this call.

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default
`out_States` : | Used to return an 'out' argument if `TRUE` is returned: The current call states. Participants where the call state flags would be 0 (all unset) may be omitted from this mapping.
`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_interface_call_state_signal_callback_call_state_changed ()

    void                (*tp_cli_channel_interface_call_state_signal_callback_call_state_changed)
                                                            (TpChannel *proxy,
                                                             guint arg_Contact,
                                                             guint arg_State,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Represents the signature of a callback for the signal CallStateChanged.

`proxy` : | The proxy on which `tp_cli_channel_interface_call_state_connect_to_call_state_changed()` was called
`arg_Contact` : | An integer handle for the contact.
`arg_State` : | The new state for this contact.
`user_data` : | User-supplied data
`weak_object` : | User-supplied weakly referenced object

### tp_cli_channel_interface_dtmf_run_start_tone ()

    gboolean            tp_cli_channel_interface_dtmf_run_start_tone
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_Stream_ID,
                                                             guchar in_Event,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method StartTone and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

Start sending a DTMF tone on this stream. Where possible, the tone will continue until <tp:member-ref>StopTone</tp:member-ref> is called. On certain protocols, it may only be possible to send events with a predetermined length. In this case, the implementation may emit a fixed-length tone, and the StopTone method call should return NotAvailable.

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default
`in_Stream_ID` : | Used to pass an 'in' argument: A stream ID as defined in the StreamedMedia channel type.
`in_Event` : | Used to pass an 'in' argument: A numeric event code from the DTMF_Event enum.
`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_interface_dtmf_run_stop_tone ()

    gboolean            tp_cli_channel_interface_dtmf_run_stop_tone
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_Stream_ID,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method StopTone and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

Stop sending any DTMF tone which has been started using the <tp:member-ref>StartTone</tp:member-ref> method. If there is no current tone, this method will do nothing.

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default
`in_Stream_ID` : | Used to pass an 'in' argument: A stream ID as defined in the StreamedMedia channel type.
`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_interface_dtmf_call_start_tone ()

    TpProxyPendingCall * tp_cli_channel_interface_dtmf_call_start_tone
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_Stream_ID,
                                                             guchar in_Event,
                                                             tp_cli_channel_interface_dtmf_callback_for_start_tone callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a StartTone method call.

Start sending a DTMF tone on this stream. Where possible, the tone will continue until <tp:member-ref>StopTone</tp:member-ref> is called. On certain protocols, it may only be possible to send events with a predetermined length. In this case, the implementation may emit a fixed-length tone, and the StopTone method call should return NotAvailable.

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`in_Stream_ID` : | Used to pass an 'in' argument: A stream ID as defined in the StreamedMedia channel type.
`in_Event` : | Used to pass an 'in' argument: A numeric event code from the DTMF_Event enum.
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_interface_dtmf_call_stop_tone ()

    TpProxyPendingCall * tp_cli_channel_interface_dtmf_call_stop_tone
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_Stream_ID,
                                                             tp_cli_channel_interface_dtmf_callback_for_stop_tone callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a StopTone method call.

Stop sending any DTMF tone which has been started using the <tp:member-ref>StartTone</tp:member-ref> method. If there is no current tone, this method will do nothing.

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`in_Stream_ID` : | Used to pass an 'in' argument: A stream ID as defined in the StreamedMedia channel type.
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_interface_dtmf_callback_for_start_tone ()

    void                (*tp_cli_channel_interface_dtmf_callback_for_start_tone)
                                                            (TpChannel *proxy,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a StartTone method call succeeds or fails.

`proxy` : | the proxy on which the call was made
`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_interface_dtmf_callback_for_stop_tone ()

    void                (*tp_cli_channel_interface_dtmf_callback_for_stop_tone)
                                                            (TpChannel *proxy,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a StopTone method call succeeds or fails.

`proxy` : | the proxy on which the call was made
`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_interface_hold_callback_for_get_hold_state ()

    void                (*tp_cli_channel_interface_hold_callback_for_get_hold_state)
                                                            (TpChannel *proxy,
                                                             guint out_HoldState,
                                                             guint out_Reason,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a GetHoldState method call succeeds or fails.

`proxy` : | the proxy on which the call was made
`out_HoldState` : | Used to return an 'out' argument if `error` is `NULL`: The state of the channel
`out_Reason` : | Used to return an 'out' argument if `error` is `NULL`: The reason why the channel is in that state
`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_interface_hold_call_get_hold_state ()

    TpProxyPendingCall * tp_cli_channel_interface_hold_call_get_hold_state
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             tp_cli_channel_interface_hold_callback_for_get_hold_state callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a GetHoldState method call.

Return whether the local user has placed the channel on hold.

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_interface_hold_run_get_hold_state ()

    gboolean            tp_cli_channel_interface_hold_run_get_hold_state
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint *out_HoldState,
                                                             guint *out_Reason,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method GetHoldState and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

Return whether the local user has placed the channel on hold.

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default
`out_HoldState` : | Used to return an 'out' argument if `TRUE` is returned: The state of the channel
`out_Reason` : | Used to return an 'out' argument if `TRUE` is returned: The reason why the channel is in that state
`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_interface_hold_callback_for_request_hold ()

    void                (*tp_cli_channel_interface_hold_callback_for_request_hold)
                                                            (TpChannel *proxy,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a RequestHold method call succeeds or fails.

`proxy` : | the proxy on which the call was made
`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_interface_hold_call_request_hold ()

    TpProxyPendingCall * tp_cli_channel_interface_hold_call_request_hold
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             gboolean in_Hold,
                                                             tp_cli_channel_interface_hold_callback_for_request_hold callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a RequestHold method call.

<tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>Request that the channel be put on hold (be instructed not to send any media streams to you) or be taken off hold.</p> <p>If the connection manager can immediately tell that the requested state change could not possibly succeed, this method SHOULD return the NotAvailable error. If the requested state is the same as the current state, this method SHOULD return successfully without doing anything.</p> <p>Otherwise, this method SHOULD immediately set the hold state to Local_Hold_State_Pending_Hold or Local_Hold_State_Pending_Unhold (as appropriate), emitting <tp:member-ref>HoldStateChanged</tp:member-ref> if this is a change, and return successfully.</p> <p>The eventual success or failure of the request is indicated by a subsequent HoldStateChanged signal, changing the hold state to Local_Hold_State_Held or Local_Hold_State_Unheld.</p> <p>If the channel has multiple streams, and the connection manager succeeds in changing the hold state of one stream but fails to change the hold state of another, it SHOULD attempt to revert all streams to their previous hold states.</p> <p>The following state transitions SHOULD be used, where appropriate:</p> <ul> <li>Successful hold: (Unheld, any reason) → (Pending_Hold, Requested) → (Held, Requested) </li> <li>Successful unhold: (Held, any reason) → (Pending_Unhold, Requested) → (Unheld, Requested) </li> <li>Attempting to unhold fails at the first attempt to acquire a resource: (Held, any reason) → (Pending_Unhold, Requested) → (Held, Resource_Not_Available) </li> <li>Attempting to unhold acquires one resource, but fails to acquire a second, and takes time to release the first: (Held, any reason) → (Pending_Unhold, Requested) → (Pending_Hold, Resource_Not_Available) → (Held, Resource_Not_Available) </li> </ul>

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`in_Hold` : | Used to pass an 'in' argument: A boolean indicating whether or not the channel should be on hold
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_interface_hold_run_request_hold ()

    gboolean            tp_cli_channel_interface_hold_run_request_hold
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             gboolean in_Hold,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method RequestHold and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

<tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>Request that the channel be put on hold (be instructed not to send any media streams to you) or be taken off hold.</p> <p>If the connection manager can immediately tell that the requested state change could not possibly succeed, this method SHOULD return the NotAvailable error. If the requested state is the same as the current state, this method SHOULD return successfully without doing anything.</p> <p>Otherwise, this method SHOULD immediately set the hold state to Local_Hold_State_Pending_Hold or Local_Hold_State_Pending_Unhold (as appropriate), emitting <tp:member-ref>HoldStateChanged</tp:member-ref> if this is a change, and return successfully.</p> <p>The eventual success or failure of the request is indicated by a subsequent HoldStateChanged signal, changing the hold state to Local_Hold_State_Held or Local_Hold_State_Unheld.</p> <p>If the channel has multiple streams, and the connection manager succeeds in changing the hold state of one stream but fails to change the hold state of another, it SHOULD attempt to revert all streams to their previous hold states.</p> <p>The following state transitions SHOULD be used, where appropriate:</p> <ul> <li>Successful hold: (Unheld, any reason) → (Pending_Hold, Requested) → (Held, Requested) </li> <li>Successful unhold: (Held, any reason) → (Pending_Unhold, Requested) → (Unheld, Requested) </li> <li>Attempting to unhold fails at the first attempt to acquire a resource: (Held, any reason) → (Pending_Unhold, Requested) → (Held, Resource_Not_Available) </li> <li>Attempting to unhold acquires one resource, but fails to acquire a second, and takes time to release the first: (Held, any reason) → (Pending_Unhold, Requested) → (Pending_Hold, Resource_Not_Available) → (Held, Resource_Not_Available) </li> </ul>

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default
`in_Hold` : | Used to pass an 'in' argument: A boolean indicating whether or not the channel should be on hold
`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_interface_hold_signal_callback_hold_state_changed ()

    void                (*tp_cli_channel_interface_hold_signal_callback_hold_state_changed)
                                                            (TpChannel *proxy,
                                                             guint arg_HoldState,
                                                             guint arg_Reason,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Represents the signature of a callback for the signal HoldStateChanged.

`proxy` : | The proxy on which `tp_cli_channel_interface_hold_connect_to_hold_state_changed()` was called
`arg_HoldState` : | The state of the channel
`arg_Reason` : | The reason for the state change
`user_data` : | User-supplied data
`weak_object` : | User-supplied weakly referenced object

### tp_cli_channel_interface_hold_connect_to_hold_state_changed ()

    TpProxySignalConnection * tp_cli_channel_interface_hold_connect_to_hold_state_changed
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_interface_hold_signal_callback_hold_state_changed callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);

Connect a handler to the signal HoldStateChanged.

Emitted to indicate that the hold state has changed for this channel. This may occur as a consequence of you requesting a change with <tp:member-ref>RequestHold</tp:member-ref>, or the state changing as a result of a request from another process.

`proxy` : | A TpChannel or subclass
`callback` : | Callback to be called when the signal is received
`user_data` : | User-supplied data for the callback
`destroy` : | Destructor for the user-supplied data, which will be called when this signal is disconnected, or before this function returns `NULL`
`weak_object` : | A GObject which will be weakly referenced; if it is destroyed, this callback will automatically be disconnected
`error` : | If not `NULL`, used to raise an error if `NULL` is returned
Returns : | a TpProxySignalConnection containing all of the above, which can be used to disconnect the signal; or `NULL` if the proxy does not have the desired interface or has become invalid.

### tp_cli_channel_interface_media_signalling_run_get_session_handlers ()

    gboolean            tp_cli_channel_interface_media_signalling_run_get_session_handlers
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             GPtrArray **out_Session_Handlers,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method GetSessionHandlers and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

Returns all currently active session handlers on this channel as a list of (session_handler_path, type).

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default
`out_Session_Handlers` : | Used to return an 'out' argument if `TRUE` is returned: (Undocumented)
`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_interface_media_signalling_call_get_session_handlers ()

    TpProxyPendingCall * tp_cli_channel_interface_media_signalling_call_get_session_handlers
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             tp_cli_channel_interface_media_signalling_callback_for_get_session_handlers callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a GetSessionHandlers method call.

Returns all currently active session handlers on this channel as a list of (session_handler_path, type).

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_interface_media_signalling_callback_for_get_session_handlers ()

    void                (*tp_cli_channel_interface_media_signalling_callback_for_get_session_handlers)
                                                            (TpChannel *proxy,
                                                             const GPtrArray *out_Session_Handlers,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a GetSessionHandlers method call succeeds or fails.

`proxy` : | the proxy on which the call was made
`out_Session_Handlers` : | Used to return an 'out' argument if `error` is `NULL`: (Undocumented)
`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_interface_media_signalling_connect_to_new_session_handler ()

    TpProxySignalConnection * tp_cli_channel_interface_media_signalling_connect_to_new_session_handler
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_interface_media_signalling_signal_callback_new_session_handler callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);

Connect a handler to the signal NewSessionHandler.

Signal that a session handler object has been created. The client should create a session object and create streams for the streams within.

`proxy` : | A TpChannel or subclass
`callback` : | Callback to be called when the signal is received
`user_data` : | User-supplied data for the callback
`destroy` : | Destructor for the user-supplied data, which will be called when this signal is disconnected, or before this function returns `NULL`
`weak_object` : | A GObject which will be weakly referenced; if it is destroyed, this callback will automatically be disconnected
`error` : | If not `NULL`, used to raise an error if `NULL` is returned
Returns : | a TpProxySignalConnection containing all of the above, which can be used to disconnect the signal; or `NULL` if the proxy does not have the desired interface or has become invalid.

### tp_cli_channel_interface_media_signalling_signal_callback_new_session_handler ()

    void                (*tp_cli_channel_interface_media_signalling_signal_callback_new_session_handler)
                                                            (TpChannel *proxy,
                                                             const gchar *arg_Session_Handler,
                                                             const gchar *arg_Session_Type,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Represents the signature of a callback for the signal NewSessionHandler.

`proxy` : | The proxy on which `tp_cli_channel_interface_media_signalling_connect_to_new_session_handler()` was called
`arg_Session_Handler` : | Object path of the new <tp:dbus-ref namespace="org.freedesktop.Telepathy">Media.SessionHandler</tp:dbus-ref> object
`arg_Session_Type` : | String indicating type of session, eg &quot;rtp&quot;
`user_data` : | User-supplied data
`weak_object` : | User-supplied weakly referenced object

## See Also

channel-group, TpChannel