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 *chooser = user_data; EmpathyAccountChooserPriv *priv = GET_PRIV (chooser); GError *error = NULL; if (!tp_account_manager_prepare_finish (manager, result, &error)) { DEBUG ("Failed to prepare account manager: %s", error->message); g_error_free (error); return; } accounts = tp_account_manager_get_valid_accounts (manager); for (l = accounts; l != NULL; l = l->next) { TpAccount *account = l->data; account_chooser_account_add_foreach (account, chooser); tp_g_signal_connect_object (account, "status-changed", G_CALLBACK (account_chooser_status_changed_cb), chooser, 0); } g_list_free (accounts); priv->ready = TRUE; g_signal_emit (chooser, signals[READY], 0); }
static void contact_blocking_dialog_am_prepared (GObject *am, GAsyncResult *result, gpointer user_data) { EmpathyContactBlockingDialog *self = user_data; GList *accounts, *ptr; GError *error = NULL; if (!tp_proxy_prepare_finish (am, result, &error)) { g_critical ("Could not prepare Account Manager: %s", error->message); g_error_free (error); return; } accounts = tp_account_manager_get_valid_accounts (TP_ACCOUNT_MANAGER (am)); for (ptr = accounts; ptr != NULL; ptr = ptr->next) { TpAccount *account = ptr->data; tp_g_signal_connect_object (account, "status-changed", G_CALLBACK (contact_blocking_dialog_connection_status_changed), self, 0); contact_blocking_dialog_refilter_account_chooser (self); } g_list_free (accounts); }
static void am_ready_cb (GObject *source_object, GAsyncResult *result, gpointer userdata) { TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object); AnerleyFeed *feed; ClutterActor *stage; ClutterActor *scroll_view; ClutterActor *icon_view; ClutterModel *model; GError *error = NULL; if (!tp_account_manager_prepare_finish (account_manager, result, &error)) { g_warning ("Failed to make account manager ready: %s", error->message); g_error_free (error); return; } feed = ANERLEY_FEED (anerley_aggregate_tp_feed_new ()); model = CLUTTER_MODEL (anerley_feed_model_new (feed)); stage = clutter_stage_get_default (); icon_view = anerley_tile_view_new (ANERLEY_FEED_MODEL (model)); scroll_view = mx_scroll_view_new (); clutter_container_add_actor (CLUTTER_CONTAINER (stage), CLUTTER_ACTOR (scroll_view)); clutter_container_add_actor (CLUTTER_CONTAINER (scroll_view), CLUTTER_ACTOR (icon_view)); clutter_actor_set_size (CLUTTER_ACTOR (scroll_view), 640, 480); clutter_actor_show_all (stage); }
static void account_manager_prepared_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object); EmpathyLogWindow *window = user_data; guint account_num; GList *accounts; GError *error = NULL; if (log_window == NULL) return; if (!tp_account_manager_prepare_finish (account_manager, result, &error)) { DEBUG ("Failed to prepare account manager: %s", error->message); g_error_free (error); return; } accounts = tp_account_manager_get_valid_accounts (account_manager); account_num = g_list_length (accounts); g_list_free (accounts); if (account_num > 1) { gtk_widget_show (window->vbox_chats); gtk_widget_show (window->account_chooser_chats); } else { gtk_widget_hide (window->vbox_chats); gtk_widget_hide (window->account_chooser_chats); } }
static void import_widget_create_account_cb (GObject *source, GAsyncResult *result, gpointer user_data) { TpAccountManager *account_manager; TpAccount *account; GError *error = NULL; EmpathyImportWidget *self = user_data; account = tp_account_manager_create_account_finish ( TP_ACCOUNT_MANAGER (source), result, &error); if (account == NULL) { DEBUG ("Failed to create account: %s", error ? error->message : "No error given"); g_clear_error (&error); return; } DEBUG ("account created\n"); if (tp_account_is_enabled (account)) { account_manager = tp_account_manager_dup (); tpaw_connect_new_account (account, account_manager); g_object_unref (account_manager); } g_object_unref (self); }
static void account_manager_prepared_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { GList *list, *l; TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object); EmpathyStatusIcon *icon = user_data; GError *error = NULL; if (!tp_account_manager_prepare_finish (account_manager, result, &error)) { DEBUG ("Failed to prepare account manager: %s", error->message); g_error_free (error); return; } list = tp_account_manager_get_valid_accounts (account_manager); for (l = list; l != NULL; l = l->next) { tp_g_signal_connect_object (l->data, "status-changed", G_CALLBACK (status_icon_status_changed_cb), icon, 0); } g_list_free (list); status_icon_presence_changed_cb (icon); }
static void account_manager_prepared_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object); EmpathyImportWidget *self = user_data; GtkTreeModel *model; GtkTreeIter iter; GList *l; EmpathyImportWidgetPriv *priv = GET_PRIV (self); 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; } 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_get_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 (accounts); gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter, COL_IMPORT, import, COL_PROTOCOL, data->protocol, COL_NAME, g_value_get_string (value), COL_SOURCE, data->source, COL_ACCOUNT_DATA, data, -1); } }
static void account_manager_ready_for_accounts_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object); const gchar *account_id = (const gchar*) user_data; GError *error = NULL; if (!tp_account_manager_prepare_finish (manager, result, &error)) { DEBUG ("Failed to prepare account manager: %s", error->message); g_clear_error (&error); return; } if (account_id != NULL) { gchar *account_path; TpAccount *account = NULL; TpDBusDaemon *bus; /* create and prep the corresponding TpAccount so it's fully ready by the * time we try to select it in the accounts dialog */ account_path = g_strdup_printf ("%s%s", TP_ACCOUNT_OBJECT_PATH_BASE, account_id); bus = tp_dbus_daemon_dup (NULL); if ((account = tp_account_new (bus, account_path, &error))) { tp_account_prepare_async (account, NULL, account_prepare_cb, manager); return; } else { DEBUG ("Failed to find account with path %s: %s", account_path, error->message); g_clear_error (&error); } g_object_unref (bus); g_free (account_path); } else { if (empathy_import_mc4_has_imported ()) { maybe_show_accounts_ui (manager); } else { EmpathyConnectionManagers *cm_mgr = empathy_connection_managers_dup_singleton (); empathy_connection_managers_prepare_async ( cm_mgr, cm_manager_prepared_cb, manager); } } }
static void cm_manager_prepared_cb (GObject *source, GAsyncResult *result, gpointer user_data) { if (!empathy_connection_managers_prepare_finish ( EMPATHY_CONNECTION_MANAGERS (source), result, NULL)) { g_warning ("Failed to prepare connection managers singleton"); gtk_main_quit (); return; } empathy_accounts_import (TP_ACCOUNT_MANAGER (user_data), EMPATHY_CONNECTION_MANAGERS (source)); maybe_show_accounts_ui (TP_ACCOUNT_MANAGER (user_data)); }
static void account_manager_ready_for_accounts_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object); GError *error = NULL; GApplication *app = G_APPLICATION (user_data); if (!tp_proxy_prepare_finish (manager, result, &error)) { DEBUG ("Failed to prepare account manager: %s", error->message); g_clear_error (&error); goto out; } if (selected_account_name != NULL) { gchar *account_path; TpAccount *account; /* create and prep the corresponding TpAccount so it's fully ready by the * time we try to select it in the accounts dialog */ if (g_str_has_prefix (selected_account_name, TP_ACCOUNT_OBJECT_PATH_BASE)) account_path = g_strdup (selected_account_name); else account_path = g_strdup_printf ("%s%s", TP_ACCOUNT_OBJECT_PATH_BASE, selected_account_name); account = find_account (manager, account_path); if (account != NULL) { empathy_accounts_show_accounts_ui (manager, account, app); goto out; } else { DEBUG ("Failed to find account with path %s", account_path); g_clear_error (&error); maybe_show_accounts_ui (manager, app); } g_free (account_path); } else { maybe_show_accounts_ui (manager, app); } out: g_application_release (app); }
static void account_manager_ready_for_accounts_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object); GError *error = NULL; if (!tp_proxy_prepare_finish (manager, result, &error)) { DEBUG ("Failed to prepare account manager: %s", error->message); g_clear_error (&error); return; } account_manager_prepared = TRUE; if (selected_account_name != NULL) { gchar *account_path; TpAccount *account = NULL; TpDBusDaemon *bus; /* create and prep the corresponding TpAccount so it's fully ready by the * time we try to select it in the accounts dialog */ if (g_str_has_prefix (selected_account_name, TP_ACCOUNT_OBJECT_PATH_BASE)) account_path = g_strdup (selected_account_name); else account_path = g_strdup_printf ("%s%s", TP_ACCOUNT_OBJECT_PATH_BASE, selected_account_name); bus = tp_dbus_daemon_dup (NULL); if ((account = tp_account_new (bus, account_path, &error))) { tp_proxy_prepare_async (account, NULL, account_prepare_cb, manager); g_object_unref (bus); return; } else { DEBUG ("Failed to find account with path %s: %s", account_path, error->message); g_clear_error (&error); maybe_show_accounts_ui (manager); } g_object_unref (bus); g_free (account_path); } else { maybe_show_accounts_ui (manager); } }
static void account_manager_chatroom_ready_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object); EmpathyChatroomManager *chatroom_manager = user_data; GList *accounts, *l; GError *error = NULL; if (!tp_account_manager_prepare_finish (account_manager, result, &error)) { DEBUG ("Failed to prepare account manager: %s", error->message); g_error_free (error); return; } accounts = tp_account_manager_get_valid_accounts (account_manager); for (l = accounts; l != NULL; l = g_list_next (l)) { TpAccount *account = TP_ACCOUNT (l->data); TpConnection *conn; GList *chatrooms, *p; conn = tp_account_get_connection (account); chatrooms = empathy_chatroom_manager_get_chatrooms ( chatroom_manager, account); for (p = chatrooms; p != NULL; p = p->next) { EmpathyChatroom *room = EMPATHY_CHATROOM (p->data); if (!empathy_chatroom_get_auto_connect (room)) continue; if (conn == NULL) { g_signal_connect (G_OBJECT (account), "status-changed", G_CALLBACK (account_status_changed_cb), room); } else { empathy_dispatcher_join_muc (conn, empathy_chatroom_get_room (room), NULL, NULL); } } g_list_free (chatrooms); } g_list_free (accounts); }
static void migration_account_manager_prepared_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { TpAccountManager *am = TP_ACCOUNT_MANAGER (source_object); GError *error = NULL; GList *accounts, *l; GSettings *gsettings; if (!tp_proxy_prepare_finish (am, result, &error)) { DEBUG ("Failed to prepare the account manager: %s", error->message); g_error_free (error); return; } accounts = tp_account_manager_get_valid_accounts (am); for (l = accounts; l != NULL; l = l->next) { TpAccount *account = TP_ACCOUNT (l->data); gchar *dir, *cm; tp_account_parse_object_path (tp_proxy_get_object_path (account), &cm, NULL, NULL, NULL); if (tp_strdiff (cm, "butterfly")) { g_free (cm); continue; } dir = get_log_dir_for_account (account); DEBUG ("Migrating all logs from dir: %s", dir); migrate_log_files_in_dir (dir); g_free (cm); g_free (dir); } DEBUG ("Finished all migrating"); gsettings = g_settings_new (EMPATHY_PREFS_SCHEMA); g_settings_set_boolean (gsettings, EMPATHY_PREFS_BUTTERFLY_LOGS_MIGRATED, TRUE); g_object_unref (gsettings); g_list_free (accounts); }
static void account_manager_ready_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object); GError *error = NULL; EmpathyIdle *idle; EmpathyConnectivity *connectivity; gboolean autoconnect = TRUE; if (!tp_account_manager_prepare_finish (manager, result, &error)) { DEBUG ("Failed to prepare account manager: %s", error->message); g_error_free (error); return; } /* Autoconnect */ idle = empathy_idle_dup_singleton (); connectivity = empathy_connectivity_dup_singleton (); empathy_conf_get_bool (empathy_conf_get (), EMPATHY_PREFS_AUTOCONNECT, &autoconnect); if (autoconnect && !no_connect && tp_connection_presence_type_cmp_availability (empathy_idle_get_state (idle), TP_CONNECTION_PRESENCE_TYPE_OFFLINE) <= 0) /* if current state is Offline, then put it online */ empathy_idle_set_state (idle, TP_CONNECTION_PRESENCE_TYPE_AVAILABLE); if (should_create_salut_account (manager) || !empathy_import_mc4_has_imported ()) { EmpathyConnectionManagers *managers; managers = empathy_connection_managers_dup_singleton (); if (!check_connection_managers_ready (managers)) { g_signal_connect (managers, "notify::ready", G_CALLBACK (connection_managers_ready_cb), NULL); } } else if (!start_hidden) { maybe_show_account_assistant (); } g_object_unref (idle); g_object_unref (connectivity); }
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 void account_manager_prepared_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object); GError *error = NULL; if (!tp_account_manager_prepare_finish (account_manager, result, &error)) { DEBUG ("Failed to prepare account manager: %s", error->message); g_error_free (error); return; } }
static void account_manager_ready_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { EmpathyIdle *idle = user_data; TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object); EmpathyIdlePriv *priv; TpConnectionPresenceType state; gchar *status, *status_message; GList *accounts, *l; GError *error = NULL; /* In case we've been finalized before reading this callback */ if (idle_singleton == NULL) return; priv = GET_PRIV (idle); priv->ready = TRUE; if (!tp_account_manager_prepare_finish (account_manager, result, &error)) { DEBUG ("Failed to prepare account manager: %s", error->message); g_error_free (error); return; } state = tp_account_manager_get_most_available_presence (priv->manager, &status, &status_message); idle_presence_changed_cb (account_manager, state, status, status_message, idle); accounts = tp_account_manager_get_valid_accounts (priv->manager); for (l = accounts; l != NULL; l = l->next) { empathy_signal_connect_weak (l->data, "status-changed", G_CALLBACK (account_status_changed_cb), G_OBJECT (idle)); } g_list_free (accounts); g_free (status); g_free (status_message); }
static void account_prepare_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { TpAccountManager *manager = TP_ACCOUNT_MANAGER (user_data); TpAccount *account = TP_ACCOUNT (source_object); GError *error = NULL; if (!tp_proxy_prepare_finish (account, result, &error)) { DEBUG ("Failed to prepare account: %s", error->message); g_error_free (error); account = NULL; } empathy_accounts_show_accounts_ui (manager, account, G_CALLBACK (gtk_main_quit)); }
static void account_manager_ready_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { EmpathyChatroomManager *self = EMPATHY_CHATROOM_MANAGER (user_data); EmpathyChatroomManagerPriv *priv = GET_PRIV (self); TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object); GError *error = NULL; GFile *file = NULL; if (!tp_proxy_prepare_finish (manager, result, &error)) { DEBUG ("Failed to prepare account manager: %s", error->message); g_error_free (error); goto out; } chatroom_manager_get_all (self); /* Set up file monitor */ file = g_file_new_for_path (priv->file); priv->monitor = g_file_monitor (file, 0, NULL, &error); if (priv->monitor == NULL) { DEBUG ("Failed to create file monitor on %s: %s", priv->file, error->message); g_error_free (error); goto out; } g_signal_connect (priv->monitor, "changed", G_CALLBACK (file_changed_cb), self); out: tp_clear_object (&file); g_object_unref (self); }
static void account_manager_prepared_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { GList *accounts, *j; TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object); EmpathyMainWindow *window = user_data; GError *error = NULL; if (!tp_account_manager_prepare_finish (manager, result, &error)) { DEBUG ("Failed to prepare account manager: %s", error->message); g_error_free (error); return; } accounts = tp_account_manager_get_valid_accounts (window->account_manager); for (j = accounts; j != NULL; j = j->next) { TpAccount *account = TP_ACCOUNT (j->data); gulong handler_id; handler_id = g_signal_connect (account, "status-changed", G_CALLBACK (main_window_connection_changed_cb), window); g_hash_table_insert (window->status_changed_handlers, account, GUINT_TO_POINTER (handler_id)); } g_signal_connect (manager, "account-validity-changed", G_CALLBACK (main_window_account_validity_changed_cb), window); main_window_update_status (window); /* Disable the "Previous Conversations" menu entry if there is no account */ gtk_action_set_sensitive (window->view_history, g_list_length (accounts) > 0); g_list_free (accounts); }
static void account_manager_prepared_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { GList *accounts, *l; EmpathyContactManager *manager = user_data; TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object); GError *error = NULL; if (!tp_account_manager_prepare_finish (account_manager, result, &error)) { DEBUG ("Failed to prepare account manager: %s", error->message); g_error_free (error); return; } accounts = tp_account_manager_get_valid_accounts (account_manager); for (l = accounts; l != NULL; l = l->next) { TpAccount *account = l->data; TpConnection *conn = tp_account_get_connection (account); if (conn != NULL) { contact_manager_status_changed_cb (account, 0, 0, 0, NULL, NULL, manager); } tp_g_signal_connect_object (account, "status-changed", G_CALLBACK (contact_manager_status_changed_cb), manager, 0); } g_list_free (accounts); tp_g_signal_connect_object (account_manager, "account-validity-changed", G_CALLBACK (contact_manager_validity_changed_cb), manager, 0); }
static void create_salut_account_am_ready_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object); EmpathyConnectionManagers *managers = user_data; EmpathyAccountSettings *settings; TpConnectionManager *manager; const TpConnectionManagerProtocol *protocol; EBook *book; EContact *contact; gchar *nickname = NULL; gchar *first_name = NULL; gchar *last_name = NULL; gchar *email = NULL; gchar *jid = NULL; GError *error = NULL; if (!tp_account_manager_prepare_finish (account_manager, result, &error)) { DEBUG ("Failed to prepare account manager: %s", error->message); g_error_free (error); goto out; } if (!should_create_salut_account (account_manager)) goto out; manager = empathy_connection_managers_get_cm (managers, "salut"); if (manager == NULL) { DEBUG ("Salut not installed, not making a salut account"); goto out; } protocol = tp_connection_manager_get_protocol (manager, "local-xmpp"); if (protocol == NULL) { DEBUG ("Salut doesn't support local-xmpp!!"); goto out; } DEBUG ("Trying to add a salut account..."); /* Get self EContact from EDS */ if (!e_book_get_self (&contact, &book, &error)) { DEBUG ("Failed to get self econtact: %s", error ? error->message : "No error given"); g_clear_error (&error); goto out; } settings = empathy_account_settings_new ("salut", "local-xmpp", _("People nearby")); nickname = e_contact_get (contact, E_CONTACT_NICKNAME); first_name = e_contact_get (contact, E_CONTACT_GIVEN_NAME); last_name = e_contact_get (contact, E_CONTACT_FAMILY_NAME); email = e_contact_get (contact, E_CONTACT_EMAIL_1); jid = e_contact_get (contact, E_CONTACT_IM_JABBER_HOME_1); if (!tp_strdiff (nickname, "nickname")) { g_free (nickname); nickname = NULL; } DEBUG ("Salut account created:\nnickname=%s\nfirst-name=%s\n" "last-name=%s\nemail=%s\njid=%s\n", nickname, first_name, last_name, email, jid); empathy_account_settings_set_string (settings, "nickname", nickname ? nickname : ""); empathy_account_settings_set_string (settings, "first-name", first_name ? first_name : ""); empathy_account_settings_set_string (settings, "last-name", last_name ? last_name : ""); empathy_account_settings_set_string (settings, "email", email ? email : ""); empathy_account_settings_set_string (settings, "jid", jid ? jid : ""); empathy_account_settings_apply_async (settings, salut_account_created, NULL); g_free (nickname); g_free (first_name); g_free (last_name); g_free (email); g_free (jid); g_object_unref (settings); g_object_unref (contact); g_object_unref (book); out: g_object_unref (managers); }