static void
import_widget_add_accounts_to_model (EmpathyImportWidget *self)
{
TpAccountManager *manager;
GtkTreeModel *model;
GList *l;
EmpathyImportWidgetPriv *priv = GET_PRIV (self);
gint min, natural;
manager = tp_account_manager_dup ();
model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->treeview));
for (l = priv->accounts; l; l = l->next)
{
GValue *value;
EmpathyImportAccountData *data = l->data;
gboolean import;
GList *accounts;
TpConnectionManager *cm = NULL;
if (!empathy_import_protocol_is_supported (data->protocol, &cm))
continue;
data->connection_manager = g_strdup (
tp_connection_manager_get_name (cm));
value = g_hash_table_lookup (data->settings, "account");
accounts = tp_account_manager_dup_valid_accounts (manager);
/* Only set the "Import" cell to be active if there isn't already an
* account set up with the same account id. */
import = !import_widget_account_id_in_list (accounts,
g_value_get_string (value));
g_list_free_full (accounts, g_object_unref);
gtk_list_store_insert_with_values (GTK_LIST_STORE (model), NULL, -1,
COL_IMPORT, import,
COL_PROTOCOL, data->protocol,
COL_NAME, g_value_get_string (value),
COL_SOURCE, data->source,
COL_ACCOUNT_DATA, data,
-1);
}
/* Display as much rows as possible */
gtk_widget_get_preferred_height (priv->treeview, &min, &natural);
gtk_widget_set_size_request (priv->scrolledwindow, -1,
MIN (natural, MAX_TREEVIEW_HEIGHT));
g_object_unref (manager);
}
static void
manager_prepared_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
TpWeakRef *wr = user_data;
EmpathyAppPluginWidget *self = tp_weak_ref_dup_object (wr);
TpAccountManager *manager = (TpAccountManager *) source;
GList *accounts;
GError *error = NULL;
if (self == NULL)
{
tp_weak_ref_destroy (wr);
return;
}
if (!tp_proxy_prepare_finish (manager, result, &error))
{
g_debug ("Error preparing Account Manager: %s", error->message);
g_clear_error (&error);
goto out;
}
accounts = tp_account_manager_dup_valid_accounts (manager);
while (accounts != NULL)
{
TpAccount *account = accounts->data;
const GValue *value;
value = tp_account_get_storage_identifier (account);
if (G_VALUE_HOLDS_UINT (value) &&
g_value_get_uint (value) == self->priv->account->id)
{
GtkWidget *alig;
alig = gtk_alignment_new (0.5, 0, 0, 0);
self->priv->user_info = tpaw_user_info_new (account);
gtk_container_add (GTK_CONTAINER (alig), self->priv->user_info);
gtk_widget_show (self->priv->user_info);
gtk_box_pack_start (GTK_BOX (self), alig, TRUE, TRUE, 0);
gtk_widget_show (alig);
break;
}
accounts = g_list_delete_link (accounts, accounts);
}
g_list_free_full (accounts, g_object_unref);
out:
tp_weak_ref_destroy (wr);
g_object_unref (self);
}
static void
account_manager_prepared_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
GList *accounts, *l;
TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object);
EmpathyAccountChooser *self = user_data;
GError *error = NULL;
if (!tp_proxy_prepare_finish (manager, result, &error))
{
DEBUG ("Failed to prepare account manager: %s", error->message);
g_error_free (error);
return;
}
accounts = tp_account_manager_dup_valid_accounts (manager);
for (l = accounts; l != NULL; l = l->next)
{
TpAccount *account = l->data;
account_chooser_account_add_foreach (account, self);
tp_g_signal_connect_object (account, "status-changed",
G_CALLBACK (account_chooser_status_changed_cb),
self, 0);
/* We generally use the TpConnection from the account to filter it so,
* just relying on the account status is not enough. In some case we the
* status change can be notified while the TpConnection is still
* preparing. */
tp_g_signal_connect_object (account, "notify::connection",
G_CALLBACK (account_connection_notify_cb),
self, 0);
}
g_list_free_full (accounts, g_object_unref);
if (self->priv->select_when_ready != NULL)
{
select_account (self, self->priv->select_when_ready);
g_clear_object (&self->priv->select_when_ready);
}
self->priv->ready = TRUE;
g_signal_emit (self, signals[READY], 0);
}
static TpAccount *
find_tp_account (GoaObject *goa_object,
GMainLoop *loop,
GError **out_error)
{
GoaAccount *goa_account = NULL;
const gchar *id = NULL;
TpAccountManager *account_manager;
GList *tp_accounts = NULL;
GList *l = NULL;
TpAccount *tp_account = NULL;
GError *error = NULL;
goa_account = goa_object_peek_account (goa_object);
id = goa_account_get_identity (goa_account);
account_manager = tp_account_manager_dup ();
if (!prepare_tp_proxy (account_manager, NULL, loop, &error))
goto out;
tp_accounts = tp_account_manager_dup_valid_accounts (account_manager);
for (l = tp_accounts; l != NULL; l = l->next)
{
if (g_strcmp0 (tp_proxy_get_object_path (l->data), id) == 0)
{
tp_account = g_object_ref (l->data);
break;
}
}
if (tp_account == NULL)
{
g_set_error (&error,
GOA_ERROR,
GOA_ERROR_FAILED,
_("Telepathy chat account not found"));
goto out;
}
out:
if (error != NULL)
g_propagate_error (out_error, error);
g_clear_error (&error);
g_clear_object (&account_manager);
g_list_free_full (tp_accounts, g_object_unref);
return tp_account;
}
static TpAccount *
find_account (TpAccountManager *mgr,
const gchar *path)
{
GList *accounts, *l;
TpAccount *found = NULL;
accounts = tp_account_manager_dup_valid_accounts (mgr);
for (l = accounts; l != NULL; l = g_list_next (l))
{
if (!tp_strdiff (tp_proxy_get_object_path (l->data), path))
{
found = l->data;
break;
}
}
g_list_free_full (accounts, g_object_unref);
return found;
}
static void
chat_conversations_list_account_manager_prepare (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
ChatConversationsList *self = CHAT_CONVERSATIONS_LIST (user_data);
ChatConversationsListPrivate *priv = self->priv;
GError *error;
GList *accounts = NULL;
GList *l;
error = NULL;
if (!tp_proxy_prepare_finish (source_object, res, &error))
{
g_warning ("Unable to prepare the account manager: %s", error->message);
g_error_free (error);
goto out;
}
accounts = tp_account_manager_dup_valid_accounts (priv->am);
for (l = accounts; l != NULL; l = l->next)
{
TpAccount *account = TP_ACCOUNT (l->data);
TpConnection *conn;
const gchar *cm_name;
cm_name = tp_account_get_cm_name (account);
if (g_strcmp0 (cm_name, "idle") == 0)
continue;
conn = tp_account_get_connection (account);
if (conn == NULL)
continue;
tp_proxy_prepare_async (conn, NULL, chat_conversations_list_connection_prepare, g_object_ref (self));
g_hash_table_insert (priv->accounts, g_object_ref (account), NULL);
}
out:
g_list_free_full (accounts, g_object_unref);
g_object_unref (self);
}
gboolean
empathy_account_manager_get_accounts_connected (gboolean *connecting)
{
TpAccountManager *manager;
GList *accounts, *l;
gboolean out_connecting = FALSE;
gboolean out_connected = FALSE;
manager = tp_account_manager_dup ();
if (G_UNLIKELY (!tp_proxy_is_prepared (manager,
TP_ACCOUNT_MANAGER_FEATURE_CORE)))
g_critical (G_STRLOC ": %s called before AccountManager ready", G_STRFUNC);
accounts = tp_account_manager_dup_valid_accounts (manager);
for (l = accounts; l != NULL; l = l->next)
{
TpConnectionStatus s = tp_account_get_connection_status (
TP_ACCOUNT (l->data), NULL);
if (s == TP_CONNECTION_STATUS_CONNECTING)
out_connecting = TRUE;
else if (s == TP_CONNECTION_STATUS_CONNECTED)
out_connected = TRUE;
if (out_connecting && out_connected)
break;
}
g_list_free_full (accounts, g_object_unref);
g_object_unref (manager);
if (connecting != NULL)
*connecting = out_connecting;
return out_connected;
}
gboolean
empathy_local_xmpp_assistant_widget_should_create_account (
TpAccountManager *manager)
{
gboolean salut_created = FALSE;
GList *accounts, *l;
accounts = tp_account_manager_dup_valid_accounts (manager);
for (l = accounts; l != NULL; l = g_list_next (l))
{
TpAccount *account = TP_ACCOUNT (l->data);
if (!tp_strdiff (tp_account_get_protocol_name (account), "local-xmpp"))
{
salut_created = TRUE;
break;
}
}
g_list_free_full (accounts, g_object_unref);
return !salut_created;
}
