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.

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>

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>

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>

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.

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.

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.

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.

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.

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>

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>

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>

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>

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>

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

<p>Start sending a DTMF tone to all eligible streams in the channel. 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.</p> <tp:rationale> The client may wish to control the exact duration and timing of the tones sent as a result of user's interaction with the dialpad, thus starting and stopping the tone sending explicitly. </tp:rationale> <p>Tone overlaping or queueing is not supported, so this method can only be called if no DTMF tones are already being played.</p>

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 tones which have been started using the <tp:member-ref>StartTone</tp:member-ref> or <tp:member-ref>MultipleTones</tp:member-ref> methods. If there is no current tone, this method will do nothing. If MultipleTones was used, the client should not assume the sending has stopped immediately; instead, the client should wait for the StoppedTones signal. <tp:rationale> On some protocols it might be impossible to cancel queued tones immediately. </tp:rationale>

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.

<p>Start sending a DTMF tone to all eligible streams in the channel. 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.</p> <tp:rationale> The client may wish to control the exact duration and timing of the tones sent as a result of user's interaction with the dialpad, thus starting and stopping the tone sending explicitly. </tp:rationale> <p>Tone overlaping or queueing is not supported, so this method can only be called if no DTMF tones are already being played.</p>

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 tones which have been started using the <tp:member-ref>StartTone</tp:member-ref> or <tp:member-ref>MultipleTones</tp:member-ref> methods. If there is no current tone, this method will do nothing. If MultipleTones was used, the client should not assume the sending has stopped immediately; instead, the client should wait for the StoppedTones signal. <tp:rationale> On some protocols it might be impossible to cancel queued tones immediately. </tp:rationale>

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.

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.

tp_cli_channel_interface_dtmf_call_multiple_tones ()

TpProxyPendingCall *
tp_cli_channel_interface_dtmf_call_multiple_tones
                               (TpChannel *proxy,
                                gint timeout_ms,
                                const gchar *in_Tones,
                                tp_cli_channel_interface_dtmf_callback_for_multiple_tones callback,
                                gpointer user_data,
                                GDestroyNotify destroy,
                                GObject *weak_object);

Start a MultipleTones method call.

<p>Send multiple DTMF events to all eligible streams in the channel. Each tone will be played for an implementation-defined number of milliseconds (typically 250ms), followed by a gap before the next tone is played (typically 100ms). The duration and gap are defined by the protocol or connection manager.</p> <tp:rationale> <p>In cases where the client knows in advance the tone sequence it wants to send, it's easier to use this method than manually start and stop each tone in the sequence.</p> <p>The tone and gap lengths may need to vary for interoperability, according to the protocol and other implementations' ability to recognise tones. At the time of writing, GStreamer uses a minimum of 250ms tones and 100ms gaps when playing in-band DTMF in the normal audio stream, or 70ms tones and 50ms gaps when encoding DTMF as <code>audio/telephone-event</code>.</p> </tp:rationale> <p>Tone overlaping or queueing is not supported, so this method can only be called if no DTMF tones are already being played.</p>

tp_cli_channel_interface_dtmf_callback_for_multiple_tones ()

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

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

tp_cli_channel_interface_dtmf_connect_to_sending_tones ()

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

Connect a handler to the signal SendingTones.

<tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>DTMF tone(s)are being sent to all eligible streams in the channel. The signal is provided to indicating the fact that the streams are currently being used to send one or more DTMF tones, so any other media input is not getting through to the audio stream. It also serves as a cue for the <tp:member-ref>StopTone</tp:member-ref> method.</p>

tp_cli_channel_interface_dtmf_signal_callback_sending_tones ()

void
(*tp_cli_channel_interface_dtmf_signal_callback_sending_tones)
                               (TpChannel *proxy,
                                const gchar *arg_Tones,
                                gpointer user_data,
                                GObject *weak_object);

Represents the signature of a callback for the signal SendingTones.

tp_cli_channel_interface_dtmf_connect_to_stopped_tones ()

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

Connect a handler to the signal StoppedTones.

<tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>DTMF tones have finished playing on streams in this channel.</p>

tp_cli_channel_interface_dtmf_signal_callback_stopped_tones ()

void
(*tp_cli_channel_interface_dtmf_signal_callback_stopped_tones)
                               (TpChannel *proxy,
                                gboolean arg_Cancelled,
                                gpointer user_data,
                                GObject *weak_object);

Represents the signature of a callback for the signal StoppedTones.

tp_cli_channel_interface_dtmf_connect_to_tones_deferred ()

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

Connect a handler to the signal TonesDeferred.

<tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>Emitted when 'w' or 'W', indicating &quot;wait for the user to continue&quot;, is encountered while playing a DTMF string queued by <tp:member-ref>MultipleTones</tp:member-ref> or <tp:member-ref>InitialTones</tp:member-ref>. Any queued DTMF events after the 'w', which have not yet been played, are placed in the <tp:member-ref>DeferredTones</tp:member-ref> property and copied into this signal's argument.</p> <p>When the channel handler is ready to continue, it MAY pass the value of <tp:member-ref>DeferredTones</tp:member-ref> to <tp:member-ref>MultipleTones</tp:member-ref>, to resume sending. Alternatively, it MAY ignore the deferred tones, or even play different tones instead. Any deferred tones are discarded the next time a tone is played.</p> <p>This signal SHOULD NOT be emitted if there is nothing left to play, i.e. if the 'w' was the last character in the DTMF string.</p>

tp_cli_channel_interface_dtmf_signal_callback_tones_deferred ()

void
(*tp_cli_channel_interface_dtmf_signal_callback_tones_deferred)
                               (TpChannel *proxy,
                                const gchar *arg_Tones,
                                gpointer user_data,
                                GObject *weak_object);

Represents the signature of a callback for the signal TonesDeferred.

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.

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.

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.

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.

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>

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>

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.

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.

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).

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).

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.

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.

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.