TpConnection

TpConnection — proxy object for a Telepathy connection

Synopsis


#include <telepathy-glib/connection.h>

void                (*TpConnectionNameListCb)           (const gchar * const *names,
                                                         gsize n,
                                                         const gchar * const *cms,
                                                         const gchar * const *protocols,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);
void                tp_list_connection_names            (TpDBusDaemon *bus_daemon,
                                                         TpConnectionNameListCb callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);
TpConnection*       tp_connection_new                   (TpDBusDaemon *dbus,
                                                         const gchar *bus_name,
                                                         const gchar *object_path,
                                                         GError **error);
gboolean            tp_connection_run_until_ready       (TpConnection *self,
                                                         gboolean connect,
                                                         GError **error,
                                                         GMainLoop **loop);
void                (*TpConnectionWhenReadyCb)          (TpConnection *connection,
                                                         const GError *error,
                                                         gpointer user_data);
void                tp_connection_call_when_ready       (TpConnection *self,
                                                         TpConnectionWhenReadyCb callback,
                                                         gpointer user_data);
gboolean            tp_connection_is_ready              (TpConnection *self);
TpConnectionStatus  tp_connection_get_status            (TpConnection *self,
                                                         TpConnectionStatusReason *reason);
TpHandle            tp_connection_get_self_handle       (TpConnection *self);
void                (*TpConnectionRequestHandlesCb)     (TpConnection *connection,
                                                         TpHandleType handle_type,
                                                         guint n_handles,
                                                         const TpHandle *handles,
                                                         const gchar * const *ids,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);
void                tp_connection_request_handles       (TpConnection *self,
                                                         gint timeout_ms,
                                                         TpHandleType handle_type,
                                                         const gchar * const *ids,
                                                         TpConnectionRequestHandlesCb callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);
void                (*TpConnectionHoldHandlesCb)        (TpConnection *connection,
                                                         TpHandleType handle_type,
                                                         guint n_handles,
                                                         const TpHandle *handles,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);
void                tp_connection_get_contact_attributes
                                                        (TpConnection *self,
                                                         gint timeout_ms,
                                                         guint n_handles,
                                                         const TpHandle *handles,
                                                         const gchar * const *interfaces,
                                                         gboolean hold,
                                                         tp_cli_connection_interface_contacts_callback_for_get_contact_attributes callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);
void                tp_connection_hold_handles          (TpConnection *self,
                                                         gint timeout_ms,
                                                         TpHandleType handle_type,
                                                         guint n_handles,
                                                         const TpHandle *handles,
                                                         TpConnectionHoldHandlesCb callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);
void                tp_connection_unref_handles         (TpConnection *self,
                                                         TpHandleType handle_type,
                                                         guint n_handles,
                                                         const TpHandle *handles);
void                tp_connection_init_known_interfaces (void);
gint                tp_connection_presence_type_cmp_availability
                                                        (TpConnectionPresenceType p1,
                                                         TpConnectionPresenceType p2);
gboolean            tp_connection_parse_object_path     (TpConnection *self,
                                                         gchar **protocol,
                                                         gchar **cm_name);
                    TpConnection;
                    TpConnectionClass;
#define             TP_UNKNOWN_CONNECTION_STATUS
#define             TP_ERRORS_DISCONNECTED


void                (*tp_cli_connection_callback_for_connect)
                                                        (TpConnection *proxy,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);
TpProxyPendingCall* tp_cli_connection_call_connect      (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         tp_cli_connection_callback_for_connect callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);
gboolean            tp_cli_connection_run_connect       (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         GError **error,
                                                         GMainLoop **loop);
void                (*tp_cli_connection_callback_for_disconnect)
                                                        (TpConnection *proxy,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);
TpProxyPendingCall* tp_cli_connection_call_disconnect   (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         tp_cli_connection_callback_for_disconnect callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);
gboolean            tp_cli_connection_run_disconnect    (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         GError **error,
                                                         GMainLoop **loop);
void                (*tp_cli_connection_callback_for_get_interfaces)
                                                        (TpConnection *proxy,
                                                         const gchar **out_Interfaces,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);
TpProxyPendingCall* tp_cli_connection_call_get_interfaces
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         tp_cli_connection_callback_for_get_interfaces callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);
gboolean            tp_cli_connection_run_get_interfaces
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         gchar ***out_Interfaces,
                                                         GError **error,
                                                         GMainLoop **loop);
void                (*tp_cli_connection_callback_for_get_protocol)
                                                        (TpConnection *proxy,
                                                         const gchar *out_Protocol,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);
TpProxyPendingCall* tp_cli_connection_call_get_protocol (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         tp_cli_connection_callback_for_get_protocol callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);
gboolean            tp_cli_connection_run_get_protocol  (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         gchar **out_Protocol,
                                                         GError **error,
                                                         GMainLoop **loop);
void                (*tp_cli_connection_callback_for_get_self_handle)
                                                        (TpConnection *proxy,
                                                         guint out_Self_Handle,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);
TpProxyPendingCall* tp_cli_connection_call_get_self_handle
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         tp_cli_connection_callback_for_get_self_handle callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);
gboolean            tp_cli_connection_run_get_self_handle
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         guint *out_Self_Handle,
                                                         GError **error,
                                                         GMainLoop **loop);
void                (*tp_cli_connection_callback_for_get_status)
                                                        (TpConnection *proxy,
                                                         guint out_Status,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);
TpProxyPendingCall* tp_cli_connection_call_get_status   (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         tp_cli_connection_callback_for_get_status callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);
gboolean            tp_cli_connection_run_get_status    (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         guint *out_Status,
                                                         GError **error,
                                                         GMainLoop **loop);
void                (*tp_cli_connection_callback_for_hold_handles)
                                                        (TpConnection *proxy,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);
TpProxyPendingCall* tp_cli_connection_call_hold_handles (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         guint in_Handle_Type,
                                                         const GArray *in_Handles,
                                                         tp_cli_connection_callback_for_hold_handles callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);
gboolean            tp_cli_connection_run_hold_handles  (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         guint in_Handle_Type,
                                                         const GArray *in_Handles,
                                                         GError **error,
                                                         GMainLoop **loop);
void                (*tp_cli_connection_callback_for_inspect_handles)
                                                        (TpConnection *proxy,
                                                         const gchar **out_Identifiers,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);
TpProxyPendingCall* tp_cli_connection_call_inspect_handles
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         guint in_Handle_Type,
                                                         const GArray *in_Handles,
                                                         tp_cli_connection_callback_for_inspect_handles callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);
gboolean            tp_cli_connection_run_inspect_handles
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         guint in_Handle_Type,
                                                         const GArray *in_Handles,
                                                         gchar ***out_Identifiers,
                                                         GError **error,
                                                         GMainLoop **loop);
void                (*tp_cli_connection_callback_for_list_channels)
                                                        (TpConnection *proxy,
                                                         const GPtrArray *out_Channel_Info,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);
TpProxyPendingCall* tp_cli_connection_call_list_channels
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         tp_cli_connection_callback_for_list_channels callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);
gboolean            tp_cli_connection_run_list_channels (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         GPtrArray **out_Channel_Info,
                                                         GError **error,
                                                         GMainLoop **loop);
void                (*tp_cli_connection_callback_for_release_handles)
                                                        (TpConnection *proxy,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);
TpProxyPendingCall* tp_cli_connection_call_release_handles
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         guint in_Handle_Type,
                                                         const GArray *in_Handles,
                                                         tp_cli_connection_callback_for_release_handles callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);
gboolean            tp_cli_connection_run_release_handles
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         guint in_Handle_Type,
                                                         const GArray *in_Handles,
                                                         GError **error,
                                                         GMainLoop **loop);
void                (*tp_cli_connection_callback_for_request_channel)
                                                        (TpConnection *proxy,
                                                         const gchar *out_Object_Path,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);
TpProxyPendingCall* tp_cli_connection_call_request_channel
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         const gchar *in_Type,
                                                         guint in_Handle_Type,
                                                         guint in_Handle,
                                                         gboolean in_Suppress_Handler,
                                                         tp_cli_connection_callback_for_request_channel callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);
gboolean            tp_cli_connection_run_request_channel
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         const gchar *in_Type,
                                                         guint in_Handle_Type,
                                                         guint in_Handle,
                                                         gboolean in_Suppress_Handler,
                                                         gchar **out_Object_Path,
                                                         GError **error,
                                                         GMainLoop **loop);
void                (*tp_cli_connection_callback_for_request_handles)
                                                        (TpConnection *proxy,
                                                         const GArray *out_Handles,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);
TpProxyPendingCall* tp_cli_connection_call_request_handles
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         guint in_Handle_Type,
                                                         const gchar **in_Identifiers,
                                                         tp_cli_connection_callback_for_request_handles callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);
gboolean            tp_cli_connection_run_request_handles
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         guint in_Handle_Type,
                                                         const gchar **in_Identifiers,
                                                         GArray **out_Handles,
                                                         GError **error,
                                                         GMainLoop **loop);
void                (*tp_cli_connection_signal_callback_new_channel)
                                                        (TpConnection *proxy,
                                                         const gchar *arg_Object_Path,
                                                         const gchar *arg_Channel_Type,
                                                         guint arg_Handle_Type,
                                                         guint arg_Handle,
                                                         gboolean arg_Suppress_Handler,
                                                         gpointer user_data,
                                                         GObject *weak_object);
TpProxySignalConnection* tp_cli_connection_connect_to_new_channel
                                                        (TpConnection *proxy,
                                                         tp_cli_connection_signal_callback_new_channel callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object,
                                                         GError **error);
void                (*tp_cli_connection_signal_callback_self_handle_changed)
                                                        (TpConnection *proxy,
                                                         guint arg_Self_Handle,
                                                         gpointer user_data,
                                                         GObject *weak_object);
TpProxySignalConnection* tp_cli_connection_connect_to_self_handle_changed
                                                        (TpConnection *proxy,
                                                         tp_cli_connection_signal_callback_self_handle_changed callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object,
                                                         GError **error);
void                (*tp_cli_connection_signal_callback_status_changed)
                                                        (TpConnection *proxy,
                                                         guint arg_Status,
                                                         guint arg_Reason,
                                                         gpointer user_data,
                                                         GObject *weak_object);
TpProxySignalConnection* tp_cli_connection_connect_to_status_changed
                                                        (TpConnection *proxy,
                                                         tp_cli_connection_signal_callback_status_changed callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object,
                                                         GError **error);
void                (*tp_cli_connection_signal_callback_connection_error)
                                                        (TpConnection *proxy,
                                                         const gchar *arg_Error,
                                                         GHashTable *arg_Details,
                                                         gpointer user_data,
                                                         GObject *weak_object);
TpProxySignalConnection* tp_cli_connection_connect_to_connection_error
                                                        (TpConnection *proxy,
                                                         tp_cli_connection_signal_callback_connection_error callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object,
                                                         GError **error);

Object Hierarchy

  GObject
   +----TpProxy
         +----TpConnection

Properties

  "connection-ready"         gboolean              : Read
  "self-handle"              guint                 : Read
  "status"                   guint                 : Read
  "status-reason"            guint                 : Read

Description

TpConnection objects represent Telepathy instant messaging connections accessed via D-Bus.

Compared with a simple proxy for method calls, they add the following features:

  • connection status tracking
  • calling GetInterfaces() automatically

Details

TpConnectionNameListCb ()

void                (*TpConnectionNameListCb)           (const gchar * const *names,
                                                         gsize n,
                                                         const gchar * const *cms,
                                                         const gchar * const *protocols,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);

Signature of the callback supplied to tp_list_connection_names().

names : NULL-terminated array of n connection bus names, or NULL on error
n : number of names (not including the final NULL), or 0 on error
cms : NULL-terminated array of n connection manager names (e.g. "gabble") in the same order as names, or NULL on error
protocols : NULL-terminated array of n protocol names as defined in the Telepathy spec (e.g. "jabber") in the same order as names, or NULL on error
error : NULL on success, or an error that occurred
user_data : user-supplied data
weak_object : user-supplied weakly referenced object

Since 0.7.1


tp_list_connection_names ()

void                tp_list_connection_names            (TpDBusDaemon *bus_daemon,
                                                         TpConnectionNameListCb callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);

List the bus names of all the connections that currently exist, together with the connection manager name and the protocol name for each connection. Call the callback when done.

The bus names passed to the callback can be used to construct TpConnection objects for any connections that are of interest.

bus_daemon : proxy for the D-Bus daemon
callback : callback to be called when listing the connections succeeds or fails; not called if the D-Bus connection fails completely or if the weak_object goes away
user_data : user-supplied data for the callback
destroy : callback to destroy the user-supplied data, called after callback, but also if the D-Bus connection fails or if the weak_object goes away
weak_object : if not NULL, will be weakly referenced; the callback will not be called if the object has vanished

Since 0.7.1


tp_connection_new ()

TpConnection*       tp_connection_new                   (TpDBusDaemon *dbus,
                                                         const gchar *bus_name,
                                                         const gchar *object_path,
                                                         GError **error);

dbus : a D-Bus daemon; may not be NULL
bus_name : the well-known or unique name of the connection process; if well-known, this function will make a blocking call to the bus daemon to resolve the unique name. May be NULL if object_path is not, in which case a well-known name will be derived from object_path.
object_path : the object path of the connection process. May be NULL if bus_name is a well-known name, in which case the object path will be derived from bus_name.
error : used to indicate the error if NULL is returned
Returns : a new connection proxy, or NULL if unique-name resolution fails or on invalid arguments

Since 0.7.1


tp_connection_run_until_ready ()

gboolean            tp_connection_run_until_ready       (TpConnection *self,
                                                         gboolean connect,
                                                         GError **error,
                                                         GMainLoop **loop);

If self is connected and ready for use, return immediately. Otherwise, call Connect() (unless connect is FALSE) and re-enter the main loop until the connection becomes invalid, the connection connects successfully and is introspected, or the main loop stored via loop is cancelled.

self : a connection
connect : if TRUE, call Connect() if it appears to be necessary; if FALSE, rely on Connect() to be called by another client
error : if not NULL and FALSE is returned, used to raise an error
loop : if not NULL, a GMainLoop is placed here while it is being run (so calling code can call g_main_loop_quit() to abort), and NULL is placed here after the loop has been run
Returns : TRUE if the connection is now connected and ready for use, FALSE if the connection has become invalid.

Since 0.7.1


TpConnectionWhenReadyCb ()

void                (*TpConnectionWhenReadyCb)          (TpConnection *connection,
                                                         const GError *error,
                                                         gpointer user_data);

Signature of a callback passed to tp_connection_call_when_ready(), which will be called exactly once, when the connection becomes ready or invalid (whichever happens first)

connection : the connection (which may be in the middle of being disposed, if error is non-NULL, error->domain is TP_DBUS_ERRORS and error->code is TP_DBUS_ERROR_PROXY_UNREFERENCED)
error : NULL if the connection is ready for use, or the error with which it was invalidated if it is now invalid
user_data : whatever was passed to tp_connection_call_when_ready()

tp_connection_call_when_ready ()

void                tp_connection_call_when_ready       (TpConnection *self,
                                                         TpConnectionWhenReadyCb callback,
                                                         gpointer user_data);

If self is ready for use or has been invalidated, call callback immediately, then return. Otherwise, arrange for callback to be called when self either becomes ready for use or becomes invalid.

Note that if the connection is not in state CONNECTED, the callback will not be called until the connection either goes to state CONNECTED or is invalidated (e.g. by going to state DISCONNECTED or by becoming unreferenced). In particular, this method does not call Connect(). Call tp_cli_connection_call_connect() too, if you want to do that.

self : a connection
callback : called when the connection becomes ready or invalidated, whichever happens first
user_data : arbitrary user-supplied data passed to the callback

Since 0.7.7


tp_connection_is_ready ()

gboolean            tp_connection_is_ready              (TpConnection *self);

Returns the same thing as the "connection-ready" property.

self : a connection
Returns : TRUE if introspection has completed

Since 0.7.17


tp_connection_get_status ()

TpConnectionStatus  tp_connection_get_status            (TpConnection *self,
                                                         TpConnectionStatusReason *reason);

If reason is not NULL it is set to the reason why "status" changed to its current value, or TP_CONNECTION_STATUS_REASON_NONE_SPECIFIED if unknown.

self : a connection
reason : a TpConnectionStatusReason, or NULL
Returns : This connection's status, or TP_UNKNOWN_CONNECTION_STATUS if we don't know yet.

Since 0.7.14


tp_connection_get_self_handle ()

TpHandle            tp_connection_get_self_handle       (TpConnection *self);

Return the TP_HANDLE_TYPE_CONTACT handle of the local user on this connection, or 0 if the connection is not ready (the TpConnection:connection-ready property is false) or has become invalid (the TpProxy::invalidated signal).

The returned handle is not necessarily valid forever (the notify::self-handle signal will be emitted if it changes, which can happen on protocols such as IRC). Construct a TpContact object if you want to track the local user's identifier in the protocol, or other information like their presence status, over time.

self : a connection
Returns : the value of the TpConnection:self-handle property

Since 0.7.26


TpConnectionRequestHandlesCb ()

void                (*TpConnectionRequestHandlesCb)     (TpConnection *connection,
                                                         TpHandleType handle_type,
                                                         guint n_handles,
                                                         const TpHandle *handles,
                                                         const gchar * const *ids,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);

Signature of the callback called when tp_connection_request_handles() succeeds or fails.

On success, the caller has one reference to each handle in handles, which may be released later with tp_connection_unref_handles(). If not released, the handles will remain valid until connection becomes invalid (signalled by TpProxy::invalidated).

For convenience, the handle type and IDs requested by the caller are passed through to this callback, so the caller does not have to include them in user_data.

connection : the connection
handle_type : the handle type that was passed to tp_connection_request_handles()
n_handles : the number of IDs that were passed to tp_connection_request_handles() on success, or 0 on failure
handles : the n_handles handles corresponding to ids, in the same order, or NULL on failure
ids : a copy of the array of n_handles IDs that was passed to tp_connection_request_handles() on success, or NULL on failure
error : NULL on success, or an error on failure
user_data : the same arbitrary pointer that was passed to tp_connection_request_handles()
weak_object : the same object that was passed to tp_connection_request_handles()

tp_connection_request_handles ()

void                tp_connection_request_handles       (TpConnection *self,
                                                         gint timeout_ms,
                                                         TpHandleType handle_type,
                                                         const gchar * const *ids,
                                                         TpConnectionRequestHandlesCb callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);

Request the handles corresponding to the given identifiers, and if they are valid, hold (ensure a reference to) the corresponding handles.

If they are valid, the callback will later be called with the given handles; if not all of them are valid, the callback will be called with an error.

self : a connection
timeout_ms : the timeout in milliseconds, or -1 to use the default
handle_type : the handle type
ids : an array of string identifiers for which handles are required, terminated by NULL (must not be NULL or empty)
callback : called on success or failure (unless weak_object has become unreferenced)
user_data : arbitrary user-supplied data
destroy : called to destroy user_data after calling callback, or when weak_object becomes unreferenced (whichever occurs sooner)
weak_object : if not NULL, an object to be weakly referenced: if it is destroyed, callback will not be called

TpConnectionHoldHandlesCb ()

void                (*TpConnectionHoldHandlesCb)        (TpConnection *connection,
                                                         TpHandleType handle_type,
                                                         guint n_handles,
                                                         const TpHandle *handles,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);

Signature of the callback called when tp_connection_hold_handles() succeeds or fails.

On success, the caller has one reference to each handle in handles, which may be released later with tp_connection_unref_handles(). If not released, the handles will remain valid until connection becomes invalid (signalled by "invalidated").

For convenience, the handle type and handles requested by the caller are passed through to this callback on success, so the caller does not have to include them in user_data.

connection : the connection
handle_type : the handle type that was passed to tp_connection_hold_handles()
n_handles : the number of handles that were passed to tp_connection_hold_handles() on success, or 0 on failure
handles : a copy of the array of n_handles handles that was passed to tp_connection_hold_handles() on success, or NULL on failure
error : NULL on success, or an error on failure
user_data : the same arbitrary pointer that was passed to tp_connection_hold_handles()
weak_object : the same object that was passed to tp_connection_hold_handles()

tp_connection_get_contact_attributes ()

void                tp_connection_get_contact_attributes
                                                        (TpConnection *self,
                                                         gint timeout_ms,
                                                         guint n_handles,
                                                         const TpHandle *handles,
                                                         const gchar * const *interfaces,
                                                         gboolean hold,
                                                         tp_cli_connection_interface_contacts_callback_for_get_contact_attributes callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);

Return (via a callback) any number of attributes of the given handles, and if they are valid and hold is TRUE, hold a reference to them.

This is a thin wrapper around the GetContactAttributes D-Bus method, and should be used in preference to tp_cli_connection_interface_contacts_get_contact_attributes(); mixing this function, tp_connection_hold_handles(), tp_connection_unref_handles(), and TpContact with direct use of the RequestHandles, HoldHandles and GetContactAttributes D-Bus methods is unwise, as TpConnection and TpContact perform client-side reference counting of handles. The TpContact API provides a higher-level abstraction which should usually be used instead.

callback will later be called with the attributes of those of the given handles that were valid. Invalid handles are simply omitted from the parameter to the callback.

If hold is TRUE, the callback is given one reference to each handle that appears as a key in the callback's attributes parameter.

self : a connection
timeout_ms : the timeout in milliseconds, or -1 to use the default
n_handles : the number of handles in handles (must be at least 1)
handles : an array of handles
interfaces : a GStrv of interfaces
hold : if TRUE, the callback will hold one reference to each valid handle
callback : called on success or failure (unless weak_object has become unreferenced)
user_data : arbitrary user-supplied data
destroy : called to destroy user_data after calling callback, or when weak_object becomes unreferenced (whichever occurs sooner)
weak_object : if not NULL, an object to be weakly referenced: if it is destroyed, callback will not be called

tp_connection_hold_handles ()

void                tp_connection_hold_handles          (TpConnection *self,
                                                         gint timeout_ms,
                                                         TpHandleType handle_type,
                                                         guint n_handles,
                                                         const TpHandle *handles,
                                                         TpConnectionHoldHandlesCb callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);

Hold (ensure a reference to) the given handles, if they are valid.

If they are valid, the callback will later be called with the given handles; if not all of them are valid, the callback will be called with an error.

This function, along with tp_connection_unref_handles(), tp_connection_get_contact_attributes() and TpContact, keeps a client-side reference count of handles; you should not use the RequestHandles, HoldHandles and GetContactAttributes D-Bus methods directly as well as these functions.

self : a connection
timeout_ms : the timeout in milliseconds, or -1 to use the default
handle_type : the handle type
n_handles : the number of handles in handles (must be at least 1)
handles : an array of handles
callback : called on success or failure (unless weak_object has become unreferenced)
user_data : arbitrary user-supplied data
destroy : called to destroy user_data after calling callback, or when weak_object becomes unreferenced (whichever occurs sooner)
weak_object : if not NULL, an object to be weakly referenced: if it is destroyed, callback will not be called

tp_connection_unref_handles ()

void                tp_connection_unref_handles         (TpConnection *self,
                                                         TpHandleType handle_type,
                                                         guint n_handles,
                                                         const TpHandle *handles);

Release the reference to the handles in handles that was obtained by calling tp_connection_hold_handles() or tp_connection_request_handles().

This function might release any references held by calling tp_cli_connection_call_request_handles(), tp_cli_connection_run_request_handles(), tp_cli_connection_call_hold_handles(), tp_cli_connection_run_hold_handles(), tp_cli_connection_interface_contacts_call_get_contact_attributes() or tp_cli_connection_interface_contacts_run_get_contact_attributes() directly. Those functions should be avoided in favour of using TpContact, tp_connection_hold_handles(), tp_connection_request_handles() and tp_connection_get_contact_attributes(), which along with this function perform client-side reference counting of handles.

If self has already become invalid, this function does nothing.

self : a connection
handle_type : a handle type
n_handles : the number of handles in handles
handles : an array of n_handles handles

tp_connection_init_known_interfaces ()

void                tp_connection_init_known_interfaces (void);

Ensure that the known interfaces for TpConnection have been set up. This is done automatically when necessary, but for correct overriding of library interfaces by local extensions, you should call this function before calling tp_proxy_or_subclass_hook_on_interface_add() with first argument TP_TYPE_CONNECTION.

Since 0.7.6


tp_connection_presence_type_cmp_availability ()

gint                tp_connection_presence_type_cmp_availability
                                                        (TpConnectionPresenceType p1,
                                                         TpConnectionPresenceType p2);

Compares p1 and p2 like strcmp(). p1 > p2 means p1 is more available than p2.

The order used is: available > busy > away > xa > hidden > offline > error > unknown > unset

p1 : a TpConnectionPresenceType
p2 : a TpConnectionPresenceType
Returns : -1, 0 or 1, if p1 is <, == or > than p2.

Since 0.7.16


tp_connection_parse_object_path ()

gboolean            tp_connection_parse_object_path     (TpConnection *self,
                                                         gchar **protocol,
                                                         gchar **cm_name);

If the object path of connection is in the correct form, set protocol and cm_name, return TRUE. Otherwise leave them unchanged and return FALSE.

self : a connection
protocol : If not NULL, used to return the protocol of the connection
cm_name : If not NULL, used to return the connection manager name of the connection
Returns : TRUE if the object path was correctly parsed, FALSE otherwise.

Since 0.7.27


TpConnection

typedef struct _TpConnection TpConnection;

A proxy object for a Telepathy connection.

(Changed in 0.7.12: the layout of the structure is visible, allowing subclassing.)

Since 0.7.1


TpConnectionClass

typedef struct {
    TpProxyClass parent_class;
} TpConnectionClass;

The class of a TpConnection. In addition to parent_class there are four pointers reserved for possible future use.

(Changed in 0.7.12: the layout of the structure is visible, allowing subclassing.)

TpProxyClass parent_class; the parent class

Since 0.7.1


TP_UNKNOWN_CONNECTION_STATUS

#define TP_UNKNOWN_CONNECTION_STATUS ((TpConnectionStatus) -1)

An invalid connection status used in TpConnection to indicate that the status has not yet been discovered.

Since 0.7.1


TP_ERRORS_DISCONNECTED

#define TP_ERRORS_DISCONNECTED (tp_errors_disconnected_quark ())

GError domain representing a Telepathy connection becoming disconnected. The code in a GError with this domain must be a member of TpConnectionStatusReason.

This macro expands to a function call returning a GQuark.

Since 0.7.1


tp_cli_connection_callback_for_connect ()

void                (*tp_cli_connection_callback_for_connect)
                                                        (TpConnection *proxy,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);

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

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

tp_cli_connection_call_connect ()

TpProxyPendingCall* tp_cli_connection_call_connect      (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         tp_cli_connection_callback_for_connect callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);

Start a Connect method call.

<tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>Request that the connection be established. This will be done asynchronously and errors will be returned by emitting <tp:member-ref>StatusChanged</tp:member-ref> signals.</p> <p>Calling this method on a Connection that is already connecting or connected is allowed, and has no effect.</p>

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

gboolean            tp_cli_connection_run_connect       (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         GError **error,
                                                         GMainLoop **loop);

Call the method Connect 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 connection be established. This will be done asynchronously and errors will be returned by emitting <tp:member-ref>StatusChanged</tp:member-ref> signals.</p> <p>Calling this method on a Connection that is already connecting or connected is allowed, and has no effect.</p>

proxy : A TpConnection or subclass
timeout_ms : Timeout in milliseconds, or -1 for default
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_connection_callback_for_disconnect ()

void                (*tp_cli_connection_callback_for_disconnect)
                                                        (TpConnection *proxy,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);

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

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

tp_cli_connection_call_disconnect ()

TpProxyPendingCall* tp_cli_connection_call_disconnect   (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         tp_cli_connection_callback_for_disconnect callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);

Start a Disconnect method call.

Request that the connection be closed. This closes the connection if it's not already in DISCONNECTED state, and destroys the connection object.

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

gboolean            tp_cli_connection_run_disconnect    (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         GError **error,
                                                         GMainLoop **loop);

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

Request that the connection be closed. This closes the connection if it's not already in DISCONNECTED state, and destroys the connection object.

proxy : A TpConnection or subclass
timeout_ms : Timeout in milliseconds, or -1 for default
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_connection_callback_for_get_interfaces ()

void                (*tp_cli_connection_callback_for_get_interfaces)
                                                        (TpConnection *proxy,
                                                         const gchar **out_Interfaces,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);

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

proxy : the proxy on which the call was made
out_Interfaces : Used to return an 'out' argument if error is NULL: An array of D-Bus interface names
error : NULL on success, or an error on failure
user_data : user-supplied data
weak_object : user-supplied object

tp_cli_connection_call_get_interfaces ()

TpProxyPendingCall* tp_cli_connection_call_get_interfaces
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         tp_cli_connection_callback_for_get_interfaces callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);

Start a GetInterfaces method call.

<tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>Get the optional interfaces supported by this connection. Before the connection status changes to CONNECTED, the return from this method may change at any time, but it is guaranteed that interfaces will only be added, not removed. After the connection status changes to CONNECTED, the return from this method cannot change further.</p> <p>There is no explicit change notification; reasonable behaviour for a client would be to retrieve the interfaces list once initially, and once more when it becomes CONNECTED.</p> <tp:rationale> <p>In some connection managers, certain capabilities of a connection are known to be implemented for all connections (e.g. support for SimplePresence), and some interfaces (like SimplePresence) can even be used before connecting. Other capabilities may or may not exist, depending on server functionality; by the time the connection goes CONNECTED, the connection manager is expected to have evaluated the server's functionality and enabled any extra interfaces for the remainder of the Connection's lifetime.</p> </tp:rationale>

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

gboolean            tp_cli_connection_run_get_interfaces
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         gchar ***out_Interfaces,
                                                         GError **error,
                                                         GMainLoop **loop);

Call the method GetInterfaces 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>Get the optional interfaces supported by this connection. Before the connection status changes to CONNECTED, the return from this method may change at any time, but it is guaranteed that interfaces will only be added, not removed. After the connection status changes to CONNECTED, the return from this method cannot change further.</p> <p>There is no explicit change notification; reasonable behaviour for a client would be to retrieve the interfaces list once initially, and once more when it becomes CONNECTED.</p> <tp:rationale> <p>In some connection managers, certain capabilities of a connection are known to be implemented for all connections (e.g. support for SimplePresence), and some interfaces (like SimplePresence) can even be used before connecting. Other capabilities may or may not exist, depending on server functionality; by the time the connection goes CONNECTED, the connection manager is expected to have evaluated the server's functionality and enabled any extra interfaces for the remainder of the Connection's lifetime.</p> </tp:rationale>

proxy : A TpConnection or subclass
timeout_ms : Timeout in milliseconds, or -1 for default
out_Interfaces : Used to return an 'out' argument if TRUE is returned: An array of D-Bus interface names
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_connection_callback_for_get_protocol ()

void                (*tp_cli_connection_callback_for_get_protocol)
                                                        (TpConnection *proxy,
                                                         const gchar *out_Protocol,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);

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

proxy : the proxy on which the call was made
out_Protocol : Used to return an 'out' argument if error is NULL: A string identifier for the protocol
error : NULL on success, or an error on failure
user_data : user-supplied data
weak_object : user-supplied object

tp_cli_connection_call_get_protocol ()

TpProxyPendingCall* tp_cli_connection_call_get_protocol (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         tp_cli_connection_callback_for_get_protocol callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);

Start a GetProtocol method call.

Get the protocol this connection is using.

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

gboolean            tp_cli_connection_run_get_protocol  (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         gchar **out_Protocol,
                                                         GError **error,
                                                         GMainLoop **loop);

Call the method GetProtocol 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 protocol this connection is using.

proxy : A TpConnection or subclass
timeout_ms : Timeout in milliseconds, or -1 for default
out_Protocol : Used to return an 'out' argument if TRUE is returned: A string identifier for the protocol
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_connection_callback_for_get_self_handle ()

void                (*tp_cli_connection_callback_for_get_self_handle)
                                                        (TpConnection *proxy,
                                                         guint out_Self_Handle,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);

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

proxy : the proxy on which the call was made
out_Self_Handle : Used to return an 'out' argument if error is NULL: The value of the <tp:member-ref>SelfHandle</tp:member-ref> property
error : NULL on success, or an error on failure
user_data : user-supplied data
weak_object : user-supplied object

tp_cli_connection_call_get_self_handle ()

TpProxyPendingCall* tp_cli_connection_call_get_self_handle
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         tp_cli_connection_callback_for_get_self_handle callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);

Start a GetSelfHandle method call.

Returns the value of the SelfHandle property. Change notification is via the SelfHandleChanged signal.

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

gboolean            tp_cli_connection_run_get_self_handle
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         guint *out_Self_Handle,
                                                         GError **error,
                                                         GMainLoop **loop);

Call the method GetSelfHandle 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 the value of the SelfHandle property. Change notification is via the SelfHandleChanged signal.

proxy : A TpConnection or subclass
timeout_ms : Timeout in milliseconds, or -1 for default
out_Self_Handle : Used to return an 'out' argument if TRUE is returned: The value of the <tp:member-ref>SelfHandle</tp:member-ref> property
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_connection_callback_for_get_status ()

void                (*tp_cli_connection_callback_for_get_status)
                                                        (TpConnection *proxy,
                                                         guint out_Status,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);

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

proxy : the proxy on which the call was made
out_Status : Used to return an 'out' argument if error is NULL: An integer representing the current status
error : NULL on success, or an error on failure
user_data : user-supplied data
weak_object : user-supplied object

tp_cli_connection_call_get_status ()

TpProxyPendingCall* tp_cli_connection_call_get_status   (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         tp_cli_connection_callback_for_get_status callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);

Start a GetStatus method call.

Get the current status as defined in the <tp:member-ref>StatusChanged</tp:member-ref> signal.

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

gboolean            tp_cli_connection_run_get_status    (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         guint *out_Status,
                                                         GError **error,
                                                         GMainLoop **loop);

Call the method GetStatus 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 status as defined in the <tp:member-ref>StatusChanged</tp:member-ref> signal.

proxy : A TpConnection or subclass
timeout_ms : Timeout in milliseconds, or -1 for default
out_Status : Used to return an 'out' argument if TRUE is returned: An integer representing the current status
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_connection_callback_for_hold_handles ()

void                (*tp_cli_connection_callback_for_hold_handles)
                                                        (TpConnection *proxy,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);

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

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

tp_cli_connection_call_hold_handles ()

TpProxyPendingCall* tp_cli_connection_call_hold_handles (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         guint in_Handle_Type,
                                                         const GArray *in_Handles,
                                                         tp_cli_connection_callback_for_hold_handles callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);

Start a HoldHandles method call.

<tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>Notify the connection manger that your client is holding a copy of handles which may not be in use in any existing channel or list, and were not obtained by using the <tp:member-ref>RequestHandles</tp:member-ref> method. For example, a handle observed in an emitted signal, or displayed somewhere in the UI that is not associated with a channel. The connection manager must not deallocate a handle where any clients have used this method to indicate it is in use until the <tp:member-ref>ReleaseHandles</tp:member-ref> method is called, or the clients disappear from the bus.</p> <p>Note that HoldHandles is idempotent - calling it multiple times is equivalent to calling it once. If a handle is &quot;referenced&quot; by several components which share a D-Bus unique name, the client should perform reference counting internally, and only call ReleaseHandles when none of the cooperating components need the handle any longer.</p>

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

tp_cli_connection_run_hold_handles ()

gboolean            tp_cli_connection_run_hold_handles  (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         guint in_Handle_Type,
                                                         const GArray *in_Handles,
                                                         GError **error,
                                                         GMainLoop **loop);

Call the method HoldHandles 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>Notify the connection manger that your client is holding a copy of handles which may not be in use in any existing channel or list, and were not obtained by using the <tp:member-ref>RequestHandles</tp:member-ref> method. For example, a handle observed in an emitted signal, or displayed somewhere in the UI that is not associated with a channel. The connection manager must not deallocate a handle where any clients have used this method to indicate it is in use until the <tp:member-ref>ReleaseHandles</tp:member-ref> method is called, or the clients disappear from the bus.</p> <p>Note that HoldHandles is idempotent - calling it multiple times is equivalent to calling it once. If a handle is &quot;referenced&quot; by several components which share a D-Bus unique name, the client should perform reference counting internally, and only call ReleaseHandles when none of the cooperating components need the handle any longer.</p>

proxy : A TpConnection or subclass
timeout_ms : Timeout in milliseconds, or -1 for default
in_Handle_Type : Used to pass an 'in' argument: The type of handle to be held
in_Handles : Used to pass an 'in' argument: A array of integer handles to hold
error : If not NULL, used to return errors if FALSE is returned
loop : If not NULL, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with g_main_loop_quit(), causing a return of FALSE with error set to TP_DBUS_ERROR_CANCELLED
Returns : TRUE on success, FALSE and sets error on error

tp_cli_connection_callback_for_inspect_handles ()

void                (*tp_cli_connection_callback_for_inspect_handles)
                                                        (TpConnection *proxy,
                                                         const gchar **out_Identifiers,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);

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

proxy : the proxy on which the call was made
out_Identifiers : Used to return an 'out' argument if error is NULL: An array of identifiers corresponding to the given handles, in the same order.
error : NULL on success, or an error on failure
user_data : user-supplied data
weak_object : user-supplied object

tp_cli_connection_call_inspect_handles ()

TpProxyPendingCall* tp_cli_connection_call_inspect_handles
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         guint in_Handle_Type,
                                                         const GArray *in_Handles,
                                                         tp_cli_connection_callback_for_inspect_handles callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);

Start a InspectHandles method call.

Return a string representation for a number of handles of a given type.

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

tp_cli_connection_run_inspect_handles ()

gboolean            tp_cli_connection_run_inspect_handles
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         guint in_Handle_Type,
                                                         const GArray *in_Handles,
                                                         gchar ***out_Identifiers,
                                                         GError **error,
                                                         GMainLoop **loop);

Call the method InspectHandles 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 a string representation for a number of handles of a given type.

proxy : A TpConnection or subclass
timeout_ms : Timeout in milliseconds, or -1 for default
in_Handle_Type : Used to pass an 'in' argument: The type of handle to be inspected
in_Handles : Used to pass an 'in' argument: An array of integer handles of this type
out_Identifiers : Used to return an 'out' argument if TRUE is returned: An array of identifiers corresponding to the given handles, in the same order.
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_connection_callback_for_list_channels ()

void                (*tp_cli_connection_callback_for_list_channels)
                                                        (TpConnection *proxy,
                                                         const GPtrArray *out_Channel_Info,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);

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

proxy : the proxy on which the call was made
out_Channel_Info : Used to return an 'out' argument if error is NULL: An array of structs representing channels.
error : NULL on success, or an error on failure
user_data : user-supplied data
weak_object : user-supplied object

tp_cli_connection_call_list_channels ()

TpProxyPendingCall* tp_cli_connection_call_list_channels
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         tp_cli_connection_callback_for_list_channels callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);

Start a ListChannels method call.

List all the channels which currently exist on this connection.

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

gboolean            tp_cli_connection_run_list_channels (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         GPtrArray **out_Channel_Info,
                                                         GError **error,
                                                         GMainLoop **loop);

Call the method ListChannels 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 all the channels which currently exist on this connection.

proxy : A TpConnection or subclass
timeout_ms : Timeout in milliseconds, or -1 for default
out_Channel_Info : Used to return an 'out' argument if TRUE is returned: An array of structs representing channels.
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_connection_callback_for_release_handles ()

void                (*tp_cli_connection_callback_for_release_handles)
                                                        (TpConnection *proxy,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);

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

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

tp_cli_connection_call_release_handles ()

TpProxyPendingCall* tp_cli_connection_call_release_handles
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         guint in_Handle_Type,
                                                         const GArray *in_Handles,
                                                         tp_cli_connection_callback_for_release_handles callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);

Start a ReleaseHandles method call.

Explicitly notify the connection manager that your client is no longer holding any references to the given handles, and that they may be deallocated if they are not held by any other clients or referenced by any existing channels. See HoldHandles for notes.

proxy : the TpProxy
timeout_ms : the timeout in milliseconds, or -1 to use the default
in_Handle_Type : Used to pass an 'in' argument: An integer handle type (as defined in RequestHandle)
in_Handles : Used to pass an 'in' argument: An array of integer handles being held by the client
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_connection_run_release_handles ()

gboolean            tp_cli_connection_run_release_handles
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         guint in_Handle_Type,
                                                         const GArray *in_Handles,
                                                         GError **error,
                                                         GMainLoop **loop);

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

Explicitly notify the connection manager that your client is no longer holding any references to the given handles, and that they may be deallocated if they are not held by any other clients or referenced by any existing channels. See HoldHandles for notes.

proxy : A TpConnection or subclass
timeout_ms : Timeout in milliseconds, or -1 for default
in_Handle_Type : Used to pass an 'in' argument: An integer handle type (as defined in RequestHandle)
in_Handles : Used to pass an 'in' argument: An array of integer handles being held by the client
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_connection_callback_for_request_channel ()

void                (*tp_cli_connection_callback_for_request_channel)
                                                        (TpConnection *proxy,
                                                         const gchar *out_Object_Path,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);

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

proxy : the proxy on which the call was made
out_Object_Path : Used to return an 'out' argument if error is NULL: The D-Bus object path for the channel created or retrieved
error : NULL on success, or an error on failure
user_data : user-supplied data
weak_object : user-supplied object

tp_cli_connection_call_request_channel ()

TpProxyPendingCall* tp_cli_connection_call_request_channel
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         const gchar *in_Type,
                                                         guint in_Handle_Type,
                                                         guint in_Handle,
                                                         gboolean in_Suppress_Handler,
                                                         tp_cli_connection_callback_for_request_channel callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);

Start a RequestChannel method call.

<tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>Request a channel satisfying the specified type and communicating with the contact, room, list etc. indicated by the given handle_type and handle. The handle_type and handle may both be zero to request the creation of a new, empty channel, which may or may not be possible, depending on the protocol and channel type.</p> <p>On success, the returned channel will always be of the requested type (i.e. implement the requested channel-type interface).</p> <p>If a new, empty channel is requested, on success the returned channel will always be an &quot;anonymous&quot; channel for which the type and handle are both zero.</p> <p>If a channel to a contact, room etc. is requested, on success, the returned channel may either be a new or existing channel to the requested entity (i.e. its <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel">TargetHandleType</tp:dbus-ref> and <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel">TargetHandle</tp:dbus-ref> properties are the requested handle type and handle), or a newly created &quot;anonymous&quot; channel associated with the requested handle in some implementation-specific way.</p> <p>For example, for a contact handle, the returned channel might be &quot;anonymous&quot;, but implement the groups interface and have the requested contact already present among the members.</p> <p>If the request cannot be satisfied, an error is raised and no channel is created.</p>

proxy : the TpProxy
timeout_ms : the timeout in milliseconds, or -1 to use the default
in_Type : Used to pass an 'in' argument: A D-Bus interface name representing base channel type
in_Handle_Type : Used to pass an 'in' argument: An integer representing the handle type, or Handle_Type_None if no handle is specified
in_Handle : Used to pass an 'in' argument: A nonzero integer handle representing a contact, room, list etc. according to handle_type, or zero if the handle_type is Handle_Type_None
in_Suppress_Handler : Used to pass an 'in' argument: <p>Clients SHOULD always set this to true.</p> <tp:rationale> <p>The historical meaning was that clients that did not intend to take responsibility for displaying the channel to the user could set this to FALSE, in which case the channel dispatcher would launch an appropriate channel handler.</p> <p>However, clients whose functionality relies on having a working channel dispatcher should obtain that functionality by calling methods on the channel dispatcher, so that they will get an appropriate error if the channel dispatcher is missing or not working.</p> <p>The channel dispatcher itself should set this to true too, so that it will ignore the <tp:member-ref>NewChannel</tp:member-ref> signal that results from the creation of the channel. It can then dispatch the channel returned from this method to an appropriate handler.</p> <p>So, there is no sensible use-case for setting this to false, and setting it to false can result in unhandled channels (in the case where clients assume that a channel dispatcher is present, but it isn't).</p> </tp:rationale>
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_connection_run_request_channel ()

gboolean            tp_cli_connection_run_request_channel
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         const gchar *in_Type,
                                                         guint in_Handle_Type,
                                                         guint in_Handle,
                                                         gboolean in_Suppress_Handler,
                                                         gchar **out_Object_Path,
                                                         GError **error,
                                                         GMainLoop **loop);

Call the method RequestChannel 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 channel satisfying the specified type and communicating with the contact, room, list etc. indicated by the given handle_type and handle. The handle_type and handle may both be zero to request the creation of a new, empty channel, which may or may not be possible, depending on the protocol and channel type.</p> <p>On success, the returned channel will always be of the requested type (i.e. implement the requested channel-type interface).</p> <p>If a new, empty channel is requested, on success the returned channel will always be an &quot;anonymous&quot; channel for which the type and handle are both zero.</p> <p>If a channel to a contact, room etc. is requested, on success, the returned channel may either be a new or existing channel to the requested entity (i.e. its <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel">TargetHandleType</tp:dbus-ref> and <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel">TargetHandle</tp:dbus-ref> properties are the requested handle type and handle), or a newly created &quot;anonymous&quot; channel associated with the requested handle in some implementation-specific way.</p> <p>For example, for a contact handle, the returned channel might be &quot;anonymous&quot;, but implement the groups interface and have the requested contact already present among the members.</p> <p>If the request cannot be satisfied, an error is raised and no channel is created.</p>

proxy : A TpConnection or subclass
timeout_ms : Timeout in milliseconds, or -1 for default
in_Type : Used to pass an 'in' argument: A D-Bus interface name representing base channel type
in_Handle_Type : Used to pass an 'in' argument: An integer representing the handle type, or Handle_Type_None if no handle is specified
in_Handle : Used to pass an 'in' argument: A nonzero integer handle representing a contact, room, list etc. according to handle_type, or zero if the handle_type is Handle_Type_None
in_Suppress_Handler : Used to pass an 'in' argument: <p>Clients SHOULD always set this to true.</p> <tp:rationale> <p>The historical meaning was that clients that did not intend to take responsibility for displaying the channel to the user could set this to FALSE, in which case the channel dispatcher would launch an appropriate channel handler.</p> <p>However, clients whose functionality relies on having a working channel dispatcher should obtain that functionality by calling methods on the channel dispatcher, so that they will get an appropriate error if the channel dispatcher is missing or not working.</p> <p>The channel dispatcher itself should set this to true too, so that it will ignore the <tp:member-ref>NewChannel</tp:member-ref> signal that results from the creation of the channel. It can then dispatch the channel returned from this method to an appropriate handler.</p> <p>So, there is no sensible use-case for setting this to false, and setting it to false can result in unhandled channels (in the case where clients assume that a channel dispatcher is present, but it isn't).</p> </tp:rationale>
out_Object_Path : Used to return an 'out' argument if TRUE is returned: The D-Bus object path for the channel created or retrieved
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_connection_callback_for_request_handles ()

void                (*tp_cli_connection_callback_for_request_handles)
                                                        (TpConnection *proxy,
                                                         const GArray *out_Handles,
                                                         const GError *error,
                                                         gpointer user_data,
                                                         GObject *weak_object);

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

proxy : the proxy on which the call was made
out_Handles : Used to return an 'out' argument if error is NULL: An array of integer handle numbers in the same order as the given identifiers.
error : NULL on success, or an error on failure
user_data : user-supplied data
weak_object : user-supplied object

tp_cli_connection_call_request_handles ()

TpProxyPendingCall* tp_cli_connection_call_request_handles
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         guint in_Handle_Type,
                                                         const gchar **in_Identifiers,
                                                         tp_cli_connection_callback_for_request_handles callback,
                                                         gpointer user_data,
                                                         GDestroyNotify destroy,
                                                         GObject *weak_object);

Start a RequestHandles method call.

Request several handles from the connection manager which represent a number of contacts, rooms or server-stored lists on the service. The connection manager should record that these handles are in use by the client who invokes this method, and must not deallocate the handles until the client disconnects from the bus or calls the <tp:member-ref>ReleaseHandles</tp:member-ref> method. Where the identifier refers to an entity that already has a handle in this connection manager, this handle should be returned instead. The handle number 0 must not be returned by the connection manager.

proxy : the TpProxy
timeout_ms : the timeout in milliseconds, or -1 to use the default
in_Handle_Type : Used to pass an 'in' argument: The type of handle required
in_Identifiers : Used to pass an 'in' argument: An array of identifiers of entities to request handles for
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_connection_run_request_handles ()

gboolean            tp_cli_connection_run_request_handles
                                                        (TpConnection *proxy,
                                                         gint timeout_ms,
                                                         guint in_Handle_Type,
                                                         const gchar **in_Identifiers,
                                                         GArray **out_Handles,
                                                         GError **error,
                                                         GMainLoop **loop);

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

Request several handles from the connection manager which represent a number of contacts, rooms or server-stored lists on the service. The connection manager should record that these handles are in use by the client who invokes this method, and must not deallocate the handles until the client disconnects from the bus or calls the <tp:member-ref>ReleaseHandles</tp:member-ref> method. Where the identifier refers to an entity that already has a handle in this connection manager, this handle should be returned instead. The handle number 0 must not be returned by the connection manager.

proxy : A TpConnection or subclass
timeout_ms : Timeout in milliseconds, or -1 for default
in_Handle_Type : Used to pass an 'in' argument: The type of handle required
in_Identifiers : Used to pass an 'in' argument: An array of identifiers of entities to request handles for
out_Handles : Used to return an 'out' argument if TRUE is returned: An array of integer handle numbers in the same order as the given identifiers.
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_connection_signal_callback_new_channel ()

void                (*tp_cli_connection_signal_callback_new_channel)
                                                        (TpConnection *proxy,
                                                         const gchar *arg_Object_Path,
                                                         const gchar *arg_Channel_Type,
                                                         guint arg_Handle_Type,
                                                         guint arg_Handle,
                                                         gboolean arg_Suppress_Handler,
                                                         gpointer user_data,
                                                         GObject *weak_object);

Represents the signature of a callback for the signal NewChannel.

proxy : The proxy on which tp_cli_connection_connect_to_new_channel() was called
arg_Object_Path : A D-Bus object path for the channel object on this service
arg_Channel_Type : A D-Bus interface name representing the channel type
arg_Handle_Type : An integer representing the type of handle this channel communicates with, or Handle_Type_None if no handle is specified
arg_Handle : A handle indicating the specific contact, room or list this channel communicates with, or zero if no handle is specified
arg_Suppress_Handler : <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>If true, the channel was requested by a client that intends to present it to the user itself (i.e. it passed suppress_handler=TRUE to the <tp:member-ref>RequestChannel</tp:member-ref> method), so no other handler should be launched. Clients MAY assume that channels where this is true were created by a user request.</p> <p>If false, either the channel was created due to incoming information from the service, or the channel was requested by a local client that does not intend to handle the channel itself (this usage is deprecated).</p> <p>Clients MUST NOT assume that only incoming channels will have this flag set to false.</p>
user_data : User-supplied data
weak_object : User-supplied weakly referenced object

tp_cli_connection_connect_to_new_channel ()