/**
* tp_connection_get_contact_attributes:
* @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: (array length=n_handles): an array of handles
* @interfaces: a #GStrv of interfaces
* @hold: if %TRUE, the callback will hold one reference to each valid handle
* @callback: (type GObject.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
*
* Return (via a callback) any number of attributes of the given handles.
*
* Since telepathy-glib version 0.13.8,
* the handles will remain valid until @connection becomes invalid
* (signalled by #TpProxy::invalidated). In earlier versions, if @hold
* was %TRUE, the callback would hold a reference to them which could be
* released with tp_connection_unref_handles().
*
* This is a thin wrapper around the GetContactAttributes D-Bus method, and
* should be used in preference to
* tp_cli_connection_interface_contacts_call_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.
*
* Deprecated: Use tp_simple_client_factory_ensure_contact() instead.
*/
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)
{
GArray *a;
guint i;
DEBUG ("%u handles", n_handles);
for (i = 0; i < n_handles; i++)
DEBUG ("- %u", handles[i]);
g_return_if_fail (TP_IS_CONNECTION (self));
g_return_if_fail (n_handles >= 1);
g_return_if_fail (handles != NULL);
g_return_if_fail (callback != NULL);
a = g_array_sized_new (FALSE, FALSE, sizeof (guint), n_handles);
g_array_append_vals (a, handles, n_handles);
/* We ignore @hold, and always hold the handles anyway */
tp_cli_connection_interface_contacts_call_get_contact_attributes (self, -1,
a, (const gchar **) interfaces, TRUE, callback,
user_data, destroy, weak_object);
g_array_unref (a);
}
/**
* tp_connection_hold_handles:
* @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: (array length=n_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
*
* 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.
*
* Deprecated: Holding handles is not needed with Connection Managers having
* immortal handles (any Connection Manager using telepathy-glib >= 0.13.8).
* Other Connection Managers are considered deprecated, clients wanting to
* still support them should continue using this deprecated function.
*/
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)
{
HoldHandlesContext *context;
g_return_if_fail (TP_IS_CONNECTION (self));
g_return_if_fail (handle_type > TP_HANDLE_TYPE_NONE);
g_return_if_fail (handle_type < TP_NUM_HANDLE_TYPES);
g_return_if_fail (n_handles >= 1);
g_return_if_fail (callback != NULL);
context = g_slice_new0 (HoldHandlesContext);
context->handle_type = handle_type;
context->user_data = user_data;
context->destroy = destroy;
context->handles = g_array_sized_new (FALSE, FALSE, sizeof (guint),
n_handles);
g_array_append_vals (context->handles, handles, n_handles);
context->callback = callback;
tp_cli_connection_call_hold_handles (self, timeout_ms, handle_type,
context->handles, connection_held_handles,
context, hold_handles_context_free, weak_object);
}
/**
* tp_connection_request_handles:
* @self: a connection
* @timeout_ms: the timeout in milliseconds, or -1 to use the default
* @handle_type: the handle type
* @ids: (array zero-terminated=1): 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
*
* 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.
*
* Deprecated: If @handle_type is TP_HANDLE_TYPE_CONTACT, use
* tp_connection_dup_contact_by_id_async() instead. For channel requests,
* use tp_account_channel_request_set_target_id() instead.
*/
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)
{
RequestHandlesContext *context;
g_return_if_fail (TP_IS_CONNECTION (self));
g_return_if_fail (handle_type > TP_HANDLE_TYPE_NONE);
g_return_if_fail (handle_type < TP_NUM_HANDLE_TYPES);
g_return_if_fail (ids != NULL);
g_return_if_fail (ids[0] != NULL);
g_return_if_fail (callback != NULL);
context = g_slice_new0 (RequestHandlesContext);
context->handle_type = handle_type;
context->ids = g_strdupv ((GStrv) ids);
context->user_data = user_data;
context->destroy = destroy;
context->callback = callback;
tp_cli_connection_call_request_handles (self, timeout_ms, handle_type,
(const gchar **) context->ids, connection_requested_handles,
context, request_handles_context_free, weak_object);
}
void
empathy_tp_contact_factory_get_from_handle (TpConnection *connection,
TpHandle handle,
EmpathyTpContactFactoryContactCb callback,
gpointer user_data,
GDestroyNotify destroy,
GObject *weak_object)
{
GetContactsData *data;
g_return_if_fail (TP_IS_CONNECTION (connection));
data = g_slice_new (GetContactsData);
data->callback.contact_cb = callback;
data->user_data = user_data;
data->destroy = destroy;
data->connection = g_object_ref (connection);
tp_connection_get_contacts_by_handle (connection,
1, &handle,
G_N_ELEMENTS (contact_features),
contact_features,
get_contact_by_handle_cb,
data,
(GDestroyNotify) get_contacts_data_free,
weak_object);
}
EmpathyTpContactFactory *
empathy_tp_contact_factory_dup_singleton (TpConnection *connection)
{
EmpathyTpContactFactory *tp_factory;
g_return_val_if_fail (TP_IS_CONNECTION (connection), NULL);
if (factories == NULL) {
factories = g_hash_table_new_full (empathy_proxy_hash,
empathy_proxy_equal,
tp_contact_factory_remove_connection,
NULL);
}
tp_factory = g_hash_table_lookup (factories, connection);
if (tp_factory == NULL) {
tp_factory = g_object_new (EMPATHY_TYPE_TP_CONTACT_FACTORY,
"connection", connection,
NULL);
g_hash_table_insert (factories, g_object_ref (connection),
tp_factory);
g_object_weak_ref (G_OBJECT (tp_factory),
tp_contact_factory_connection_weak_notify_cb,
connection);
g_signal_connect (connection, "invalidated",
G_CALLBACK (tp_contact_factory_connection_invalidated_cb),
NULL);
} else {
g_object_ref (tp_factory);
}
return tp_factory;
}
static void
on_connection_future_ensure_sidecar_returned (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
gchar *object_path;
GError *error = NULL;
g_return_if_fail (TP_IS_CONNECTION (source_object));
object_path = _tp_yts_connection_future_ensure_sidecar_finish (
TP_CONNECTION (source_object), result, NULL, &error);
if (error != NULL)
{
g_simple_async_result_set_from_error (res, error);
g_clear_error (&error);
g_simple_async_result_complete_in_idle (res);
g_object_unref (res);
return;
}
g_async_initable_new_async (TP_TYPE_YTS_STATUS, G_PRIORITY_DEFAULT, NULL,
on_status_new_returned, res,
"dbus-daemon", tp_proxy_get_dbus_daemon (source_object),
"dbus-connection", tp_proxy_get_dbus_connection (source_object),
"bus-name", tp_proxy_get_bus_name (source_object),
"object-path", object_path,
NULL);
g_free (object_path);
}
/* The callback is NOT given a reference to the EmpathyContact objects */
void
empathy_tp_contact_factory_get_from_handles (TpConnection *connection,
guint n_handles,
const TpHandle *handles,
EmpathyTpContactFactoryContactsByHandleCb callback,
gpointer user_data,
GDestroyNotify destroy,
GObject *weak_object)
{
GetContactsData *data;
if (n_handles == 0) {
callback (connection, 0, NULL, 0, NULL, NULL, user_data, weak_object);
return;
}
g_return_if_fail (TP_IS_CONNECTION (connection));
g_return_if_fail (handles != NULL);
data = g_slice_new (GetContactsData);
data->callback.handles_cb = callback;
data->user_data = user_data;
data->destroy = destroy;
data->connection = g_object_ref (connection);
tp_connection_get_contacts_by_handle (connection,
n_handles, handles,
G_N_ELEMENTS (contact_features),
contact_features,
get_contacts_by_handle_cb,
data,
(GDestroyNotify) get_contacts_data_free,
weak_object);
}
/* The callback is NOT given a reference to the EmpathyContact objects */
void
empathy_tp_contact_factory_get_from_ids (TpConnection *connection,
guint n_ids,
const gchar * const *ids,
EmpathyTpContactFactoryContactsByIdCb callback,
gpointer user_data,
GDestroyNotify destroy,
GObject *weak_object)
{
GetContactsData *data;
g_return_if_fail (TP_IS_CONNECTION (connection));
g_return_if_fail (ids != NULL);
data = g_slice_new (GetContactsData);
data->callback.ids_cb = callback;
data->user_data = user_data;
data->destroy = destroy;
data->connection = g_object_ref (connection);
tp_connection_get_contacts_by_id (connection,
n_ids, ids,
G_N_ELEMENTS (contact_features),
contact_features,
get_contacts_by_id_cb,
data,
(GDestroyNotify) get_contacts_data_free,
weak_object);
}
TpStreamTubeChannel *
_tp_stream_tube_channel_new_with_factory (
TpSimpleClientFactory *factory,
TpConnection *conn,
const gchar *object_path,
const GHashTable *immutable_properties,
GError **error)
{
TpProxy *conn_proxy = (TpProxy *) conn;
g_return_val_if_fail (TP_IS_CONNECTION (conn), NULL);
g_return_val_if_fail (object_path != NULL, NULL);
g_return_val_if_fail (immutable_properties != NULL, NULL);
if (!tp_dbus_check_valid_object_path (object_path, error))
return NULL;
return g_object_new (TP_TYPE_STREAM_TUBE_CHANNEL,
"connection", conn,
"dbus-daemon", conn_proxy->dbus_daemon,
"bus-name", conn_proxy->bus_name,
"object-path", object_path,
"handle-type", (guint) TP_UNKNOWN_HANDLE_TYPE,
"channel-properties", immutable_properties,
"factory", factory,
NULL);
}
EmpathyTpContactList *
empathy_contact_manager_get_list (EmpathyContactManager *manager,
TpConnection *connection)
{
EmpathyContactManagerPriv *priv = GET_PRIV (manager);
g_return_val_if_fail (EMPATHY_IS_CONTACT_MANAGER (manager), NULL);
g_return_val_if_fail (TP_IS_CONNECTION (connection), NULL);
return g_hash_table_lookup (priv->lists, connection);
}
gboolean
empathy_connection_can_group_personas (TpConnection *connection,
FolksIndividual *individual)
{
gboolean retval;
g_return_val_if_fail (TP_IS_CONNECTION (connection), FALSE);
if (tp_connection_get_status (connection, NULL) !=
TP_CONNECTION_STATUS_CONNECTED)
return FALSE;
retval = check_writeable_property (connection, individual, "groups");
return retval;
}
/**
* tp_connection_get_contact_list_attributes:
* @self: a connection
* @timeout_ms: the timeout in milliseconds (using a large timeout is
* recommended)
* @interfaces: a #GStrv of interfaces
* @hold: if %TRUE, the callback will hold one reference to each handle it
* receives
* @callback: (type GObject.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
*
* Return (via a callback) the contacts on the contact list and any number of
* their attributes.
*
* Since telepathy-glib version 0.13.8,
* the handles will remain valid until @connection becomes invalid
* (signalled by #TpProxy::invalidated). In earlier versions, if @hold
* was %TRUE, the callback would hold a reference to them which could be
* released with tp_connection_unref_handles().
*
* This is a thin wrapper around the RequestContactList D-Bus method,
* and should be used in preference to lower-level functions; it is similar
* to tp_connection_get_contact_attributes().
*
* The #TpContact API provides a higher-level abstraction which should
* usually be used instead.
*
* If @hold is %TRUE, the @callback is given a reference to each handle
* that appears as a key in the callback's @attributes parameter.
*
* Deprecated: Use tp_connection_dup_contact_list() instead.
*/
void
tp_connection_get_contact_list_attributes (TpConnection *self,
gint timeout_ms,
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)
{
g_return_if_fail (TP_IS_CONNECTION (self));
g_return_if_fail (callback != NULL);
/* We ignore @hold, and always hold the handles anyway */
tp_cli_connection_interface_contact_list_call_get_contact_list_attributes (
self, -1, (const gchar **) interfaces, TRUE,
callback, user_data, destroy, weak_object);
}
/**
* folks_tp_lowlevel_connection_set_contact_alias_finish:
* @result: a #GAsyncResult
* @error: return location for a #GError, or %NULL
*
* Finish an asynchronous call to
* folks_tp_lowlevel_connection-set_contact_alias_async().
*/
void
folks_tp_lowlevel_connection_set_contact_alias_finish (
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
TpConnection *conn;
g_return_if_fail (G_IS_SIMPLE_ASYNC_RESULT (simple));
conn = TP_CONNECTION (g_async_result_get_source_object (result));
g_return_if_fail (TP_IS_CONNECTION (conn));
g_return_if_fail (g_simple_async_result_is_valid (result,
G_OBJECT (conn),
folks_tp_lowlevel_connection_set_contact_alias_finish));
g_simple_async_result_propagate_error (simple, error);
}
gboolean
empathy_connection_can_add_personas (TpConnection *connection)
{
gboolean retval;
FolksPersonaStore *persona_store;
g_return_val_if_fail (TP_IS_CONNECTION (connection), FALSE);
if (tp_connection_get_status (connection, NULL) !=
TP_CONNECTION_STATUS_CONNECTED)
return FALSE;
persona_store = FOLKS_PERSONA_STORE (
empathy_dup_persona_store_for_connection (connection));
retval = (folks_persona_store_get_can_add_personas (persona_store) ==
FOLKS_MAYBE_BOOL_TRUE);
g_clear_object (&persona_store);
return retval;
}
/**
* folks_tp_lowlevel_connection_get_alias_flags_finish:
* @result: a #GAsyncResult
* @error: return location for a #GError, or %NULL
*
* Determine the alias-related capabilities of the #TpConnection.
*
* Returns: the #TpConnectionAliasFlags
*/
TpConnectionAliasFlags
folks_tp_lowlevel_connection_get_alias_flags_finish (
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
TpConnection *conn;
g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (simple), FALSE);
conn = TP_CONNECTION (g_async_result_get_source_object (result));
g_return_val_if_fail (TP_IS_CONNECTION (conn), FALSE);
if (g_simple_async_result_propagate_error (simple, error))
return 0;
g_return_val_if_fail (g_simple_async_result_is_valid (result,
G_OBJECT (conn), folks_tp_lowlevel_connection_get_alias_flags_finish),
0);
return (TpConnectionAliasFlags) (g_simple_async_result_get_op_res_gpointer (
G_SIMPLE_ASYNC_RESULT (result)));
}
