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);
}
static void
conn_ready (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
GError *error = NULL;
TpConnection *conn = TP_CONNECTION (source);
if (!tp_proxy_prepare_finish (conn, result, &error))
{
g_warning ("%s", error->message);
g_main_loop_quit (mainloop);
g_clear_error (&error);
return;
}
if (!tp_proxy_has_interface_by_id (conn,
EXAMPLE_IFACE_QUARK_CONNECTION_INTERFACE_HATS))
{
g_warning ("Connection does not support Hats interface");
g_main_loop_quit (mainloop);
return;
}
/* Get contact object for someone else */
tp_connection_dup_contact_by_id_async (conn, "other@server", 0, NULL,
contact_ready_cb, NULL);
}
/**
* 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);
}
static void
connection_ready (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
ChVisitor *self = (ChVisitor*) user_data;
TpConnection *connection = TP_CONNECTION (source);
GError *error = NULL;
if (!tp_proxy_prepare_finish (source, result, &error)) {
g_printerr ("error loading connection: %s\n", error->message);
}
// Run callback, 0 indicates failure reason
if (self->visit_connection) {
self->visit_connection (self, connection, 0);
}
ch_visitor_decref (self);
}
static void
conn_prepared_cb (GObject *conn,
GAsyncResult *result,
gpointer user_data)
{
FilterCallbackData *data = user_data;
GError *myerr = NULL;
TpCapabilities *caps;
if (!tp_proxy_prepare_finish (conn, result, &myerr)) {
data->callback (FALSE, data->user_data);
g_slice_free (FilterCallbackData, data);
return;
}
caps = tp_connection_get_capabilities (TP_CONNECTION (conn));
data->callback (tp_capabilities_supports_text_chatrooms (caps),
data->user_data);
g_slice_free (FilterCallbackData, data);
}
static void
unblock_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
EmpathyContactBlockingDialog *self = user_data;
GError *error = NULL;
if (!tp_connection_unblock_contacts_finish (TP_CONNECTION (source), result,
&error))
{
DEBUG ("Error unblocking contacts: %s", error->message);
contact_blocking_dialog_set_error (
EMPATHY_CONTACT_BLOCKING_DIALOG (self), error);
g_error_free (error);
return;
}
DEBUG ("Contacts unblocked");
}
static void
_empathy_account_connection_invalidated_cb (TpProxy *self,
guint domain,
gint code,
gchar *message,
gpointer user_data)
{
EmpathyAccount *account = EMPATHY_ACCOUNT (user_data);
EmpathyAccountPriv *priv = GET_PRIV (account);
if (priv->connection == NULL)
return;
DEBUG ("(%s) Connection invalidated",
empathy_account_get_unique_name (account));
g_assert (priv->connection == TP_CONNECTION (self));
empathy_account_free_connection (account);
g_object_notify (G_OBJECT (account), "connection");
}
/**
* 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)));
}
static void
mex_telepathy_channel_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
MexTelepathyChannel *self = MEX_TELEPATHY_CHANNEL (object);
MexTelepathyChannelPrivate *priv = self->priv;
switch (property_id)
{
case PROP_CHANNEL:
priv->channel = TP_CHANNEL (g_value_get_object (value));
mex_telepathy_channel_initialize_channel(self);
break;
case PROP_CONNECTION:
priv->connection = TP_CONNECTION (g_value_get_object (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
static void
chat_conversations_list_connection_prepare (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
ChatConversationsList *self = CHAT_CONVERSATIONS_LIST (user_data);
ChatConversationsListPrivate *priv = self->priv;
GError *error;
GList *contacts = NULL;
GPtrArray *contact_list = NULL;
TpAccount *account;
TpConnection *conn = TP_CONNECTION (source_object);
TpContactListState state;
guint i;
error = NULL;
if (!tp_proxy_prepare_finish (source_object, res, &error))
{
g_warning ("Unable to prepare the connection: %s", error->message);
g_error_free (error);
goto out;
}
state = tp_connection_get_contact_list_state (conn);
if (state != TP_CONTACT_LIST_STATE_SUCCESS)
{
g_warning ("Value of connection:contact-list-state %p was %d", conn, state);
goto out;
}
account = tp_connection_get_account (conn);
contact_list = tp_connection_dup_contact_list (conn);
for (i = 0; i < contact_list->len; i++)
{
ChatConversationsListGetFilteredEventsData *data;
TpContact *contact;
TplEntity *entity;
contact = TP_CONTACT (g_ptr_array_index (contact_list, i));
entity = tpl_entity_new_from_tp_contact (contact, TPL_ENTITY_CONTACT);
if (tpl_log_manager_exists (priv->lm, account, entity, TPL_EVENT_MASK_TEXT))
{
g_message ("%s", tp_contact_get_alias (contact));
contacts = g_list_prepend (contacts, g_object_ref (contact));
data = chat_conversations_list_get_filtered_events_data_new (self, contact);
tpl_log_manager_get_filtered_events_async (priv->lm,
account,
entity,
TPL_EVENT_MASK_TEXT,
1,
NULL,
NULL,
chat_conversations_list_get_filtered_events,
data);
}
g_object_unref (entity);
}
g_hash_table_insert (priv->accounts, g_object_ref (account), contacts);
out:
if (contact_list != NULL)
g_ptr_array_unref (contact_list);
g_object_unref (self);
}
