TpProxyPrepareAsync ()

void
(*TpProxyPrepareAsync) (TpProxy *proxy,
                        const TpProxyFeature *feature,
                        GAsyncReadyCallback callback,
                        gpointer user_data);

Function called when feature has to be prepared for proxy .

TpProxyClassFeatureListFunc ()

const TpProxyFeature *
(*TpProxyClassFeatureListFunc) (TpProxyClass *cls);

A function called to list the features supported by tp_proxy_prepare_async(). Currently, only code inside telepathy-glib can implement this.

Since 0.11.3

tp_proxy_has_interface ()

gboolean
tp_proxy_has_interface (gpointer self,
                        const gchar *iface);

Return whether this proxy is known to have a particular interface. In versions older than 0.11.11, this was a macro wrapper around tp_proxy_has_interface_by_id().

For objects that discover their interfaces at runtime, this method will indicate that interfaces are missing until they are known to be present. In subclasses that define features for use with tp_proxy_prepare_async(), successfully preparing the "core" feature for that subclass (such as TP_CHANNEL_FEATURE_CORE or TP_CONNECTION_FEATURE_CORE) implies that the interfaces are known.

Since 0.7.1

tp_proxy_has_interface_by_id ()

gboolean
tp_proxy_has_interface_by_id (gpointer self,
                              GQuark iface);

Return whether this proxy is known to have a particular interface, by its quark ID. This is equivalent to using g_quark_to_string() followed by tp_proxy_has_interface(), but more efficient.

Since 0.7.1

tp_proxy_is_prepared ()

gboolean
tp_proxy_is_prepared (gpointer self,
                      GQuark feature);

Return TRUE if feature has been prepared successfully, or FALSE if feature has not been requested, has not been prepared yet, or is not available on this object at all.

(For instance, if feature is TP_CHANNEL_FEATURE_CHAT_STATES and self is a TpChannel in a protocol that doesn't actually implement chat states, or is not a TpChannel at all, then this method will return FALSE.)

To prepare features, call tp_proxy_prepare_async().

Since 0.11.3

tp_proxy_prepare_async ()

void
tp_proxy_prepare_async (gpointer self,
                        const GQuark *features,
                        GAsyncReadyCallback callback,
                        gpointer user_data);

TpProxy itself does not support any features, but subclasses like TpChannel can support features, which can either be core functionality like TP_CHANNEL_FEATURE_CORE, or extended functionality like TP_CHANNEL_FEATURE_CHAT_STATES.

Proxy instances start with no features prepared. When features are requested via tp_proxy_prepare_async(), the proxy starts to do the necessary setup to use those features.

tp_proxy_prepare_async() always waits for core functionality of the proxy's class to be prepared, even if it is not specifically requested: for instance, because TP_CHANNEL_FEATURE_CORE is core functionality of a TpChannel,

1
2
3

TpChannel *channel = ...;

tp_proxy_prepare_async (channel, NULL, callback, user_data);

is equivalent to

1
2
3
4

TpChannel *channel = ...;
GQuark features[] = { TP_CHANNEL_FEATURE_CORE, 0 };

tp_proxy_prepare_async (channel, features, callback, user_data);

If a feature represents core functionality (like TP_CHANNEL_FEATURE_CORE), failure to prepare it will result in tp_proxy_prepare_async() finishing unsuccessfully: if failure to prepare the feature indicates that the proxy is no longer useful, it will also emit “invalidated”.

If a feature represents non-essential functionality (like TP_CHANNEL_FEATURE_CHAT_STATES), or is not supported by the object at all, then failure to prepare it is not fatal: tp_proxy_prepare_async() will complete successfully, but tp_proxy_is_prepared() will still return FALSE for the feature, and accessor methods for the feature will typically return a dummy value.

Some TpProxy subclasses automatically start to prepare their core features when instantiated, and features will sometimes become prepared as a side-effect of other actions, but to ensure that a feature is present you must generally call tp_proxy_prepare_async() and wait for the result.

Since 0.11.3

tp_proxy_prepare_finish ()

gboolean
tp_proxy_prepare_finish (gpointer self,
                         GAsyncResult *result,
                         GError **error);

Check for error in a call to tp_proxy_prepare_async(). An error here generally indicates that either the asynchronous call was cancelled, or self has emitted “invalidated”.

Since 0.11.3

tp_proxy_pending_call_cancel ()

void
tp_proxy_pending_call_cancel (TpProxyPendingCall *pc);

Cancel the given pending call. After this function returns, you must not assume that the pending call remains valid, but you must not explicitly free it either.

Since 0.7.1

tp_proxy_signal_connection_disconnect ()

void
tp_proxy_signal_connection_disconnect (TpProxySignalConnection *sc);

Disconnect the given signal connection. After this function returns, you must not assume that the signal connection remains valid, but you must not explicitly free it either.

It is not safe to call this function if sc has been disconnected already, which happens in each of these situations:

Since 0.7.1

tp_proxy_get_factory ()

TpClientFactory *
tp_proxy_get_factory (gpointer self);

Since 0.15.5

tp_proxy_get_dbus_connection ()

GDBusConnection *
tp_proxy_get_dbus_connection (gpointer self);

Since 0.7.17

tp_proxy_get_bus_name ()

const gchar *
tp_proxy_get_bus_name (gpointer self);

Since 0.7.17

tp_proxy_get_object_path ()

const gchar *
tp_proxy_get_object_path (gpointer self);

Since 0.7.17

tp_proxy_get_invalidated ()

const GError *
tp_proxy_get_invalidated (gpointer self);

Since 0.7.17

tp_proxy_dbus_error_to_gerror ()

void
tp_proxy_dbus_error_to_gerror (gpointer self,
                               const char *dbus_error,
                               const char *debug_message,
                               GError **error);

Convert a D-Bus error name into a GError as if it was returned by a method on this proxy. This method is useful when D-Bus error names are emitted in signals, such as Connection.ConnectionError and Group.MembersChanged.

Since 0.7.24

TP_DBUS_ERRORS

#define TP_DBUS_ERRORS (tp_dbus_errors_quark ())

GError domain representing D-Bus errors not directly related to Telepathy, for use by TpProxy. The code in a GError with this domain must be a member of TpDBusError.

This macro expands to a function call returning a GQuark.

Since 0.7.1

TP_NUM_DBUS_ERRORS

#define TP_NUM_DBUS_ERRORS (TP_DBUS_ERROR_CANCELLED + 1)

1 more than the highest valid TpDBusError at the time of compilation

Since 0.19.0

TP_TYPE_DBUS_ERROR

#define TP_TYPE_DBUS_ERROR (tp_dbus_error_get_type ())

The GEnumClass type of a TpDBusError.

Since 0.11.5

struct TpProxy

struct TpProxy;

Structure representing a Telepathy client-side proxy.

Since 0.7.1

struct TpProxyFeature

struct TpProxyFeature {
    GQuark name;
    gboolean core;

    TpProxyPrepareAsync prepare_async;
    TpProxyPrepareAsync prepare_before_signalling_connected_async;

    const GQuark *interfaces_needed;
    /* Features we depend on */
    const GQuark *depends_on;

    gboolean can_retry;
};

Structure representing a feature.

Since 0.11.3

struct TpProxyClass

struct TpProxyClass {
    GObjectClass parent_class;

    GQuark interface;

    unsigned int must_have_unique_name:1;
};

The class of a TpProxy. The struct fields not documented here are reserved.

Since 0.7.1

TpProxyPendingCall

typedef struct _TpProxyPendingCall TpProxyPendingCall;

Opaque structure representing a pending D-Bus call.

Since 0.7.1

TpProxySignalConnection

typedef struct _TpProxySignalConnection TpProxySignalConnection;

Opaque structure representing a D-Bus signal connection.

Since 0.7.1

enum TpDBusError

GError codes for use with the TP_DBUS_ERRORS domain.

Since 0.11.5, there is a corresponding GEnumClass type, TP_TYPE_DBUS_ERROR.

Since 0.7.1

The “bus-name” property

  “bus-name”                 gchar *

The D-Bus bus name for this object. Read-only except during construction.

Flags: Read / Write / Construct Only

Default value: NULL

The “dbus-connection” property

  “dbus-connection”          GDBusConnection *

The D-Bus connection for this object. Read-only except during construction.

Flags: Read / Write / Construct Only

The “factory” property

  “factory”                  TpClientFactory *

The TpClientFactory used to create this proxy, or NULL if this proxy was not created through a factory.

Flags: Read / Write / Construct Only

The “interfaces” property

  “interfaces”               GStrv

Known D-Bus interface names for this object.

Flags: Read

The “object-path” property

  “object-path”              gchar *

The D-Bus object path for this object. Read-only except during construction.

Flags: Read / Write / Construct Only

Default value: NULL

The “invalidated” signal

void
user_function (TpProxy *self,
               guint    domain,
               gint     code,
               gchar   *message,
               gpointer user_data)

Emitted when this proxy has been become invalid for whatever reason. Any more specific signal should be emitted first.

An invalidated proxy is one which can make no more method calls and will emit no more D-Bus signals. This is typically because the D-Bus object represented by the proxy ceased to exist, or there was some error obtaining the initial state.

Any pending or future method calls made on this proxy will fail gracefully with the same error as returned by tp_proxy_get_invalidated().

Flags: Has Details