Tubes channels: telepathy-glib API Reference Manual

## Tubes channels Tubes channels — client-side wrappers for the Tubes channel type |

## Functions

gboolean | tp_cli_channel_type_tubes_run_accept_d_bus_tube ()
gboolean | tp_cli_channel_type_tubes_run_accept_stream_tube ()
gboolean | tp_cli_channel_type_tubes_run_close_tube ()
gboolean | tp_cli_channel_type_tubes_run_get_available_stream_tube_types ()
gboolean | tp_cli_channel_type_tubes_run_get_available_tube_types ()
gboolean | tp_cli_channel_type_tubes_run_get_d_bus_names ()
gboolean | tp_cli_channel_type_tubes_run_get_d_bus_tube_address ()
gboolean | tp_cli_channel_type_tubes_run_get_stream_tube_socket_address ()
gboolean | tp_cli_channel_type_tubes_run_list_tubes ()
gboolean | tp_cli_channel_type_tubes_run_offer_d_bus_tube ()
gboolean | tp_cli_channel_type_tubes_run_offer_stream_tube ()
TpProxyPendingCall * | tp_cli_channel_type_tubes_call_accept_d_bus_tube ()
TpProxyPendingCall * | tp_cli_channel_type_tubes_call_accept_stream_tube ()
TpProxyPendingCall * | tp_cli_channel_type_tubes_call_close_tube ()
TpProxyPendingCall * | tp_cli_channel_type_tubes_call_get_available_stream_tube_types ()
TpProxyPendingCall * | tp_cli_channel_type_tubes_call_get_available_tube_types ()
TpProxyPendingCall * | tp_cli_channel_type_tubes_call_get_d_bus_names ()
TpProxyPendingCall * | tp_cli_channel_type_tubes_call_get_d_bus_tube_address ()
TpProxyPendingCall * | tp_cli_channel_type_tubes_call_get_stream_tube_socket_address ()
TpProxyPendingCall * | tp_cli_channel_type_tubes_call_list_tubes ()
TpProxyPendingCall * | tp_cli_channel_type_tubes_call_offer_d_bus_tube ()
TpProxyPendingCall * | tp_cli_channel_type_tubes_call_offer_stream_tube ()
void | (*tp_cli_channel_type_tubes_callback_for_accept_d_bus_tube) ()
void | (*tp_cli_channel_type_tubes_callback_for_accept_stream_tube) ()
void | (*tp_cli_channel_type_tubes_callback_for_close_tube) ()
void | (*tp_cli_channel_type_tubes_callback_for_get_available_stream_tube_types) ()
void | (*tp_cli_channel_type_tubes_callback_for_get_available_tube_types) ()
void | (*tp_cli_channel_type_tubes_callback_for_get_d_bus_names) ()
void | (*tp_cli_channel_type_tubes_callback_for_get_d_bus_tube_address) ()
void | (*tp_cli_channel_type_tubes_callback_for_get_stream_tube_socket_address) ()
void | (*tp_cli_channel_type_tubes_callback_for_list_tubes) ()
void | (*tp_cli_channel_type_tubes_callback_for_offer_d_bus_tube) ()
void | (*tp_cli_channel_type_tubes_callback_for_offer_stream_tube) ()
TpProxySignalConnection * | tp_cli_channel_type_tubes_connect_to_d_bus_names_changed ()
TpProxySignalConnection * | tp_cli_channel_type_tubes_connect_to_new_tube ()
TpProxySignalConnection * | tp_cli_channel_type_tubes_connect_to_stream_tube_new_connection ()
TpProxySignalConnection * | tp_cli_channel_type_tubes_connect_to_tube_closed ()
TpProxySignalConnection * | tp_cli_channel_type_tubes_connect_to_tube_state_changed ()
void | (*tp_cli_channel_type_tubes_signal_callback_d_bus_names_changed) ()
void | (*tp_cli_channel_type_tubes_signal_callback_new_tube) ()
void | (*tp_cli_channel_type_tubes_signal_callback_stream_tube_new_connection) ()
void | (*tp_cli_channel_type_tubes_signal_callback_tube_closed) ()
void | (*tp_cli_channel_type_tubes_signal_callback_tube_state_changed) ()

## Includes

    #include <telepathy-glib/telepathy-glib-dbus.h>

## Description

A "tube" is a mechanism for arbitrary data transfer. This section documents the auto-generated C wrappers for the Tubes channel type.

## Functions

### tp_cli_channel_type_tubes_run_accept_d_bus_tube ()

    gboolean
    tp_cli_channel_type_tubes_run_accept_d_bus_tube
                                   (TpChannel *proxy,
                                    gint timeout_ms,
                                    guint in_ID,
                                    gchar **out_Address,
                                    GError **error,
                                    GMainLoop **loop);

`tp_cli_channel_type_tubes_run_accept_d_bus_tube` is deprecated and should not be used in newly-written code.

Call the method AcceptDBusTube 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.

Accept a D-Bus tube that's in the "local pending" state. The connection manager will attempt to open the tube. The tube remains in the "local pending" state until the TubeStateChanged signal is emitted.

#### Parameters

proxy | A TpChannel or subclass |
timeout_ms | Timeout in milliseconds, or -1 for default |
in_ID | Used to pass an 'in' argument: The ID of the tube to accept. (TpTubeID) |
out_Address | Used to return an 'out' argument if `TRUE` is returned: The string describing the address of the private bus. The client should not attempt to connect to the address until the tube is open. |
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_tubes_run_accept_stream_tube ()

    gboolean
    tp_cli_channel_type_tubes_run_accept_stream_tube
                                   (TpChannel *proxy,
                                    gint timeout_ms,
                                    guint in_ID,
                                    guint in_Address_Type,
                                    guint in_Access_Control,
                                    const GValue *in_Access_Control_Param,
                                    GValue **out_Address,
                                    GError **error,
                                    GMainLoop **loop);

`tp_cli_channel_type_tubes_run_accept_stream_tube` is deprecated and should not be used in newly-written code.

Call the method AcceptStreamTube 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.

Accept a stream tube that's in the "local pending" state. The connection manager will attempt to open the tube. The tube remains in the "local pending" state until the TubeStateChanged signal is emitted.

#### Parameters

proxy | A TpChannel or subclass |
timeout_ms | Timeout in milliseconds, or -1 for default |
in_ID | Used to pass an 'in' argument: The ID of the tube to accept. (TpTubeID) |
in_Address_Type | Used to pass an 'in' argument: The type of address the connection manager should listen on. (TpSocketAddressType) |
in_Access_Control | Used to pass an 'in' argument: The type of access control the connection manager should apply to the socket. (TpSocketAccessControl) |
in_Access_Control_Param | Used to pass an 'in' argument: A parameter for the access control type, to be interpreted as specified in the documentation for the Socket_Access_Control enum. |
out_Address | Used to return an 'out' argument if `TRUE` is returned: The address on which the connection manager will listen for connections to this tube. The client should not attempt to connect to the address until the tube is open. |
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_tubes_run_close_tube ()

    gboolean
    tp_cli_channel_type_tubes_run_close_tube
                                   (TpChannel *proxy,
                                    gint timeout_ms,
                                    guint in_ID,
                                    GError **error,
                                    GMainLoop **loop);

`tp_cli_channel_type_tubes_run_close_tube` is deprecated and should not be used in newly-written code.

Call the method CloseTube 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.

Close a tube.

#### Parameters

proxy | A TpChannel or subclass |
timeout_ms | Timeout in milliseconds, or -1 for default |
in_ID | Used to pass an 'in' argument: The ID of the tube to close. (TpTubeID) |
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_tubes_run_get_available_stream_tube_types ()

    gboolean
    tp_cli_channel_type_tubes_run_get_available_stream_tube_types
                                   (TpChannel *proxy,
                                    gint timeout_ms,
                                    GHashTable **out_Available_Stream_Tube_Types,
                                    GError **error,
                                    GMainLoop **loop);

`tp_cli_channel_type_tubes_run_get_available_stream_tube_types` is deprecated and should not be used in newly-written code.

Call the method GetAvailableStreamTubeTypes 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.

List the available address types and access-control types for stream tubes.

#### Parameters

proxy | A TpChannel or subclass |
timeout_ms | Timeout in milliseconds, or -1 for default |
out_Available_Stream_Tube_Types | Used to return an 'out' argument if `TRUE` is returned: <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>A mapping from address types (members of Socket_Address_Type) to arrays of access-control type (members of Socket_Access_Control) that the connection manager supports for stream tubes with that address type. For simplicity, if a CM supports offering a particular type of tube, it is assumed to support accepting it.</p> <p>A typical value for a host without IPv6 support:</p> <pre> { Socket_Address_Type_IPv4: [Socket_Access_Control_Localhost, Socket_Access_Control_Port, Socket_Access_Control_Netmask], Socket_Address_Type_Unix: [Socket_Access_Control_Localhost, Socket_Access_Control_Credentials] } </pre> <p>If stream tubes are not supported, this will be an empty dictionary.</p> |
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_tubes_run_get_available_tube_types ()

    gboolean
    tp_cli_channel_type_tubes_run_get_available_tube_types
                                   (TpChannel *proxy,
                                    gint timeout_ms,
                                    GArray **out_Available_Tube_Types,
                                    GError **error,
                                    GMainLoop **loop);

`tp_cli_channel_type_tubes_run_get_available_tube_types` is deprecated and should not be used in newly-written code.

Call the method GetAvailableTubeTypes 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.

(Undocumented)

#### Parameters

proxy | A TpChannel or subclass |
timeout_ms | Timeout in milliseconds, or -1 for default |
out_Available_Tube_Types | Used to return an 'out' argument if `TRUE` is returned: An array of the available tube types, as defined by the Tube_Type 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_type_tubes_run_get_d_bus_names ()

    gboolean
    tp_cli_channel_type_tubes_run_get_d_bus_names
                                   (TpChannel *proxy,
                                    gint timeout_ms,
                                    guint in_ID,
                                    GPtrArray **out_DBus_Names,
                                    GError **error,
                                    GMainLoop **loop);

`tp_cli_channel_type_tubes_run_get_d_bus_names` is deprecated and should not be used in newly-written code.

Call the method GetDBusNames 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.

For a multi-user (i.e. Handle_Type_Room) D-Bus tube, obtain a mapping between contact handles and their unique bus names on this tube.

#### Parameters

proxy | A TpChannel or subclass |
timeout_ms | Timeout in milliseconds, or -1 for default |
in_ID | Used to pass an 'in' argument: The ID of the tube to get names for. (TpTubeID) |
out_DBus_Names | Used to return an 'out' argument if `TRUE` is returned: An array of structures, each containing a contact handle and a D-Bus bus name. |
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_tubes_run_get_d_bus_tube_address ()

    gboolean
    tp_cli_channel_type_tubes_run_get_d_bus_tube_address
                                   (TpChannel *proxy,
                                    gint timeout_ms,
                                    guint in_ID,
                                    gchar **out_Address,
                                    GError **error,
                                    GMainLoop **loop);

`tp_cli_channel_type_tubes_run_get_d_bus_tube_address` is deprecated and should not be used in newly-written code.

Call the method GetDBusTubeAddress 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.

For a D-Bus tube, return a string describing the address of the private bus.

#### Parameters

proxy | A TpChannel or subclass |
timeout_ms | Timeout in milliseconds, or -1 for default |
in_ID | Used to pass an 'in' argument: The ID of the tube to get an address for. (TpTubeID) |
out_Address | Used to return an 'out' argument if `TRUE` is returned: The bus address. |
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_tubes_run_get_stream_tube_socket_address ()

    gboolean
    tp_cli_channel_type_tubes_run_get_stream_tube_socket_address
                                   (TpChannel *proxy,
                                    gint timeout_ms,
                                    guint in_ID,
                                    guint *out_Address_Type,
                                    GValue **out_Address,
                                    GError **error,
                                    GMainLoop **loop);

`tp_cli_channel_type_tubes_run_get_stream_tube_socket_address` is deprecated and should not be used in newly-written code.

Call the method GetStreamTubeSocketAddress 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.

For a stream tube, obtain the address of the socket used to communicate over this tube.

#### Parameters

proxy | A TpChannel or subclass |
timeout_ms | Timeout in milliseconds, or -1 for default |
in_ID | Used to pass an 'in' argument: The ID of the stream tube to get the socket for. (TpTubeID) |
out_Address_Type | Used to return an 'out' argument if `TRUE` is returned: The type of the listening address of the socket, as a member of Socket_Address_Type. |
out_Address | Used to return an 'out' argument if `TRUE` is returned: The listening address of the socket, as indicated by the address_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_type_tubes_run_list_tubes ()

    gboolean
    tp_cli_channel_type_tubes_run_list_tubes
                                   (TpChannel *proxy,
                                    gint timeout_ms,
                                    GPtrArray **out_Tubes,
                                    GError **error,
                                    GMainLoop **loop);

`tp_cli_channel_type_tubes_run_list_tubes` is deprecated and should not be used in newly-written code.

Call the method ListTubes 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.

(Undocumented)

#### Parameters

proxy | A TpChannel or subclass |
timeout_ms | Timeout in milliseconds, or -1 for default |
out_Tubes | Used to return an 'out' argument if `TRUE` is returned: Return an array of tuples, each representing a tube, with the following members: <ul> <li>the tube's ID</li> <li>the tube's initiator</li> <li>the tube's type</li> <li>the tube's service</li> <li>the tube's parameters</li> <li>the tube's state</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_tubes_run_offer_d_bus_tube ()

    gboolean
    tp_cli_channel_type_tubes_run_offer_d_bus_tube
                                   (TpChannel *proxy,
                                    gint timeout_ms,
                                    const gchar *in_Service,
                                    GHashTable *in_Parameters,
                                    guint *out_Tube_ID,
                                    GError **error,
                                    GMainLoop **loop);

`tp_cli_channel_type_tubes_run_offer_d_bus_tube` is deprecated and should not be used in newly-written code.

Call the method OfferDBusTube 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.

Offers a D-Bus tube providing the service specified.

#### Parameters

proxy | A TpChannel or subclass |
timeout_ms | Timeout in milliseconds, or -1 for default |
in_Service | Used to pass an 'in' argument: A string representing the service name that will be used over the tube. It should be a well-known D-Bus service name, of the form com.example.ServiceName. |
in_Parameters | Used to pass an 'in' argument: A dictionary of properties for the new tube; the allowable keys, types and values are defined by the service. Connection managers must support the value being any primitive (non-container) D-Bus type, or a byte array 'ay'. |
out_Tube_ID | Used to return an 'out' argument if `TRUE` is returned: The ID of the new tube. |
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_tubes_run_offer_stream_tube ()

    gboolean
    tp_cli_channel_type_tubes_run_offer_stream_tube
                                   (TpChannel *proxy,
                                    gint timeout_ms,
                                    const gchar *in_Service,
                                    GHashTable *in_Parameters,
                                    guint in_Address_Type,
                                    const GValue *in_Address,
                                    guint in_Access_Control,
                                    const GValue *in_Access_Control_Param,
                                    guint *out_Tube_ID,
                                    GError **error,
                                    GMainLoop **loop);

`tp_cli_channel_type_tubes_run_offer_stream_tube` is deprecated and should not be used in newly-written code.

Call the method OfferStreamTube 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.

Offer a stream tube exporting the local socket specified.

#### Parameters

proxy | A TpChannel or subclass |
timeout_ms | Timeout in milliseconds, or -1 for default |
in_Service | Used to pass an 'in' argument: <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> A string representing the service name that will be used over the tube. It should be a well-known TCP service name as defined by <a href="http://www.iana.org/assignments/port-numbers"> http://www.iana.org/assignments/port-numbers</a> or <a href="http://www.dns-sd.org/ServiceTypes.html"> http://www.dns-sd.org/ServiceTypes.html</a>, for instance "rsync" or "daap". |
in_Parameters | Used to pass an 'in' argument: <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>A dictionary of properties for the new tube; the allowable keys, types and values are defined by the service. Connection managers must support the value being any primitive (non-container) D-Bus type, or a byte array 'ay'.</p> <p>These should usually be the same key-value pairs specified for use in the DNS-SD TXT record for that service.</p> |
in_Address_Type | Used to pass an 'in' argument: The type of the listening address of the local service, as a member of Socket_Address_Type. (TpSocketAddressType) |
in_Address | Used to pass an 'in' argument: The listening address of the local service, as indicated by the address_type. |
in_Access_Control | Used to pass an 'in' argument: The access control the local service applies to the local socket, specified so the connection manager can behave appropriately when it connects. (TpSocketAccessControl) |
in_Access_Control_Param | Used to pass an 'in' argument: A parameter for the access control type, to be interpreted as specified in the documentation for the Socket_Access_Control enum. |
out_Tube_ID | Used to return an 'out' argument if `TRUE` is returned: The ID of the new tube. |
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_tubes_call_accept_d_bus_tube ()

    TpProxyPendingCall *
    tp_cli_channel_type_tubes_call_accept_d_bus_tube
                                   (TpChannel *proxy,
                                    gint timeout_ms,
                                    guint in_ID,
                                    tp_cli_channel_type_tubes_callback_for_accept_d_bus_tube callback,
                                    gpointer user_data,
                                    GDestroyNotify destroy,
                                    GObject *weak_object);

Start a AcceptDBusTube method call.

Accept a D-Bus tube that's in the "local pending" state. The connection manager will attempt to open the tube. The tube remains in the "local pending" state until the TubeStateChanged signal is emitted.

#### Parameters

proxy | the TpProxy |
timeout_ms | the timeout in milliseconds, or -1 to use the default |
in_ID | Used to pass an 'in' argument: The ID of the tube to accept. (TpTubeID) |
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_tubes_call_accept_stream_tube ()

    TpProxyPendingCall *
    tp_cli_channel_type_tubes_call_accept_stream_tube
                                   (TpChannel *proxy,
                                    gint timeout_ms,
                                    guint in_ID,
                                    guint in_Address_Type,
                                    guint in_Access_Control,
                                    const GValue *in_Access_Control_Param,
                                    tp_cli_channel_type_tubes_callback_for_accept_stream_tube callback,
                                    gpointer user_data,
                                    GDestroyNotify destroy,
                                    GObject *weak_object);

Start a AcceptStreamTube method call.

Accept a stream tube that's in the "local pending" state. The connection manager will attempt to open the tube. The tube remains in the "local pending" state until the TubeStateChanged signal is emitted.

#### Parameters

proxy | the TpProxy |
timeout_ms | the timeout in milliseconds, or -1 to use the default |
in_ID | Used to pass an 'in' argument: The ID of the tube to accept. (TpTubeID) |
in_Address_Type | Used to pass an 'in' argument: The type of address the connection manager should listen on. (TpSocketAddressType) |
in_Access_Control | Used to pass an 'in' argument: The type of access control the connection manager should apply to the socket. (TpSocketAccessControl) |
in_Access_Control_Param | Used to pass an 'in' argument: A parameter for the access control type, to be interpreted as specified in the documentation for the Socket_Access_Control 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_type_tubes_call_close_tube ()

    TpProxyPendingCall *
    tp_cli_channel_type_tubes_call_close_tube
                                   (TpChannel *proxy,
                                    gint timeout_ms,
                                    guint in_ID,
                                    tp_cli_channel_type_tubes_callback_for_close_tube callback,
                                    gpointer user_data,
                                    GDestroyNotify destroy,
                                    GObject *weak_object);

Start a CloseTube method call.

Close a tube.

#### Parameters

proxy | the TpProxy |
timeout_ms | the timeout in milliseconds, or -1 to use the default |
in_ID | Used to pass an 'in' argument: The ID of the tube to close. (TpTubeID) |
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_tubes_call_get_available_stream_tube_types ()

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

Start a GetAvailableStreamTubeTypes method call.

List the available address types and access-control types for stream tubes.

#### Parameters

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_tubes_call_get_available_tube_types ()

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

Start a GetAvailableTubeTypes method call.

(Undocumented)

#### Parameters

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_tubes_call_get_d_bus_names ()

    TpProxyPendingCall *
    tp_cli_channel_type_tubes_call_get_d_bus_names
                                   (TpChannel *proxy,
                                    gint timeout_ms,
                                    guint in_ID,
                                    tp_cli_channel_type_tubes_callback_for_get_d_bus_names callback,
                                    gpointer user_data,
                                    GDestroyNotify destroy,
                                    GObject *weak_object);

Start a GetDBusNames method call.

For a multi-user (i.e. Handle_Type_Room) D-Bus tube, obtain a mapping between contact handles and their unique bus names on this tube.

#### Parameters

proxy | the TpProxy |
timeout_ms | the timeout in milliseconds, or -1 to use the default |
in_ID | Used to pass an 'in' argument: The ID of the tube to get names for. (TpTubeID) |
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_tubes_call_get_d_bus_tube_address ()

    TpProxyPendingCall *
    tp_cli_channel_type_tubes_call_get_d_bus_tube_address
                                   (TpChannel *proxy,
                                    gint timeout_ms,
                                    guint in_ID,
                                    tp_cli_channel_type_tubes_callback_for_get_d_bus_tube_address callback,
                                    gpointer user_data,
                                    GDestroyNotify destroy,
                                    GObject *weak_object);

Start a GetDBusTubeAddress method call.

For a D-Bus tube, return a string describing the address of the private bus.

#### Parameters

proxy | the TpProxy |
timeout_ms | the timeout in milliseconds, or -1 to use the default |
in_ID | Used to pass an 'in' argument: The ID of the tube to get an address for. (TpTubeID) |
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_tubes_call_get_stream_tube_socket_address ()

    TpProxyPendingCall *
    tp_cli_channel_type_tubes_call_get_stream_tube_socket_address
                                   (TpChannel *proxy,
                                    gint timeout_ms,
                                    guint in_ID,
                                    tp_cli_channel_type_tubes_callback_for_get_stream_tube_socket_address callback,
                                    gpointer user_data,
                                    GDestroyNotify destroy,
                                    GObject *weak_object);

Start a GetStreamTubeSocketAddress method call.

For a stream tube, obtain the address of the socket used to communicate over this tube.

#### Parameters

proxy | the TpProxy |
timeout_ms | the timeout in milliseconds, or -1 to use the default |
in_ID | Used to pass an 'in' argument: The ID of the stream tube to get the socket for. (TpTubeID) |
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_tubes_call_list_tubes ()

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

Start a ListTubes method call.

(Undocumented)

#### Parameters

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_tubes_call_offer_d_bus_tube ()

    TpProxyPendingCall *
    tp_cli_channel_type_tubes_call_offer_d_bus_tube
                                   (TpChannel *proxy,
                                    gint timeout_ms,
                                    const gchar *in_Service,
                                    GHashTable *in_Parameters,
                                    tp_cli_channel_type_tubes_callback_for_offer_d_bus_tube callback,
                                    gpointer user_data,
                                    GDestroyNotify destroy,
                                    GObject *weak_object);

Start a OfferDBusTube method call.

Offers a D-Bus tube providing the service specified.

#### Parameters

proxy | the TpProxy |
timeout_ms | the timeout in milliseconds, or -1 to use the default |
in_Service | Used to pass an 'in' argument: A string representing the service name that will be used over the tube. It should be a well-known D-Bus service name, of the form com.example.ServiceName. |
in_Parameters | Used to pass an 'in' argument: A dictionary of properties for the new tube; the allowable keys, types and values are defined by the service. Connection managers must support the value being any primitive (non-container) D-Bus type, or a byte array 'ay'. |
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_tubes_call_offer_stream_tube ()

    TpProxyPendingCall *
    tp_cli_channel_type_tubes_call_offer_stream_tube
                                   (TpChannel *proxy,
                                    gint timeout_ms,
                                    const gchar *in_Service,
                                    GHashTable *in_Parameters,
                                    guint in_Address_Type,
                                    const GValue *in_Address,
                                    guint in_Access_Control,
                                    const GValue *in_Access_Control_Param,
                                    tp_cli_channel_type_tubes_callback_for_offer_stream_tube callback,
                                    gpointer user_data,
                                    GDestroyNotify destroy,
                                    GObject *weak_object);

Start a OfferStreamTube method call.

Offer a stream tube exporting the local socket specified.

#### Parameters

proxy | the TpProxy |
timeout_ms | the timeout in milliseconds, or -1 to use the default |
in_Service | Used to pass an 'in' argument: <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> A string representing the service name that will be used over the tube. It should be a well-known TCP service name as defined by <a href="http://www.iana.org/assignments/port-numbers"> http://www.iana.org/assignments/port-numbers</a> or <a href="http://www.dns-sd.org/ServiceTypes.html"> http://www.dns-sd.org/ServiceTypes.html</a>, for instance "rsync" or "daap". |
in_Parameters | Used to pass an 'in' argument: <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>A dictionary of properties for the new tube; the allowable keys, types and values are defined by the service. Connection managers must support the value being any primitive (non-container) D-Bus type, or a byte array 'ay'.</p> <p>These should usually be the same key-value pairs specified for use in the DNS-SD TXT record for that service.</p> |
in_Address_Type | Used to pass an 'in' argument: The type of the listening address of the local service, as a member of Socket_Address_Type. (TpSocketAddressType) |
in_Address | Used to pass an 'in' argument: The listening address of the local service, as indicated by the address_type. |
in_Access_Control | Used to pass an 'in' argument: The access control the local service applies to the local socket, specified so the connection manager can behave appropriately when it connects. (TpSocketAccessControl) |
in_Access_Control_Param | Used to pass an 'in' argument: A parameter for the access control type, to be interpreted as specified in the documentation for the Socket_Access_Control 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_type_tubes_callback_for_accept_d_bus_tube ()

    void
    (*tp_cli_channel_type_tubes_callback_for_accept_d_bus_tube)
                                   (TpChannel *proxy,
                                    const gchar *out_Address,
                                    const GError *error,
                                    gpointer user_data,
                                    GObject *weak_object);

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

#### Parameters

proxy | the proxy on which the call was made |
out_Address | Used to return an 'out' argument if `error` is `NULL`: The string describing the address of the private bus. The client should not attempt to connect to the address until the tube is open. |
error | `NULL` on success, or an error on failure |
user_data | user-supplied data |
weak_object | user-supplied object |

### tp_cli_channel_type_tubes_callback_for_accept_stream_tube ()

    void
    (*tp_cli_channel_type_tubes_callback_for_accept_stream_tube)
                                   (TpChannel *proxy,
                                    const GValue *out_Address,
                                    const GError *error,
                                    gpointer user_data,
                                    GObject *weak_object);

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

#### Parameters

proxy | the proxy on which the call was made |
out_Address | Used to return an 'out' argument if `error` is `NULL`: The address on which the connection manager will listen for connections to this tube. The client should not attempt to connect to the address until the tube is open. |
error | `NULL` on success, or an error on failure |
user_data | user-supplied data |
weak_object | user-supplied object |

### tp_cli_channel_type_tubes_callback_for_close_tube ()

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

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

#### Parameters

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_tubes_callback_for_get_available_stream_tube_types ()

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

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

#### Parameters

proxy | the proxy on which the call was made |
out_Available_Stream_Tube_Types | Used to return an 'out' argument if `error` is `NULL`: <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>A mapping from address types (members of Socket_Address_Type) to arrays of access-control type (members of Socket_Access_Control) that the connection manager supports for stream tubes with that address type. For simplicity, if a CM supports offering a particular type of tube, it is assumed to support accepting it.</p> <p>A typical value for a host without IPv6 support:</p> <pre> { Socket_Address_Type_IPv4: [Socket_Access_Control_Localhost, Socket_Access_Control_Port, Socket_Access_Control_Netmask], Socket_Address_Type_Unix: [Socket_Access_Control_Localhost, Socket_Access_Control_Credentials] } </pre> <p>If stream tubes are not supported, this will be an empty dictionary.</p> |
error | `NULL` on success, or an error on failure |
user_data | user-supplied data |
weak_object | user-supplied object |

### tp_cli_channel_type_tubes_callback_for_get_available_tube_types ()

    void
    (*tp_cli_channel_type_tubes_callback_for_get_available_tube_types)
                                   (TpChannel *proxy,
                                    const GArray *out_Available_Tube_Types,
                                    const GError *error,
                                    gpointer user_data,
                                    GObject *weak_object);

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

#### Parameters

proxy | the proxy on which the call was made |
out_Available_Tube_Types | Used to return an 'out' argument if `error` is `NULL`: An array of the available tube types, as defined by the Tube_Type enum. |
error | `NULL` on success, or an error on failure |
user_data | user-supplied data |
weak_object | user-supplied object |

### tp_cli_channel_type_tubes_callback_for_get_d_bus_names ()

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

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

#### Parameters

proxy | the proxy on which the call was made |
out_DBus_Names | Used to return an 'out' argument if `error` is `NULL`: An array of structures, each containing a contact handle and a D-Bus bus name. |
error | `NULL` on success, or an error on failure |
user_data | user-supplied data |
weak_object | user-supplied object |

### tp_cli_channel_type_tubes_callback_for_get_d_bus_tube_address ()

    void
    (*tp_cli_channel_type_tubes_callback_for_get_d_bus_tube_address)
                                   (TpChannel *proxy,
                                    const gchar *out_Address,
                                    const GError *error,
                                    gpointer user_data,
                                    GObject *weak_object);

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

#### Parameters

proxy | the proxy on which the call was made |
out_Address | Used to return an 'out' argument if `error` is `NULL`: The bus address. |
error | `NULL` on success, or an error on failure |
user_data | user-supplied data |
weak_object | user-supplied object |

### tp_cli_channel_type_tubes_callback_for_get_stream_tube_socket_address ()

    void
    (*tp_cli_channel_type_tubes_callback_for_get_stream_tube_socket_address)
                                   (TpChannel *proxy,
                                    guint out_Address_Type,
                                    const GValue *out_Address,
                                    const GError *error,
                                    gpointer user_data,
                                    GObject *weak_object);

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

#### Parameters

proxy | the proxy on which the call was made |
out_Address_Type | Used to return an 'out' argument if `error` is `NULL`: The type of the listening address of the socket, as a member of Socket_Address_Type. (TpSocketAddressType) |
out_Address | Used to return an 'out' argument if `error` is `NULL`: The listening address of the socket, as indicated by the address_type. |
error | `NULL` on success, or an error on failure |
user_data | user-supplied data |
weak_object | user-supplied object |

### tp_cli_channel_type_tubes_callback_for_list_tubes ()

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

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

#### Parameters

proxy | the proxy on which the call was made |
out_Tubes | Used to return an 'out' argument if `error` is `NULL`: Return an array of tuples, each representing a tube, with the following members: <ul> <li>the tube's ID</li> <li>the tube's initiator</li> <li>the tube's type</li> <li>the tube's service</li> <li>the tube's parameters</li> <li>the tube's state</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_tubes_callback_for_offer_d_bus_tube ()

    void
    (*tp_cli_channel_type_tubes_callback_for_offer_d_bus_tube)
                                   (TpChannel *proxy,
                                    guint out_Tube_ID,
                                    const GError *error,
                                    gpointer user_data,
                                    GObject *weak_object);

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

#### Parameters

proxy | the proxy on which the call was made |
out_Tube_ID | Used to return an 'out' argument if `error` is `NULL`: The ID of the new tube. (TpTubeID) |
error | `NULL` on success, or an error on failure |
user_data | user-supplied data |
weak_object | user-supplied object |

### tp_cli_channel_type_tubes_callback_for_offer_stream_tube ()

    void
    (*tp_cli_channel_type_tubes_callback_for_offer_stream_tube)
                                   (TpChannel *proxy,
                                    guint out_Tube_ID,
                                    const GError *error,
                                    gpointer user_data,
                                    GObject *weak_object);

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

#### Parameters

proxy | the proxy on which the call was made |
out_Tube_ID | Used to return an 'out' argument if `error` is `NULL`: The ID of the new tube. (TpTubeID) |
error | `NULL` on success, or an error on failure |
user_data | user-supplied data |
weak_object | user-supplied object |

### tp_cli_channel_type_tubes_connect_to_d_bus_names_changed ()

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

Connect a handler to the signal DBusNamesChanged.

Emitted on a multi-user (i.e. Handle_Type_Room) D-Bus tube when a participant opens or closes the tube.

#### Parameters

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_tubes_connect_to_new_tube ()

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

Connect a handler to the signal NewTube.

Emitted when a tube is created.

#### Parameters

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_tubes_connect_to_stream_tube_new_connection ()

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

Connect a handler to the signal StreamTubeNewConnection.

Emitted on a stream tube when a participant opens a new connection to its socket.

#### Parameters

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_tubes_connect_to_tube_closed ()

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

Connect a handler to the signal TubeClosed.

Emitted when a tube has been closed. The ID of a closed tube is no longer valid. The ID may later be reused for a new tube.

#### Parameters

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_tubes_connect_to_tube_state_changed ()

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

Connect a handler to the signal TubeStateChanged.

Emitted when the state of a tube changes.

#### Parameters

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_tubes_signal_callback_d_bus_names_changed ()

    void
    (*tp_cli_channel_type_tubes_signal_callback_d_bus_names_changed)
                                   (TpChannel *proxy,
                                    guint arg_ID,
                                    const GPtrArray *arg_Added,
                                    const GArray *arg_Removed,
                                    gpointer user_data,
                                    GObject *weak_object);

Represents the signature of a callback for the signal DBusNamesChanged.

#### Parameters

proxy | The proxy on which `tp_cli_channel_type_tubes_connect_to_d_bus_names_changed()` was called |
arg_ID | The ID of the tube whose names have changed. (TpTubeID) |
arg_Added | Array of handles and D-Bus names of new participants. |
arg_Removed | Array of handles of former participants. |
user_data | User-supplied data |
weak_object | User-supplied weakly referenced object |

### tp_cli_channel_type_tubes_signal_callback_new_tube ()

    void
    (*tp_cli_channel_type_tubes_signal_callback_new_tube)
                                   (TpChannel *proxy,
                                    guint arg_ID,
                                    guint arg_Initiator,
                                    guint arg_Type,
                                    const gchar *arg_Service,
                                    GHashTable *arg_Parameters,
                                    guint arg_State,
                                    gpointer user_data,
                                    GObject *weak_object);

Represents the signature of a callback for the signal NewTube.

#### Parameters

proxy | The proxy on which `tp_cli_channel_type_tubes_connect_to_new_tube()` was called |
arg_ID | The ID of the new tube. (TpTubeID) |
arg_Initiator | The handle of the contact who initiated the tube. (TpContactHandle) |
arg_Type | The tube type, as defined by the Tube_Type enum. (TpTubeType) |
arg_Service | A string representing the service that will be used over the tube. |
arg_Parameters | The new tube's properties. |
arg_State | The new tube's state. (TpTubeState) |
user_data | User-supplied data |
weak_object | User-supplied weakly referenced object |

### tp_cli_channel_type_tubes_signal_callback_stream_tube_new_connection ()

    void
    (*tp_cli_channel_type_tubes_signal_callback_stream_tube_new_connection)
                                   (TpChannel *proxy,
                                    guint arg_ID,
                                    guint arg_Handle,
                                    gpointer user_data,
                                    GObject *weak_object);

Represents the signature of a callback for the signal StreamTubeNewConnection.

#### Parameters

proxy | The proxy on which `tp_cli_channel_type_tubes_connect_to_stream_tube_new_connection()` was called |
arg_ID | The ID of the tube (TpTubeID) |
arg_Handle | The handle of the participant who opened the new connection (TpContactHandle) |
user_data | User-supplied data |
weak_object | User-supplied weakly referenced object |

### tp_cli_channel_type_tubes_signal_callback_tube_closed ()

    void
    (*tp_cli_channel_type_tubes_signal_callback_tube_closed)
                                   (TpChannel *proxy,
                                    guint arg_ID,
                                    gpointer user_data,
                                    GObject *weak_object);

Represents the signature of a callback for the signal TubeClosed.

#### Parameters

proxy | The proxy on which `tp_cli_channel_type_tubes_connect_to_tube_closed()` was called |
arg_ID | The ID of the tube that was closed. (TpTubeID) |
user_data | User-supplied data |
weak_object | User-supplied weakly referenced object |

### tp_cli_channel_type_tubes_signal_callback_tube_state_changed ()

    void
    (*tp_cli_channel_type_tubes_signal_callback_tube_state_changed)
                                   (TpChannel *proxy,
                                    guint arg_ID,
                                    guint arg_State,
                                    gpointer user_data,
                                    GObject *weak_object);

Represents the signature of a callback for the signal TubeStateChanged.

#### Parameters

proxy | The proxy on which `tp_cli_channel_type_tubes_connect_to_tube_state_changed()` was called |
arg_ID | The ID of the tube that changed state. (TpTubeID) |
arg_State | The new state of the tube; see the Tube_State enumeration. (TpTubeState) |
user_data | User-supplied data |
weak_object | User-supplied weakly referenced object |

## See Also

channel-group