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); }