Merge branch 'accountz'

61 files changed, 1308 insertions, 3462 deletions

diff --git a/configure.ac b/configure.ac
index 67b2d2e4f..b68ebb696 100644
--- a/configure.ac
+++ b/configure.ac
@@ -33,7 +33,7 @@ GLIB_REQUIRED=2.22.0
 GTK_REQUIRED=2.16.0
 GCONF_REQUIRED=1.2.0
 LIBPANELAPPLET_REQUIRED=2.10.0
-TELEPATHY_GLIB_REQUIRED=0.7.35
+TELEPATHY_GLIB_REQUIRED=0.9.0
 ENCHANT_REQUIRED=1.2.0
 ISO_CODES_REQUIRED=0.35
 LIBNOTIFY_REQUIRED=0.4.4
diff --git a/libempathy-gtk/empathy-account-chooser.c b/libempathy-gtk/empathy-account-chooser.c
index a91b0eb29..8256707c0 100644
--- a/libempathy-gtk/empathy-account-chooser.c
+++ b/libempathy-gtk/empathy-account-chooser.c
@@ -29,12 +29,16 @@
 #include <glib/gi18n-lib.h>
 #include <gtk/gtk.h>
 
-#include <libempathy/empathy-account-manager.h>
+#include <telepathy-glib/account-manager.h>
+
 #include <libempathy/empathy-utils.h>
 
 #include "empathy-ui-utils.h"
 #include "empathy-account-chooser.h"
 
+#define DEBUG_FLAG EMPATHY_DEBUG_OTHER
+#include <libempathy/empathy-debug.h>
+
 /**
  * SECTION:empathy-account-chooser
  * @title:EmpathyAccountChooser
@@ -54,7 +58,7 @@
 
 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyAccountChooser)
 typedef struct {
-	EmpathyAccountManager          *manager;
+	TpAccountManager               *manager;
 	gboolean                        set_active_item;
 	gboolean			account_manually_set;
 	gboolean                        has_all_option;
@@ -64,7 +68,7 @@ typedef struct {
 
 typedef struct {
 	EmpathyAccountChooser *chooser;
-	EmpathyAccount        *account;
+	TpAccount             *account;
 	gboolean               set;
 } SetAccountData;
 
@@ -86,24 +90,26 @@ static void     account_chooser_set_property           (GObject
 							const GValue             *value,
 							GParamSpec               *pspec);
 static void     account_chooser_setup                  (EmpathyAccountChooser    *chooser);
-static void     account_chooser_account_created_cb     (EmpathyAccountManager    *manager,
-							EmpathyAccount           *account,
+static void     account_chooser_account_validity_changed_cb (TpAccountManager    *manager,
+							TpAccount                *account,
+							gboolean                  valid,
 							EmpathyAccountChooser    *chooser);
-static void     account_chooser_account_add_foreach    (EmpathyAccount                *account,
+static void     account_chooser_account_add_foreach    (TpAccount                *account,
 							EmpathyAccountChooser    *chooser);
-static void     account_chooser_account_deleted_cb     (EmpathyAccountManager    *manager,
-							EmpathyAccount           *account,
+static void     account_chooser_account_removed_cb     (TpAccountManager         *manager,
+							TpAccount                *account,
 							EmpathyAccountChooser    *chooser);
-static void     account_chooser_account_remove_foreach (EmpathyAccount                *account,
+static void     account_chooser_account_remove_foreach (TpAccount                *account,
 							EmpathyAccountChooser    *chooser);
 static void     account_chooser_update_iter            (EmpathyAccountChooser    *chooser,
 							GtkTreeIter              *iter);
-static void     account_chooser_connection_changed_cb  (EmpathyAccountManager    *manager,
-							EmpathyAccount                *account,
-							TpConnectionStatusReason  reason,
-							TpConnectionStatus        new_status,
-							TpConnectionStatus        old_status,
-							EmpathyAccountChooser    *chooser);
+static void     account_chooser_status_changed_cb      (TpAccount  *account,
+							guint       old_status,
+							guint       new_status,
+							guint       reason,
+							gchar      *dbus_error_name,
+							GHashTable *details,
+							gpointer    user_data);
 static gboolean account_chooser_separator_func         (GtkTreeModel             *model,
 							GtkTreeIter              *iter,
 							EmpathyAccountChooser    *chooser);
@@ -156,16 +162,13 @@ empathy_account_chooser_init (EmpathyAccountChooser *chooser)
 	priv->filter = NULL;
 	priv->filter_data = NULL;
 
-	priv->manager = empathy_account_manager_dup_singleton ();
+	priv->manager = tp_account_manager_dup ();
 
-	g_signal_connect (priv->manager, "account-created",
-			  G_CALLBACK (account_chooser_account_created_cb),
-			  chooser);
-	g_signal_connect (priv->manager, "account-deleted",
-			  G_CALLBACK (account_chooser_account_deleted_cb),
+	g_signal_connect (priv->manager, "account-validity-changed",
+			  G_CALLBACK (account_chooser_account_validity_changed_cb),
 			  chooser);
-	g_signal_connect (priv->manager, "account-connection-changed",
-			  G_CALLBACK (account_chooser_connection_changed_cb),
+	g_signal_connect (priv->manager, "account-removed",
+			  G_CALLBACK (account_chooser_account_removed_cb),
 			  chooser);
 
 	account_chooser_setup (EMPATHY_ACCOUNT_CHOOSER (chooser));
@@ -177,13 +180,10 @@ account_chooser_finalize (GObject *object)
 	EmpathyAccountChooserPriv *priv = GET_PRIV (object);
 
 	g_signal_handlers_disconnect_by_func (priv->manager,
-					      account_chooser_connection_changed_cb,
+					      account_chooser_account_validity_changed_cb,
 					      object);
 	g_signal_handlers_disconnect_by_func (priv->manager,
-					      account_chooser_account_created_cb,
-					      object);
-	g_signal_handlers_disconnect_by_func (priv->manager,
-					      account_chooser_account_deleted_cb,
+					      account_chooser_account_removed_cb,
 					      object);
 	g_object_unref (priv->manager);
 
@@ -253,16 +253,16 @@ empathy_account_chooser_new (void)
  * @chooser: an #EmpathyAccountChooser
  *
  * Returns the account which is currently selected in the chooser or %NULL
- * if there is no account selected. The #EmpathyAccount returned should be
+ * if there is no account selected. The #TpAccount returned should be
  * unrefed with g_object_unref() when finished with.
  *
- * Return value: a new ref to the #EmpathyAccount currently selected, or %NULL.
+ * Return value: a new ref to the #TpAccount currently selected, or %NULL.
  */
-EmpathyAccount *
+TpAccount *
 empathy_account_chooser_dup_account (EmpathyAccountChooser *chooser)
 {
 	EmpathyAccountChooserPriv *priv;
-	EmpathyAccount           *account;
+	TpAccount                 *account;
 	GtkTreeModel             *model;
 	GtkTreeIter               iter;
 
@@ -295,7 +295,7 @@ TpConnection *
 empathy_account_chooser_get_connection (EmpathyAccountChooser *chooser)
 {
 	EmpathyAccountChooserPriv *priv;
-	EmpathyAccount            *account;
+	TpAccount                 *account;
 	TpConnection              *connection;
 
 	g_return_val_if_fail (EMPATHY_IS_ACCOUNT_CHOOSER (chooser), NULL);
@@ -303,7 +303,7 @@ empathy_account_chooser_get_connection (EmpathyAccountChooser *chooser)
 	priv = GET_PRIV (chooser);
 
 	account = empathy_account_chooser_dup_account (chooser);
-	connection = empathy_account_get_connection (account);
+	connection = tp_account_get_connection (account);
 	g_object_unref (account);
 
 	return connection;
@@ -312,7 +312,7 @@ empathy_account_chooser_get_connection (EmpathyAccountChooser *chooser)
 /**
  * empathy_account_chooser_set_account:
  * @chooser: an #EmpathyAccountChooser
- * @account: an #EmpathyAccount
+ * @account: a #TpAccount
  *
  * Sets the currently selected account to @account, if it exists in the list.
  *
@@ -320,7 +320,7 @@ empathy_account_chooser_get_connection (EmpathyAccountChooser *chooser)
  */
 gboolean
 empathy_account_chooser_set_account (EmpathyAccountChooser *chooser,
-				     EmpathyAccount *account)
+				     TpAccount             *account)
 {
 	EmpathyAccountChooserPriv *priv;
 	GtkComboBox    *combobox;
@@ -443,10 +443,40 @@ empathy_account_chooser_set_has_all_option (EmpathyAccountChooser *chooser,
 }
 
 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;
+	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);
+
+		empathy_signal_connect_weak (account, "status-changed",
+					     G_CALLBACK (account_chooser_status_changed_cb),
+					     G_OBJECT (chooser));
+	}
+
+	g_list_free (accounts);
+}
+
+static void
 account_chooser_setup (EmpathyAccountChooser *chooser)
 {
 	EmpathyAccountChooserPriv *priv;
-	GList                    *accounts;
 	GtkListStore             *store;
 	GtkCellRenderer          *renderer;
 	GtkComboBox              *combobox;
@@ -462,7 +492,7 @@ account_chooser_setup (EmpathyAccountChooser *chooser)
 				    G_TYPE_STRING,    /* Image */
 				    G_TYPE_STRING,    /* Name */
 				    G_TYPE_BOOLEAN,   /* Enabled */
-				    EMPATHY_TYPE_ACCOUNT);
+				    TP_TYPE_ACCOUNT);
 
 	gtk_combo_box_set_model (combobox, GTK_TREE_MODEL (store));
 
@@ -482,25 +512,27 @@ account_chooser_setup (EmpathyAccountChooser *chooser)
 					NULL);
 
 	/* Populate accounts */
-	accounts = empathy_account_manager_dup_accounts (priv->manager);
-	g_list_foreach (accounts,
-			(GFunc) account_chooser_account_add_foreach,
-			chooser);
+	tp_account_manager_prepare_async (priv->manager, NULL,
+					  account_manager_prepared_cb, chooser);
 
-	g_list_free (accounts);
 	g_object_unref (store);
 }
 
 static void
-account_chooser_account_created_cb (EmpathyAccountManager *manager,
-				    EmpathyAccount        *account,
-				    EmpathyAccountChooser *chooser)
+account_chooser_account_validity_changed_cb (TpAccountManager      *manager,
+					     TpAccount             *account,
+					     gboolean               valid,
+					     EmpathyAccountChooser *chooser)
 {
-	account_chooser_account_add_foreach (account, chooser);
+	if (valid) {
+		account_chooser_account_add_foreach (account, chooser);
+	} else {
+		account_chooser_account_remove_foreach (account, chooser);
+	}
 }
 
 static void
-account_chooser_account_add_foreach (EmpathyAccount        *account,
+account_chooser_account_add_foreach (TpAccount             *account,
 				     EmpathyAccountChooser *chooser)
 {
 	GtkListStore *store;
@@ -516,20 +548,18 @@ account_chooser_account_add_foreach (EmpathyAccount        *account,
 					   COL_ACCOUNT_POINTER, account,
 					   -1);
 	account_chooser_update_iter (chooser, &iter);
-	/* We got a reffed account and it was reffed by the liststore as well */
-	g_object_unref (account);
 }
 
 static void
-account_chooser_account_deleted_cb (EmpathyAccountManager *manager,
-				    EmpathyAccount        *account,
+account_chooser_account_removed_cb (TpAccountManager      *manager,
+				    TpAccount             *account,
 				    EmpathyAccountChooser *chooser)
 {
 	account_chooser_account_remove_foreach (account, chooser);
 }
 
 typedef struct {
-	EmpathyAccount   *account;
+	TpAccount   *account;
 	GtkTreeIter *iter;
 	gboolean     found;
 } FindAccountData;
@@ -541,7 +571,7 @@ account_chooser_find_account_foreach (GtkTreeModel *model,
 				      gpointer      user_data)
 {
 	FindAccountData *data = user_data;
-	EmpathyAccount  *account;
+	TpAccount  *account;
 
 	gtk_tree_model_get (model, iter, COL_ACCOUNT_POINTER, &account, -1);
 
@@ -560,7 +590,7 @@ account_chooser_find_account_foreach (GtkTreeModel *model,
 
 static gboolean
 account_chooser_find_account (EmpathyAccountChooser *chooser,
-			      EmpathyAccount        *account,
+			      TpAccount             *account,
 			      GtkTreeIter           *iter)
 {
 	GtkListStore    *store;
@@ -580,7 +610,7 @@ account_chooser_find_account (EmpathyAccountChooser *chooser,
 }
 
 static void
-account_chooser_account_remove_foreach (EmpathyAccount        *account,
+account_chooser_account_remove_foreach (TpAccount             *account,
 					EmpathyAccountChooser *chooser)
 {
 	GtkListStore *store;
@@ -602,7 +632,7 @@ account_chooser_update_iter (EmpathyAccountChooser *chooser,
 	EmpathyAccountChooserPriv *priv;
 	GtkListStore              *store;
 	GtkComboBox               *combobox;
-	EmpathyAccount            *account;
+	TpAccount                 *account;
 	const gchar               *icon_name;
 	gboolean                   is_enabled = TRUE;
 
@@ -615,14 +645,14 @@ account_chooser_update_iter (EmpathyAccountChooser *chooser,
 			    COL_ACCOUNT_POINTER, &account,
 			    -1);
 
-	icon_name = empathy_account_get_icon_name (account);
+	icon_name = tp_account_get_icon_name (account);
 	if (priv->filter) {
 		is_enabled = priv->filter (account, priv->filter_data);
 	}
 
 	gtk_list_store_set (store, iter,
 			    COL_ACCOUNT_IMAGE, icon_name,
-			    COL_ACCOUNT_TEXT, empathy_account_get_display_name (account),
+			    COL_ACCOUNT_TEXT, tp_account_get_display_name (account),
 			    COL_ACCOUNT_ENABLED, is_enabled,
 			    -1);
 
@@ -637,13 +667,15 @@ account_chooser_update_iter (EmpathyAccountChooser *chooser,
 }
 
 static void
-account_chooser_connection_changed_cb (EmpathyAccountManager   *manager,
-				       EmpathyAccount          *account,
-				       TpConnectionStatusReason reason,
-				       TpConnectionStatus       new_status,
-				       TpConnectionStatus       old_status,
-				       EmpathyAccountChooser   *chooser)
+account_chooser_status_changed_cb (TpAccount  *account,
+				   guint       old_status,
+				   guint       new_status,
+				   guint       reason,
+				   gchar      *dbus_error_name,
+				   GHashTable *details,
+				   gpointer    user_data)
 {
+	EmpathyAccountChooser *chooser = user_data;
 	GtkTreeIter iter;
 
 	if (account_chooser_find_account (chooser, account, &iter)) {
@@ -679,7 +711,7 @@ account_chooser_set_account_foreach (GtkTreeModel   *model,
 				     GtkTreeIter    *iter,
 				     SetAccountData *data)
 {
-	EmpathyAccount *account;
+	TpAccount *account;
 	gboolean   equal;
 
 	gtk_tree_model_get (model, iter, COL_ACCOUNT_POINTER, &account, -1);
@@ -750,7 +782,7 @@ empathy_account_chooser_set_filter (EmpathyAccountChooser           *chooser,
 
 /**
  * EmpathyAccountChooserFilterFunc:
- * @account: an #EmpathyAccount
+ * @account: a #TpAccount
  * @user_data: user data, or %NULL
  *
  * A function which decides whether the account indicated by @account
@@ -761,7 +793,7 @@ empathy_account_chooser_set_filter (EmpathyAccountChooser           *chooser,
 
 /**
  * empathy_account_chooser_filter_is_connected:
- * @account: an #EmpathyAccount
+ * @account: a #TpAccount
  * @user_data: user data or %NULL
  *
  * A useful #EmpathyAccountChooserFilterFunc that one could pass into
@@ -770,13 +802,10 @@ empathy_account_chooser_set_filter (EmpathyAccountChooser           *chooser,
  * Return value: Whether @account is connected
  */
 gboolean
-empathy_account_chooser_filter_is_connected (EmpathyAccount *account,
+empathy_account_chooser_filter_is_connected (TpAccount *account,
 					     gpointer   user_data)
 {
-	TpConnectionStatus  status;
-
-	g_object_get (account, "connection-status", &status, NULL);
-
-	return status == TP_CONNECTION_STATUS_CONNECTED;
+	return (tp_account_get_connection_status (account, NULL)
+	    == TP_CONNECTION_STATUS_CONNECTED);
 }
 
diff --git a/libempathy-gtk/empathy-account-chooser.h b/libempathy-gtk/empathy-account-chooser.h
index 255b6841f..075bea81c 100644
--- a/libempathy-gtk/empathy-account-chooser.h
+++ b/libempathy-gtk/empathy-account-chooser.h
@@ -27,7 +27,7 @@
 
 #include <gtk/gtk.h>
 
-#include <libempathy/empathy-account.h>
+#include <telepathy-glib/account.h>
 
 G_BEGIN_DECLS
 
@@ -38,7 +38,7 @@ G_BEGIN_DECLS
 #define EMPATHY_IS_ACCOUNT_CHOOSER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), EMPATHY_TYPE_ACCOUNT_CHOOSER))
 #define EMPATHY_ACCOUNT_CHOOSER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), EMPATHY_TYPE_ACCOUNT_CHOOSER, EmpathyAccountChooserClass))
 
-typedef gboolean (* EmpathyAccountChooserFilterFunc) (EmpathyAccount *account,
+typedef gboolean (* EmpathyAccountChooserFilterFunc) (TpAccount *account,
 						      gpointer   user_data);
 
 
@@ -58,17 +58,17 @@ struct _EmpathyAccountChooserClass {
 
 GType          empathy_account_chooser_get_type           (void) G_GNUC_CONST;
 GtkWidget *    empathy_account_chooser_new                (void);
-EmpathyAccount *    empathy_account_chooser_dup_account        (EmpathyAccountChooser *chooser);
+TpAccount *    empathy_account_chooser_dup_account        (EmpathyAccountChooser *chooser);
 TpConnection * empathy_account_chooser_get_connection     (EmpathyAccountChooser *chooser);
 gboolean       empathy_account_chooser_set_account        (EmpathyAccountChooser *chooser,
-							   EmpathyAccount        *account);
+							   TpAccount             *account);
 gboolean       empathy_account_chooser_get_has_all_option (EmpathyAccountChooser *chooser);
 void           empathy_account_chooser_set_has_all_option (EmpathyAccountChooser *chooser,
 							   gboolean               has_all_option);
 void           empathy_account_chooser_set_filter         (EmpathyAccountChooser *chooser,
 							   EmpathyAccountChooserFilterFunc filter,
 							   gpointer               user_data);
-gboolean       empathy_account_chooser_filter_is_connected (EmpathyAccount       *account,
+gboolean       empathy_account_chooser_filter_is_connected (TpAccount            *account,
 							   gpointer               user_data);
 
 G_END_DECLS
diff --git a/libempathy-gtk/empathy-account-widget.c b/libempathy-gtk/empathy-account-widget.c
index 05911144a..293b2c711 100644
--- a/libempathy-gtk/empathy-account-widget.c
+++ b/libempathy-gtk/empathy-account-widget.c
@@ -35,8 +35,8 @@
 #endif
 
 #include <libempathy/empathy-utils.h>
-#include <libempathy/empathy-account.h>
 
+#include <telepathy-glib/account.h>
 #include <telepathy-glib/connection-manager.h>
 #include <telepathy-glib/util.h>
 #include <dbus/dbus-protocol.h>
@@ -570,10 +570,10 @@ account_widget_account_enabled_cb (GObject *source_object,
     gpointer user_data)
 {
   GError *error = NULL;
-  EmpathyAccount *account = EMPATHY_ACCOUNT (source_object);
+  TpAccount *account = TP_ACCOUNT (source_object);
   EmpathyAccountWidget *widget = EMPATHY_ACCOUNT_WIDGET (user_data);
 
-  empathy_account_set_enabled_finish (account, res, &error);
+  tp_account_set_enabled_finish (account, res, &error);
 
   if (error != NULL)
     {
@@ -592,7 +592,7 @@ account_widget_applied_cb (GObject *source_object,
     gpointer user_data)
 {
   GError *error = NULL;
-  EmpathyAccount *account;
+  TpAccount *account;
   EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (source_object);
   EmpathyAccountWidget *widget = EMPATHY_ACCOUNT_WIDGET (user_data);
   EmpathyAccountWidgetPriv *priv = GET_PRIV (widget);
@@ -613,7 +613,7 @@ account_widget_applied_cb (GObject *source_object,
       if (priv->creating_account)
         {
           /* By default, when an account is created, we enable it. */
-          empathy_account_set_enabled_async (account, TRUE,
+          tp_account_set_enabled_async (account, TRUE,
               account_widget_account_enabled_cb, widget);
         }
       else if (priv->enabled_checkbox != NULL)
@@ -629,12 +629,12 @@ account_widget_applied_cb (GObject *source_object,
                 NBTK_GTK_LIGHT_SWITCH (priv->enabled_checkbox));
 #endif
 
-          if (empathy_account_is_enabled (account) && enabled_checked)
+          if (tp_account_is_enabled (account) && enabled_checked)
             {
               /* After having applied changes to a user account, we
                * automatically reconnect it. This is done so the new
                * information entered by the user is validated on the server. */
-              empathy_account_reconnect_async (account, NULL, NULL);
+              tp_account_reconnect_async (account, NULL, NULL);
             }
         }
     }
@@ -1047,13 +1047,13 @@ account_widget_destroy_cb (GtkWidget *widget,
 }
 
 static void
-empathy_account_widget_enabled_cb (EmpathyAccount *account,
+empathy_account_widget_enabled_cb (TpAccount *account,
       GParamSpec *spec,
       gpointer user_data)
 {
   EmpathyAccountWidget *widget = EMPATHY_ACCOUNT_WIDGET (user_data);
   EmpathyAccountWidgetPriv *priv = GET_PRIV (widget);
-  gboolean enabled = empathy_account_is_enabled (account);
+  gboolean enabled = tp_account_is_enabled (account);
 
   if (priv->enabled_checkbox != NULL)
     {
@@ -1079,7 +1079,7 @@ account_widget_switch_flipped_cb (NbtkGtkLightSwitch *sw,
 #endif /* HAVE_MOBLIN */
 {
   EmpathyAccountWidgetPriv *priv = GET_PRIV (user_data);
-  EmpathyAccount *account;
+  TpAccount *account;
 #ifndef HAVE_MOBLIN
   gboolean state;
 
@@ -1089,7 +1089,7 @@ account_widget_switch_flipped_cb (NbtkGtkLightSwitch *sw,
   account = empathy_account_settings_get_account (priv->settings);
 
   /* Enable the account according to the value of the "Enabled" checkbox */
-  empathy_account_set_enabled_async (account, state, NULL, NULL);
+  tp_account_set_enabled_async (account, state, NULL, NULL);
 }
 
 static void
@@ -1153,7 +1153,7 @@ do_constructed (GObject *obj)
 {
   EmpathyAccountWidget *self = EMPATHY_ACCOUNT_WIDGET (obj);
   EmpathyAccountWidgetPriv *priv = GET_PRIV (self);
-  EmpathyAccount *account;
+  TpAccount *account;
   const gchar *protocol, *cm_name;
   guint i = 0;
   struct {
@@ -1295,7 +1295,7 @@ do_constructed (GObject *obj)
       guint nb_rows, nb_columns;
       gboolean is_enabled;
 
-      is_enabled = empathy_account_is_enabled (account);
+      is_enabled = tp_account_is_enabled (account);
 
 #ifndef HAVE_MOBLIN
       priv->enabled_checkbox =
@@ -1373,7 +1373,7 @@ do_dispose (GObject *obj)
 
   if (priv->settings != NULL)
     {
-      EmpathyAccount *account;
+      TpAccount *account;
       account = empathy_account_settings_get_account (priv->settings);
 
       if (account != NULL)
diff --git a/libempathy-gtk/empathy-chat-text-view.c b/libempathy-gtk/empathy-chat-text-view.c
index 5822a429d..de777f2fb 100644
--- a/libempathy-gtk/empathy-chat-text-view.c
+++ b/libempathy-gtk/empathy-chat-text-view.c
@@ -36,7 +36,6 @@
 #include <telepathy-glib/util.h>
 
 #include <libempathy/empathy-utils.h>
-#include <libempathy/empathy-account.h>
 
 #include "empathy-chat-text-view.h"
 #include "empathy-chat.h"
diff --git a/libempathy-gtk/empathy-chat.c b/libempathy-gtk/empathy-chat.c
index 3931115be..7984b8a3a 100644
--- a/libempathy-gtk/empathy-chat.c
+++ b/libempathy-gtk/empathy-chat.c
@@ -34,9 +34,9 @@
 #include <glib/gi18n-lib.h>
 #include <gtk/gtk.h>
 
+#include <telepathy-glib/account-manager.h>
 #include <telepathy-glib/util.h>
 
-#include <libempathy/empathy-account-manager.h>
 #include <libempathy/empathy-log-manager.h>
 #include <libempathy/empathy-contact-list.h>
 #include <libempathy/empathy-utils.h>
@@ -64,7 +64,7 @@
 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyChat)
 typedef struct {
 	EmpathyTpChat     *tp_chat;
-	EmpathyAccount    *account;
+	TpAccount         *account;
 	gchar             *id;
 	gchar             *name;
 	gchar             *subject;
@@ -72,7 +72,7 @@ typedef struct {
 	gboolean           show_contacts;
 
 	EmpathyLogManager *log_manager;
-	EmpathyAccountManager *account_manager;
+	TpAccountManager  *account_manager;
 	GSList            *sent_messages;
 	gint               sent_messages_index;
 	GList             *compositors;
@@ -196,15 +196,19 @@ chat_connect_channel_reconnected (EmpathyDispatchOperation *dispatch,
 }
 
 static void
-chat_new_connection_cb (EmpathyAccountManager *manager,
-			TpConnection *connection,
+chat_new_connection_cb (TpAccount   *account,
+			guint        old_status,
+			guint        new_status,
+			guint        reason,
+			gchar       *dbus_error_name,
+			GHashTable  *details,
 			EmpathyChat *chat)
 {
 	EmpathyChatPriv *priv = GET_PRIV (chat);
-	EmpathyAccount *account;
+	TpConnection *connection;
+
+	connection = tp_account_get_connection (account);
 
-	account = empathy_account_manager_get_account_for_connection (manager,
-		connection);
 	if (!priv->tp_chat && account == priv->account &&
 	    priv->handle_type != TP_HANDLE_TYPE_NONE &&
 	    !EMP_STR_EMPTY (priv->id)) {
@@ -1540,9 +1544,6 @@ chat_finalize (GObject *object)
 
 	chat_composing_remove_timeout (chat);
 
-	g_signal_handlers_disconnect_by_func (priv->account_manager,
-					      chat_new_connection_cb, object);
-
 	g_object_unref (priv->account_manager);
 	g_object_unref (priv->log_manager);
 
@@ -1621,7 +1622,7 @@ empathy_chat_class_init (EmpathyChatClass *klass)
 					 g_param_spec_object ("account",
 							      "Account of the chat",
 							      "The account of the chat",
-							      EMPATHY_TYPE_ACCOUNT,
+							      TP_TYPE_ACCOUNT,
 							      G_PARAM_READABLE |
 							      G_PARAM_STATIC_STRINGS));
 	g_object_class_install_property (object_class,
@@ -1699,6 +1700,34 @@ chat_block_events_timeout_cb (gpointer data)
 }
 
 static void
+account_manager_prepared_cb (GObject *source_object,
+			     GAsyncResult *result,
+			     gpointer user_data)
+{
+	GList *accounts, *l;
+	TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object);
+	EmpathyChat *chat = user_data;
+	GError *error = NULL;
+
+	if (!tp_account_manager_prepare_finish (account_manager, result, &error)) {
+		DEBUG ("Failed to prepare the 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;
+		empathy_signal_connect_weak (account, "status-changed",
+					     G_CALLBACK (chat_new_connection_cb),
+					     G_OBJECT (chat));
+	}
+
+	g_list_free (accounts);
+}
+
+static void
 empathy_chat_init (EmpathyChat *chat)
 {
 	EmpathyChatPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (chat,
@@ -1709,12 +1738,10 @@ empathy_chat_init (EmpathyChat *chat)
 	priv->contacts_width = -1;
 	priv->sent_messages = NULL;
 	priv->sent_messages_index = -1;
-	priv->account_manager = empathy_account_manager_dup_singleton ();
+	priv->account_manager = tp_account_manager_dup ();
 
-	g_signal_connect (priv->account_manager,
-			  "new-connection",
-			  G_CALLBACK (chat_new_connection_cb),
-			  chat);
+	tp_account_manager_prepare_async (priv->account_manager, NULL,
+					  account_manager_prepared_cb, chat);
 
 	empathy_conf_get_bool (empathy_conf_get (),
 			       EMPATHY_PREFS_CHAT_SHOW_CONTACTS_IN_ROOMS,
@@ -1767,10 +1794,7 @@ empathy_chat_set_tp_chat (EmpathyChat   *chat,
 
 	priv->tp_chat = g_object_ref (tp_chat);
 	connection = empathy_tp_chat_get_connection (priv->tp_chat);
-	priv->account = empathy_account_manager_get_account_for_connection (
-							     priv->account_manager,
-							     connection);
-	g_object_ref (priv->account);
+	priv->account = g_object_ref (empathy_get_account_for_connection (connection));
 
 	g_signal_connect (tp_chat, "destroy",
 			  G_CALLBACK (chat_destroy_cb),
@@ -1813,7 +1837,7 @@ empathy_chat_set_tp_chat (EmpathyChat   *chat,
 	show_pending_messages (chat);
 }
 
-EmpathyAccount *
+TpAccount *
 empathy_chat_get_account (EmpathyChat *chat)
 {
 	EmpathyChatPriv *priv = GET_PRIV (chat);
diff --git a/libempathy-gtk/empathy-chat.h b/libempathy-gtk/empathy-chat.h
index c7158759a..9123d11dd 100644
--- a/libempathy-gtk/empathy-chat.h
+++ b/libempathy-gtk/empathy-chat.h
@@ -66,7 +66,7 @@ EmpathyChat *      empathy_chat_new                  (EmpathyTpChat *tp_chat);
 EmpathyTpChat *    empathy_chat_get_tp_chat          (EmpathyChat   *chat);
 void               empathy_chat_set_tp_chat          (EmpathyChat   *chat,
 						      EmpathyTpChat *tp_chat);
-EmpathyAccount *        empathy_chat_get_account          (EmpathyChat   *chat);
+TpAccount *        empathy_chat_get_account          (EmpathyChat   *chat);
 const gchar *      empathy_chat_get_id               (EmpathyChat   *chat);
 const gchar *      empathy_chat_get_name             (EmpathyChat   *chat);
 const gchar *      empathy_chat_get_subject          (EmpathyChat   *chat);
diff --git a/libempathy-gtk/empathy-contact-dialogs.c b/libempathy-gtk/empathy-contact-dialogs.c
index 6c15dd876..b7108d8f3 100644
--- a/libempathy-gtk/empathy-contact-dialogs.c
+++ b/libempathy-gtk/empathy-contact-dialogs.c
@@ -27,8 +27,9 @@
 #include <gtk/gtk.h>
 #include <glib/gi18n-lib.h>
 
+#include <telepathy-glib/account-manager.h>
+
 #include <libempathy/empathy-contact-manager.h>
-#include <libempathy/empathy-account-manager.h>
 #include <libempathy/empathy-contact-list.h>
 #include <libempathy/empathy-utils.h>
 
@@ -327,14 +328,14 @@ empathy_contact_personal_dialog_show (GtkWindow *parent)
  */
 
 static gboolean
-can_add_contact_to_account (EmpathyAccount *account,
+can_add_contact_to_account (TpAccount *account,
 			    gpointer   user_data)
 {
 	EmpathyContactManager *contact_manager;
 	TpConnection          *connection;
 	gboolean               result;
 
-	connection = empathy_account_get_connection (account);
+	connection = tp_account_get_connection (account);
 	if (connection == NULL)
 		return FALSE;
 
diff --git a/libempathy-gtk/empathy-contact-list-view.c b/libempathy-gtk/empathy-contact-list-view.c
index a6623506b..c19ad32df 100644
--- a/libempathy-gtk/empathy-contact-list-view.c
+++ b/libempathy-gtk/empathy-contact-list-view.c
@@ -31,9 +31,9 @@
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
 
+#include <telepathy-glib/account-manager.h>
 #include <telepathy-glib/util.h>
 
-#include <libempathy/empathy-account-manager.h>
 #include <libempathy/empathy-call-factory.h>
 #include <libempathy/empathy-tp-contact-factory.h>
 #include <libempathy/empathy-contact-list.h>
@@ -244,9 +244,9 @@ contact_list_view_drag_data_received (GtkWidget         *view,
 				      guint              time_)
 {
 	EmpathyContactListViewPriv *priv;
-	EmpathyAccountManager      *account_manager;
+	TpAccountManager           *account_manager;
 	EmpathyTpContactFactory    *factory = NULL;
-	EmpathyAccount             *account = NULL;
+	TpAccount                  *account = NULL;
 	GtkTreeModel               *model;
 	GtkTreeViewDropPosition     position;
 	GtkTreePath                *path;
@@ -298,17 +298,19 @@ contact_list_view_drag_data_received (GtkWidget         *view,
 		context->action == GDK_ACTION_COPY ? "copy" : "",
 		id);
 
-	account_manager = empathy_account_manager_dup_singleton ();
+	/* FIXME: should probably make sure the account manager is prepared
+	 * before calling _ensure_account on it. See bug 600115. */
+	account_manager = tp_account_manager_dup ();
 	strv = g_strsplit (id, ":", 2);
 	if (g_strv_length (strv) == 2) {
 		account_id = strv[0];
 		contact_id = strv[1];
-		account = empathy_account_manager_get_account (account_manager, account_id);
+		account = tp_account_manager_ensure_account (account_manager, account_id);
 	}
 	if (account) {
 		TpConnection *connection;
 
-		connection = empathy_account_get_connection (account);
+		connection = tp_account_get_connection (account);
 		if (connection) {
 			factory = empathy_tp_contact_factory_dup_singleton (connection);
 		}
@@ -458,7 +460,7 @@ contact_list_view_drag_data_get (GtkWidget        *widget,
 	GtkTreeIter                 iter;
 	GtkTreeModel               *model;
 	EmpathyContact             *contact;
-	EmpathyAccount             *account;
+	TpAccount                  *account;
 	const gchar                *contact_id;
 	const gchar                *account_id;
 	gchar                      *str;
@@ -488,7 +490,7 @@ contact_list_view_drag_data_get (GtkWidget        *widget,
 	}
 
 	account = empathy_contact_get_account (contact);
-	account_id = empathy_account_get_unique_name (account);
+	account_id = tp_proxy_get_object_path (account);
 	contact_id = empathy_contact_get_id (contact);
 	g_object_unref (contact);
 	str = g_strconcat (account_id, ":", contact_id, NULL);
diff --git a/libempathy-gtk/empathy-contact-widget.c b/libempathy-gtk/empathy-contact-widget.c
index 17bed7298..81e01ff0b 100644
--- a/libempathy-gtk/empathy-contact-widget.c
+++ b/libempathy-gtk/empathy-contact-widget.c
@@ -32,6 +32,7 @@
 #include <champlain-gtk/champlain-gtk.h>
 #endif
 
+#include <telepathy-glib/account.h>
 #include <telepathy-glib/util.h>
 
 #include <libempathy/empathy-tp-contact-factory.h>
@@ -40,7 +41,6 @@
 #include <libempathy/empathy-location.h>
 #include <libempathy/empathy-time.h>
 #include <libempathy/empathy-utils.h>
-#include <libempathy/empathy-account.h>
 
 #include "empathy-contact-widget.h"
 #include "empathy-account-chooser.h"
@@ -718,7 +718,7 @@ contact_widget_contact_setup (EmpathyContactWidget *information)
 static void
 contact_widget_contact_update (EmpathyContactWidget *information)
 {
-  EmpathyAccount *account = NULL;
+  TpAccount *account = NULL;
   const gchar *id = NULL;
 
   /* Connect and get info from new contact */
@@ -758,7 +758,7 @@ contact_widget_contact_update (EmpathyContactWidget *information)
         {
           const gchar *name;
 
-          name = empathy_account_get_display_name (account);
+          name = tp_account_get_display_name (account);
           gtk_label_set_label (GTK_LABEL (information->widget_account), name);
         }
     }
diff --git a/libempathy-gtk/empathy-irc-network-dialog.c b/libempathy-gtk/empathy-irc-network-dialog.c
index 8d4676417..69f83637d 100644
--- a/libempathy-gtk/empathy-irc-network-dialog.c
+++ b/libempathy-gtk/empathy-irc-network-dialog.c
@@ -28,7 +28,6 @@
 #include <gtk/gtk.h>
 
 #include <libempathy/empathy-utils.h>
-#include <libempathy/empathy-account.h>
 
 #include <libempathy/empathy-irc-network-manager.h>
 #include "empathy-ui-utils.h"
diff --git a/libempathy-gtk/empathy-location-manager.c b/libempathy-gtk/empathy-location-manager.c
index a00d6cb63..4ef27dba7 100644
--- a/libempathy-gtk/empathy-location-manager.c
+++ b/libempathy-gtk/empathy-location-manager.c
@@ -26,6 +26,7 @@
 
 #include <glib/gi18n.h>
 
+#include <telepathy-glib/account-manager.h>
 #include <telepathy-glib/util.h>
 
 #include <geoclue/geoclue-master.h>
@@ -35,7 +36,6 @@
 #include "empathy-location-manager.h"
 #include "empathy-conf.h"
 
-#include "libempathy/empathy-account-manager.h"
 #include "libempathy/empathy-enum-types.h"
 #include "libempathy/empathy-location.h"
 #include "libempathy/empathy-tp-contact-factory.h"
@@ -63,7 +63,7 @@ typedef struct {
     GeoclueAddress *gc_address;
 
     gboolean reduce_accuracy;
-    EmpathyAccountManager *account_manager;
+    TpAccountManager *account_manager;
 
     /* The idle id for publish_on_idle func */
     guint timeout_id;
@@ -217,21 +217,57 @@ publish_location (EmpathyLocationManager *self,
   g_object_unref (factory);
 }
 
+typedef struct
+{
+  EmpathyLocationManager *self;
+  gboolean force_publication;
+} PublishToAllData;
+
+static void
+publish_to_all_am_prepared_cb (GObject *source_object,
+    GAsyncResult *result,
+    gpointer user_data)
+{
+  TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object);
+  PublishToAllData *data = user_data;
+  GList *accounts, *l;
+  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);
+      goto out;
+    }
+
+  accounts = tp_account_manager_get_valid_accounts (manager);
+  for (l = accounts; l; l = l->next)
+    {
+      TpConnection *conn = tp_account_get_connection (TP_ACCOUNT (l->data));
+
+      if (conn != NULL)
+        publish_location (data->self, conn, data->force_publication);
+    }
+  g_list_free (accounts);
+
+out:
+  g_object_unref (data->self);
+  g_slice_free (PublishToAllData, data);
+}
+
 static void
 publish_to_all_connections (EmpathyLocationManager *self,
     gboolean force_publication)
 {
   EmpathyLocationManagerPriv *priv = GET_PRIV (self);
-  GList *connections = NULL, *l;
+  PublishToAllData *data;
 
-  connections = empathy_account_manager_dup_connections (priv->account_manager);
-  for (l = connections; l; l = l->next)
-    {
-      publish_location (self, l->data, force_publication);
-      g_object_unref (l->data);
-    }
-  g_list_free (connections);
+  data = g_slice_new0 (PublishToAllData);
+  data->self = g_object_ref (self);
+  data->force_publication = force_publication;
 
+  tp_account_manager_prepare_async (priv->account_manager, NULL,
+      publish_to_all_am_prepared_cb, data);
 }
 
 static gboolean
@@ -246,11 +282,19 @@ publish_on_idle (gpointer user_data)
 }
 
 static void
-new_connection_cb (EmpathyAccountManager *manager,
-    TpConnection *conn,
+new_connection_cb (TpAccount *account,
+    guint old_status,
+    guint new_status,
+    guint reason,
+    gchar *dbus_error_name,
+    GHashTable *details,
     gpointer *self)
 {
   EmpathyLocationManagerPriv *priv = GET_PRIV (self);
+  TpConnection *conn;
+
+  conn = tp_account_get_connection (account);
+
   DEBUG ("New connection %p", conn);
 
   /* Don't publish if it is already planned (ie startup) */
@@ -626,6 +670,34 @@ accuracy_cb (EmpathyConf  *conf,
 }
 
 static void
+account_manager_prepared_cb (GObject *source_object,
+    GAsyncResult *result,
+    gpointer user_data)
+{
+  GList *accounts, *l;
+  TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object);
+  EmpathyLocationManager *self = 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;
+    }
+
+  accounts = tp_account_manager_get_valid_accounts (account_manager);
+  for (l = accounts; l != NULL; l = l->next)
+    {
+      TpAccount *account = TP_ACCOUNT (l->data);
+
+      empathy_signal_connect_weak (account, "status-changed",
+          G_CALLBACK (new_connection_cb), G_OBJECT (self));
+    }
+  g_list_free (accounts);
+}
+
+static void
 empathy_location_manager_init (EmpathyLocationManager *self)
 {
   EmpathyConf               *conf;
@@ -638,10 +710,10 @@ empathy_location_manager_init (EmpathyLocationManager *self)
       g_free, (GDestroyNotify) tp_g_value_slice_free);
 
   /* Setup account status callbacks */
-  priv->account_manager = empathy_account_manager_dup_singleton ();
-  g_signal_connect (priv->account_manager,
-    "new-connection",
-    G_CALLBACK (new_connection_cb), self);
+  priv->account_manager = tp_account_manager_dup ();
+
+  tp_account_manager_prepare_async (priv->account_manager, NULL,
+      account_manager_prepared_cb, self);
 
   /* Setup settings status callbacks */
   conf = empathy_conf_get ();
diff --git a/libempathy-gtk/empathy-log-window.c b/libempathy-gtk/empathy-log-window.c
index 11ddca74b..247a99806 100644
--- a/libempathy-gtk/empathy-log-window.c
+++ b/libempathy-gtk/empathy-log-window.c
@@ -30,8 +30,9 @@
 #include <glib/gi18n-lib.h>
 #include <gtk/gtk.h>
 
+#include <telepathy-glib/account-manager.h>
+
 #include <libempathy/empathy-log-manager.h>
-#include <libempathy/empathy-account-manager.h>
 #include <libempathy/empathy-chatroom-manager.h>
 #include <libempathy/empathy-chatroom.h>
 #include <libempathy/empathy-message.h>
@@ -95,11 +96,11 @@ static void     log_window_chats_setup                     (EmpathyLogWindow *wi
 static void     log_window_chats_accounts_changed_cb       (GtkWidget        *combobox,
 							    EmpathyLogWindow *window);
 static void     log_window_chats_set_selected              (EmpathyLogWindow *window,
-							    EmpathyAccount   *account,
+							    TpAccount        *account,
 							    const gchar      *chat_id,
 							    gboolean          is_chatroom);
 static gboolean log_window_chats_get_selected              (EmpathyLogWindow *window,
-							    EmpathyAccount  **account,
+							    TpAccount       **account,
 							    gchar           **chat_id,
 							    gboolean         *is_chatroom);
 static void     log_window_chats_get_messages              (EmpathyLogWindow *window,
@@ -134,16 +135,45 @@ enum {
 	COL_CHAT_COUNT
 };
 
+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 (!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);
+	}
+}
+
 GtkWidget *
-empathy_log_window_show (EmpathyAccount   *account,
+empathy_log_window_show (TpAccount  *account,
 			const gchar *chat_id,
 			gboolean     is_chatroom,
 			GtkWindow   *parent)
 {
 	static EmpathyLogWindow *window = NULL;
 	EmpathyAccountChooser   *account_chooser;
-	EmpathyAccountManager  *account_manager;
-	gint                    account_num;
+	TpAccountManager        *account_manager;
 	GtkBuilder             *gui;
 	gchar                  *filename;
 
@@ -229,18 +259,11 @@ empathy_log_window_show (EmpathyAccount   *account,
 			  window);
 
 	/* Populate */
-	account_manager = empathy_account_manager_dup_singleton ();
-	account_num = empathy_account_manager_get_count (account_manager);
+	account_manager = tp_account_manager_dup ();
+	tp_account_manager_prepare_async (account_manager, NULL,
+					  account_manager_prepared_cb, window);
 	g_object_unref (account_manager);
 
-	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);
-	}
-
 	/* Search List */
 	log_window_find_setup (window);
 
@@ -302,7 +325,7 @@ log_window_find_changed_cb (GtkTreeSelection *selection,
 	GtkTreeView   *view;
 	GtkTreeModel  *model;
 	GtkTreeIter    iter;
-	EmpathyAccount     *account;
+	TpAccount     *account;
 	gchar         *chat_id;
 	gboolean       is_chatroom;
 	gchar         *date;
@@ -418,8 +441,8 @@ log_window_find_populate (EmpathyLogWindow *window,
 		}
 
 		date_readable = empathy_log_manager_get_date_readable (hit->date);
-		account_name = empathy_account_get_display_name (hit->account);
-		account_icon = empathy_account_get_icon_name (hit->account);
+		account_name = tp_account_get_display_name (hit->account);
+		account_icon = tp_account_get_icon_name (hit->account);
 
 		gtk_list_store_append (store, &iter);
 		gtk_list_store_set (store, &iter,
@@ -465,7 +488,7 @@ log_window_find_setup (EmpathyLogWindow *window)
 	store = gtk_list_store_new (COL_FIND_COUNT,
 				    G_TYPE_STRING,          /* account icon name */
 				    G_TYPE_STRING,          /* account name */
-				    EMPATHY_TYPE_ACCOUNT,   /* account */
+				    TP_TYPE_ACCOUNT,        /* account */
 				    G_TYPE_STRING,          /* chat name */
 				    G_TYPE_STRING,          /* chat id */
 				    G_TYPE_BOOLEAN,         /* is chatroom */
@@ -609,7 +632,7 @@ static void
 log_window_chats_populate (EmpathyLogWindow *window)
 {
 	EmpathyAccountChooser *account_chooser;
-	EmpathyAccount       *account;
+	TpAccount             *account;
 	GList                *chats, *l;
 
 	GtkTreeView          *view;
@@ -687,7 +710,7 @@ log_window_chats_setup (EmpathyLogWindow *window)
 	store = gtk_list_store_new (COL_CHAT_COUNT,
 				    G_TYPE_STRING,        /* icon */
 				    G_TYPE_STRING,        /* name */
-				    EMPATHY_TYPE_ACCOUNT, /* account */
+				    TP_TYPE_ACCOUNT,      /* account */
 				    G_TYPE_STRING,        /* id */
 				    G_TYPE_BOOLEAN);      /* is chatroom */
 
@@ -740,7 +763,7 @@ log_window_chats_accounts_changed_cb (GtkWidget       *combobox,
 
 static void
 log_window_chats_set_selected  (EmpathyLogWindow *window,
-				EmpathyAccount  *account,
+				TpAccount        *account,
 				const gchar     *chat_id,
 				gboolean         is_chatroom)
 {
@@ -764,7 +787,7 @@ log_window_chats_set_selected  (EmpathyLogWindow *window,
 	}
 
 	for (ok = TRUE; ok; ok = gtk_tree_model_iter_next (model, &iter)) {
-		EmpathyAccount *this_account;
+		TpAccount *this_account;
 		gchar     *this_chat_id;
 		gboolean   this_is_chatroom;
 
@@ -793,7 +816,7 @@ log_window_chats_set_selected  (EmpathyLogWindow *window,
 
 static gboolean
 log_window_chats_get_selected (EmpathyLogWindow  *window,
-			       EmpathyAccount  **account,
+			       TpAccount       **account,
 			       gchar           **chat_id,
 			       gboolean         *is_chatroom)
 {
@@ -802,7 +825,7 @@ log_window_chats_get_selected (EmpathyLogWindow  *window,
 	GtkTreeSelection *selection;
 	GtkTreeIter       iter;
 	gchar            *id = NULL;
-	EmpathyAccount   *acc = NULL;
+	TpAccount        *acc = NULL;
 	gboolean          room = FALSE;
 
 	view = GTK_TREE_VIEW (window->treeview_chats);
@@ -840,7 +863,7 @@ static void
 log_window_chats_get_messages (EmpathyLogWindow *window,
 			       const gchar     *date_to_show)
 {
-	EmpathyAccount     *account;
+	TpAccount     *account;
 	gchar         *chat_id;
 	gboolean       is_chatroom;
 	EmpathyMessage *message;
@@ -1000,7 +1023,7 @@ static void
 log_window_calendar_chats_month_changed_cb (GtkWidget       *calendar,
 					    EmpathyLogWindow *window)
 {
-	EmpathyAccount     *account;
+	TpAccount     *account;
 	gchar         *chat_id;
 	gboolean       is_chatroom;
 	guint          year_selected;
diff --git a/libempathy-gtk/empathy-log-window.h b/libempathy-gtk/empathy-log-window.h
index 298d96099..def0d846b 100644
--- a/libempathy-gtk/empathy-log-window.h
+++ b/libempathy-gtk/empathy-log-window.h
@@ -25,11 +25,11 @@
 #ifndef __EMPATHY_LOG_WINDOW_H__
 #define __EMPATHY_LOG_WINDOW_H__
 
-#include <libempathy/empathy-account.h>
+#include <telepathy-glib/account.h>
 
 G_BEGIN_DECLS
 
-GtkWidget * empathy_log_window_show (EmpathyAccount   *account,
+GtkWidget * empathy_log_window_show (TpAccount   *account,
 				     const gchar *chat_id,
 				     gboolean     chatroom,
 				     GtkWindow   *parent);
diff --git a/libempathy-gtk/empathy-new-message-dialog.c b/libempathy-gtk/empathy-new-message-dialog.c
index 66b2adb2d..d39f71bcc 100644
--- a/libempathy-gtk/empathy-new-message-dialog.c
+++ b/libempathy-gtk/empathy-new-message-dialog.c
@@ -32,7 +32,6 @@
 #include <libempathy/empathy-contact-manager.h>
 #include <libempathy/empathy-dispatcher.h>
 #include <libempathy/empathy-utils.h>
-#include <libempathy/empathy-account.h>
 
 #define DEBUG_FLAG EMPATHY_DEBUG_CONTACT
 #include <libempathy/empathy-debug.h>
diff --git a/libempathy-gtk/empathy-presence-chooser.c b/libempathy-gtk/empathy-presence-chooser.c
index 7113c77fd..678ec835c 100644
--- a/libempathy-gtk/empathy-presence-chooser.c
+++ b/libempathy-gtk/empathy-presence-chooser.c
@@ -33,13 +33,13 @@
 #include <gtk/gtk.h>
 #include <gdk/gdkkeysyms.h>
 
+#include <telepathy-glib/account-manager.h>
 #include <telepathy-glib/util.h>
 
 #include <libempathy/empathy-connectivity.h>
 #include <libempathy/empathy-idle.h>
 #include <libempathy/empathy-utils.h>
 #include <libempathy/empathy-status-presets.h>
-#include <libempathy/empathy-account-manager.h>
 
 #define DEBUG_FLAG EMPATHY_DEBUG_OTHER
 #include <libempathy/empathy-debug.h>
@@ -114,7 +114,7 @@ typedef struct {
 	TpConnectionPresenceType   flash_state_2;
 	guint        flash_timeout_id;
 
-	EmpathyAccountManager *account_manager;
+	TpAccountManager *account_manager;
 } EmpathyPresenceChooserPriv;
 
 /* States to be listed in the menu.
@@ -715,21 +715,32 @@ presence_chooser_entry_focus_out_cb (EmpathyPresenceChooser *chooser,
 }
 
 static void
-presence_chooser_update_sensitivity (EmpathyPresenceChooser *chooser)
+update_sensitivity_am_prepared_cb (GObject *source_object,
+				   GAsyncResult *result,
+				   gpointer user_data)
 {
+	TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object);
+	EmpathyPresenceChooser *chooser = user_data;
 	EmpathyPresenceChooserPriv *priv = GET_PRIV (chooser);
 	gboolean sensitive = FALSE;
 	GList *accounts, *l;
+	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 = empathy_account_manager_dup_accounts (priv->account_manager);
+	accounts = tp_account_manager_get_valid_accounts (manager);
 
 	for (l = accounts ; l != NULL ; l = g_list_next (l)) {
-		EmpathyAccount *a = EMPATHY_ACCOUNT (l->data);
+		TpAccount *a = TP_ACCOUNT (l->data);
 
-		if (empathy_account_is_enabled (a))
+		if (tp_account_is_enabled (a)) {
 			sensitive = TRUE;
-
-		g_object_unref (a);
+			break;
+		}
 	}
 
 	g_list_free (accounts);
@@ -741,9 +752,29 @@ presence_chooser_update_sensitivity (EmpathyPresenceChooser *chooser)
 }
 
 static void
+presence_chooser_update_sensitivity (EmpathyPresenceChooser *chooser)
+{
+	EmpathyPresenceChooserPriv *priv = GET_PRIV (chooser);
+
+	tp_account_manager_prepare_async (priv->account_manager, NULL,
+					  update_sensitivity_am_prepared_cb,
+					  chooser);
+}
+
+static void
+presence_chooser_account_manager_account_validity_changed_cb (
+	TpAccountManager *manager,
+	TpAccount *account,
+	gboolean valid,
+	EmpathyPresenceChooser *chooser)
+{
+	presence_chooser_update_sensitivity (chooser);
+}
+
+static void
 presence_chooser_account_manager_account_changed_cb (
-	EmpathyAccountManager *manager,
-	EmpathyAccount *account,
+	TpAccountManager *manager,
+	TpAccount *account,
 	EmpathyPresenceChooser *chooser)
 {
 	presence_chooser_update_sensitivity (chooser);
@@ -825,12 +856,12 @@ empathy_presence_chooser_init (EmpathyPresenceChooser *chooser)
 		G_CALLBACK (presence_chooser_presence_changed_cb),
 		chooser);
 
-	priv->account_manager = empathy_account_manager_dup_singleton ();
+	priv->account_manager = tp_account_manager_dup ();
 
-	empathy_signal_connect_weak (priv->account_manager, "account-created",
-		G_CALLBACK (presence_chooser_account_manager_account_changed_cb),
+	empathy_signal_connect_weak (priv->account_manager, "account-validity-changed",
+		G_CALLBACK (presence_chooser_account_manager_account_validity_changed_cb),
 		G_OBJECT (chooser));
-	empathy_signal_connect_weak (priv->account_manager, "account-deleted",
+	empathy_signal_connect_weak (priv->account_manager, "account-removed",
 		G_CALLBACK (presence_chooser_account_manager_account_changed_cb),
 		G_OBJECT (chooser));
 	empathy_signal_connect_weak (priv->account_manager, "account-enabled",
diff --git a/libempathy-gtk/empathy-theme-adium.c b/libempathy-gtk/empathy-theme-adium.c
index fcf95ca02..a41cbd6c0 100644
--- a/libempathy-gtk/empathy-theme-adium.c
+++ b/libempathy-gtk/empathy-theme-adium.c
@@ -441,7 +441,7 @@ theme_adium_append_message (EmpathyChatView *view,
 	EmpathyThemeAdium     *theme = EMPATHY_THEME_ADIUM (view);
 	EmpathyThemeAdiumPriv *priv = GET_PRIV (theme);
 	EmpathyContact        *sender;
-	EmpathyAccount        *account;
+	TpAccount             *account;
 	gchar                 *dup_body = NULL;
 	const gchar           *body;
 	const gchar           *name;
@@ -467,9 +467,9 @@ theme_adium_append_message (EmpathyChatView *view,
 	sender = empathy_message_get_sender (msg);
 	account = empathy_contact_get_account (sender);
 	service_name = empathy_protocol_name_to_display_name
-		(empathy_account_get_protocol (account));
+		(tp_account_get_protocol (account));
 	if (service_name == NULL)
-		service_name = empathy_account_get_protocol (account);
+		service_name = tp_account_get_protocol (account);
 	timestamp = empathy_message_get_timestamp (msg);
 	body = empathy_message_get_body (msg);
 	dup_body = theme_adium_parse_body (theme, body);
diff --git a/libempathy-gtk/empathy-ui-utils.h b/libempathy-gtk/empathy-ui-utils.h
index 39baeaf41..486301cb1 100644
--- a/libempathy-gtk/empathy-ui-utils.h
+++ b/libempathy-gtk/empathy-ui-utils.h
@@ -35,7 +35,6 @@
 #include <gtk/gtk.h>
 
 #include <libempathy/empathy-contact.h>
-#include <libempathy/empathy-account.h>
 #include <libempathy/empathy-ft-handler.h>
 
 #include "empathy-chat-view.h"
diff --git a/libempathy/Makefile.am b/libempathy/Makefile.am
index 1e7d01ca3..91fdf7ba1 100644
--- a/libempathy/Makefile.am
+++ b/libempathy/Makefile.am
@@ -27,8 +27,6 @@ noinst_LTLIBRARIES = libempathy.la
 
 libempathy_headers =				\
 	empathy-account-settings.h		\
-	empathy-account.h			\
-	empathy-account-manager.h		\
 	empathy-chatroom.h			\
 	empathy-chatroom-manager.h		\
 	empathy-call-factory.h			\
@@ -70,9 +68,7 @@ libempathy_headers =				\
 
 libempathy_la_SOURCES =					\
 	$(libempathy_headers)				\
-	empathy-account.c				\
 	empathy-account-settings.c			\
-	empathy-account-manager.c			\
 	empathy-chatroom.c				\
 	empathy-chatroom-manager.c			\
 	empathy-call-factory.c				\
diff --git a/libempathy/empathy-account-manager.c b/libempathy/empathy-account-manager.c
deleted file mode 100644
index c71439bd4..000000000
--- a/libempathy/empathy-account-manager.c
+++ /dev/null
@@ -1,1060 +0,0 @@
-/*
- * Copyright (C) 2008 Collabora Ltd.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Authors: Cosimo Cecchi <cosimo.cecchi@collabora.co.uk>
- *          Sjoerd Simons <sjoerd.simons@collabora.co.uk>
- */
-
-#include "config.h"
-
-#include <telepathy-glib/util.h>
-#include <telepathy-glib/account-manager.h>
-#include <telepathy-glib/enums.h>
-#include <telepathy-glib/defs.h>
-#include <telepathy-glib/dbus.h>
-#include <telepathy-glib/interfaces.h>
-
-#include "empathy-account-manager.h"
-#include "empathy-marshal.h"
-#include "empathy-utils.h"
-
-#define DEBUG_FLAG EMPATHY_DEBUG_ACCOUNT
-#include <libempathy/empathy-debug.h>
-
-#define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyAccountManager)
-
-#define MC5_BUS_NAME "org.freedesktop.Telepathy.MissionControl5"
-
-typedef struct {
-  /* (owned) unique name -> (reffed) EmpathyAccount */
-  GHashTable       *accounts;
-  int               connected;
-  int               connecting;
-  gboolean          dispose_run;
-  gboolean          ready;
-  TpAccountManager *tp_manager;
-  TpDBusDaemon *dbus;
-
-  /* global presence */
-  EmpathyAccount *global_account;
-
-  TpConnectionPresenceType global_presence;
-  gchar *global_status;
-  gchar *global_status_message;
-
-  /* requested global presence, could be different
-   * from the actual global one.
-   */
-  TpConnectionPresenceType requested_presence;
-  gchar *requested_status;
-  gchar *requested_status_message;
-
-  GHashTable *create_results;
-} EmpathyAccountManagerPriv;
-
-enum {
-  ACCOUNT_CREATED,
-  ACCOUNT_DELETED,
-  ACCOUNT_ENABLED,
-  ACCOUNT_DISABLED,
-  ACCOUNT_CHANGED,
-  ACCOUNT_CONNECTION_CHANGED,
-  GLOBAL_PRESENCE_CHANGED,
-  NEW_CONNECTION,
-  LAST_SIGNAL
-};
-
-enum {
-  PROP_READY = 1,
-};
-
-static guint signals[LAST_SIGNAL];
-static EmpathyAccountManager *manager_singleton = NULL;
-
-G_DEFINE_TYPE (EmpathyAccountManager, empathy_account_manager, G_TYPE_OBJECT);
-
-static void
-emp_account_connection_cb (EmpathyAccount *account,
-  GParamSpec *spec,
-  gpointer manager)
-{
-  TpConnection *connection = empathy_account_get_connection (account);
-
-  DEBUG ("Signalling connection %p of account %s",
-      connection, empathy_account_get_unique_name (account));
-
-  if (connection != NULL)
-    g_signal_emit (manager, signals[NEW_CONNECTION], 0, connection);
-}
-
-static void
-emp_account_enabled_cb (EmpathyAccount *account,
-  GParamSpec *spec,
-  gpointer manager)
-{
-  if (empathy_account_is_enabled (account))
-    g_signal_emit (manager, signals[ACCOUNT_ENABLED], 0, account);
-  else
-    g_signal_emit (manager, signals[ACCOUNT_DISABLED], 0, account);
-}
-
-static void
-emp_account_status_changed_cb (EmpathyAccount *account,
-  TpConnectionStatus old,
-  TpConnectionStatus new,
-  TpConnectionStatusReason reason,
-  gpointer user_data)
-{
-  EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data);
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-
-  switch (old)
-    {
-      case TP_CONNECTION_STATUS_CONNECTING:
-        priv->connecting--;
-        break;
-      case TP_CONNECTION_STATUS_CONNECTED:
-        priv->connected--;
-        break;
-      default:
-        break;
-    }
-
-  switch (new)
-    {
-      case TP_CONNECTION_STATUS_CONNECTING:
-        priv->connecting++;
-        break;
-      case TP_CONNECTION_STATUS_CONNECTED:
-        priv->connected++;
-        break;
-      default:
-        break;
-    }
-
-  g_signal_emit (manager, signals[ACCOUNT_CONNECTION_CHANGED], 0,
-    account, reason, new, old);
-}
-
-static void
-emp_account_manager_update_global_presence (EmpathyAccountManager *manager)
-{
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-  TpConnectionPresenceType presence = TP_CONNECTION_PRESENCE_TYPE_OFFLINE;
-  EmpathyAccount *account = NULL;
-  GHashTableIter iter;
-  gpointer value;
-
-  /* Make the global presence is equal to the presence of the account with the
-   * highest availability */
-
-  g_hash_table_iter_init (&iter, priv->accounts);
-  while (g_hash_table_iter_next (&iter, NULL, &value))
-    {
-      EmpathyAccount *a = EMPATHY_ACCOUNT (value);
-      TpConnectionPresenceType p;
-
-      g_object_get (a, "presence", &p, NULL);
-
-      if (tp_connection_presence_type_cmp_availability (p, presence) > 0)
-        {
-          account = a;
-          presence = p;
-        }
-    }
-
-  priv->global_account = account;
-  g_free (priv->global_status);
-  g_free (priv->global_status_message);
-
-  if (account == NULL)
-    {
-      priv->global_presence = presence;
-      priv->global_status = NULL;
-      priv->global_status_message = NULL;
-      return;
-    }
-
-  g_object_get (account,
-    "presence", &priv->global_presence,
-    "status", &priv->global_status,
-    "status-message", &priv->global_status_message,
-    NULL);
-
-  DEBUG ("Updated global presence to: %s (%d) \"%s\"",
-    priv->global_status, priv->global_presence, priv->global_status_message);
-}
-
-static void
-emp_account_presence_changed_cb (EmpathyAccount *account,
-  TpConnectionPresenceType presence,
-  const gchar *status,
-  const gchar *status_message,
-  gpointer user_data)
-{
-  EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data);
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-
-  if (tp_connection_presence_type_cmp_availability (presence,
-      priv->global_presence) > 0)
-    {
-      priv->global_account = account;
-
-      priv->global_presence = presence;
-
-      g_free (priv->global_status);
-      priv->global_status = g_strdup (status);
-
-      g_free (priv->global_status_message);
-      priv->global_status_message = g_strdup (status_message);
-
-      goto signal;
-    }
-  else if (priv->global_account == account)
-    {
-      emp_account_manager_update_global_presence (manager);
-      goto signal;
-    }
-
-  return;
-signal:
-    g_signal_emit (manager, signals[GLOBAL_PRESENCE_CHANGED], 0,
-      priv->global_presence, priv->global_status, priv->global_status_message);
-}
-
-static void
-emp_account_removed_cb (EmpathyAccount *account, gpointer user_data)
-{
-  EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data);
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-
-  g_object_ref (account);
-  g_hash_table_remove (priv->accounts,
-    empathy_account_get_unique_name (account));
-
-  g_signal_emit (manager, signals[ACCOUNT_DELETED], 0, account);
-  g_object_unref (account);
-}
-
-static void
-empathy_account_manager_check_ready (EmpathyAccountManager *manager)
-{
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-  GHashTableIter iter;
-  gpointer value;
-
-  if (priv->ready)
-    return;
-
-  g_hash_table_iter_init (&iter, priv->accounts);
-  while (g_hash_table_iter_next (&iter, NULL, &value))
-    {
-      EmpathyAccount *account = EMPATHY_ACCOUNT (value);
-      gboolean ready;
-
-      g_object_get (account, "ready", &ready, NULL);
-
-      if (!ready)
-        return;
-    }
-
-  /* Rerequest global presence on the initial set of accounts for cases where a
-   * global presence was requested before the manager was ready */
-  if (priv->requested_presence != TP_CONNECTION_PRESENCE_TYPE_UNSET)
-    empathy_account_manager_request_global_presence (manager,
-      priv->requested_presence,
-      priv->requested_status,
-      priv->requested_status_message);
-
-  priv->ready = TRUE;
-  g_object_notify (G_OBJECT (manager), "ready");
-}
-
-static void
-account_manager_account_ready_cb (GObject *obj,
-    GParamSpec *spec,
-    gpointer user_data)
-{
-  EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data);
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-  EmpathyAccount *account = EMPATHY_ACCOUNT (obj);
-  GSimpleAsyncResult *result;
-  gboolean ready;
-
-  g_object_get (account, "ready", &ready, NULL);
-
-  if (!ready)
-    return;
-
-  /* see if there's any pending callbacks for this account */
-  result = g_hash_table_lookup (priv->create_results, account);
-  if (result != NULL)
-    {
-      g_simple_async_result_set_op_res_gpointer (
-          G_SIMPLE_ASYNC_RESULT (result), account, NULL);
-
-      g_simple_async_result_complete (result);
-
-      g_hash_table_remove (priv->create_results, account);
-      g_object_unref (result);
-    }
-
-  g_signal_emit (manager, signals[ACCOUNT_CREATED], 0, account);
-
-  g_signal_connect (account, "notify::connection",
-    G_CALLBACK (emp_account_connection_cb), manager);
-
-  g_signal_connect (account, "notify::enabled",
-    G_CALLBACK (emp_account_enabled_cb), manager);
-
-  g_signal_connect (account, "status-changed",
-    G_CALLBACK (emp_account_status_changed_cb), manager);
-
-  g_signal_connect (account, "presence-changed",
-    G_CALLBACK (emp_account_presence_changed_cb), manager);
-
-  g_signal_connect (account, "removed",
-    G_CALLBACK (emp_account_removed_cb), manager);
-
-  empathy_account_manager_check_ready (manager);
-}
-
-EmpathyAccount *
-empathy_account_manager_get_account (EmpathyAccountManager *manager,
-  const gchar *path)
-{
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-
-  return g_hash_table_lookup (priv->accounts, path);
-}
-
-EmpathyAccount *
-empathy_account_manager_ensure_account (EmpathyAccountManager *manager,
-  const gchar *path)
-{
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-  EmpathyAccount *account;
-
-  account = g_hash_table_lookup (priv->accounts, path);
-  if (account != NULL)
-    return account;
-
-  account = empathy_account_new (priv->dbus, path);
-  g_hash_table_insert (priv->accounts, g_strdup (path), account);
-
-  g_signal_connect (account, "notify::ready",
-    G_CALLBACK (account_manager_account_ready_cb), manager);
-
-  return account;
-}
-
-
-static void
-account_manager_ensure_all_accounts (EmpathyAccountManager *manager,
-    GPtrArray *accounts)
-{
-  guint i, missing_accounts;
-  GHashTableIter iter;
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-  gpointer value;
-  EmpathyAccount *account;
-  gboolean found = FALSE;
-  const gchar *name;
-
-  /* ensure all accounts coming from MC5 first */
-  for (i = 0; i < accounts->len; i++)
-    {
-      name = g_ptr_array_index (accounts, i);
-
-      account = empathy_account_manager_ensure_account (manager, name);
-      empathy_account_refresh_properties (account);
-    }
-
-  missing_accounts = empathy_account_manager_get_count (manager) -
-    accounts->len;
-
-  if (missing_accounts > 0)
-    {
-      /* look for accounts we have and the Tp AccountManager doesn't,
-       * and remove them from our cache.
-       */
-
-      DEBUG ("%d missing accounts", missing_accounts);
-
-      g_hash_table_iter_init (&iter, priv->accounts);
-
-      while (g_hash_table_iter_next (&iter, NULL, &value) &&
-	     missing_accounts > 0)
-        {
-          account = value;
-
-          /* look for this account in the AccountManager provided array */
-          for (i = 0; i < accounts->len; i++)
-            {
-              name = g_ptr_array_index (accounts, i);
-
-              if (!tp_strdiff
-                  (name, empathy_account_get_unique_name (account)))
-                {
-                  found = TRUE;
-                  break;
-                }
-            }
-
-          if (!found)
-            {
-              DEBUG ("Account %s was not found, remove it from the cache",
-		     empathy_account_get_unique_name (account));
-
-	      g_object_ref (account);
-	      g_hash_table_iter_remove (&iter);
-	      g_signal_emit (manager, signals[ACCOUNT_DELETED], 0, account);
-	      g_object_unref (account);
-
-              missing_accounts--;
-            }
-
-          found = FALSE;
-        }
-    }
-}
-
-static void
-account_manager_got_all_cb (TpProxy *proxy,
-    GHashTable *properties,
-    const GError *error,
-    gpointer user_data,
-    GObject *weak_object)
-{
-  EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (weak_object);
-  GPtrArray *accounts;
-
-  if (error != NULL)
-    {
-      DEBUG ("Failed to get account manager properties: %s", error->message);
-      return;
-    }
-
-  accounts = tp_asv_get_boxed (properties, "ValidAccounts",
-    EMPATHY_ARRAY_TYPE_OBJECT);
-
-  if (accounts != NULL)
-    account_manager_ensure_all_accounts (manager, accounts);
-
-  empathy_account_manager_check_ready (manager);
-}
-
-static void
-account_validity_changed_cb (TpAccountManager *proxy,
-    const gchar *path,
-    gboolean valid,
-    gpointer user_data,
-    GObject *weak_object)
-{
-  EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (weak_object);
-
-  if (!valid)
-    return;
-
-  empathy_account_manager_ensure_account (manager, path);
-}
-
-static void
-account_manager_start_mc5 (TpDBusDaemon *bus)
-{
-  TpProxy *mc5_proxy;
-
-  /* trigger MC5 starting */
-  mc5_proxy = g_object_new (TP_TYPE_PROXY,
-    "dbus-daemon", bus,
-    "dbus-connection", tp_proxy_get_dbus_connection (TP_PROXY (bus)),
-    "bus-name", MC5_BUS_NAME,
-    "object-path", "/",
-    NULL);
-
-  tp_cli_dbus_peer_call_ping (mc5_proxy, -1, NULL, NULL, NULL, NULL);
-
-  g_object_unref (mc5_proxy);
-}
-
-static void
-account_manager_name_owner_cb (TpDBusDaemon *proxy,
-    const gchar *name,
-    const gchar *new_owner,
-    gpointer user_data)
-{
-  EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data);
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-
-  DEBUG ("Name owner changed for %s, new name: %s", name, new_owner);
-
-  if (EMP_STR_EMPTY (new_owner))
-    {
-      /* MC5 quit or crashed for some reason, let's start it again */
-      account_manager_start_mc5 (priv->dbus);
-
-      if (priv->tp_manager != NULL)
-        g_object_unref (priv->tp_manager);
-
-      priv->tp_manager = NULL;
-      return;
-    }
-
-  if (priv->tp_manager == NULL)
-    {
-      priv->tp_manager = tp_account_manager_new (priv->dbus);
-
-      tp_cli_account_manager_connect_to_account_validity_changed (
-          priv->tp_manager,
-          account_validity_changed_cb,
-          NULL,
-          NULL,
-          G_OBJECT (manager),
-          NULL);
-
-      tp_cli_dbus_properties_call_get_all (priv->tp_manager, -1,
-          TP_IFACE_ACCOUNT_MANAGER,
-          account_manager_got_all_cb,
-          NULL,
-          NULL,
-          G_OBJECT (manager));
-    }
-}
-
-static void
-empathy_account_manager_init (EmpathyAccountManager *manager)
-{
-  EmpathyAccountManagerPriv *priv;
-
-  priv = G_TYPE_INSTANCE_GET_PRIVATE (manager,
-      EMPATHY_TYPE_ACCOUNT_MANAGER, EmpathyAccountManagerPriv);
-
-  manager->priv = priv;
-  priv->connected = priv->connecting = 0;
-  priv->global_presence = TP_CONNECTION_PRESENCE_TYPE_UNSET;
-
-  priv->accounts = g_hash_table_new_full (g_str_hash, g_str_equal,
-      g_free, (GDestroyNotify) g_object_unref);
-
-  priv->create_results = g_hash_table_new (g_direct_hash, g_direct_equal);
-
-  priv->dbus = tp_dbus_daemon_dup (NULL);
-
-  tp_dbus_daemon_watch_name_owner (priv->dbus,
-      TP_ACCOUNT_MANAGER_BUS_NAME,
-      account_manager_name_owner_cb,
-      manager,
-      NULL);
-
-  account_manager_start_mc5 (priv->dbus);
-}
-
-static void
-do_finalize (GObject *obj)
-{
-  EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-
-  g_hash_table_destroy (priv->create_results);
-  g_hash_table_destroy (priv->accounts);
-
-  g_free (priv->global_status);
-  g_free (priv->global_status_message);
-
-  g_free (priv->requested_status);
-  g_free (priv->requested_status_message);
-
-  G_OBJECT_CLASS (empathy_account_manager_parent_class)->finalize (obj);
-}
-
-static void
-do_dispose (GObject *obj)
-{
-  EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-  GHashTableIter iter;
-  GSimpleAsyncResult *result;
-
-  if (priv->dispose_run)
-    return;
-
-  priv->dispose_run = TRUE;
-
-  /* the manager is being destroyed while there are account creation
-   * processes pending; this should not happen, but emit the callbacks
-   * with an error anyway.
-   */
-  g_hash_table_iter_init (&iter, priv->create_results);
-  while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &result))
-    {
-      g_simple_async_result_set_error (result, G_IO_ERROR,
-          G_IO_ERROR_CANCELLED, "The account manager was disposed while "
-          "creating the account");
-      g_simple_async_result_complete (result);
-      g_object_unref (result);
-    }
-  g_hash_table_remove_all (priv->create_results);
-
-  if (priv->dbus != NULL)
-    {
-      tp_dbus_daemon_cancel_name_owner_watch (priv->dbus,
-        TP_ACCOUNT_MANAGER_BUS_NAME, account_manager_name_owner_cb, manager);
-
-      g_object_unref (priv->dbus);
-      priv->dbus = NULL;
-    }
-
-  G_OBJECT_CLASS (empathy_account_manager_parent_class)->dispose (obj);
-}
-
-static GObject *
-do_constructor (GType type,
-                guint n_construct_params,
-                GObjectConstructParam *construct_params)
-{
-  GObject *retval;
-
-  if (!manager_singleton)
-    {
-      retval = G_OBJECT_CLASS
-        (empathy_account_manager_parent_class)->constructor (type,
-            n_construct_params, construct_params);
-      manager_singleton = EMPATHY_ACCOUNT_MANAGER (retval);
-      g_object_add_weak_pointer (retval, (gpointer) &manager_singleton);
-    }
-  else
-    {
-      retval = g_object_ref (manager_singleton);
-    }
-
-  return retval;
-}
-
-static void
-do_get_property (GObject *object,
-    guint prop_id,
-    GValue *value,
-    GParamSpec *pspec)
-{
-  EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (object);
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-
-  switch (prop_id)
-    {
-      case PROP_READY:
-        g_value_set_boolean (value, priv->ready);
-        break;
-      default:
-        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-        break;
-    }
-}
-
-static void
-empathy_account_manager_class_init (EmpathyAccountManagerClass *klass)
-{
-  GObjectClass *oclass = G_OBJECT_CLASS (klass);
-
-  oclass->finalize = do_finalize;
-  oclass->dispose = do_dispose;
-  oclass->constructor = do_constructor;
-  oclass->get_property = do_get_property;
-
-  g_object_class_install_property (oclass, PROP_READY,
-    g_param_spec_boolean ("ready",
-      "Ready",
-      "Whether the initial state dump from the account manager is finished",
-      FALSE,
-      G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
-
-  signals[ACCOUNT_CREATED] =
-    g_signal_new ("account-created",
-                  G_TYPE_FROM_CLASS (klass),
-                  G_SIGNAL_RUN_LAST,
-                  0,
-                  NULL, NULL,
-                  g_cclosure_marshal_VOID__OBJECT,
-                  G_TYPE_NONE,
-                  1, EMPATHY_TYPE_ACCOUNT);
-
-  signals[ACCOUNT_DELETED] =
-    g_signal_new ("account-deleted",
-                  G_TYPE_FROM_CLASS (klass),
-                  G_SIGNAL_RUN_LAST,
-                  0,
-                  NULL, NULL,
-                  g_cclosure_marshal_VOID__OBJECT,
-                  G_TYPE_NONE,
-                  1, EMPATHY_TYPE_ACCOUNT);
-
-  signals[ACCOUNT_ENABLED] =
-    g_signal_new ("account-enabled",
-                  G_TYPE_FROM_CLASS (klass),
-                  G_SIGNAL_RUN_LAST,
-                  0,
-                  NULL, NULL,
-                  g_cclosure_marshal_VOID__OBJECT,
-                  G_TYPE_NONE,
-                  1, EMPATHY_TYPE_ACCOUNT);
-
-  signals[ACCOUNT_DISABLED] =
-    g_signal_new ("account-disabled",
-                  G_TYPE_FROM_CLASS (klass),
-                  G_SIGNAL_RUN_LAST,
-                  0,
-                  NULL, NULL,
-                  g_cclosure_marshal_VOID__OBJECT,
-                  G_TYPE_NONE,
-                  1, EMPATHY_TYPE_ACCOUNT);
-
-  signals[ACCOUNT_CHANGED] =
-    g_signal_new ("account-changed",
-                  G_TYPE_FROM_CLASS (klass),
-                  G_SIGNAL_RUN_LAST,
-                  0,
-                  NULL, NULL,
-                  g_cclosure_marshal_VOID__OBJECT,
-                  G_TYPE_NONE,
-                  1, EMPATHY_TYPE_ACCOUNT);
-
-  signals[ACCOUNT_CONNECTION_CHANGED] =
-    g_signal_new ("account-connection-changed",
-                  G_TYPE_FROM_CLASS (klass),
-                  G_SIGNAL_RUN_LAST,
-                  0,
-                  NULL, NULL,
-                  _empathy_marshal_VOID__OBJECT_INT_UINT_UINT,
-                  G_TYPE_NONE,
-                  4, EMPATHY_TYPE_ACCOUNT,
-                  G_TYPE_INT,   /* reason */
-                  G_TYPE_UINT,  /* actual connection */
-                  G_TYPE_UINT); /* previous connection */
-
-  signals[GLOBAL_PRESENCE_CHANGED] =
-    g_signal_new ("global-presence-changed",
-                  G_TYPE_FROM_CLASS (klass),
-                  G_SIGNAL_RUN_LAST,
-                  0,
-                  NULL, NULL,
-                  _empathy_marshal_VOID__UINT_STRING_STRING,
-                  G_TYPE_NONE,
-                  3, G_TYPE_UINT, /* Presence type */
-                  G_TYPE_STRING,  /* status */
-                  G_TYPE_STRING); /* stauts message*/
-
-  signals[NEW_CONNECTION] =
-    g_signal_new ("new-connection",
-                  G_TYPE_FROM_CLASS (klass),
-                  G_SIGNAL_RUN_LAST,
-                  0,
-                  NULL, NULL,
-                  g_cclosure_marshal_VOID__OBJECT,
-                  G_TYPE_NONE,
-                  1, TP_TYPE_CONNECTION);
-
-  g_type_class_add_private (oclass, sizeof (EmpathyAccountManagerPriv));
-}
-
-/* public methods */
-
-EmpathyAccountManager *
-empathy_account_manager_dup_singleton (void)
-{
-  return g_object_new (EMPATHY_TYPE_ACCOUNT_MANAGER, NULL);
-}
-
-gboolean
-empathy_account_manager_is_ready (EmpathyAccountManager *manager)
-{
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-
-  return priv->ready;
-}
-
-int
-empathy_account_manager_get_connected_accounts (EmpathyAccountManager *manager)
-{
-  EmpathyAccountManagerPriv *priv;
-
-  g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
-
-  priv = GET_PRIV (manager);
-
-  return priv->connected;
-}
-
-int
-empathy_account_manager_get_connecting_accounts (
-    EmpathyAccountManager *manager)
-{
-  EmpathyAccountManagerPriv *priv;
-
-  g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
-
-  priv = GET_PRIV (manager);
-
-  return priv->connecting;
-}
-
-/**
- * empathy_account_manager_get_count:
- * @manager: a #EmpathyAccountManager
- *
- * Get the number of accounts.
- *
- * Returns: the number of accounts.
- **/
-int
-empathy_account_manager_get_count (EmpathyAccountManager *manager)
-{
-  EmpathyAccountManagerPriv *priv;
-
-  g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
-
-  priv = GET_PRIV (manager);
-
-  return g_hash_table_size (priv->accounts);
-}
-
-EmpathyAccount *
-empathy_account_manager_get_account_for_connection (
-    EmpathyAccountManager *manager,
-    TpConnection          *connection)
-{
-  EmpathyAccountManagerPriv *priv;
-  GHashTableIter iter;
-  gpointer value;
-
-  g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
-
-  priv = GET_PRIV (manager);
-
-  g_hash_table_iter_init (&iter, priv->accounts);
-  while (g_hash_table_iter_next (&iter, NULL, &value))
-    {
-      EmpathyAccount *account = EMPATHY_ACCOUNT (value);
-
-      if (connection == empathy_account_get_connection (account))
-          return account;
-    }
-
-  return NULL;
-}
-
-GList *
-empathy_account_manager_dup_accounts (EmpathyAccountManager *manager)
-{
-  EmpathyAccountManagerPriv *priv;
-  GList *ret;
-
-  g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), NULL);
-
-  priv = GET_PRIV (manager);
-
-  ret = g_hash_table_get_values (priv->accounts);
-  g_list_foreach (ret, (GFunc) g_object_ref, NULL);
-
-  return ret;
-}
-
-/**
- * empathy_account_manager_dup_connections:
- * @manager: a #EmpathyAccountManager
- *
- * Get a #GList of all ready #TpConnection. The list must be freed with
- * g_list_free, and its elements must be unreffed.
- *
- * Returns: the list of connections
- **/
-GList *
-empathy_account_manager_dup_connections (EmpathyAccountManager *manager)
-{
-  EmpathyAccountManagerPriv *priv;
-  GHashTableIter iter;
-  gpointer value;
-  GList *ret = NULL;
-
-  g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), NULL);
-
-  priv = GET_PRIV (manager);
-
-  g_hash_table_iter_init (&iter, priv->accounts);
-  while (g_hash_table_iter_next (&iter, NULL, &value))
-    {
-      EmpathyAccount *account = EMPATHY_ACCOUNT (value);
-      TpConnection *connection;
-
-      connection = empathy_account_get_connection (account);
-      if (connection != NULL)
-        ret = g_list_prepend (ret, g_object_ref (connection));
-    }
-
-  return ret;
-}
-
-void
-empathy_account_manager_request_global_presence (
-  EmpathyAccountManager *manager,
-  TpConnectionPresenceType type,
-  const gchar *status,
-  const gchar *message)
-{
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-  GHashTableIter iter;
-  gpointer value;
-
-  DEBUG ("request global presence, type: %d, status: %s, message: %s",
-         type, status, message);
-
-  g_hash_table_iter_init (&iter, priv->accounts);
-  while (g_hash_table_iter_next (&iter, NULL, &value))
-    {
-      EmpathyAccount *account = EMPATHY_ACCOUNT (value);
-      gboolean ready;
-
-      g_object_get (account, "ready", &ready, NULL);
-
-      if (ready)
-        empathy_account_request_presence (account, type, status, message);
-    }
-
-  /* save the requested global presence, to use it in case we create
-   * new accounts or some accounts become ready.
-   */
-  priv->requested_presence = type;
-
-  if (tp_strdiff (priv->requested_status, status))
-    {
-      g_free (priv->requested_status);
-      priv->requested_status = g_strdup (status);
-    }
-
-  if (tp_strdiff (priv->requested_status_message, message))
-    {
-      g_free (priv->requested_status_message);
-      priv->requested_status_message = g_strdup (message);
-    }
-}
-
-TpConnectionPresenceType
-empathy_account_manager_get_requested_global_presence (
-  EmpathyAccountManager *manager,
-  gchar **status,
-  gchar **message)
-{
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-
-  if (status != NULL)
-    *status = g_strdup (priv->requested_status);
-  if (message != NULL)
-    *message = g_strdup (priv->requested_status_message);
-
-  return priv->requested_presence;
-}
-
-TpConnectionPresenceType
-empathy_account_manager_get_global_presence (
-  EmpathyAccountManager *manager,
-  gchar **status,
-  gchar **message)
-{
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-
-  if (status != NULL)
-    *status = g_strdup (priv->global_status);
-  if (message != NULL)
-    *message = g_strdup (priv->global_status_message);
-
-  return priv->global_presence;
-}
-
-static void
-empathy_account_manager_created_cb (TpAccountManager *proxy,
-    const gchar *account_path,
-    const GError *error,
-    gpointer user_data,
-    GObject *weak_object)
-{
-  EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (weak_object);
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-  GSimpleAsyncResult *my_res = user_data;
-  EmpathyAccount *account;
-
-  if (error != NULL)
-    {
-      g_simple_async_result_set_from_error (my_res,
-          (GError *) error);
-      g_simple_async_result_complete (my_res);
-      g_object_unref (my_res);
-
-      return;
-    }
-
-  account = empathy_account_manager_ensure_account (manager, account_path);
-
-  g_hash_table_insert (priv->create_results, account, my_res);
-}
-
-void
-empathy_account_manager_create_account_async (EmpathyAccountManager *manager,
-    const gchar *connection_manager,
-    const gchar *protocol,
-    const gchar *display_name,
-    GHashTable *parameters,
-    GHashTable *properties,
-    GAsyncReadyCallback callback,
-    gpointer user_data)
-{
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-  GSimpleAsyncResult *res;
-
-  res = g_simple_async_result_new
-    (G_OBJECT (manager), callback, user_data,
-     empathy_account_manager_create_account_finish);
-
-  tp_cli_account_manager_call_create_account (priv->tp_manager,
-      -1,
-      connection_manager,
-      protocol,
-      display_name,
-      parameters,
-      properties,
-      empathy_account_manager_created_cb,
-      res,
-      NULL,
-      G_OBJECT (manager));
-}
-
-EmpathyAccount *
-empathy_account_manager_create_account_finish (
-  EmpathyAccountManager *manager, GAsyncResult *result, GError **error)
-{
-  EmpathyAccount *retval;
-
-  if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
-      error))
-    return NULL;
-
-  g_return_val_if_fail (g_simple_async_result_is_valid (result,
-    G_OBJECT (manager), empathy_account_manager_create_account_finish), NULL);
-
-  retval = EMPATHY_ACCOUNT (g_simple_async_result_get_op_res_gpointer (
-    G_SIMPLE_ASYNC_RESULT (result)));
-
-  return retval;
-}
-
diff --git a/libempathy/empathy-account-manager.h b/libempathy/empathy-account-manager.h
deleted file mode 100644
index 7b4ebd9bb..000000000
--- a/libempathy/empathy-account-manager.h
+++ /dev/null
@@ -1,111 +0,0 @@
-/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; -*- */
-/*
- * Copyright (C) 2008 Collabora Ltd.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Authors: Cosimo Cecchi <cosimo.cecchi@collabora.co.uk>
- */
-
-#ifndef __EMPATHY_ACCOUNT_MANAGER_H__
-#define __EMPATHY_ACCOUNT_MANAGER_H__
-
-#include <glib-object.h>
-
-#include "empathy-account.h"
-
-G_BEGIN_DECLS
-
-#define EMPATHY_TYPE_ACCOUNT_MANAGER  (empathy_account_manager_get_type ())
-#define EMPATHY_ACCOUNT_MANAGER(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), \
-  EMPATHY_TYPE_ACCOUNT_MANAGER, EmpathyAccountManager))
-#define EMPATHY_ACCOUNT_MANAGER_CLASS(k)  (G_TYPE_CHECK_CLASS_CAST ((k), \
-  EMPATHY_TYPE_ACCOUNT_MANAGER, EmpathyAccountManagerClass))
-#define EMPATHY_IS_ACCOUNT_MANAGER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), \
-  EMPATHY_TYPE_ACCOUNT_MANAGER))
-#define EMPATHY_IS_ACCOUNT_MANAGER_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), \
-  EMPATHY_TYPE_ACCOUNT_MANAGER))
-#define EMPATHY_ACCOUNT_MANAGER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), \
-  EMPATHY_TYPE_ACCOUNT_MANAGER, EmpathyAccountManagerClass))
-
-typedef struct _EmpathyAccountManager      EmpathyAccountManager;
-typedef struct _EmpathyAccountManagerClass EmpathyAccountManagerClass;
-
-struct _EmpathyAccountManager {
-  GObject parent;
-  gpointer priv;
-};
-
-struct _EmpathyAccountManagerClass {
-  GObjectClass parent_class;
-};
-
-GType empathy_account_manager_get_type (void);
-
-/* public methods */
-
-EmpathyAccountManager * empathy_account_manager_dup_singleton (void);
-
-gboolean empathy_account_manager_is_ready (EmpathyAccountManager *manager);
-
-int                     empathy_account_manager_get_connected_accounts
-                                (EmpathyAccountManager *manager);
-int                     empathy_account_manager_get_connecting_accounts
-                                (EmpathyAccountManager *manager);
-int                     empathy_account_manager_get_count
-                                (EmpathyAccountManager *manager);
-EmpathyAccount *        empathy_account_manager_get_account_for_connection
-                                (EmpathyAccountManager *manager,
-                                 TpConnection          *connection);
-EmpathyAccount *        empathy_account_manager_ensure_account
-                                (EmpathyAccountManager *manager,
-                                 const gchar *unique_name);
-EmpathyAccount *        empathy_account_manager_get_account
-                                (EmpathyAccountManager *manager,
-                                 const gchar *unique_name);
-GList *                 empathy_account_manager_dup_accounts
-                                (EmpathyAccountManager *manager);
-GList *                 empathy_account_manager_dup_connections
-                                (EmpathyAccountManager *manager);
-
-void empathy_account_manager_request_global_presence (
-  EmpathyAccountManager *manager,
-  TpConnectionPresenceType type,
-  const gchar *status,
-  const gchar *message);
-
-TpConnectionPresenceType empathy_account_manager_get_requested_global_presence (
-  EmpathyAccountManager *manager,
-  gchar **status,
-  gchar **message);
-
-TpConnectionPresenceType empathy_account_manager_get_global_presence (
-  EmpathyAccountManager *manager,
-  gchar **status,
-  gchar **message);
-
-void empathy_account_manager_create_account_async (
-  EmpathyAccountManager *manager, const gchar *connection_manager,
-  const gchar *protocol, const gchar *display_name,
-  GHashTable *parameters, GHashTable *properties,
-  GAsyncReadyCallback callback, gpointer user_data);
-
-EmpathyAccount * empathy_account_manager_create_account_finish (
-  EmpathyAccountManager *settings, GAsyncResult *result, GError **error);
-
-G_END_DECLS
-
-#endif /* __EMPATHY_ACCOUNT_MANAGER_H__ */
-
diff --git a/libempathy/empathy-account-settings.c b/libempathy/empathy-account-settings.c
index 0acc8006f..f33e43799 100644
--- a/libempathy/empathy-account-settings.c
+++ b/libempathy/empathy-account-settings.c
@@ -22,14 +22,15 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#include <telepathy-glib/account-manager.h>
 #include <telepathy-glib/util.h>
 #include <telepathy-glib/interfaces.h>
 #include <telepathy-glib/gtypes.h>
 
 #include "empathy-account-settings.h"
-#include "empathy-account-manager.h"
 #include "empathy-connection-managers.h"
 #include "empathy-utils.h"
+#include "empathy-idle.h"
 
 #define DEBUG_FLAG EMPATHY_DEBUG_ACCOUNT
 #include <libempathy/empathy-debug.h>
@@ -54,12 +55,11 @@ struct _EmpathyAccountSettingsPriv
 {
   gboolean dispose_has_run;
   EmpathyConnectionManagers *managers;
-  EmpathyAccountManager *account_manager;
-  gulong account_manager_ready_id;
+  TpAccountManager *account_manager;
 
   TpConnectionManager *manager;
 
-  EmpathyAccount *account;
+  TpAccount *account;
   gchar *cm_name;
   gchar *protocol;
   gchar *display_name;
@@ -72,7 +72,6 @@ struct _EmpathyAccountSettingsPriv
   GArray *required_params;
 
   gulong managers_ready_id;
-  gulong account_ready_id;
 
   GSimpleAsyncResult *apply_result;
 };
@@ -87,7 +86,7 @@ empathy_account_settings_init (EmpathyAccountSettings *obj)
 
   /* allocate any data required by the object here */
   priv->managers = empathy_connection_managers_dup_singleton ();
-  priv->account_manager = empathy_account_manager_dup_singleton ();
+  priv->account_manager = tp_account_manager_dup ();
 
   priv->parameters = g_hash_table_new_full (g_str_hash, g_str_equal,
     g_free, (GDestroyNotify) tp_g_value_slice_free);
@@ -97,8 +96,10 @@ empathy_account_settings_init (EmpathyAccountSettings *obj)
 
 static void empathy_account_settings_dispose (GObject *object);
 static void empathy_account_settings_finalize (GObject *object);
-static void empathy_account_settings_ready_cb (GObject *obj,
-  GParamSpec *spec, gpointer user_data);
+static void empathy_account_settings_account_ready_cb (GObject *source_object,
+    GAsyncResult *result, gpointer user_data);
+static void empathy_account_settings_managers_ready_cb (GObject *obj,
+    GParamSpec *pspec, gpointer user_data);
 static void empathy_account_settings_check_readyness (
     EmpathyAccountSettings *self);
 
@@ -181,11 +182,11 @@ empathy_account_settings_constructed (GObject *object)
       g_free (priv->protocol);
 
       priv->cm_name =
-        g_strdup (empathy_account_get_connection_manager (priv->account));
+        g_strdup (tp_account_get_connection_manager (priv->account));
       priv->protocol =
-        g_strdup (empathy_account_get_protocol (priv->account));
+        g_strdup (tp_account_get_protocol (priv->account));
       priv->icon_name = g_strdup
-        (empathy_account_get_icon_name (priv->account));
+        (tp_account_get_icon_name (priv->account));
     }
   else
     {
@@ -198,10 +199,10 @@ empathy_account_settings_constructed (GObject *object)
 
   if (!priv->ready)
     {
-      g_signal_connect (priv->account, "notify::ready",
-        G_CALLBACK (empathy_account_settings_ready_cb), self);
+      tp_account_prepare_async (priv->account, NULL,
+          empathy_account_settings_account_ready_cb, self);
       g_signal_connect (priv->managers, "notify::ready",
-        G_CALLBACK (empathy_account_settings_ready_cb), self);
+        G_CALLBACK (empathy_account_settings_managers_ready_cb), self);
     }
 
   if (G_OBJECT_CLASS (
@@ -229,8 +230,8 @@ empathy_account_settings_class_init (
   g_object_class_install_property (object_class, PROP_ACCOUNT,
     g_param_spec_object ("account",
       "Account",
-      "The EmpathyAccount backing these settings",
-      EMPATHY_TYPE_ACCOUNT,
+      "The TpAccount backing these settings",
+      TP_TYPE_ACCOUNT,
       G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 
   g_object_class_install_property (object_class, PROP_CM_NAME,
@@ -293,19 +294,10 @@ empathy_account_settings_dispose (GObject *object)
     g_object_unref (priv->manager);
   priv->manager = NULL;
 
-  if (priv->account_manager_ready_id != 0)
-    g_signal_handler_disconnect (priv->account_manager,
-        priv->account_manager_ready_id);
-  priv->account_manager_ready_id = 0;
-
   if (priv->account_manager != NULL)
     g_object_unref (priv->account_manager);
   priv->account_manager = NULL;
 
-  if (priv->account_ready_id != 0)
-    g_signal_handler_disconnect (priv->account, priv->account_ready_id);
-  priv->account_ready_id = 0;
-
   if (priv->account != NULL)
     g_object_unref (priv->account);
   priv->account = NULL;
@@ -360,7 +352,8 @@ empathy_account_settings_check_readyness (EmpathyAccountSettings *self)
   if (priv->ready)
     return;
 
-  if (priv->account != NULL && !empathy_account_is_ready (priv->account))
+  if (priv->account != NULL
+      && !tp_account_is_prepared (priv->account, TP_ACCOUNT_FEATURE_CORE))
       return;
 
   if (!empathy_connection_managers_is_ready (priv->managers))
@@ -376,11 +369,11 @@ empathy_account_settings_check_readyness (EmpathyAccountSettings *self)
     {
       g_free (priv->display_name);
       priv->display_name =
-        g_strdup (empathy_account_get_display_name (priv->account));
+        g_strdup (tp_account_get_display_name (priv->account));
 
       g_free (priv->icon_name);
       priv->icon_name =
-        g_strdup (empathy_account_get_icon_name (priv->account));
+        g_strdup (tp_account_get_icon_name (priv->account));
     }
 
   tp_protocol = tp_connection_manager_get_protocol (priv->manager,
@@ -416,8 +409,27 @@ empathy_account_settings_check_readyness (EmpathyAccountSettings *self)
 }
 
 static void
-empathy_account_settings_ready_cb (GObject *obj,
-    GParamSpec *spec,
+empathy_account_settings_account_ready_cb (GObject *source_object,
+    GAsyncResult *result,
+    gpointer user_data)
+{
+  EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (user_data);
+  TpAccount *account = TP_ACCOUNT (source_object);
+  GError *error = NULL;
+
+  if (!tp_account_prepare_finish (account, result, &error))
+    {
+      DEBUG ("Failed to prepare account: %s", error->message);
+      g_error_free (error);
+      return;
+    }
+
+  empathy_account_settings_check_readyness (settings);
+}
+
+static void
+empathy_account_settings_managers_ready_cb (GObject *object,
+    GParamSpec *pspec,
     gpointer user_data)
 {
   EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (user_data);
@@ -438,7 +450,7 @@ empathy_account_settings_new (const gchar *connection_manager,
 }
 
 EmpathyAccountSettings *
-empathy_account_settings_new_for_account (EmpathyAccount *account)
+empathy_account_settings_new_for_account (TpAccount *account)
 {
   return g_object_new (EMPATHY_TYPE_ACCOUNT_SETTINGS,
       "account", account,
@@ -506,7 +518,7 @@ empathy_account_settings_get_display_name (EmpathyAccountSettings *settings)
   return priv->display_name;
 }
 
-EmpathyAccount *
+TpAccount *
 empathy_account_settings_get_account (EmpathyAccountSettings *settings)
 {
   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
@@ -621,7 +633,7 @@ empathy_account_settings_get (EmpathyAccountSettings *settings,
     {
       const GHashTable *parameters;
 
-      parameters = empathy_account_get_parameters (priv->account);
+      parameters = tp_account_get_parameters (priv->account);
       result = tp_asv_lookup (parameters, param);
 
       if (result != NULL)
@@ -910,10 +922,10 @@ account_settings_display_name_set_cb (GObject *src,
     gpointer user_data)
 {
   GError *error = NULL;
-  EmpathyAccount *account = EMPATHY_ACCOUNT (src);
+  TpAccount *account = TP_ACCOUNT (src);
   GSimpleAsyncResult *set_result = user_data;
 
-  empathy_account_set_display_name_finish (account, res, &error);
+  tp_account_set_display_name_finish (account, res, &error);
 
   if (error != NULL)
     {
@@ -950,7 +962,7 @@ empathy_account_settings_set_display_name_async (
       return;
     }
 
-  empathy_account_set_display_name_async (priv->account, name,
+  tp_account_set_display_name_async (priv->account, name,
       account_settings_display_name_set_cb, result);
 }
 
@@ -977,10 +989,10 @@ account_settings_icon_name_set_cb (GObject *src,
     gpointer user_data)
 {
   GError *error = NULL;
-  EmpathyAccount *account = EMPATHY_ACCOUNT (src);
+  TpAccount *account = TP_ACCOUNT (src);
   GSimpleAsyncResult *set_result = user_data;
 
-  empathy_account_set_icon_name_finish (account, res, &error);
+  tp_account_set_icon_name_finish (account, res, &error);
 
   if (error != NULL)
     {
@@ -1017,7 +1029,7 @@ empathy_account_settings_set_icon_name_async (
       return;
     }
 
-  empathy_account_set_icon_name_async (priv->account, name,
+  tp_account_set_icon_name_async (priv->account, name,
       account_settings_icon_name_set_cb, result);
 }
 
@@ -1048,8 +1060,8 @@ empathy_account_settings_account_updated (GObject *source,
   GSimpleAsyncResult *r;
   GError *error = NULL;
 
-  if (!empathy_account_update_settings_finish (EMPATHY_ACCOUNT (source),
-    result, &error))
+  if (!tp_account_update_parameters_finish (TP_ACCOUNT (source),
+          result, NULL, &error))
     {
       g_simple_async_result_set_from_error (priv->apply_result, error);
       g_error_free (error);
@@ -1073,12 +1085,12 @@ empathy_account_settings_created_cb (GObject *source,
 {
   EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (user_data);
   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
-  EmpathyAccount *account;
+  TpAccount *account;
   GError *error = NULL;
   GSimpleAsyncResult *r;
 
-  account = empathy_account_manager_create_account_finish (
-    EMPATHY_ACCOUNT_MANAGER (source), result, &error);
+  account = tp_account_manager_create_account_finish (
+    TP_ACCOUNT_MANAGER (source), result, &error);
 
   if (account == NULL)
     {
@@ -1106,11 +1118,13 @@ empathy_account_settings_do_create_account (EmpathyAccountSettings *settings)
   TpConnectionPresenceType type;
   gchar *status;
   gchar *message;
+  EmpathyIdle *idle;
 
   properties = tp_asv_new (NULL, NULL);
 
-  type = empathy_account_manager_get_requested_global_presence
-    (priv->account_manager, &status, &message);
+  idle = empathy_idle_dup_singleton ();
+  type = empathy_idle_get_requested_presence (idle, &status, &message);
+  g_object_unref (idle);
 
   if (type != TP_CONNECTION_PRESENCE_TYPE_UNSET)
     {
@@ -1142,7 +1156,7 @@ empathy_account_settings_do_create_account (EmpathyAccountSettings *settings)
   tp_asv_set_string (properties, TP_IFACE_ACCOUNT ".Icon",
       priv->icon_name);
 
-  empathy_account_manager_create_account_async (priv->account_manager,
+  tp_account_manager_create_account_async (priv->account_manager,
     priv->cm_name, priv->protocol, priv->display_name,
     priv->parameters, properties,
     empathy_account_settings_created_cb,
@@ -1152,22 +1166,24 @@ empathy_account_settings_do_create_account (EmpathyAccountSettings *settings)
 }
 
 static void
-empathy_account_settings_manager_ready_cb (EmpathyAccountManager *manager,
-    GParamSpec *spec,
+empathy_account_settings_manager_ready_cb (GObject *source_object,
+    GAsyncResult *result,
     gpointer user_data)
 {
   EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (user_data);
   EmpathyAccountSettingsPriv *priv = GET_PRIV (settings);
+  TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object);
+  GError *error = NULL;
 
-  if (empathy_account_manager_is_ready (manager))
+  if (!tp_account_manager_prepare_finish (account_manager, result, &error))
     {
-      g_assert (priv->apply_result != NULL && priv->account == NULL);
-      g_signal_handler_disconnect (priv->account_manager,
-        priv->account_manager_ready_id);
-      priv->account_manager_ready_id = 0;
-
-      empathy_account_settings_do_create_account (settings);
+      DEBUG ("Failed to prepare account manager: %s", error->message);
+      g_error_free (error);
+      return;
     }
+
+  g_assert (priv->apply_result != NULL && priv->account == NULL);
+  empathy_account_settings_do_create_account (settings);
 }
 
 void
@@ -1180,8 +1196,8 @@ empathy_account_settings_apply_async (EmpathyAccountSettings *settings,
   if (priv->apply_result != NULL)
     {
       g_simple_async_report_error_in_idle (G_OBJECT (settings),
-        callback, user_data,
-        G_IO_ERROR, G_IO_ERROR_PENDING, "Applying already in progress");
+          callback, user_data,
+          G_IO_ERROR, G_IO_ERROR_PENDING, "Applying already in progress");
       return;
     }
 
@@ -1190,20 +1206,14 @@ empathy_account_settings_apply_async (EmpathyAccountSettings *settings,
 
   if (priv->account == NULL)
     {
-      if (empathy_account_manager_is_ready (priv->account_manager))
-        empathy_account_settings_do_create_account (settings);
-      else
-        priv->account_manager_ready_id = g_signal_connect (
-            priv->account_manager,
-            "notify::ready",
-            G_CALLBACK (empathy_account_settings_manager_ready_cb),
-            settings);
+      tp_account_manager_prepare_async (priv->account_manager, NULL,
+          empathy_account_settings_manager_ready_cb, settings);
     }
   else
     {
-      empathy_account_update_settings_async (priv->account,
-        priv->parameters, (const gchar **)priv->unset_parameters->data,
-        empathy_account_settings_account_updated, settings);
+      tp_account_update_parameters_async (priv->account,
+          priv->parameters, (const gchar **)priv->unset_parameters->data,
+          empathy_account_settings_account_updated, settings);
     }
 }
 
@@ -1224,12 +1234,12 @@ empathy_account_settings_apply_finish (EmpathyAccountSettings *settings,
 
 gboolean
 empathy_account_settings_has_account (EmpathyAccountSettings *settings,
-    EmpathyAccount *account)
+    TpAccount *account)
 {
   EmpathyAccountSettingsPriv *priv;
 
   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_SETTINGS (settings), FALSE);
-  g_return_val_if_fail (EMPATHY_IS_ACCOUNT (account), FALSE);
+  g_return_val_if_fail (TP_IS_ACCOUNT (account), FALSE);
 
   priv = GET_PRIV (settings);
 
@@ -1262,7 +1272,7 @@ empathy_account_settings_is_valid (EmpathyAccountSettings *settings)
         {
           const GHashTable *account_params;
 
-          account_params = empathy_account_get_parameters (priv->account);
+          account_params = tp_account_get_parameters (priv->account);
           if (tp_asv_lookup (account_params, current))
             continue;
         }
diff --git a/libempathy/empathy-account-settings.h b/libempathy/empathy-account-settings.h
index c7d263e3b..0ea9b5567 100644
--- a/libempathy/empathy-account-settings.h
+++ b/libempathy/empathy-account-settings.h
@@ -24,7 +24,7 @@
 #include <glib-object.h>
 #include <gio/gio.h>
 
-#include <libempathy/empathy-account.h>
+#include <telepathy-glib/account.h>
 #include <telepathy-glib/connection-manager.h>
 
 G_BEGIN_DECLS
@@ -66,7 +66,7 @@ EmpathyAccountSettings * empathy_account_settings_new (
     const char *display_name);
 
 EmpathyAccountSettings * empathy_account_settings_new_for_account (
-    EmpathyAccount *account);
+    TpAccount *account);
 
 gboolean empathy_account_settings_is_ready (EmpathyAccountSettings *settings);
 
@@ -74,11 +74,11 @@ const gchar *empathy_account_settings_get_cm (EmpathyAccountSettings *settings);
 const gchar *empathy_account_settings_get_protocol (
     EmpathyAccountSettings *settings);
 
-EmpathyAccount *empathy_account_settings_get_account (
+TpAccount *empathy_account_settings_get_account (
     EmpathyAccountSettings *settings);
 
 gboolean empathy_account_settings_has_account (
-    EmpathyAccountSettings *settings, EmpathyAccount *account);
+    EmpathyAccountSettings *settings, TpAccount *account);
 
 TpConnectionManagerParam *empathy_account_settings_get_tp_params (
     EmpathyAccountSettings *settings);
diff --git a/libempathy/empathy-account.c b/libempathy/empathy-account.c
deleted file mode 100644
index fb1b2756d..000000000
--- a/libempathy/empathy-account.c
+++ /dev/null
@@ -1,1305 +0,0 @@
-/*
- * empathy-account.c - Source for EmpathyAccount
- * Copyright (C) 2009 Collabora Ltd.
- * @author Sjoerd Simons <sjoerd.simons@collabora.co.uk>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <telepathy-glib/enums.h>
-#include <telepathy-glib/dbus.h>
-#include <telepathy-glib/account.h>
-#include <telepathy-glib/gtypes.h>
-#include <telepathy-glib/util.h>
-#include <telepathy-glib/interfaces.h>
-#include <telepathy-glib/defs.h>
-
-#define DEBUG_FLAG EMPATHY_DEBUG_ACCOUNT
-#include <libempathy/empathy-debug.h>
-
-#include <glib/gi18n-lib.h>
-
-#include "empathy-account.h"
-#include "empathy-account-manager.h"
-#include "empathy-utils.h"
-#include "empathy-marshal.h"
-
-/* signals */
-enum {
-  STATUS_CHANGED,
-  PRESENCE_CHANGED,
-  REMOVED,
-  LAST_SIGNAL
-};
-
-static guint signals[LAST_SIGNAL];
-
-/* properties */
-enum {
-  PROP_ENABLED = 1,
-  PROP_PRESENCE,
-  PROP_STATUS,
-  PROP_STATUS_MESSAGE,
-  PROP_READY,
-  PROP_CONNECTION_STATUS,
-  PROP_CONNECTION_STATUS_REASON,
-  PROP_CONNECTION,
-  PROP_UNIQUE_NAME,
-  PROP_DBUS_DAEMON,
-  PROP_DISPLAY_NAME
-};
-
-G_DEFINE_TYPE(EmpathyAccount, empathy_account, G_TYPE_OBJECT)
-
-/* private structure */
-typedef struct _EmpathyAccountPriv EmpathyAccountPriv;
-
-struct _EmpathyAccountPriv
-{
-  gboolean dispose_has_run;
-
-  TpConnection *connection;
-  guint connection_invalidated_id;
-
-  TpConnectionStatus connection_status;
-  TpConnectionStatusReason reason;
-
-  TpConnectionPresenceType presence;
-  gchar *status;
-  gchar *message;
-
-  gboolean enabled;
-  gboolean valid;
-  gboolean ready;
-  gboolean removed;
-  /* Timestamp when the connection got connected in seconds since the epoch */
-  glong connect_time;
-
-  gchar *cm_name;
-  gchar *proto_name;
-  gchar *icon_name;
-
-  gchar *unique_name;
-  gchar *display_name;
-  TpDBusDaemon *dbus;
-
-  TpAccount *account;
-  GHashTable *parameters;
-};
-
-#define GET_PRIV(obj)  EMPATHY_GET_PRIV (obj, EmpathyAccount)
-
-static void _empathy_account_set_connection (EmpathyAccount *account,
-    const gchar *path);
-
-static void
-empathy_account_init (EmpathyAccount *obj)
-{
-  EmpathyAccountPriv *priv;
-
-  priv =  G_TYPE_INSTANCE_GET_PRIVATE (obj,
-    EMPATHY_TYPE_ACCOUNT, EmpathyAccountPriv);
-
-  obj->priv = priv;
-
-  priv->connection_status = TP_CONNECTION_STATUS_DISCONNECTED;
-}
-
-static void
-empathy_account_set_property (GObject *object,
-    guint prop_id,
-    const GValue *value,
-    GParamSpec *pspec)
-{
-  EmpathyAccount *account = EMPATHY_ACCOUNT (object);
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-
-  switch (prop_id)
-    {
-      case PROP_ENABLED:
-        empathy_account_set_enabled_async (account,
-            g_value_get_boolean (value), NULL, NULL);
-        break;
-      case PROP_UNIQUE_NAME:
-        priv->unique_name = g_value_dup_string (value);
-        break;
-      case PROP_DBUS_DAEMON:
-        priv->dbus = g_value_get_object (value);
-        break;
-      default:
-        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-        break;
-    }
-}
-
-static void
-empathy_account_get_property (GObject *object,
-    guint prop_id,
-    GValue *value,
-    GParamSpec *pspec)
-{
-  EmpathyAccount *account = EMPATHY_ACCOUNT (object);
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-
-  switch (prop_id)
-    {
-      case PROP_ENABLED:
-        g_value_set_boolean (value, priv->enabled);
-        break;
-      case PROP_READY:
-        g_value_set_boolean (value, priv->ready);
-        break;
-      case PROP_PRESENCE:
-        g_value_set_uint (value, priv->presence);
-        break;
-      case PROP_STATUS:
-        g_value_set_string (value, priv->status);
-        break;
-      case PROP_STATUS_MESSAGE:
-        g_value_set_string (value, priv->message);
-        break;
-      case PROP_CONNECTION_STATUS:
-        g_value_set_uint (value, priv->connection_status);
-        break;
-      case PROP_CONNECTION_STATUS_REASON:
-        g_value_set_uint (value, priv->reason);
-        break;
-      case PROP_CONNECTION:
-        g_value_set_object (value,
-            empathy_account_get_connection (account));
-        break;
-      case PROP_UNIQUE_NAME:
-        g_value_set_string (value,
-            empathy_account_get_unique_name (account));
-        break;
-      case PROP_DISPLAY_NAME:
-        g_value_set_string (value,
-            empathy_account_get_display_name (account));
-        break;
-      case PROP_DBUS_DAEMON:
-        g_value_set_object (value, priv->dbus);
-        break;
-      default:
-        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-        break;
-    }
-}
-
-static void
-empathy_account_update (EmpathyAccount *account,
-    GHashTable *properties)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-  GValueArray *arr;
-  TpConnectionStatus old_s = priv->connection_status;
-  gboolean presence_changed = FALSE;
-
-  if (g_hash_table_lookup (properties, "ConnectionStatus") != NULL)
-    priv->connection_status =
-      tp_asv_get_int32 (properties, "ConnectionStatus", NULL);
-
-  if (g_hash_table_lookup (properties, "ConnectionStatusReason") != NULL)
-    priv->reason = tp_asv_get_int32 (properties,
-      "ConnectionStatusReason", NULL);
-
-  if (g_hash_table_lookup (properties, "CurrentPresence") != NULL)
-    {
-      presence_changed = TRUE;
-      arr = tp_asv_get_boxed (properties, "CurrentPresence",
-        TP_STRUCT_TYPE_SIMPLE_PRESENCE);
-      priv->presence = g_value_get_uint (g_value_array_get_nth (arr, 0));
-
-      g_free (priv->status);
-      priv->status = g_value_dup_string (g_value_array_get_nth (arr, 1));
-
-      g_free (priv->message);
-      priv->message = g_value_dup_string (g_value_array_get_nth (arr, 2));
-    }
-
-  if (g_hash_table_lookup (properties, "DisplayName") != NULL)
-    {
-      g_free (priv->display_name);
-      priv->display_name =
-        g_strdup (tp_asv_get_string (properties, "DisplayName"));
-      g_object_notify (G_OBJECT (account), "display-name");
-    }
-
-  if (g_hash_table_lookup (properties, "Icon") != NULL)
-    {
-      const gchar *icon_name;
-
-      icon_name = tp_asv_get_string (properties, "Icon");
-
-      g_free (priv->icon_name);
-
-      if (EMP_STR_EMPTY (icon_name))
-        priv->icon_name = empathy_protocol_icon_name (priv->proto_name);
-      else
-        priv->icon_name = g_strdup (icon_name);
-    }
-
-  if (g_hash_table_lookup (properties, "Enabled") != NULL)
-    {
-      gboolean enabled = tp_asv_get_boolean (properties, "Enabled", NULL);
-      if (priv->enabled != enabled)
-        {
-          priv->enabled = enabled;
-          g_object_notify (G_OBJECT (account), "enabled");
-        }
-    }
-
-  if (g_hash_table_lookup (properties, "Valid") != NULL)
-    priv->valid = tp_asv_get_boolean (properties, "Valid", NULL);
-
-  if (g_hash_table_lookup (properties, "Parameters") != NULL)
-    {
-      GHashTable *parameters;
-
-      parameters = tp_asv_get_boxed (properties, "Parameters",
-        TP_HASH_TYPE_STRING_VARIANT_MAP);
-
-      if (priv->parameters != NULL)
-        g_hash_table_unref (priv->parameters);
-
-      priv->parameters = g_boxed_copy (TP_HASH_TYPE_STRING_VARIANT_MAP,
-        parameters);
-    }
-
-  if (!priv->ready)
-    {
-      priv->ready = TRUE;
-      g_object_notify (G_OBJECT (account), "ready");
-    }
-
-  if (priv->connection_status != old_s)
-    {
-      if (priv->connection_status == TP_CONNECTION_STATUS_CONNECTED)
-        {
-          GTimeVal val;
-          g_get_current_time (&val);
-
-          priv->connect_time = val.tv_sec;
-        }
-
-      g_signal_emit (account, signals[STATUS_CHANGED], 0,
-        old_s, priv->connection_status, priv->reason);
-
-      g_object_notify (G_OBJECT (account), "connection-status");
-      g_object_notify (G_OBJECT (account), "connection-status-reason");
-    }
-
-  if (presence_changed)
-    {
-      g_signal_emit (account, signals[PRESENCE_CHANGED], 0,
-        priv->presence, priv->status, priv->message);
-      g_object_notify (G_OBJECT (account), "presence");
-      g_object_notify (G_OBJECT (account), "status");
-      g_object_notify (G_OBJECT (account), "status-message");
-    }
-
-  if (g_hash_table_lookup (properties, "Connection") != NULL)
-    {
-      const gchar *conn_path =
-        tp_asv_get_object_path (properties, "Connection");
-
-      _empathy_account_set_connection (account, conn_path);
-    }
-}
-
-static void
-empathy_account_properties_changed (TpAccount *proxy,
-    GHashTable *properties,
-    gpointer user_data,
-    GObject *weak_object)
-{
-  EmpathyAccount *account = EMPATHY_ACCOUNT (weak_object);
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-
-  if (!priv->ready)
-    return;
-
-  empathy_account_update (account, properties);
-}
-
-static void
-empathy_account_removed_cb (TpAccount *proxy,
-    gpointer user_data,
-    GObject *weak_object)
-{
-  EmpathyAccount *account = EMPATHY_ACCOUNT (weak_object);
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-
-  if (priv->removed)
-    return;
-
-  priv->removed = TRUE;
-
-  g_signal_emit (account, signals[REMOVED], 0);
-}
-
-static void
-empathy_account_got_all_cb (TpProxy *proxy,
-    GHashTable *properties,
-    const GError *error,
-    gpointer user_data,
-    GObject *weak_object)
-{
-  EmpathyAccount *account = EMPATHY_ACCOUNT (weak_object);
-
-  DEBUG ("Got whole set of properties for %s",
-    empathy_account_get_unique_name (account));
-
-  if (error != NULL)
-    {
-      DEBUG ("Failed to get the initial set of account properties: %s",
-        error->message);
-      return;
-    }
-
-  empathy_account_update (account, properties);
-}
-
-static gchar *
-empathy_account_unescape_protocol (const gchar *protocol, gssize len)
-{
-  gchar  *result, *escape;
-  /* Bad implementation might accidentally use tp_escape_as_identifier,
-   * which escapes - in the wrong way... */
-  if ((escape = g_strstr_len (protocol, len, "_2d")) != NULL)
-    {
-      GString *str;
-      const gchar *input;
-
-      str = g_string_new ("");
-      input = protocol;
-      do {
-        g_string_append_len (str, input, escape - input);
-        g_string_append_c (str, '-');
-
-        len -= escape - input + 3;
-        input = escape + 3;
-      } while ((escape = g_strstr_len (input, len, "_2d")) != NULL);
-
-      g_string_append_len (str, input, len);
-
-      result = g_string_free (str, FALSE);
-    }
-  else
-    {
-      result = g_strndup (protocol, len);
-    }
-
-  g_strdelimit (result, "_", '-');
-
-  return result;
-}
-
-static gboolean
-empathy_account_parse_unique_name (const gchar *bus_name,
-    gchar **protocol, gchar **manager)
-{
-  const gchar *proto, *proto_end;
-  const gchar *cm, *cm_end;
-
-  g_return_val_if_fail (
-    g_str_has_prefix (bus_name, TP_ACCOUNT_OBJECT_PATH_BASE), FALSE);
-
-  cm = bus_name + strlen (TP_ACCOUNT_OBJECT_PATH_BASE);
-
-  for (cm_end = cm; *cm_end != '/' && *cm_end != '\0'; cm_end++)
-    /* pass */;
-
-  if (*cm_end == '\0')
-    return FALSE;
-
-  if (cm_end == '\0')
-    return FALSE;
-
-  proto = cm_end + 1;
-
-  for (proto_end = proto; *proto_end != '/' && *proto_end != '\0'; proto_end++)
-    /* pass */;
-
-  if (*proto_end == '\0')
-    return FALSE;
-
-  if (protocol != NULL)
-    {
-      *protocol = empathy_account_unescape_protocol (proto, proto_end - proto);
-    }
-
-  if (manager != NULL)
-    *manager = g_strndup (cm, cm_end - cm);
-
-  return TRUE;
-}
-
-static void
-account_invalidated_cb (TpProxy *proxy, guint domain, gint code,
-  gchar *message, gpointer user_data)
-{
-  EmpathyAccount *account = EMPATHY_ACCOUNT (user_data);
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-
-  if (priv->removed)
-    return;
-
-  priv->removed = TRUE;
-
-  g_signal_emit (account, signals[REMOVED], 0);
-}
-
-static void
-empathy_account_constructed (GObject *object)
-{
-  EmpathyAccount *account = EMPATHY_ACCOUNT (object);
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-
-  priv->account = tp_account_new (priv->dbus, priv->unique_name, NULL);
-
-  g_signal_connect (priv->account, "invalidated",
-    G_CALLBACK (account_invalidated_cb), object);
-
-  empathy_account_parse_unique_name (priv->unique_name,
-    &(priv->proto_name), &(priv->cm_name));
-
-  priv->icon_name = empathy_protocol_icon_name (priv->proto_name);
-
-  tp_cli_account_connect_to_account_property_changed (priv->account,
-    empathy_account_properties_changed,
-    NULL, NULL, object, NULL);
-
-  tp_cli_account_connect_to_removed (priv->account,
-    empathy_account_removed_cb,
-    NULL, NULL, object, NULL);
-
-  empathy_account_refresh_properties (account);
-}
-
-static void empathy_account_dispose (GObject *object);
-static void empathy_account_finalize (GObject *object);
-
-static void
-empathy_account_class_init (EmpathyAccountClass *empathy_account_class)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (empathy_account_class);
-
-  g_type_class_add_private (empathy_account_class,
-    sizeof (EmpathyAccountPriv));
-
-  object_class->set_property = empathy_account_set_property;
-  object_class->get_property = empathy_account_get_property;
-  object_class->dispose = empathy_account_dispose;
-  object_class->finalize = empathy_account_finalize;
-  object_class->constructed = empathy_account_constructed;
-
-  g_object_class_install_property (object_class, PROP_ENABLED,
-    g_param_spec_boolean ("enabled",
-      "Enabled",
-      "Whether this account is enabled or not",
-      FALSE,
-      G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE));
-
-  g_object_class_install_property (object_class, PROP_READY,
-    g_param_spec_boolean ("ready",
-      "Ready",
-      "Whether this account is ready to be used",
-      FALSE,
-      G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
-
-  g_object_class_install_property (object_class, PROP_PRESENCE,
-    g_param_spec_uint ("presence",
-      "Presence",
-      "The account connections presence type",
-      0,
-      NUM_TP_CONNECTION_PRESENCE_TYPES,
-      TP_CONNECTION_PRESENCE_TYPE_UNSET,
-      G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
-
-  g_object_class_install_property (object_class, PROP_STATUS,
-    g_param_spec_string ("status",
-      "Status",
-      "The Status string of the account",
-      NULL,
-      G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
-
-  g_object_class_install_property (object_class, PROP_STATUS_MESSAGE,
-    g_param_spec_string ("status-message",
-      "status-message",
-      "The Status message string of the account",
-      NULL,
-      G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
-
-  g_object_class_install_property (object_class, PROP_CONNECTION_STATUS,
-    g_param_spec_uint ("connection-status",
-      "ConnectionStatus",
-      "The accounts connections status type",
-      0,
-      NUM_TP_CONNECTION_STATUSES,
-      TP_CONNECTION_STATUS_DISCONNECTED,
-      G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
-
-  g_object_class_install_property (object_class, PROP_CONNECTION_STATUS_REASON,
-    g_param_spec_uint ("connection-status-reason",
-      "ConnectionStatusReason",
-      "The account connections status reason",
-      0,
-      NUM_TP_CONNECTION_STATUS_REASONS,
-      TP_CONNECTION_STATUS_REASON_NONE_SPECIFIED,
-      G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
-
-  g_object_class_install_property (object_class, PROP_CONNECTION,
-    g_param_spec_object ("connection",
-      "Connection",
-      "The accounts connection",
-      TP_TYPE_CONNECTION,
-      G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
-
-  g_object_class_install_property (object_class, PROP_UNIQUE_NAME,
-    g_param_spec_string ("unique-name",
-      "UniqueName",
-      "The accounts unique name",
-      NULL,
-      G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
-
-  g_object_class_install_property (object_class, PROP_DBUS_DAEMON,
-    g_param_spec_object ("dbus-daemon",
-      "dbus-daemon",
-      "The Tp Dbus daemon on which this account exists",
-      TP_TYPE_DBUS_DAEMON,
-      G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
-
-  g_object_class_install_property (object_class, PROP_DISPLAY_NAME,
-    g_param_spec_string ("display-name",
-      "DisplayName",
-      "The accounts display name",
-      NULL,
-      G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
-
-  signals[STATUS_CHANGED] = g_signal_new ("status-changed",
-    G_TYPE_FROM_CLASS (object_class),
-    G_SIGNAL_RUN_LAST,
-    0, NULL, NULL,
-    _empathy_marshal_VOID__UINT_UINT_UINT,
-    G_TYPE_NONE, 3, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT);
-
-  signals[PRESENCE_CHANGED] = g_signal_new ("presence-changed",
-    G_TYPE_FROM_CLASS (object_class),
-    G_SIGNAL_RUN_LAST,
-    0, NULL, NULL,
-    _empathy_marshal_VOID__UINT_STRING_STRING,
-    G_TYPE_NONE, 3, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING);
-
-  signals[REMOVED] = g_signal_new ("removed",
-    G_TYPE_FROM_CLASS (object_class),
-    G_SIGNAL_RUN_LAST,
-    0, NULL, NULL,
-    g_cclosure_marshal_VOID__VOID,
-    G_TYPE_NONE, 0);
-}
-
-static void
-empathy_account_free_connection (EmpathyAccount *account)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-  TpConnection *conn;
-
-  if (priv->connection == NULL)
-    return;
-
-  conn = priv->connection;
-  priv->connection = NULL;
-
-  if (priv->connection_invalidated_id != 0)
-    g_signal_handler_disconnect (conn, priv->connection_invalidated_id);
-  priv->connection_invalidated_id = 0;
-
-  g_object_unref (conn);
-}
-
-void
-empathy_account_dispose (GObject *object)
-{
-  EmpathyAccount *self = EMPATHY_ACCOUNT (object);
-  EmpathyAccountPriv *priv = GET_PRIV (self);
-
-  if (priv->dispose_has_run)
-    return;
-
-  priv->dispose_has_run = TRUE;
-
-  empathy_account_free_connection (self);
-
-  /* release any references held by the object here */
-  if (G_OBJECT_CLASS (empathy_account_parent_class)->dispose != NULL)
-    G_OBJECT_CLASS (empathy_account_parent_class)->dispose (object);
-}
-
-void
-empathy_account_finalize (GObject *object)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (object);
-
-  g_free (priv->status);
-  g_free (priv->message);
-
-  g_free (priv->cm_name);
-  g_free (priv->proto_name);
-  g_free (priv->icon_name);
-  g_free (priv->display_name);
-
-  /* free any data held directly by the object here */
-  if (G_OBJECT_CLASS (empathy_account_parent_class)->finalize != NULL)
-    G_OBJECT_CLASS (empathy_account_parent_class)->finalize (object);
-}
-
-gboolean
-empathy_account_is_just_connected (EmpathyAccount *account)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-  GTimeVal val;
-
-  if (priv->connection_status != TP_CONNECTION_STATUS_CONNECTED)
-    return FALSE;
-
-  g_get_current_time (&val);
-
-  return (val.tv_sec - priv->connect_time) < 10;
-}
-
-/**
- * empathy_account_get_connection:
- * @account: a #EmpathyAccount
- *
- * Get the connection of the account, or NULL if account is offline or the
- * connection is not yet ready. This function does not return a new ref.
- *
- * Returns: the connection of the account.
- **/
-TpConnection *
-empathy_account_get_connection (EmpathyAccount *account)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-
-  if (priv->connection != NULL &&
-      tp_connection_is_ready (priv->connection))
-    return priv->connection;
-
-  return NULL;
-}
-
-/**
- * empathy_account_get_connection_for_path:
- * @account: a #EmpathyAccount
- * @patch: the path to connection object for #EmpathyAccount
- *
- * Get the connection of the account on path. This function does not return a
- * new ref. It is not guaranteed that the returned connection object is ready
- *
- * Returns: the connection of the account.
- **/
-TpConnection *
-empathy_account_get_connection_for_path (EmpathyAccount *account,
-  const gchar *path)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-
-  /* double-check that the object path is valid */
-  if (!tp_dbus_check_valid_object_path (path, NULL))
-    return NULL;
-
-  /* Should be a full object path, not the special "/" value */
-  if (strlen (path) == 1)
-    return NULL;
-
-  _empathy_account_set_connection (account, path);
-
-  return priv->connection;
-}
-
-/**
- * empathy_account_get_unique_name:
- * @account: a #EmpathyAccount
- *
- * Returns: the unique name of the account.
- **/
-const gchar *
-empathy_account_get_unique_name (EmpathyAccount *account)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-
-  return priv->unique_name;
-}
-
-/**
- * empathy_account_get_display_name:
- * @account: a #EmpathyAccount
- *
- * Returns: the display name of the account.
- **/
-const gchar *
-empathy_account_get_display_name (EmpathyAccount *account)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-
-  return priv->display_name;
-}
-
-gboolean
-empathy_account_is_valid (EmpathyAccount *account)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-
-  return priv->valid;
-}
-
-const gchar *
-empathy_account_get_connection_manager (EmpathyAccount *account)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-
-  return priv->cm_name;
-}
-
-const gchar *
-empathy_account_get_protocol (EmpathyAccount *account)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-
-  return priv->proto_name;
-}
-
-const gchar *
-empathy_account_get_icon_name (EmpathyAccount *account)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-
-  return priv->icon_name;
-}
-
-const GHashTable *
-empathy_account_get_parameters (EmpathyAccount *account)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-
-  return priv->parameters;
-}
-
-gboolean
-empathy_account_is_enabled (EmpathyAccount *account)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-
-  return priv->enabled;
-}
-
-gboolean
-empathy_account_is_ready (EmpathyAccount *account)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-
-  return priv->ready;
-}
-
-
-EmpathyAccount *
-empathy_account_new (TpDBusDaemon *dbus,
-    const gchar *unique_name)
-{
-  return EMPATHY_ACCOUNT (g_object_new (EMPATHY_TYPE_ACCOUNT,
-    "dbus-daemon", dbus,
-    "unique-name", unique_name,
-    NULL));
-}
-
-static void
-empathy_account_connection_ready_cb (TpConnection *connection,
-    const GError *error,
-    gpointer user_data)
-{
-  EmpathyAccount *account = EMPATHY_ACCOUNT (user_data);
-
-  if (error != NULL)
-    {
-      DEBUG ("(%s) Connection failed to become ready: %s",
-        empathy_account_get_unique_name (account), error->message);
-      empathy_account_free_connection (account);
-    }
-  else
-    {
-      DEBUG ("(%s) Connection ready",
-        empathy_account_get_unique_name (account));
-      g_object_notify (G_OBJECT (account), "connection");
-    }
-}
-
-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");
-}
-
-static void
-_empathy_account_set_connection (EmpathyAccount *account,
-    const gchar *path)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-
-  if (priv->connection != NULL)
-    {
-      const gchar *current;
-
-      current = tp_proxy_get_object_path (priv->connection);
-      if (!tp_strdiff (current, path))
-        return;
-    }
-
-  empathy_account_free_connection (account);
-
-  if (tp_strdiff ("/", path))
-    {
-      GError *error = NULL;
-      priv->connection = tp_connection_new (priv->dbus, NULL, path, &error);
-
-      if (priv->connection == NULL)
-        {
-          DEBUG ("Failed to create a new TpConnection: %s",
-                error->message);
-          g_error_free (error);
-        }
-      else
-        {
-          priv->connection_invalidated_id = g_signal_connect (priv->connection,
-            "invalidated",
-            G_CALLBACK (_empathy_account_connection_invalidated_cb), account);
-
-          DEBUG ("Readying connection for %s", priv->unique_name);
-          /* notify a change in the connection property when it's ready */
-          tp_connection_call_when_ready (priv->connection,
-            empathy_account_connection_ready_cb, account);
-        }
-    }
-
-   g_object_notify (G_OBJECT (account), "connection");
-}
-
-static void
-account_enabled_set_cb (TpProxy *proxy,
-    const GError *error,
-    gpointer user_data,
-    GObject *weak_object)
-{
-  GSimpleAsyncResult *result = user_data;
-
-  if (error != NULL)
-    g_simple_async_result_set_from_error (result, (GError *) error);
-
-  g_simple_async_result_complete (result);
-  g_object_unref (result);
-}
-
-gboolean
-empathy_account_set_enabled_finish (EmpathyAccount *account,
-    GAsyncResult *result,
-    GError **error)
-{
-  if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
-          error) ||
-      !g_simple_async_result_is_valid (result, G_OBJECT (account),
-          empathy_account_set_enabled_finish))
-    return FALSE;
-
-  return TRUE;
-}
-
-void
-empathy_account_set_enabled_async (EmpathyAccount *account,
-    gboolean enabled,
-    GAsyncReadyCallback callback,
-    gpointer user_data)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-  EmpathyAccountManager *acc_manager;
-  GValue value = {0, };
-  GSimpleAsyncResult *result = g_simple_async_result_new (G_OBJECT (account),
-      callback, user_data, empathy_account_set_enabled_finish);
-  char *status = NULL;
-  char *status_message = NULL;
-  TpConnectionPresenceType presence;
-
-  if (priv->enabled == enabled)
-    {
-      g_simple_async_result_complete_in_idle (result);
-      return;
-    }
-
-  if (enabled)
-    {
-      acc_manager = empathy_account_manager_dup_singleton ();
-      presence = empathy_account_manager_get_requested_global_presence
-	(acc_manager, &status, &status_message);
-
-      if (presence != TP_CONNECTION_PRESENCE_TYPE_UNSET)
-	empathy_account_request_presence (account, presence, status,
-            status_message);
-
-      g_object_unref (acc_manager);
-      g_free (status);
-      g_free (status_message);
-    }
-
-  g_value_init (&value, G_TYPE_BOOLEAN);
-  g_value_set_boolean (&value, enabled);
-
-  tp_cli_dbus_properties_call_set (TP_PROXY (priv->account),
-      -1, TP_IFACE_ACCOUNT, "Enabled", &value,
-      account_enabled_set_cb, result, NULL, G_OBJECT (account));
-}
-
-static void
-account_reconnected_cb (TpAccount *proxy,
-    const GError *error,
-    gpointer user_data,
-    GObject *weak_object)
-{
-  GSimpleAsyncResult *result = user_data;
-
-  if (error != NULL)
-    g_simple_async_result_set_from_error (result, (GError *) error);
-
-  g_simple_async_result_complete (result);
-  g_object_unref (result);
-}
-
-gboolean
-empathy_account_reconnect_finish (EmpathyAccount *account,
-    GAsyncResult *result,
-    GError **error)
-{
-  if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
-          error) ||
-      !g_simple_async_result_is_valid (result, G_OBJECT (account),
-          empathy_account_reconnect_finish))
-    return FALSE;
-
-  return TRUE;
-}
-
-void
-empathy_account_reconnect_async (EmpathyAccount *account,
-    GAsyncReadyCallback callback,
-    gpointer user_data)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-
-  GSimpleAsyncResult *result = g_simple_async_result_new (G_OBJECT (account),
-        callback, user_data, empathy_account_reconnect_finish);
-
-  tp_cli_account_call_reconnect (priv->account,
-      -1, account_reconnected_cb, result, NULL, G_OBJECT (account));
-}
-
-static void
-empathy_account_requested_presence_cb (TpProxy *proxy,
-  const GError *error,
-  gpointer user_data,
-  GObject *weak_object)
-{
-  if (error)
-    DEBUG ("Failed to set the requested presence: %s", error->message);
-}
-
-
-void
-empathy_account_request_presence (EmpathyAccount *account,
-  TpConnectionPresenceType type,
-  const gchar *status,
-  const gchar *message)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-  GValue value = {0, };
-  GValueArray *arr;
-
-  g_value_init (&value, TP_STRUCT_TYPE_SIMPLE_PRESENCE);
-  g_value_take_boxed (&value, dbus_g_type_specialized_construct
-    (TP_STRUCT_TYPE_SIMPLE_PRESENCE));
-  arr = (GValueArray *) g_value_get_boxed (&value);
-
-  g_value_set_uint (arr->values, type);
-  g_value_set_static_string (arr->values + 1, status);
-  g_value_set_static_string (arr->values + 2, message);
-
-  tp_cli_dbus_properties_call_set (TP_PROXY (priv->account),
-    -1,
-    TP_IFACE_ACCOUNT,
-    "RequestedPresence",
-    &value,
-    empathy_account_requested_presence_cb,
-    NULL,
-    NULL,
-    G_OBJECT (account));
-
-  g_value_unset (&value);
-}
-
-static void
-empathy_account_updated_cb (TpAccount *proxy,
-    const gchar **reconnect_required,
-    const GError *error,
-    gpointer user_data,
-    GObject *weak_object)
-{
-  GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (user_data);
-
-  if (error != NULL)
-    {
-      g_simple_async_result_set_from_error (result, (GError *) error);
-    }
-
-  g_simple_async_result_complete (result);
-  g_object_unref (G_OBJECT (result));
-}
-
-void
-empathy_account_update_settings_async (EmpathyAccount *account,
-  GHashTable *parameters, const gchar **unset_parameters,
-  GAsyncReadyCallback callback, gpointer user_data)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-  GSimpleAsyncResult *result = g_simple_async_result_new (G_OBJECT (account),
-      callback, user_data, empathy_account_update_settings_finish);
-
-  tp_cli_account_call_update_parameters (priv->account,
-      -1,
-      parameters,
-      unset_parameters,
-      empathy_account_updated_cb,
-      result,
-      NULL,
-      G_OBJECT (account));
-}
-
-gboolean
-empathy_account_update_settings_finish (EmpathyAccount *account,
-  GAsyncResult *result, GError **error)
-{
-  if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
-      error))
-    return FALSE;
-
-  g_return_val_if_fail (g_simple_async_result_is_valid (result,
-    G_OBJECT (account), empathy_account_update_settings_finish), FALSE);
-
-  return TRUE;
-}
-
-static void
-account_display_name_set_cb (TpProxy *proxy,
-    const GError *error,
-    gpointer user_data,
-    GObject *weak_object)
-{
-  GSimpleAsyncResult *result = user_data;
-
-  if (error != NULL)
-    g_simple_async_result_set_from_error (result, (GError *) error);
-
-  g_simple_async_result_complete (result);
-  g_object_unref (result);
-}
-
-void
-empathy_account_set_display_name_async (EmpathyAccount *account,
-    const char *display_name,
-    GAsyncReadyCallback callback,
-    gpointer user_data)
-{
-  GSimpleAsyncResult *result;
-  GValue value = {0, };
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-
-  if (display_name == NULL)
-    {
-      g_simple_async_report_error_in_idle (G_OBJECT (account),
-          callback, user_data, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
-          _("Can't set an empty display name"));
-      return;
-    }
-
-  result = g_simple_async_result_new (G_OBJECT (account), callback,
-      user_data, empathy_account_set_display_name_finish);
-
-  g_value_init (&value, G_TYPE_STRING);
-  g_value_set_string (&value, display_name);
-
-  tp_cli_dbus_properties_call_set (priv->account, -1, TP_IFACE_ACCOUNT,
-      "DisplayName", &value, account_display_name_set_cb, result, NULL,
-      G_OBJECT (account));
-}
-
-gboolean
-empathy_account_set_display_name_finish (EmpathyAccount *account,
-    GAsyncResult *result, GError **error)
-{
-  if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
-          error) ||
-      !g_simple_async_result_is_valid (result, G_OBJECT (account),
-          empathy_account_set_display_name_finish))
-    return FALSE;
-
-  return TRUE;
-}
-
-static void
-account_icon_name_set_cb (TpProxy *proxy,
-    const GError *error,
-    gpointer user_data,
-    GObject *weak_object)
-{
-  GSimpleAsyncResult *result = user_data;
-
-  if (error != NULL)
-    g_simple_async_result_set_from_error (result, (GError *) error);
-
-  g_simple_async_result_complete (result);
-  g_object_unref (result);
-}
-
-void
-empathy_account_set_icon_name_async (EmpathyAccount *account,
-    const char *icon_name,
-    GAsyncReadyCallback callback,
-    gpointer user_data)
-{
-  GSimpleAsyncResult *result;
-  GValue value = {0, };
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-  const char *icon_name_set;
-
-  if (icon_name == NULL)
-    /* settings an empty icon name is allowed */
-    icon_name_set = "";
-  else
-    icon_name_set = icon_name;
-
-  result = g_simple_async_result_new (G_OBJECT (account), callback,
-      user_data, empathy_account_set_icon_name_finish);
-
-  g_value_init (&value, G_TYPE_STRING);
-  g_value_set_string (&value, icon_name_set);
-
-  tp_cli_dbus_properties_call_set (priv->account, -1, TP_IFACE_ACCOUNT,
-      "Icon", &value, account_icon_name_set_cb, result, NULL,
-      G_OBJECT (account));
-}
-
-gboolean
-empathy_account_set_icon_name_finish (EmpathyAccount *account,
-    GAsyncResult *result, GError **error)
-{
-  if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
-          error) ||
-      !g_simple_async_result_is_valid (result, G_OBJECT (account),
-          empathy_account_set_icon_name_finish))
-    return FALSE;
-
-  return TRUE;
-}
-
-static void
-empathy_account_remove_cb (TpAccount *proxy,
-    const GError *error,
-    gpointer user_data,
-    GObject *weak_object)
-{
-  GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (user_data);
-
-  if (error != NULL)
-    {
-      g_simple_async_result_set_from_error (result, (GError *) error);
-    }
-
-  g_simple_async_result_complete (result);
-  g_object_unref (G_OBJECT (result));
-}
-
-void
-empathy_account_remove_async (EmpathyAccount *account,
-  GAsyncReadyCallback callback, gpointer user_data)
-{
-  EmpathyAccountPriv *priv = GET_PRIV (account);
-  GSimpleAsyncResult *result = g_simple_async_result_new (G_OBJECT (account),
-      callback, user_data, empathy_account_remove_finish);
-
-  tp_cli_account_call_remove (priv->account,
-      -1,
-      empathy_account_remove_cb,
-      result,
-      NULL,
-      G_OBJECT (account));
-}
-
-gboolean
-empathy_account_remove_finish (EmpathyAccount *account,
-  GAsyncResult *result, GError **error)
-{
-  if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
-      error))
-    return FALSE;
-
-  g_return_val_if_fail (g_simple_async_result_is_valid (result,
-    G_OBJECT (account), empathy_account_update_settings_finish), FALSE);
-
-  return TRUE;
-}
-
-void
-empathy_account_refresh_properties (EmpathyAccount *account)
-{
-  EmpathyAccountPriv *priv;
-
-  g_return_if_fail (EMPATHY_IS_ACCOUNT (account));
-
-  priv = GET_PRIV (account);
-
-  tp_cli_dbus_properties_call_get_all (priv->account, -1,
-    TP_IFACE_ACCOUNT,
-    empathy_account_got_all_cb,
-    NULL,
-    NULL,
-    G_OBJECT (account));
-}
-
diff --git a/libempathy/empathy-account.h b/libempathy/empathy-account.h
deleted file mode 100644
index 66f899448..000000000
--- a/libempathy/empathy-account.h
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * empathy-account.h - Header for EmpathyAccount
- * Copyright (C) 2009 Collabora Ltd.
- * @author Sjoerd Simons <sjoerd.simons@collabora.co.uk>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#ifndef __EMPATHY_ACCOUNT_H__
-#define __EMPATHY_ACCOUNT_H__
-
-#include <glib-object.h>
-#include <gio/gio.h>
-
-#include <telepathy-glib/connection.h>
-
-G_BEGIN_DECLS
-
-typedef struct _EmpathyAccount EmpathyAccount;
-typedef struct _EmpathyAccountClass EmpathyAccountClass;
-
-struct _EmpathyAccountClass {
-    GObjectClass parent_class;
-};
-
-struct _EmpathyAccount {
-    GObject parent;
-    gpointer priv;
-};
-
-GType empathy_account_get_type (void);
-
-/* TYPE MACROS */
-#define EMPATHY_TYPE_ACCOUNT (empathy_account_get_type ())
-#define EMPATHY_ACCOUNT(obj) \
-  (G_TYPE_CHECK_INSTANCE_CAST((obj), EMPATHY_TYPE_ACCOUNT, EmpathyAccount))
-#define EMPATHY_ACCOUNT_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_CAST((klass), EMPATHY_TYPE_ACCOUNT, EmpathyAccountClass))
-#define EMPATHY_IS_ACCOUNT(obj) \
-  (G_TYPE_CHECK_INSTANCE_TYPE((obj), EMPATHY_TYPE_ACCOUNT))
-#define EMPATHY_IS_ACCOUNT_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_TYPE((klass), EMPATHY_TYPE_ACCOUNT))
-#define EMPATHY_ACCOUNT_GET_CLASS(obj) \
-  (G_TYPE_INSTANCE_GET_CLASS ((obj), EMPATHY_TYPE_ACCOUNT, \
-    EmpathyAccountClass))
-
-gboolean empathy_account_is_just_connected (EmpathyAccount *account);
-TpConnection *empathy_account_get_connection (EmpathyAccount *account);
-TpConnection *empathy_account_get_connection_for_path (EmpathyAccount *account,
-  const gchar *path);
-const gchar *empathy_account_get_unique_name (EmpathyAccount *account);
-const gchar *empathy_account_get_display_name (EmpathyAccount *account);
-
-const gchar *empathy_account_get_connection_manager (EmpathyAccount *account);
-const gchar *empathy_account_get_protocol (EmpathyAccount *account);
-const gchar *empathy_account_get_icon_name (EmpathyAccount *account);
-
-void empathy_account_set_enabled_async (EmpathyAccount *account,
-    gboolean enabled, GAsyncReadyCallback callback, gpointer user_data);
-gboolean empathy_account_set_enabled_finish (EmpathyAccount *account,
-    GAsyncResult *result, GError **error);
-
-void empathy_account_reconnect_async (EmpathyAccount *account,
-    GAsyncReadyCallback callback,
-    gpointer user_data);
-gboolean empathy_account_reconnect_finish (EmpathyAccount *account,
-    GAsyncResult *result,
-    GError **error);
-
-gboolean empathy_account_is_enabled (EmpathyAccount *account);
-
-gboolean empathy_account_is_valid (EmpathyAccount *account);
-gboolean empathy_account_is_ready (EmpathyAccount *account);
-
-void empathy_account_update_settings_async (EmpathyAccount *account,
-  GHashTable *parameters, const gchar **unset_parameters,
-  GAsyncReadyCallback callback, gpointer user_data);
-
-gboolean empathy_account_update_settings_finish (EmpathyAccount *account,
-  GAsyncResult *result, GError **error);
-
-void empathy_account_remove_async (EmpathyAccount *account,
-  GAsyncReadyCallback callback, gpointer user_data);
-gboolean empathy_account_remove_finish (EmpathyAccount *account,
-  GAsyncResult *result, GError **error);
-
-void empathy_account_set_display_name_async (EmpathyAccount *account,
-    const gchar *display_name, GAsyncReadyCallback callback,
-    gpointer user_data);
-gboolean empathy_account_set_display_name_finish (EmpathyAccount *account,
-    GAsyncResult *result, GError **error);
-
-void empathy_account_set_icon_name_async (EmpathyAccount *account,
-    const gchar *icon_name, GAsyncReadyCallback callback,
-    gpointer user_data);
-gboolean empathy_account_set_icon_name_finish (EmpathyAccount *account,
-    GAsyncResult *result, GError **error);
-
-EmpathyAccount *empathy_account_new (TpDBusDaemon *bus_daemon,
-    const gchar *unique_name);
-
-void empathy_account_request_presence (EmpathyAccount *account,
-  TpConnectionPresenceType type, const gchar *status, const gchar *message);
-
-const GHashTable *empathy_account_get_parameters (EmpathyAccount *account);
-
-void empathy_account_refresh_properties (EmpathyAccount *account);
-
-
-G_END_DECLS
-
-#endif /* #ifndef __EMPATHY_ACCOUNT_H__*/
diff --git a/libempathy/empathy-chatroom-manager.c b/libempathy/empathy-chatroom-manager.c
index b8c721bcb..56295fe5a 100644
--- a/libempathy/empathy-chatroom-manager.c
+++ b/libempathy/empathy-chatroom-manager.c
@@ -30,11 +30,11 @@
 #include <libxml/parser.h>
 #include <libxml/tree.h>
 
+#include <telepathy-glib/account-manager.h>
 #include <telepathy-glib/interfaces.h>
 
 #include "empathy-tp-chat.h"
 #include "empathy-chatroom-manager.h"
-#include "empathy-account-manager.h"
 #include "empathy-utils.h"
 
 #define DEBUG_FLAG EMPATHY_DEBUG_OTHER
@@ -51,8 +51,8 @@ typedef struct
 {
   GList *chatrooms;
   gchar *file;
-  EmpathyAccountManager *account_manager;
-  gulong account_manager_ready_handler_id;
+  TpAccountManager *account_manager;
+
   /* source id of the autosave timer */
   gint save_timer_id;
   gboolean ready;
@@ -105,7 +105,7 @@ chatroom_manager_file_save (EmpathyChatroomManager *manager)
 			continue;
 		}
 
-		account_id = empathy_account_get_unique_name (
+                account_id = tp_proxy_get_object_path (
 		  empathy_chatroom_get_account (chatroom));
 
 		node = xmlNewChild (root, NULL, (const xmlChar *) "chatroom", NULL);
@@ -184,7 +184,7 @@ chatroom_manager_parse_chatroom (EmpathyChatroomManager *manager,
 {
 	EmpathyChatroomManagerPriv *priv;
 	EmpathyChatroom            *chatroom;
-	EmpathyAccount             *account;
+	TpAccount                  *account;
 	xmlNodePtr                 child;
 	gchar                     *str;
 	gchar                     *name;
@@ -230,7 +230,7 @@ chatroom_manager_parse_chatroom (EmpathyChatroomManager *manager,
 		xmlFree (str);
 	}
 
-	account = empathy_account_manager_get_account (priv->account_manager,
+	account = tp_account_manager_ensure_account (priv->account_manager,
 		account_id);
 	if (!account) {
 		g_free (name);
@@ -369,12 +369,6 @@ chatroom_manager_finalize (GObject *object)
 
   priv = GET_PRIV (object);
 
-  if (priv->account_manager_ready_handler_id > 0)
-    {
-      g_signal_handler_disconnect (priv->account_manager,
-          priv->account_manager_ready_handler_id);
-    }
-
   g_object_unref (priv->account_manager);
 
   if (priv->save_timer_id > 0)
@@ -402,18 +396,22 @@ chatroom_manager_finalize (GObject *object)
 }
 
 static void
-account_manager_ready_cb (GObject *gobject,
-                          GParamSpec *pspec,
+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;
 
-  chatroom_manager_get_all (self);
+  if (!tp_account_manager_prepare_finish (manager, result, &error))
+    {
+      DEBUG ("Failed to prepare account manager: %s", error->message);
+      g_error_free (error);
+      return;
+    }
 
-  g_signal_handler_disconnect (gobject,
-      priv->account_manager_ready_handler_id);
-  priv->account_manager_ready_handler_id = 0;
+  chatroom_manager_get_all (self);
 }
 
 static GObject *
@@ -440,16 +438,10 @@ empathy_chatroom_manager_constructor (GType type,
   chatroom_manager_singleton = self;
   g_object_add_weak_pointer (obj, (gpointer) &chatroom_manager_singleton);
 
-  priv->account_manager = empathy_account_manager_dup_singleton ();
+  priv->account_manager = tp_account_manager_dup ();
 
-  priv->account_manager_ready_handler_id = 0;
-
-  if (empathy_account_manager_is_ready (priv->account_manager))
-    chatroom_manager_get_all (self);
-  else
-    priv->account_manager_ready_handler_id =  g_signal_connect (
-        G_OBJECT (priv->account_manager), "notify::ready",
-        G_CALLBACK (account_manager_ready_cb), self);
+  tp_account_manager_prepare_async (priv->account_manager, NULL,
+      account_manager_ready_cb, self);
 
   if (priv->file == NULL)
     {
@@ -612,7 +604,7 @@ empathy_chatroom_manager_remove (EmpathyChatroomManager *manager,
 
 EmpathyChatroom *
 empathy_chatroom_manager_find (EmpathyChatroomManager *manager,
-                               EmpathyAccount *account,
+                               TpAccount *account,
                                const gchar *room)
 {
 	EmpathyChatroomManagerPriv *priv;
@@ -625,7 +617,7 @@ empathy_chatroom_manager_find (EmpathyChatroomManager *manager,
 
 	for (l = priv->chatrooms; l; l = l->next) {
 		EmpathyChatroom *chatroom;
-		EmpathyAccount *this_account;
+		TpAccount *this_account;
 		const gchar    *this_room;
 
 		chatroom = l->data;
@@ -643,7 +635,7 @@ empathy_chatroom_manager_find (EmpathyChatroomManager *manager,
 
 GList *
 empathy_chatroom_manager_get_chatrooms (EmpathyChatroomManager *manager,
-				       EmpathyAccount *account)
+				       TpAccount *account)
 {
 	EmpathyChatroomManagerPriv *priv;
 	GList                     *chatrooms, *l;
@@ -672,7 +664,7 @@ empathy_chatroom_manager_get_chatrooms (EmpathyChatroomManager *manager,
 
 guint
 empathy_chatroom_manager_get_count (EmpathyChatroomManager *manager,
-				   EmpathyAccount *account)
+				   TpAccount *account)
 {
 	EmpathyChatroomManagerPriv *priv;
 	GList                     *l;
@@ -731,14 +723,13 @@ static void
 chatroom_manager_observe_channel_cb (EmpathyDispatcher *dispatcher,
   EmpathyDispatchOperation *operation, gpointer manager)
 {
-  EmpathyChatroomManagerPriv *priv = GET_PRIV (manager);
   EmpathyChatroom *chatroom;
   TpChannel *channel;
   EmpathyTpChat *chat;
   const gchar *roomname;
   GQuark channel_type;
   TpHandleType handle_type;
-  EmpathyAccount *account;
+  TpAccount *account;
   TpConnection *connection;
 
   channel_type = empathy_dispatch_operation_get_channel_type_id (operation);
@@ -756,8 +747,7 @@ chatroom_manager_observe_channel_cb (EmpathyDispatcher *dispatcher,
   chat = EMPATHY_TP_CHAT (
     empathy_dispatch_operation_get_channel_wrapper (operation));
   connection = empathy_tp_chat_get_connection (chat);
-  account = empathy_account_manager_get_account_for_connection (
-      priv->account_manager, connection);
+  account = empathy_get_account_for_connection (connection);
 
   roomname = empathy_tp_chat_get_id (chat);
 
diff --git a/libempathy/empathy-chatroom-manager.h b/libempathy/empathy-chatroom-manager.h
index a6038f7fc..8ee2a897a 100644
--- a/libempathy/empathy-chatroom-manager.h
+++ b/libempathy/empathy-chatroom-manager.h
@@ -27,7 +27,8 @@
 
 #include <glib-object.h>
 
-#include "empathy-account.h"
+#include <telepathy-glib/account.h>
+
 #include "empathy-chatroom.h"
 #include "empathy-dispatcher.h"
 
@@ -59,12 +60,12 @@ gboolean               empathy_chatroom_manager_add           (EmpathyChatroomMa
 void                   empathy_chatroom_manager_remove        (EmpathyChatroomManager *manager,
 							      EmpathyChatroom        *chatroom);
 EmpathyChatroom *       empathy_chatroom_manager_find          (EmpathyChatroomManager *manager,
-							      EmpathyAccount           *account,
-							      const gchar              *room);
+							      TpAccount               *account,
+							      const gchar             *room);
 GList *                empathy_chatroom_manager_get_chatrooms (EmpathyChatroomManager *manager,
-							      EmpathyAccount          *account);
+							      TpAccount               *account);
 guint                  empathy_chatroom_manager_get_count     (EmpathyChatroomManager *manager,
-							      EmpathyAccount          *account);
+							      TpAccount               *account);
 void                   empathy_chatroom_manager_observe       (EmpathyChatroomManager *manager,
 							      EmpathyDispatcher *dispatcher);
 
diff --git a/libempathy/empathy-chatroom.c b/libempathy/empathy-chatroom.c
index 33df9a3d6..5d43a3ec1 100644
--- a/libempathy/empathy-chatroom.c
+++ b/libempathy/empathy-chatroom.c
@@ -31,7 +31,7 @@
 
 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyChatroom)
 typedef struct {
-	EmpathyAccount *account;
+	TpAccount *account;
 	gchar     *room;
 	gchar     *name;
 	gboolean   auto_connect;
@@ -84,7 +84,7 @@ empathy_chatroom_class_init (EmpathyChatroomClass *klass)
 					 g_param_spec_object ("account",
 							      "Chatroom Account",
 							      "The account associated with an chatroom",
-							      EMPATHY_TYPE_ACCOUNT,
+							      TP_TYPE_ACCOUNT,
 							      G_PARAM_READWRITE));
 
 	g_object_class_install_property (object_class,
@@ -312,7 +312,7 @@ chatroom_set_property (GObject      *object,
 }
 
 EmpathyChatroom *
-empathy_chatroom_new (EmpathyAccount *account)
+empathy_chatroom_new (TpAccount *account)
 {
 	return g_object_new (EMPATHY_TYPE_CHATROOM,
 			     "account", account,
@@ -320,7 +320,7 @@ empathy_chatroom_new (EmpathyAccount *account)
 }
 
 EmpathyChatroom *
-empathy_chatroom_new_full (EmpathyAccount *account,
+empathy_chatroom_new_full (TpAccount *account,
 			  const gchar *room,
 			  const gchar *name,
 			  gboolean     auto_connect)
@@ -335,7 +335,7 @@ empathy_chatroom_new_full (EmpathyAccount *account,
 			     NULL);
 }
 
-EmpathyAccount *
+TpAccount *
 empathy_chatroom_get_account (EmpathyChatroom *chatroom)
 {
 	EmpathyChatroomPriv *priv;
@@ -348,7 +348,7 @@ empathy_chatroom_get_account (EmpathyChatroom *chatroom)
 
 void
 empathy_chatroom_set_account (EmpathyChatroom *chatroom,
-			     EmpathyAccount *account)
+			     TpAccount *account)
 {
 	EmpathyChatroomPriv *priv;
 
@@ -466,8 +466,8 @@ gboolean
 empathy_chatroom_equal (gconstpointer v1,
 		       gconstpointer v2)
 {
-	EmpathyAccount *account_a;
-	EmpathyAccount *account_b;
+	TpAccount *account_a;
+	TpAccount *account_b;
 	const gchar *room_a;
 	const gchar *room_b;
 
diff --git a/libempathy/empathy-chatroom.h b/libempathy/empathy-chatroom.h
index c18c27449..3048aded7 100644
--- a/libempathy/empathy-chatroom.h
+++ b/libempathy/empathy-chatroom.h
@@ -24,7 +24,8 @@
 
 #include <glib-object.h>
 
-#include <libempathy/empathy-account.h>
+#include <telepathy-glib/account.h>
+
 #include <libempathy/empathy-tp-chat.h>
 
 G_BEGIN_DECLS
@@ -51,14 +52,14 @@ struct _EmpathyChatroomClass {
 };
 
 GType            empathy_chatroom_get_type        (void) G_GNUC_CONST;
-EmpathyChatroom *empathy_chatroom_new             (EmpathyAccount  *account);
-EmpathyChatroom *empathy_chatroom_new_full        (EmpathyAccount  *account,
+EmpathyChatroom *empathy_chatroom_new             (TpAccount       *account);
+EmpathyChatroom *empathy_chatroom_new_full        (TpAccount       *account,
 						   const gchar     *room,
 						   const gchar     *name,
 						   gboolean         auto_connect);
-EmpathyAccount *     empathy_chatroom_get_account      (EmpathyChatroom *chatroom);
+TpAccount *     empathy_chatroom_get_account      (EmpathyChatroom *chatroom);
 void            empathy_chatroom_set_account      (EmpathyChatroom *chatroom,
-						   EmpathyAccount  *account);
+						   TpAccount       *account);
 const gchar *   empathy_chatroom_get_room         (EmpathyChatroom *chatroom);
 void            empathy_chatroom_set_room         (EmpathyChatroom *chatroom,
 						   const gchar     *room);
diff --git a/libempathy/empathy-contact-manager.c b/libempathy/empathy-contact-manager.c
index 302fad3c5..53ccfbd63 100644
--- a/libempathy/empathy-contact-manager.c
+++ b/libempathy/empathy-contact-manager.c
@@ -23,10 +23,10 @@
 
 #include <string.h>
 
+#include <telepathy-glib/account-manager.h>
 #include <telepathy-glib/enums.h>
 
 #include "empathy-contact-manager.h"
-#include "empathy-account-manager.h"
 #include "empathy-contact-monitor.h"
 #include "empathy-contact-list.h"
 #include "empathy-utils.h"
@@ -37,7 +37,7 @@
 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyContactManager)
 typedef struct {
 	GHashTable     *lists;
-	EmpathyAccountManager *account_manager;
+	TpAccountManager *account_manager;
 	EmpathyContactMonitor *contact_monitor;
 } EmpathyContactManagerPriv;
 
@@ -132,14 +132,21 @@ contact_manager_disconnect_foreach (gpointer key,
 }
 
 static void
-contact_manager_new_connection_cb (EmpathyAccountManager *account_manager,
-				   TpConnection *connection,
+contact_manager_status_changed_cb (TpAccount *account,
+				   guint old_status,
+				   guint new_status,
+				   guint reason,
+				   gchar *dbus_error_name,
+				   GHashTable *details,
 				   EmpathyContactManager *self)
 {
 	EmpathyContactManagerPriv *priv = GET_PRIV (self);
 	EmpathyTpContactList      *list;
+	TpConnection              *connection;
+
+	connection = tp_account_get_connection (account);
 
-	if (g_hash_table_lookup (priv->lists, connection)) {
+	if (connection == NULL || g_hash_table_lookup (priv->lists, connection)) {
 		return;
 	}
 
@@ -174,9 +181,6 @@ contact_manager_finalize (GObject *object)
 			      object);
 	g_hash_table_destroy (priv->lists);
 
-	g_signal_handlers_disconnect_by_func (priv->account_manager,
-					      contact_manager_new_connection_cb,
-					      object);
 	g_object_unref (priv->account_manager);
 
 	if (priv->contact_monitor) {
@@ -233,9 +237,42 @@ empathy_contact_manager_class_init (EmpathyContactManagerClass *klass)
 }
 
 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);
+		}
+
+		empathy_signal_connect_weak (account, "status-changed",
+		    G_CALLBACK (contact_manager_status_changed_cb),
+		    G_OBJECT (manager));
+	}
+	g_list_free (accounts);
+}
+
+static void
 empathy_contact_manager_init (EmpathyContactManager *manager)
 {
-	GList *connections, *l;
 	EmpathyContactManagerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (manager,
 		EMPATHY_TYPE_CONTACT_MANAGER, EmpathyContactManagerPriv);
 
@@ -244,21 +281,11 @@ empathy_contact_manager_init (EmpathyContactManager *manager)
 					     empathy_proxy_equal,
 					     (GDestroyNotify) g_object_unref,
 					     (GDestroyNotify) g_object_unref);
-	priv->account_manager = empathy_account_manager_dup_singleton ();
+	priv->account_manager = tp_account_manager_dup ();
 	priv->contact_monitor = NULL;
 
-	g_signal_connect (priv->account_manager, "new-connection",
-			  G_CALLBACK (contact_manager_new_connection_cb),
-			  manager);
-
-	/* Get ContactList for existing connections */
-	connections = empathy_account_manager_dup_connections (priv->account_manager);
-	for (l = connections; l; l = l->next) {
-		contact_manager_new_connection_cb (priv->account_manager,
-						   l->data, manager);
-		g_object_unref (l->data);
-	}
-	g_list_free (connections);
+	tp_account_manager_prepare_async (priv->account_manager, NULL,
+	    account_manager_prepared_cb, manager);
 }
 
 EmpathyContactManager *
diff --git a/libempathy/empathy-contact.c b/libempathy/empathy-contact.c
index 83ffd0780..a440ef23b 100644
--- a/libempathy/empathy-contact.c
+++ b/libempathy/empathy-contact.c
@@ -25,10 +25,10 @@
 
 #include <glib/gi18n-lib.h>
 
+#include <telepathy-glib/account-manager.h>
 #include <telepathy-glib/util.h>
 
 #include "empathy-contact.h"
-#include "empathy-account-manager.h"
 #include "empathy-utils.h"
 #include "empathy-enum-types.h"
 #include "empathy-marshal.h"
@@ -39,7 +39,7 @@
 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyContact)
 typedef struct {
   TpContact *tp_contact;
-  EmpathyAccount *account;
+  TpAccount *account;
   gchar *id;
   gchar *name;
   EmpathyAvatar *avatar;
@@ -159,7 +159,7 @@ empathy_contact_class_init (EmpathyContactClass *class)
       g_param_spec_object ("account",
         "The account",
         "The account associated with the contact",
-        EMPATHY_TYPE_ACCOUNT,
+        TP_TYPE_ACCOUNT,
         G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 
   g_object_class_install_property (object_class,
@@ -409,7 +409,7 @@ empathy_contact_new (TpContact *tp_contact)
 }
 
 EmpathyContact *
-empathy_contact_new_for_log (EmpathyAccount *account,
+empathy_contact_new_for_log (TpAccount *account,
                              const gchar *id,
                              const gchar *name,
                              gboolean is_user)
@@ -554,7 +554,7 @@ empathy_contact_set_avatar (EmpathyContact *contact,
   g_object_notify (G_OBJECT (contact), "avatar");
 }
 
-EmpathyAccount *
+TpAccount *
 empathy_contact_get_account (EmpathyContact *contact)
 {
   EmpathyContactPriv *priv;
@@ -565,16 +565,12 @@ empathy_contact_get_account (EmpathyContact *contact)
 
   if (priv->account == NULL && priv->tp_contact != NULL)
     {
-      EmpathyAccountManager *manager;
       TpConnection *connection;
 
       /* FIXME: This assume the account manager already exists */
-      manager = empathy_account_manager_dup_singleton ();
       connection = tp_contact_get_connection (priv->tp_contact);
-      priv->account = empathy_account_manager_get_account_for_connection (
-          manager, connection);
-      g_object_ref (priv->account);
-      g_object_unref (manager);
+      priv->account =
+        g_object_ref (empathy_get_account_for_connection (connection));
     }
 
   return priv->account;
@@ -855,7 +851,7 @@ static gchar *
 contact_get_avatar_filename (EmpathyContact *contact,
                              const gchar *token)
 {
-  EmpathyAccount *account;
+  TpAccount *account;
   gchar *avatar_path;
   gchar *avatar_file;
   gchar *token_escaped;
@@ -869,8 +865,8 @@ contact_get_avatar_filename (EmpathyContact *contact,
   avatar_path = g_build_filename (g_get_user_cache_dir (),
       "telepathy",
       "avatars",
-      empathy_account_get_connection_manager (account),
-      empathy_account_get_protocol (account),
+      tp_account_get_connection_manager (account),
+      tp_account_get_protocol (account),
       NULL);
   g_mkdir_with_parents (avatar_path, 0700);
 
diff --git a/libempathy/empathy-contact.h b/libempathy/empathy-contact.h
index 4e9c98756..d5525818b 100644
--- a/libempathy/empathy-contact.h
+++ b/libempathy/empathy-contact.h
@@ -25,7 +25,7 @@
 #include <glib-object.h>
 
 #include <telepathy-glib/contact.h>
-#include <libempathy/empathy-account.h>
+#include <telepathy-glib/account.h>
 
 G_BEGIN_DECLS
 
@@ -70,7 +70,7 @@ typedef enum {
 
 GType empathy_contact_get_type (void) G_GNUC_CONST;
 EmpathyContact * empathy_contact_new (TpContact *tp_contact);
-EmpathyContact * empathy_contact_new_for_log (EmpathyAccount *account,
+EmpathyContact * empathy_contact_new_for_log (TpAccount *account,
     const gchar *id, const gchar *name, gboolean is_user);
 TpContact * empathy_contact_get_tp_contact (EmpathyContact *contact);
 const gchar * empathy_contact_get_id (EmpathyContact *contact);
@@ -80,7 +80,7 @@ void empathy_contact_set_name (EmpathyContact *contact, const gchar *name);
 EmpathyAvatar * empathy_contact_get_avatar (EmpathyContact *contact);
 void empathy_contact_set_avatar (EmpathyContact *contact,
     EmpathyAvatar *avatar);
-EmpathyAccount * empathy_contact_get_account (EmpathyContact *contact);
+TpAccount * empathy_contact_get_account (EmpathyContact *contact);
 TpConnection * empathy_contact_get_connection (EmpathyContact *contact);
 TpConnectionPresenceType empathy_contact_get_presence (EmpathyContact *contact);
 void empathy_contact_set_presence (EmpathyContact *contact,
diff --git a/libempathy/empathy-dispatcher.c b/libempathy/empathy-dispatcher.c
index eb43bc10e..40045cdb1 100644
--- a/libempathy/empathy-dispatcher.c
+++ b/libempathy/empathy-dispatcher.c
@@ -28,6 +28,7 @@
 
 #include <glib/gi18n-lib.h>
 
+#include <telepathy-glib/account-manager.h>
 #include <telepathy-glib/enums.h>
 #include <telepathy-glib/connection.h>
 #include <telepathy-glib/util.h>
@@ -45,7 +46,6 @@
 #include "empathy-handler.h"
 #include "empathy-utils.h"
 #include "empathy-tube-handler.h"
-#include "empathy-account-manager.h"
 #include "empathy-tp-contact-factory.h"
 #include "empathy-chatroom-manager.h"
 #include "empathy-utils.h"
@@ -58,7 +58,7 @@ typedef struct
 {
   gboolean dispose_has_run;
 
-  EmpathyAccountManager *account_manager;
+  TpAccountManager *account_manager;
   /* connection to connection data mapping */
   GHashTable *connections;
   GHashTable *outstanding_classes_requests;
@@ -890,11 +890,18 @@ dispatcher_init_connection_if_needed (EmpathyDispatcher *self,
 }
 
 static void
-dispatcher_new_connection_cb (EmpathyAccountManager *manager,
-                              TpConnection *connection,
+dispatcher_status_changed_cb (TpAccount *account,
+                              guint old_status,
+                              guint new_status,
+                              guint reason,
+                              gchar *dbus_error_name,
+                              GHashTable *details,
                               EmpathyDispatcher *self)
 {
-  dispatcher_init_connection_if_needed (self, connection);
+  TpConnection *conn = tp_account_get_connection (account);
+
+  if (conn != NULL)
+    dispatcher_init_connection_if_needed (self, conn);
 }
 
 static void
@@ -993,9 +1000,6 @@ dispatcher_finalize (GObject *object)
       g_hash_table_destroy (priv->request_channel_class_async_ids);
     }
 
-  g_signal_handlers_disconnect_by_func (priv->account_manager,
-      dispatcher_new_connection_cb, object);
-
   for (l = priv->channels; l; l = l->next)
     {
       g_signal_handlers_disconnect_by_func (l->data,
@@ -1111,18 +1115,46 @@ empathy_dispatcher_class_init (EmpathyDispatcherClass *klass)
 }
 
 static void
+account_manager_prepared_cb (GObject *source_object,
+                             GAsyncResult *result,
+                             gpointer user_data)
+{
+  GList *accounts, *l;
+  EmpathyDispatcher *self = 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; l = l->next)
+    {
+      TpAccount *a = l->data;
+      TpConnection *conn = tp_account_get_connection (a);
+
+      if (conn != NULL)
+        dispatcher_status_changed_cb (a, 0, 0, 0, NULL, NULL, self);
+
+      empathy_signal_connect_weak (a, "status-changed",
+          G_CALLBACK (dispatcher_status_changed_cb),
+          G_OBJECT (self));
+    }
+  g_list_free (accounts);
+}
+
+static void
 empathy_dispatcher_init (EmpathyDispatcher *self)
 {
-  GList *connections, *l;
   EmpathyDispatcherPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
     EMPATHY_TYPE_DISPATCHER, EmpathyDispatcherPriv);
 
   self->priv = priv;
-  priv->account_manager = empathy_account_manager_dup_singleton ();
-
-  g_signal_connect (priv->account_manager, "new-connection",
-    G_CALLBACK (dispatcher_new_connection_cb),
-    self);
+  priv->account_manager = tp_account_manager_dup ();
 
   priv->connections = g_hash_table_new_full (g_direct_hash, g_direct_equal,
     g_object_unref, (GDestroyNotify) free_connection_data);
@@ -1132,15 +1164,8 @@ empathy_dispatcher_init (EmpathyDispatcher *self)
 
   priv->channels = NULL;
 
-  connections = empathy_account_manager_dup_connections (
-      priv->account_manager);
-  for (l = connections; l; l = l->next)
-    {
-      dispatcher_new_connection_cb (priv->account_manager, l->data,
-          self);
-      g_object_unref (l->data);
-    }
-  g_list_free (connections);
+  tp_account_manager_prepare_async (priv->account_manager, NULL,
+      account_manager_prepared_cb, self);
 
   priv->request_channel_class_async_ids = g_hash_table_new (g_direct_hash,
     g_direct_equal);
@@ -1956,15 +1981,16 @@ empathy_dispatcher_handle_channels (EmpathyHandler *handler,
   EmpathyDispatcher *self = EMPATHY_DISPATCHER (user_data);
   EmpathyDispatcherPriv *priv = GET_PRIV (self);
   guint i;
-  EmpathyAccount *account;
+  TpAccount *account;
   TpConnection *connection;
 
-  account = empathy_account_manager_ensure_account (priv->account_manager,
+  /* FIXME: should probably find out whether the account manager is prepared
+   * before ensuring. See bug #600111. */
+  account = tp_account_manager_ensure_account (priv->account_manager,
     account_path);
   g_assert (account != NULL);
 
-  connection = empathy_account_get_connection_for_path (account,
-      connection_path);
+  connection = tp_account_ensure_connection (account, connection_path);
   if (connection == NULL)
     {
       g_set_error_literal (error, TP_ERRORS, TP_ERROR_INVALID_ARGUMENT,
diff --git a/libempathy/empathy-idle.c b/libempathy/empathy-idle.c
index cc6ca62f4..8a0fcd88d 100644
--- a/libempathy/empathy-idle.c
+++ b/libempathy/empathy-idle.c
@@ -26,10 +26,10 @@
 #include <glib/gi18n-lib.h>
 #include <dbus/dbus-glib.h>
 
+#include <telepathy-glib/account-manager.h>
 #include <telepathy-glib/dbus.h>
 #include <telepathy-glib/util.h>
 
-#include "empathy-account-manager.h"
 #include "empathy-idle.h"
 #include "empathy-utils.h"
 #include "empathy-connectivity.h"
@@ -40,6 +40,10 @@
 /* Number of seconds before entering extended autoaway. */
 #define EXT_AWAY_TIME (30*60)
 
+/* Number of seconds to consider an account in the "just connected" state
+ * for. */
+#define ACCOUNT_IS_JUST_CONNECTED_SECONDS 10
+
 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyIdle)
 typedef struct {
 	DBusGProxy     *gs_proxy;
@@ -58,7 +62,14 @@ typedef struct {
 	gboolean        is_idle;
 	guint           ext_away_timeout;
 
-	EmpathyAccountManager *manager;
+	TpAccountManager *manager;
+
+	/* pointer to a TpAccount --> glong of time of connection */
+	GHashTable *connect_times;
+
+	TpConnectionPresenceType requested_presence_type;
+	gchar *requested_status_message;
+
 } EmpathyIdlePriv;
 
 typedef enum {
@@ -81,8 +92,20 @@ G_DEFINE_TYPE (EmpathyIdle, empathy_idle, G_TYPE_OBJECT);
 
 static EmpathyIdle * idle_singleton = NULL;
 
+static const gchar *presence_type_to_status[NUM_TP_CONNECTION_PRESENCE_TYPES] = {
+	NULL,
+	"offline",
+	"available",
+	"away",
+	"xa",
+	"hidden",
+	"busy",
+	NULL,
+	NULL,
+};
+
 static void
-idle_presence_changed_cb (EmpathyAccountManager *manager,
+idle_presence_changed_cb (TpAccountManager *manager,
 			  TpConnectionPresenceType state,
 			  gchar          *status,
 			  gchar          *status_message,
@@ -279,6 +302,7 @@ idle_finalize (GObject *object)
 	priv = GET_PRIV (object);
 
 	g_free (priv->status);
+	g_free (priv->requested_status_message);
 
 	if (priv->gs_proxy) {
 		g_object_unref (priv->gs_proxy);
@@ -290,6 +314,9 @@ idle_finalize (GObject *object)
 
 	g_object_unref (priv->connectivity);
 
+	g_hash_table_destroy (priv->connect_times);
+	priv->connect_times = NULL;
+
 	idle_ext_away_stop (EMPATHY_IDLE (object));
 }
 
@@ -421,22 +448,60 @@ empathy_idle_class_init (EmpathyIdleClass *klass)
 }
 
 static void
-account_manager_ready_cb (EmpathyAccountManager *account_manager,
-			  GParamSpec *pspec,
-			  EmpathyIdle *idle)
+account_status_changed_cb (TpAccount  *account,
+			   guint       old_status,
+			   guint       new_status,
+			   guint       reason,
+			   gchar      *dbus_error_name,
+			   GHashTable *details,
+			   gpointer    user_data)
 {
-	EmpathyIdlePriv *priv;
+	EmpathyIdle *idle = EMPATHY_IDLE (user_data);
+	EmpathyIdlePriv *priv = GET_PRIV (idle);
+	GTimeVal val;
+
+	if (new_status == TP_CONNECTION_STATUS_CONNECTED) {
+		g_get_current_time (&val);
+		g_hash_table_insert (priv->connect_times, account,
+				     GINT_TO_POINTER (val.tv_sec));
+	} else if (new_status == TP_CONNECTION_STATUS_DISCONNECTED) {
+		g_hash_table_remove (priv->connect_times, account);
+	}
+}
+
+static void
+account_manager_ready_cb (GObject *source_object,
+			  GAsyncResult *result,
+			  gpointer user_data)
+{
+	EmpathyIdle *idle = EMPATHY_IDLE (user_data);
+	TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object);
+	EmpathyIdlePriv *priv = GET_PRIV (idle);
 	TpConnectionPresenceType state;
 	gchar *status, *status_message;
+	GList *accounts, *l;
+	GError *error = NULL;
 
-	priv = GET_PRIV (idle);
+	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 = empathy_account_manager_get_global_presence (priv->manager,
+	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);
 }
@@ -450,18 +515,12 @@ empathy_idle_init (EmpathyIdle *idle)
 	idle->priv = priv;
 	priv->is_idle = FALSE;
 
-	priv->manager = empathy_account_manager_dup_singleton ();
-
-	if (empathy_account_manager_is_ready (priv->manager)) {
-		priv->state = empathy_account_manager_get_global_presence (priv->manager,
-			NULL, &priv->status);
-	} else {
-		g_signal_connect (priv->manager, "notify::ready",
-			G_CALLBACK (account_manager_ready_cb), idle);
-	}
+	priv->manager = tp_account_manager_dup ();
 
+	tp_account_manager_prepare_async (priv->manager, NULL,
+	    account_manager_ready_cb, idle);
 
-	g_signal_connect (priv->manager, "global-presence-changed",
+	g_signal_connect (priv->manager, "most-available-presence-changed",
 		G_CALLBACK (idle_presence_changed_cb), idle);
 
 	priv->gs_proxy = dbus_g_proxy_new_for_name (tp_get_bus (),
@@ -481,6 +540,8 @@ empathy_idle_init (EmpathyIdle *idle)
 	priv->connectivity = empathy_connectivity_dup_singleton ();
 	priv->state_change_signal_id = g_signal_connect (priv->connectivity,
 	    "state-change", G_CALLBACK (idle_state_change_cb), idle);
+
+	priv->connect_times = g_hash_table_new (g_direct_hash, g_direct_equal);
 }
 
 EmpathyIdle *
@@ -567,26 +628,21 @@ empathy_idle_do_set_presence (EmpathyIdle *idle,
 			   const gchar *status_message)
 {
 	EmpathyIdlePriv *priv = GET_PRIV (idle);
-	const gchar *statuses[NUM_TP_CONNECTION_PRESENCE_TYPES] = {
-		NULL,
-		"offline",
-		"available",
-		"away",
-		"xa",
-		"hidden",
-		"busy",
-		NULL,
-		NULL,
-	};
 	const gchar *status;
 
 	g_assert (status_type > 0 && status_type < NUM_TP_CONNECTION_PRESENCE_TYPES);
 
-	status = statuses[status_type];
+	status = presence_type_to_status[status_type];
 
 	g_return_if_fail (status != NULL);
 
-	empathy_account_manager_request_global_presence (priv->manager,
+	/* We possibly should be sure that the account manager is prepared, but
+	 * sometimes this isn't possible, like when exiting. In other words,
+	 * we need a callback to empathy_idle_set_presence to be sure the
+	 * presence is set on all accounts successfully.
+	 * However, in practice, this is fine as we've already prepared the
+	 * account manager here in _init. */
+	tp_account_manager_set_all_requested_presences (priv->manager,
 		status_type, status, status_message);
 }
 
@@ -602,6 +658,10 @@ empathy_idle_set_presence (EmpathyIdle *idle,
 
 	DEBUG ("Changing presence to %s (%d)", status, state);
 
+	g_free (priv->requested_status_message);
+	priv->requested_presence_type = state;
+	priv->requested_status_message = g_strdup (status);
+
 	/* Do not set translated default messages */
 	default_status = empathy_presence_get_default_message (state);
 	if (!tp_strdiff (status, default_status)) {
@@ -645,3 +705,50 @@ empathy_idle_set_auto_away (EmpathyIdle *idle,
 	g_object_notify (G_OBJECT (idle), "auto-away");
 }
 
+TpConnectionPresenceType
+empathy_idle_get_requested_presence (EmpathyIdle *idle,
+    gchar **status,
+    gchar **status_message)
+{
+	EmpathyIdlePriv *priv = GET_PRIV (idle);
+
+	if (status != NULL) {
+		*status = g_strdup (presence_type_to_status[priv->requested_presence_type]);
+	}
+
+	if (status_message != NULL) {
+		*status_message = g_strdup (priv->requested_status_message);
+	}
+
+	return priv->requested_presence_type;
+}
+
+/* This function returns %TRUE if EmpathyIdle considers the account
+ * @account as having just connected recently. Otherwise, it returns
+ * %FALSE. In doubt, %FALSE is returned. */
+gboolean
+empathy_idle_account_is_just_connected (EmpathyIdle *idle,
+					TpAccount *account)
+{
+	EmpathyIdlePriv *priv = GET_PRIV (idle);
+	GTimeVal val;
+	gpointer ptr;
+	glong t;
+
+	if (tp_account_get_connection_status (account, NULL)
+	    != TP_CONNECTION_STATUS_CONNECTED) {
+		return FALSE;
+	}
+
+	ptr = g_hash_table_lookup (priv->connect_times, account);
+
+	if (ptr == NULL) {
+		return FALSE;
+	}
+
+	t = GPOINTER_TO_INT (ptr);
+
+	g_get_current_time (&val);
+
+	return (val.tv_sec - t) < ACCOUNT_IS_JUST_CONNECTED_SECONDS;
+}
diff --git a/libempathy/empathy-idle.h b/libempathy/empathy-idle.h
index 47dcfee23..1a8c313bc 100644
--- a/libempathy/empathy-idle.h
+++ b/libempathy/empathy-idle.h
@@ -65,6 +65,13 @@ gboolean     empathy_idle_get_auto_away       (EmpathyIdle *idle);
 void         empathy_idle_set_auto_away       (EmpathyIdle *idle,
 					       gboolean     auto_away);
 
+TpConnectionPresenceType empathy_idle_get_requested_presence (EmpathyIdle *idle,
+							      gchar **status,
+							      gchar **status_message);
+
+gboolean empathy_idle_account_is_just_connected (EmpathyIdle *idle,
+						 TpAccount *account);
+
 G_END_DECLS
 
 #endif /* __EMPATHY_IDLE_H__ */
diff --git a/libempathy/empathy-log-manager.c b/libempathy/empathy-log-manager.c
index 309b3b60f..5a57f0c74 100644
--- a/libempathy/empathy-log-manager.c
+++ b/libempathy/empathy-log-manager.c
@@ -158,7 +158,7 @@ empathy_log_manager_add_message (EmpathyLogManager *manager,
 
 gboolean
 empathy_log_manager_exists (EmpathyLogManager *manager,
-                            EmpathyAccount *account,
+                            TpAccount *account,
                             const gchar *chat_id,
                             gboolean chatroom)
 {
@@ -182,7 +182,7 @@ empathy_log_manager_exists (EmpathyLogManager *manager,
 
 GList *
 empathy_log_manager_get_dates (EmpathyLogManager *manager,
-                               EmpathyAccount *account,
+                               TpAccount *account,
                                const gchar *chat_id,
                                gboolean chatroom)
 {
@@ -218,7 +218,7 @@ empathy_log_manager_get_dates (EmpathyLogManager *manager,
 
 GList *
 empathy_log_manager_get_messages_for_date (EmpathyLogManager *manager,
-                                           EmpathyAccount *account,
+                                           TpAccount *account,
                                            const gchar *chat_id,
                                            gboolean chatroom,
                                            const gchar *date)
@@ -259,7 +259,7 @@ log_manager_message_date_cmp (gconstpointer a,
 
 GList *
 empathy_log_manager_get_filtered_messages (EmpathyLogManager *manager,
-					   EmpathyAccount *account,
+					   TpAccount *account,
 					   const gchar *chat_id,
 					   gboolean chatroom,
 					   guint num_messages,
@@ -319,7 +319,7 @@ empathy_log_manager_get_filtered_messages (EmpathyLogManager *manager,
 
 GList *
 empathy_log_manager_get_chats (EmpathyLogManager *manager,
-                               EmpathyAccount *account)
+                               TpAccount *account)
 {
   GList *l, *out = NULL;
   EmpathyLogManagerPriv *priv;
diff --git a/libempathy/empathy-log-manager.h b/libempathy/empathy-log-manager.h
index a67f6e8dd..25f1b5fcd 100644
--- a/libempathy/empathy-log-manager.h
+++ b/libempathy/empathy-log-manager.h
@@ -63,7 +63,7 @@ struct _EmpathyLogManagerClass
 
 struct _EmpathyLogSearchHit
 {
-  EmpathyAccount *account;
+  TpAccount *account;
   gchar     *chat_id;
   gboolean   is_chatroom;
   gchar     *filename;
@@ -79,17 +79,17 @@ gboolean empathy_log_manager_add_message (EmpathyLogManager *manager,
     const gchar *chat_id, gboolean chatroom, EmpathyMessage *message,
     GError **error);
 gboolean empathy_log_manager_exists (EmpathyLogManager *manager,
-    EmpathyAccount *account, const gchar *chat_id, gboolean chatroom);
+    TpAccount *account, const gchar *chat_id, gboolean chatroom);
 GList *empathy_log_manager_get_dates (EmpathyLogManager *manager,
-    EmpathyAccount *account, const gchar *chat_id, gboolean chatroom);
+    TpAccount *account, const gchar *chat_id, gboolean chatroom);
 GList *empathy_log_manager_get_messages_for_date (EmpathyLogManager *manager,
-    EmpathyAccount *account, const gchar *chat_id, gboolean chatroom,
+    TpAccount *account, const gchar *chat_id, gboolean chatroom,
     const gchar *date);
 GList *empathy_log_manager_get_filtered_messages (EmpathyLogManager *manager,
-    EmpathyAccount *account, const gchar *chat_id, gboolean chatroom,
+    TpAccount *account, const gchar *chat_id, gboolean chatroom,
     guint num_messages, EmpathyLogMessageFilter filter, gpointer user_data);
 GList *empathy_log_manager_get_chats (EmpathyLogManager *manager,
-    EmpathyAccount *account);
+    TpAccount *account);
 GList *empathy_log_manager_search_new (EmpathyLogManager *manager,
     const gchar *text);
 void empathy_log_manager_search_free (GList *hits);
diff --git a/libempathy/empathy-log-store-empathy.c b/libempathy/empathy-log-store-empathy.c
index 9771a9f28..8a25df7bc 100644
--- a/libempathy/empathy-log-store-empathy.c
+++ b/libempathy/empathy-log-store-empathy.c
@@ -29,13 +29,13 @@
 #include <stdlib.h>
 #include <glib/gstdio.h>
 
+#include <telepathy-glib/account-manager.h>
 #include <telepathy-glib/util.h>
 #include <telepathy-glib/defs.h>
 
 #include "empathy-log-store.h"
 #include "empathy-log-store-empathy.h"
 #include "empathy-log-manager.h"
-#include "empathy-account-manager.h"
 #include "empathy-contact.h"
 #include "empathy-time.h"
 #include "empathy-utils.h"
@@ -63,7 +63,7 @@ typedef struct
 {
   gchar *basedir;
   gchar *name;
-  EmpathyAccountManager *account_manager;
+  TpAccountManager *account_manager;
 } EmpathyLogStoreEmpathyPriv;
 
 static void log_store_iface_init (gpointer g_iface,gpointer iface_data);
@@ -105,15 +105,15 @@ empathy_log_store_empathy_init (EmpathyLogStoreEmpathy *self)
     PACKAGE_NAME, "logs", NULL);
 
   priv->name = g_strdup ("Empathy");
-  priv->account_manager = empathy_account_manager_dup_singleton ();
+  priv->account_manager = tp_account_manager_dup ();
 }
 
 static gchar *
-log_store_account_to_dirname (EmpathyAccount *account)
+log_store_account_to_dirname (TpAccount *account)
 {
   const gchar *name;
 
-  name = empathy_account_get_unique_name (account);
+  name = tp_proxy_get_object_path (account);
   if (g_str_has_prefix (name, TP_ACCOUNT_OBJECT_PATH_BASE))
     name += strlen (TP_ACCOUNT_OBJECT_PATH_BASE);
 
@@ -123,7 +123,7 @@ log_store_account_to_dirname (EmpathyAccount *account)
 
 static gchar *
 log_store_empathy_get_dir (EmpathyLogStore *self,
-                           EmpathyAccount *account,
+                           TpAccount *account,
                            const gchar *chat_id,
                            gboolean chatroom)
 {
@@ -176,7 +176,7 @@ log_store_empathy_get_timestamp_from_message (EmpathyMessage *message)
 
 static gchar *
 log_store_empathy_get_filename (EmpathyLogStore *self,
-                                EmpathyAccount *account,
+                                TpAccount *account,
                                 const gchar *chat_id,
                                 gboolean chatroom)
 {
@@ -202,7 +202,7 @@ log_store_empathy_add_message (EmpathyLogStore *self,
                                GError **error)
 {
   FILE *file;
-  EmpathyAccount *account;
+  TpAccount *account;
   EmpathyContact *sender;
   const gchar *body_str;
   const gchar *str;
@@ -289,7 +289,7 @@ log_store_empathy_add_message (EmpathyLogStore *self,
 
 static gboolean
 log_store_empathy_exists (EmpathyLogStore *self,
-                          EmpathyAccount *account,
+                          TpAccount *account,
                           const gchar *chat_id,
                           gboolean chatroom)
 {
@@ -305,7 +305,7 @@ log_store_empathy_exists (EmpathyLogStore *self,
 
 static GList *
 log_store_empathy_get_dates (EmpathyLogStore *self,
-                             EmpathyAccount *account,
+                             TpAccount *account,
                              const gchar *chat_id,
                              gboolean chatroom)
 {
@@ -357,7 +357,7 @@ log_store_empathy_get_dates (EmpathyLogStore *self,
 
 static gchar *
 log_store_empathy_get_filename_for_date (EmpathyLogStore *self,
-                                         EmpathyAccount *account,
+                                         TpAccount *account,
                                          const gchar *chat_id,
                                          gboolean chatroom,
                                          const gchar *date)
@@ -406,11 +406,13 @@ log_store_empathy_search_hit_new (EmpathyLogStore *self,
   else
     account_name = strv[len-3];
 
-  accounts = empathy_account_manager_dup_accounts (priv->account_manager);
+  /* FIXME: This assumes the account manager is prepared, but the
+   * synchronous API forces this. See bug #599189. */
+  accounts = tp_account_manager_get_valid_accounts (priv->account_manager);
 
   for (l = accounts; l != NULL; l = g_list_next (l))
     {
-      EmpathyAccount *account = EMPATHY_ACCOUNT (l->data);
+      TpAccount *account = TP_ACCOUNT (l->data);
       gchar *name;
 
       name = log_store_account_to_dirname (account);
@@ -434,7 +436,7 @@ log_store_empathy_search_hit_new (EmpathyLogStore *self,
 
 static GList *
 log_store_empathy_get_messages_for_file (EmpathyLogStore *self,
-                                         EmpathyAccount *account,
+                                         TpAccount *account,
                                          const gchar *filename)
 {
   GList *messages = NULL;
@@ -703,7 +705,7 @@ log_store_empathy_get_chats_for_dir (EmpathyLogStore *self,
 
 static GList *
 log_store_empathy_get_messages_for_date (EmpathyLogStore *self,
-                                         EmpathyAccount *account,
+                                         TpAccount *account,
                                          const gchar *chat_id,
                                          gboolean chatroom,
                                          const gchar *date)
@@ -726,7 +728,7 @@ log_store_empathy_get_messages_for_date (EmpathyLogStore *self,
 
 static GList *
 log_store_empathy_get_chats (EmpathyLogStore *self,
-                              EmpathyAccount *account)
+                              TpAccount *account)
 {
   gchar *dir;
   GList *hits;
@@ -753,7 +755,7 @@ log_store_empathy_get_name (EmpathyLogStore *self)
 
 static GList *
 log_store_empathy_get_filtered_messages (EmpathyLogStore *self,
-                                         EmpathyAccount *account,
+                                         TpAccount *account,
                                          const gchar *chat_id,
                                          gboolean chatroom,
                                          guint num_messages,
diff --git a/libempathy/empathy-log-store.c b/libempathy/empathy-log-store.c
index f136f7910..512c4c09b 100644
--- a/libempathy/empathy-log-store.c
+++ b/libempathy/empathy-log-store.c
@@ -55,7 +55,7 @@ empathy_log_store_get_name (EmpathyLogStore *self)
 
 gboolean
 empathy_log_store_exists (EmpathyLogStore *self,
-                          EmpathyAccount *account,
+                          TpAccount *account,
                           const gchar *chat_id,
                           gboolean chatroom)
 {
@@ -84,7 +84,7 @@ empathy_log_store_add_message (EmpathyLogStore *self,
 
 GList *
 empathy_log_store_get_dates (EmpathyLogStore *self,
-                             EmpathyAccount *account,
+                             TpAccount *account,
                              const gchar *chat_id,
                              gboolean chatroom)
 {
@@ -97,7 +97,7 @@ empathy_log_store_get_dates (EmpathyLogStore *self,
 
 GList *
 empathy_log_store_get_messages_for_date (EmpathyLogStore *self,
-                                         EmpathyAccount *account,
+                                         TpAccount *account,
                                          const gchar *chat_id,
                                          gboolean chatroom,
                                          const gchar *date)
@@ -111,7 +111,7 @@ empathy_log_store_get_messages_for_date (EmpathyLogStore *self,
 
 GList *
 empathy_log_store_get_last_messages (EmpathyLogStore *self,
-                                     EmpathyAccount *account,
+                                     TpAccount *account,
                                      const gchar *chat_id,
                                      gboolean chatroom)
 {
@@ -124,7 +124,7 @@ empathy_log_store_get_last_messages (EmpathyLogStore *self,
 
 GList *
 empathy_log_store_get_chats (EmpathyLogStore *self,
-                             EmpathyAccount *account)
+                             TpAccount *account)
 {
   if (!EMPATHY_LOG_STORE_GET_INTERFACE (self)->get_chats)
     return NULL;
@@ -157,7 +157,7 @@ empathy_log_store_ack_message (EmpathyLogStore *self,
 
 GList *
 empathy_log_store_get_filtered_messages (EmpathyLogStore *self,
-                                         EmpathyAccount *account,
+                                         TpAccount *account,
                                          const gchar *chat_id,
                                          gboolean chatroom,
                                          guint num_messages,
diff --git a/libempathy/empathy-log-store.h b/libempathy/empathy-log-store.h
index 5b6a87875..94bc87386 100644
--- a/libempathy/empathy-log-store.h
+++ b/libempathy/empathy-log-store.h
@@ -25,7 +25,7 @@
 
 #include <glib-object.h>
 
-#include <libempathy/empathy-account.h>
+#include <telepathy-glib/account.h>
 
 #include "empathy-message.h"
 #include "empathy-log-manager.h"
@@ -50,23 +50,23 @@ struct _EmpathyLogStoreInterface
   GTypeInterface parent;
 
   const gchar * (*get_name) (EmpathyLogStore *self);
-  gboolean (*exists) (EmpathyLogStore *self, EmpathyAccount *account,
+  gboolean (*exists) (EmpathyLogStore *self, TpAccount *account,
       const gchar *chat_id, gboolean chatroom);
   gboolean (*add_message) (EmpathyLogStore *self, const gchar *chat_id,
       gboolean chatroom, EmpathyMessage *message, GError **error);
-  GList * (*get_dates) (EmpathyLogStore *self, EmpathyAccount *account,
+  GList * (*get_dates) (EmpathyLogStore *self, TpAccount *account,
       const gchar *chat_id, gboolean chatroom);
   GList * (*get_messages_for_date) (EmpathyLogStore *self,
-      EmpathyAccount *account, const gchar *chat_id, gboolean chatroom,
+      TpAccount *account, const gchar *chat_id, gboolean chatroom,
       const gchar *date);
-  GList * (*get_last_messages) (EmpathyLogStore *self, EmpathyAccount *account,
+  GList * (*get_last_messages) (EmpathyLogStore *self, TpAccount *account,
       const gchar *chat_id, gboolean chatroom);
   GList * (*get_chats) (EmpathyLogStore *self,
-            EmpathyAccount    *account);
+            TpAccount    *account);
   GList * (*search_new) (EmpathyLogStore *self, const gchar *text);
   void (*ack_message) (EmpathyLogStore *self, const gchar *chat_id,
       gboolean chatroom, EmpathyMessage *message);
-  GList * (*get_filtered_messages) (EmpathyLogStore *self, EmpathyAccount *account,
+  GList * (*get_filtered_messages) (EmpathyLogStore *self, TpAccount *account,
       const gchar *chat_id, gboolean chatroom, guint num_messages,
       EmpathyLogMessageFilter filter, gpointer user_data);
 };
@@ -75,25 +75,25 @@ GType empathy_log_store_get_type (void) G_GNUC_CONST;
 
 const gchar *empathy_log_store_get_name (EmpathyLogStore *self);
 gboolean empathy_log_store_exists (EmpathyLogStore *self,
-    EmpathyAccount *account, const gchar *chat_id, gboolean chatroom);
+    TpAccount *account, const gchar *chat_id, gboolean chatroom);
 gboolean empathy_log_store_add_message (EmpathyLogStore *self,
     const gchar *chat_id, gboolean chatroom, EmpathyMessage *message,
     GError **error);
 GList *empathy_log_store_get_dates (EmpathyLogStore *self,
-    EmpathyAccount *account, const gchar *chat_id, gboolean chatroom);
+    TpAccount *account, const gchar *chat_id, gboolean chatroom);
 GList *empathy_log_store_get_messages_for_date (EmpathyLogStore *self,
-    EmpathyAccount *account, const gchar *chat_id, gboolean chatroom,
+    TpAccount *account, const gchar *chat_id, gboolean chatroom,
     const gchar *date);
 GList *empathy_log_store_get_last_messages (EmpathyLogStore *self,
-    EmpathyAccount *account, const gchar *chat_id, gboolean chatroom);
+    TpAccount *account, const gchar *chat_id, gboolean chatroom);
 GList *empathy_log_store_get_chats (EmpathyLogStore *self,
-    EmpathyAccount *account);
+    TpAccount *account);
 GList *empathy_log_store_search_new (EmpathyLogStore *self,
     const gchar *text);
 void empathy_log_store_ack_message (EmpathyLogStore *self,
     const gchar *chat_id, gboolean chatroom, EmpathyMessage *message);
 GList *empathy_log_store_get_filtered_messages (EmpathyLogStore *self,
-    EmpathyAccount *account, const gchar *chat_id, gboolean chatroom,
+    TpAccount *account, const gchar *chat_id, gboolean chatroom,
     guint num_messages, EmpathyLogMessageFilter filter, gpointer user_data);
 
 G_END_DECLS
diff --git a/libempathy/empathy-tp-roomlist.c b/libempathy/empathy-tp-roomlist.c
index 54d232339..2e95f3957 100644
--- a/libempathy/empathy-tp-roomlist.c
+++ b/libempathy/empathy-tp-roomlist.c
@@ -28,8 +28,6 @@
 #include <telepathy-glib/util.h>
 #include <telepathy-glib/interfaces.h>
 
-#include "empathy-account.h"
-
 #include "empathy-tp-roomlist.h"
 #include "empathy-chatroom.h"
 #include "empathy-utils.h"
@@ -41,7 +39,7 @@
 typedef struct {
 	TpConnection *connection;
 	TpChannel    *channel;
-	EmpathyAccount    *account;
+	TpAccount    *account;
 	gboolean      is_listing;
 	gboolean      start_requested;
 } EmpathyTpRoomlistPriv;
@@ -354,7 +352,7 @@ tp_roomlist_constructed (GObject *list)
 {
 	EmpathyTpRoomlistPriv *priv = GET_PRIV (list);
 
-	priv->connection = empathy_account_get_connection (priv->account);
+	priv->connection = tp_account_get_connection (priv->account);
 	g_object_ref (priv->connection);
 
 	tp_cli_connection_call_request_channel (priv->connection, -1,
@@ -421,7 +419,7 @@ empathy_tp_roomlist_class_init (EmpathyTpRoomlistClass *klass)
 					 g_param_spec_object ("account",
 							      "The Account",
 							      "The account on which it lists rooms",
-							      EMPATHY_TYPE_ACCOUNT,
+							      TP_TYPE_ACCOUNT,
 							      G_PARAM_READWRITE |
 							      G_PARAM_CONSTRUCT_ONLY));
 	g_object_class_install_property (object_class,
@@ -477,7 +475,7 @@ empathy_tp_roomlist_init (EmpathyTpRoomlist *list)
 }
 
 EmpathyTpRoomlist *
-empathy_tp_roomlist_new (EmpathyAccount *account)
+empathy_tp_roomlist_new (TpAccount *account)
 {
 	EmpathyTpRoomlist *list;
 
diff --git a/libempathy/empathy-tp-roomlist.h b/libempathy/empathy-tp-roomlist.h
index 801e5c69f..f400766a9 100644
--- a/libempathy/empathy-tp-roomlist.h
+++ b/libempathy/empathy-tp-roomlist.h
@@ -24,8 +24,8 @@
 
 #include <glib.h>
 
+#include <telepathy-glib/account.h>
 #include <telepathy-glib/connection.h>
-#include <libempathy/empathy-account.h>
 
 G_BEGIN_DECLS
 
@@ -49,7 +49,7 @@ struct _EmpathyTpRoomlistClass {
 };
 
 GType              empathy_tp_roomlist_get_type   (void) G_GNUC_CONST;
-EmpathyTpRoomlist *empathy_tp_roomlist_new        (EmpathyAccount *account);
+EmpathyTpRoomlist *empathy_tp_roomlist_new        (TpAccount *account);
 gboolean           empathy_tp_roomlist_is_listing (EmpathyTpRoomlist *list);
 void               empathy_tp_roomlist_start      (EmpathyTpRoomlist *list);
 void               empathy_tp_roomlist_stop       (EmpathyTpRoomlist *list);
diff --git a/libempathy/empathy-utils.c b/libempathy/empathy-utils.c
index a0cb4111e..21b0599c8 100644
--- a/libempathy/empathy-utils.c
+++ b/libempathy/empathy-utils.c
@@ -1,4 +1,3 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
 /*
  * Copyright (C) 2003-2007 Imendio AB
  * Copyright (C) 2007-2008 Collabora Ltd.
@@ -32,6 +31,8 @@
 #include <glib/gi18n-lib.h>
 
 #include <libxml/uri.h>
+
+#include <telepathy-glib/account-manager.h>
 #include <telepathy-glib/connection.h>
 #include <telepathy-glib/channel.h>
 #include <telepathy-glib/dbus.h>
@@ -490,3 +491,67 @@ empathy_signal_connect_weak (gpointer instance,
   g_object_weak_ref (instance_obj, instance_destroyed_cb, ctx);
   g_object_weak_ref (user_data, user_data_destroyed_cb, ctx);
 }
+
+/* Note: this function depends on the account manager having its core feature
+ * prepared. */
+TpAccount *
+empathy_get_account_for_connection (TpConnection *connection)
+{
+  TpAccountManager *manager;
+  TpAccount *account = NULL;
+  GList *accounts, *l;
+
+  manager = tp_account_manager_dup ();
+
+  accounts = tp_account_manager_get_valid_accounts (manager);
+
+  for (l = accounts; l != NULL; l = l->next)
+    {
+      TpAccount *a = l->data;
+
+      if (tp_account_get_connection (a) == connection)
+        {
+          account = a;
+          break;
+        }
+    }
+
+  g_list_free (accounts);
+  g_object_unref (manager);
+
+  return account;
+}
+
+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 ();
+  accounts = tp_account_manager_get_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 (accounts);
+  g_object_unref (manager);
+
+  if (connecting != NULL)
+    *connecting = out_connecting;
+
+  return out_connected;
+}
diff --git a/libempathy/empathy-utils.h b/libempathy/empathy-utils.h
index d62e096ae..97e5e85b7 100644
--- a/libempathy/empathy-utils.h
+++ b/libempathy/empathy-utils.h
@@ -85,6 +85,10 @@ void empathy_signal_connect_weak (gpointer instance,
     GCallback c_handler,
     GObject *user_data);
 
+TpAccount * empathy_get_account_for_connection (TpConnection *connection);
+
+gboolean empathy_account_manager_get_accounts_connected (gboolean *connecting);
+
 G_END_DECLS
 
 #endif /*  __EMPATHY_UTILS_H__ */
diff --git a/po/POTFILES.in b/po/POTFILES.in
index fdb074483..6af70385d 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -4,7 +4,6 @@
 data/empathy.desktop.in.in
 data/empathy.schemas.in
 
-libempathy/empathy-account.c
 libempathy/empathy-ft-handler.c
 libempathy/empathy-tp-contact-list.c
 libempathy/empathy-tp-file.c
diff --git a/src/empathy-account-assistant.c b/src/empathy-account-assistant.c
index d9834f38b..08cf025d3 100644
--- a/src/empathy-account-assistant.c
+++ b/src/empathy-account-assistant.c
@@ -225,7 +225,7 @@ account_assistant_account_enabled_cb (GObject *source,
   EmpathyAccountAssistant *self = user_data;
   EmpathyAccountAssistantPriv *priv = GET_PRIV (self);
 
-  empathy_account_set_enabled_finish (EMPATHY_ACCOUNT (source),
+  tp_account_set_enabled_finish (TP_ACCOUNT (source),
       result, &error);
 
   if (error)
@@ -249,7 +249,7 @@ account_assistant_apply_account_cb (GObject *source,
   EmpathyAccountAssistant *self = user_data;
   EmpathyAccountAssistantPriv *priv = GET_PRIV (self);
   EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (source);
-  EmpathyAccount *account;
+  TpAccount *account;
 
   empathy_account_settings_apply_finish (settings, result, &error);
 
@@ -265,7 +265,7 @@ account_assistant_apply_account_cb (GObject *source,
 
   /* enable the newly created account */
   account = empathy_account_settings_get_account (settings);
-  empathy_account_set_enabled_async (account, TRUE,
+  tp_account_set_enabled_async (account, TRUE,
       account_assistant_account_enabled_cb, self);
 }
 
diff --git a/src/empathy-accounts-dialog.c b/src/empathy-accounts-dialog.c
index e877e632f..460ea9023 100644
--- a/src/empathy-accounts-dialog.c
+++ b/src/empathy-accounts-dialog.c
@@ -32,10 +32,10 @@
 #include <glib/gi18n.h>
 #include <dbus/dbus-glib.h>
 
+#include <telepathy-glib/account-manager.h>
 #include <telepathy-glib/util.h>
 
 #include <libempathy/empathy-utils.h>
-#include <libempathy/empathy-account-manager.h>
 #include <libempathy/empathy-connection-managers.h>
 #include <libempathy-gtk/empathy-ui-utils.h>
 
@@ -107,11 +107,11 @@ typedef struct {
   gulong  settings_ready_id;
   EmpathyAccountSettings *settings_ready;
 
-  EmpathyAccountManager *account_manager;
+  TpAccountManager *account_manager;
   EmpathyConnectionManagers *cms;
 
   GtkWindow *parent_window;
-  EmpathyAccount *initial_selection;
+  TpAccount *initial_selection;
 
   /* Those are needed when changing the selected row. When a user selects
    * another account and there are unsaved changes on the currently selected
@@ -146,9 +146,6 @@ static gboolean accounts_dialog_get_settings_iter (
 
 static void accounts_dialog_model_select_first (EmpathyAccountsDialog *dialog);
 
-static void accounts_dialog_update (EmpathyAccountsDialog *dialog,
-    EmpathyAccountSettings *settings);
-
 static void accounts_dialog_update_settings (EmpathyAccountsDialog *dialog,
     EmpathyAccountSettings *settings);
 
@@ -175,7 +172,7 @@ empathy_account_dialog_widget_cancelled_cb (
   GtkTreeSelection *selection;
   GtkTreeIter iter;
   EmpathyAccountSettings *settings;
-  EmpathyAccount *account;
+  TpAccount *account;
   EmpathyAccountsDialogPriv *priv = GET_PRIV (dialog);
 
   view = GTK_TREE_VIEW (priv->treeview);
@@ -354,7 +351,7 @@ accounts_dialog_model_select_first (EmpathyAccountsDialog *dialog)
 
 static gboolean
 accounts_dialog_has_pending_change (EmpathyAccountsDialog *dialog,
-    EmpathyAccount **account)
+    TpAccount **account)
 {
   GtkTreeIter iter;
   GtkTreeModel *model;
@@ -502,13 +499,13 @@ static void
 accounts_dialog_button_add_clicked_cb (GtkWidget *button,
     EmpathyAccountsDialog *dialog)
 {
-  EmpathyAccount *account = NULL;
+  TpAccount *account = NULL;
 
   if (accounts_dialog_has_pending_change (dialog, &account))
     {
       gchar *question_dialog_primary_text = g_strdup_printf (
           PENDING_CHANGES_QUESTION_PRIMARY_TEXT,
-          empathy_account_get_display_name (account));
+          tp_account_get_display_name (account));
 
       accounts_dialog_show_question_dialog (dialog,
           question_dialog_primary_text,
@@ -708,9 +705,11 @@ accounts_dialog_name_edited_cb (GtkCellRendererText *renderer,
   GtkTreePath  *treepath;
   GtkTreeIter   iter;
   EmpathyAccountsDialogPriv *priv = GET_PRIV (dialog);
+  gboolean connecting;
 
-  if (empathy_account_manager_get_connecting_accounts
-      (priv->account_manager) > 0)
+  empathy_account_manager_get_accounts_connected (&connecting);
+
+  if (connecting)
     {
       priv->connecting_id = g_timeout_add (FLASH_TIMEOUT,
           (GSourceFunc) accounts_dialog_flash_connecting_cb,
@@ -739,7 +738,7 @@ accounts_dialog_delete_account_response_cb (GtkDialog *message_dialog,
   gint response_id,
   gpointer user_data)
 {
-  EmpathyAccount *account;
+  TpAccount *account;
   GtkTreeModel *model;
   GtkTreeIter iter;
   GtkTreeSelection *selection;
@@ -757,7 +756,7 @@ accounts_dialog_delete_account_response_cb (GtkDialog *message_dialog,
 
       if (account != NULL)
         {
-          empathy_account_remove_async (account, NULL, NULL);
+          tp_account_remove_async (account, NULL, NULL);
           g_object_unref (account);
           account = NULL;
         }
@@ -774,7 +773,7 @@ accounts_dialog_view_delete_activated_cb (EmpathyCellRendererActivatable *cell,
     const gchar *path_string,
     EmpathyAccountsDialog *dialog)
 {
-  EmpathyAccount *account;
+  TpAccount *account;
   GtkTreeModel *model;
   GtkTreeIter iter;
   gchar *question_dialog_primary_text;
@@ -787,7 +786,7 @@ accounts_dialog_view_delete_activated_cb (EmpathyCellRendererActivatable *cell,
 
   gtk_tree_model_get (model, &iter, COL_ACCOUNT_POINTER, &account, -1);
 
-  if (account == NULL || !empathy_account_is_valid (account))
+  if (account == NULL || !tp_account_is_valid (account))
     {
       gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
       accounts_dialog_model_select_first (dialog);
@@ -802,7 +801,7 @@ accounts_dialog_view_delete_activated_cb (EmpathyCellRendererActivatable *cell,
       /* Translators: this is used only when built on a moblin platform */
       _("Do you want to remove %s from your computer?"),
 #endif /* HAVE_MOBLIN */
-      empathy_account_get_display_name (account));
+      tp_account_get_display_name (account));
 
   accounts_dialog_show_question_dialog (dialog, question_dialog_primary_text,
 #ifndef HAVE_MOBLIN
@@ -977,7 +976,7 @@ accounts_dialog_account_selection_change (GtkTreeSelection *selection,
     gboolean path_currently_selected,
     gpointer data)
 {
-  EmpathyAccount *account = NULL;
+  TpAccount *account = NULL;
   EmpathyAccountsDialog *dialog = EMPATHY_ACCOUNTS_DIALOG (data);
   EmpathyAccountsDialogPriv *priv = GET_PRIV (dialog);
 
@@ -1000,7 +999,7 @@ accounts_dialog_account_selection_change (GtkTreeSelection *selection,
 
       question_dialog_primary_text = g_strdup_printf (
           PENDING_CHANGES_QUESTION_PRIMARY_TEXT,
-          empathy_account_get_display_name (account));
+          tp_account_get_display_name (account));
 
       accounts_dialog_show_question_dialog (dialog,
           question_dialog_primary_text,
@@ -1031,7 +1030,7 @@ accounts_dialog_model_setup (EmpathyAccountsDialog *dialog)
   store = gtk_list_store_new (COL_COUNT,
       G_TYPE_STRING,         /* name */
       G_TYPE_UINT,           /* status */
-      EMPATHY_TYPE_ACCOUNT,   /* account */
+      TP_TYPE_ACCOUNT,   /* account */
       EMPATHY_TYPE_ACCOUNT_SETTINGS); /* settings */
 
   gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview),
@@ -1093,7 +1092,7 @@ accounts_dialog_get_settings_iter (EmpathyAccountsDialog *dialog,
 
 static gboolean
 accounts_dialog_get_account_iter (EmpathyAccountsDialog *dialog,
-    EmpathyAccount *account,
+    TpAccount *account,
     GtkTreeIter *iter)
 {
   GtkTreeView      *view;
@@ -1162,11 +1161,12 @@ accounts_dialog_add (EmpathyAccountsDialog *dialog,
 }
 
 static void
-accounts_dialog_connection_changed_cb     (EmpathyAccountManager *manager,
-    EmpathyAccount *account,
-    TpConnectionStatusReason reason,
-    TpConnectionStatus current,
-    TpConnectionStatus previous,
+accounts_dialog_connection_changed_cb (TpAccount *account,
+    guint old_status,
+    guint current,
+    guint reason,
+    gchar *dbus_error_name,
+    GHashTable *details,
     EmpathyAccountsDialog *dialog)
 {
   GtkTreeModel *model;
@@ -1190,7 +1190,7 @@ accounts_dialog_connection_changed_cb     (EmpathyAccountManager *manager,
       gtk_tree_path_free (path);
     }
 
-  found = (empathy_account_manager_get_connecting_accounts (manager) > 0);
+  empathy_account_manager_get_accounts_connected (&found);
 
   if (!found && priv->connecting_id)
     {
@@ -1205,7 +1205,7 @@ accounts_dialog_connection_changed_cb     (EmpathyAccountManager *manager,
 }
 
 static void
-accounts_dialog_account_display_name_changed_cb (EmpathyAccount *account,
+accounts_dialog_account_display_name_changed_cb (TpAccount *account,
   GParamSpec *pspec,
   gpointer user_data)
 {
@@ -1213,11 +1213,11 @@ accounts_dialog_account_display_name_changed_cb (EmpathyAccount *account,
   GtkTreeIter iter;
   GtkTreeModel *model;
   EmpathyAccountSettings *settings;
-  EmpathyAccount *selected_account;
+  TpAccount *selected_account;
   EmpathyAccountsDialog *dialog = EMPATHY_ACCOUNTS_DIALOG (user_data);
   EmpathyAccountsDialogPriv *priv = GET_PRIV (dialog);
 
-  display_name = empathy_account_get_display_name (account);
+  display_name = tp_account_get_display_name (account);
   model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->treeview));
   settings = accounts_dialog_model_get_selected_settings (dialog);
   if (settings == NULL)
@@ -1240,7 +1240,7 @@ accounts_dialog_account_display_name_changed_cb (EmpathyAccount *account,
 
 static void
 accounts_dialog_add_account (EmpathyAccountsDialog *dialog,
-    EmpathyAccount *account)
+    TpAccount *account)
 {
   EmpathyAccountSettings *settings;
   GtkTreeModel       *model;
@@ -1251,9 +1251,9 @@ accounts_dialog_add_account (EmpathyAccountsDialog *dialog,
   EmpathyAccountsDialogPriv *priv = GET_PRIV (dialog);
 
   model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->treeview));
-  g_object_get (account, "connection-status", &status, NULL);
-  name = empathy_account_get_display_name (account);
-  enabled = empathy_account_is_enabled (account);
+  status = tp_account_get_connection_status (account, NULL);
+  name = tp_account_get_display_name (account);
+  enabled = tp_account_is_enabled (account);
 
   settings = empathy_account_settings_new_for_account (account);
 
@@ -1267,11 +1267,12 @@ accounts_dialog_add_account (EmpathyAccountsDialog *dialog,
       COL_ACCOUNT_SETTINGS_POINTER, settings,
       -1);
 
-  accounts_dialog_connection_changed_cb (priv->account_manager,
-      account,
-      TP_CONNECTION_STATUS_REASON_NONE_SPECIFIED,
+  accounts_dialog_connection_changed_cb (account,
+      0,
       status,
       TP_CONNECTION_STATUS_DISCONNECTED,
+      NULL,
+      NULL,
       dialog);
 
   empathy_signal_connect_weak (account, "notify::display-name",
@@ -1282,48 +1283,16 @@ accounts_dialog_add_account (EmpathyAccountsDialog *dialog,
 }
 
 static void
-accounts_dialog_update (EmpathyAccountsDialog *dialog,
-    EmpathyAccountSettings *settings)
-{
-  GtkTreeModel       *model;
-  GtkTreeIter         iter;
-  TpConnectionStatus  status = TP_CONNECTION_STATUS_DISCONNECTED;
-  const gchar        *name;
-  gboolean            enabled = FALSE;
-  EmpathyAccount     *account;
-  EmpathyAccountsDialogPriv *priv = GET_PRIV (dialog);
-
-  model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->treeview));
-  name = empathy_account_settings_get_display_name (settings);
-
-  account = empathy_account_settings_get_account (settings);
-  if (account != NULL)
-    {
-      enabled = empathy_account_is_enabled (account);
-      g_object_get (account, "connection-status", &status, NULL);
-    }
-
-  accounts_dialog_get_settings_iter (dialog, settings, &iter);
-  gtk_list_store_set (GTK_LIST_STORE (model), &iter,
-      COL_NAME, name,
-      COL_STATUS, status,
-      COL_ACCOUNT_POINTER, account,
-      COL_ACCOUNT_SETTINGS_POINTER, settings,
-      -1);
-}
-
-static void
-accounts_dialog_account_added_cb (EmpathyAccountManager *manager,
-    EmpathyAccount *account,
+accounts_dialog_account_validity_changed_cb (TpAccountManager *manager,
+    TpAccount *account,
     EmpathyAccountsDialog *dialog)
 {
   accounts_dialog_add_account (dialog, account);
 }
 
-
 static void
-accounts_dialog_account_removed_cb (EmpathyAccountManager *manager,
-    EmpathyAccount *account,
+accounts_dialog_account_removed_cb (TpAccountManager *manager,
+    TpAccount *account,
     EmpathyAccountsDialog *dialog)
 {
   GtkTreeIter iter;
@@ -1338,7 +1307,7 @@ accounts_dialog_account_removed_cb (EmpathyAccountManager *manager,
 
 static void
 enable_or_disable_account (EmpathyAccountsDialog *dialog,
-    EmpathyAccount *account,
+    TpAccount *account,
     gboolean enabled)
 {
   GtkTreeModel *model;
@@ -1348,60 +1317,27 @@ enable_or_disable_account (EmpathyAccountsDialog *dialog,
   model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->treeview));
 
   DEBUG ("Account %s is now %s",
-      empathy_account_get_display_name (account),
+      tp_account_get_display_name (account),
       enabled ? "enabled" : "disabled");
 }
 
 static void
-accounts_dialog_account_disabled_cb (EmpathyAccountManager *manager,
-    EmpathyAccount *account,
+accounts_dialog_account_disabled_cb (TpAccountManager *manager,
+    TpAccount *account,
     EmpathyAccountsDialog *dialog)
 {
   enable_or_disable_account (dialog, account, FALSE);
 }
 
 static void
-accounts_dialog_account_enabled_cb (EmpathyAccountManager *manager,
-    EmpathyAccount *account,
+accounts_dialog_account_enabled_cb (TpAccountManager *manager,
+    TpAccount *account,
     EmpathyAccountsDialog *dialog)
 {
   enable_or_disable_account (dialog, account, TRUE);
 }
 
 static void
-accounts_dialog_account_changed_cb (EmpathyAccountManager *manager,
-    EmpathyAccount *account,
-    EmpathyAccountsDialog  *dialog)
-{
-  EmpathyAccountSettings *settings, *selected_settings;
-  GtkTreeModel *model;
-  GtkTreeIter iter;
-  EmpathyAccountsDialogPriv *priv = GET_PRIV (dialog);
-
-  model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->treeview));
-
-  if (!accounts_dialog_get_account_iter (dialog, account, &iter))
-    return;
-
-  gtk_tree_model_get (model, &iter,
-      COL_ACCOUNT_SETTINGS_POINTER, &settings,
-      -1);
-
-  accounts_dialog_update (dialog, settings);
-  selected_settings = accounts_dialog_model_get_selected_settings (dialog);
-
-  if (settings == selected_settings)
-    accounts_dialog_update_name_label (dialog,
-        empathy_account_settings_get_display_name (settings));
-
-  if (settings)
-    g_object_unref (settings);
-
-  if (selected_settings)
-    g_object_unref (selected_settings);
-}
-
-static void
 accounts_dialog_button_create_clicked_cb (GtkWidget *button,
     EmpathyAccountsDialog *dialog)
 {
@@ -1504,14 +1440,14 @@ accounts_dialog_response_cb (GtkWidget *widget,
     gint response,
     EmpathyAccountsDialog *dialog)
 {
-  EmpathyAccount *account = NULL;
+  TpAccount *account = NULL;
 
   if (accounts_dialog_has_pending_change (dialog, &account))
     {
       gchar *question_dialog_primary_text;
       question_dialog_primary_text = g_strdup_printf (
           PENDING_CHANGES_QUESTION_PRIMARY_TEXT,
-          empathy_account_get_display_name (account));
+          tp_account_get_display_name (account));
 
       accounts_dialog_show_question_dialog (dialog,
           question_dialog_primary_text,
@@ -1549,7 +1485,7 @@ accounts_dialog_destroy_cb (GtkObject *obj,
 
 static void
 accounts_dialog_set_selected_account (EmpathyAccountsDialog *dialog,
-    EmpathyAccount *account)
+    TpAccount *account)
 {
   GtkTreeSelection *selection;
   GtkTreeIter       iter;
@@ -1587,10 +1523,10 @@ accounts_dialog_accounts_setup (EmpathyAccountsDialog *dialog)
   EmpathyAccountsDialogPriv *priv = GET_PRIV (dialog);
   GList *accounts, *l;
 
-  g_signal_connect (priv->account_manager, "account-created",
-      G_CALLBACK (accounts_dialog_account_added_cb),
+  g_signal_connect (priv->account_manager, "account-validity-changed",
+      G_CALLBACK (accounts_dialog_account_validity_changed_cb),
       dialog);
-  g_signal_connect (priv->account_manager, "account-deleted",
+  g_signal_connect (priv->account_manager, "account-removed",
       G_CALLBACK (accounts_dialog_account_removed_cb),
       dialog);
   g_signal_connect (priv->account_manager, "account-enabled",
@@ -1599,19 +1535,15 @@ accounts_dialog_accounts_setup (EmpathyAccountsDialog *dialog)
   g_signal_connect (priv->account_manager, "account-disabled",
       G_CALLBACK (accounts_dialog_account_disabled_cb),
       dialog);
-  g_signal_connect (priv->account_manager, "account-changed",
-      G_CALLBACK (accounts_dialog_account_changed_cb),
-      dialog);
-  g_signal_connect (priv->account_manager, "account-connection-changed",
-      G_CALLBACK (accounts_dialog_connection_changed_cb),
-      dialog);
 
   /* Add existing accounts */
-  accounts = empathy_account_manager_dup_accounts (priv->account_manager);
+  accounts = tp_account_manager_get_valid_accounts (priv->account_manager);
   for (l = accounts; l; l = l->next)
     {
       accounts_dialog_add_account (dialog, l->data);
-      g_object_unref (l->data);
+
+      empathy_signal_connect_weak (l->data, "status-changed",
+          G_CALLBACK (accounts_dialog_connection_changed_cb), G_OBJECT (dialog));
     }
   g_list_free (accounts);
 
@@ -1624,12 +1556,19 @@ accounts_dialog_accounts_setup (EmpathyAccountsDialog *dialog)
 }
 
 static void
-accounts_dialog_manager_ready_cb (EmpathyAccountManager *manager,
-    GParamSpec *pspec,
+accounts_dialog_manager_ready_cb (GObject *source_object,
+    GAsyncResult *result,
     gpointer user_data)
 {
-  if (!empathy_account_manager_is_ready (manager))
-    return;
+  TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object);
+  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_dialog_accounts_setup (user_data);
 }
@@ -1709,7 +1648,7 @@ do_dispose (GObject *obj)
 
   /* Disconnect signals */
   g_signal_handlers_disconnect_by_func (priv->account_manager,
-      accounts_dialog_account_added_cb,
+      accounts_dialog_account_validity_changed_cb,
       dialog);
   g_signal_handlers_disconnect_by_func (priv->account_manager,
       accounts_dialog_account_removed_cb,
@@ -1721,12 +1660,6 @@ do_dispose (GObject *obj)
       accounts_dialog_account_disabled_cb,
       dialog);
   g_signal_handlers_disconnect_by_func (priv->account_manager,
-      accounts_dialog_account_changed_cb,
-      dialog);
-  g_signal_handlers_disconnect_by_func (priv->account_manager,
-      accounts_dialog_connection_changed_cb,
-      dialog);
-  g_signal_handlers_disconnect_by_func (priv->account_manager,
       accounts_dialog_manager_ready_cb,
       dialog);
 
@@ -1827,13 +1760,10 @@ do_constructed (GObject *object)
   accounts_dialog_model_setup (dialog);
 
   /* Set up signalling */
-  priv->account_manager = empathy_account_manager_dup_singleton ();
+  priv->account_manager = tp_account_manager_dup ();
 
-  if (!empathy_account_manager_is_ready (priv->account_manager))
-    g_signal_connect (priv->account_manager, "notify::ready",
-        G_CALLBACK (accounts_dialog_manager_ready_cb), dialog);
-  else
-    accounts_dialog_accounts_setup (dialog);
+  tp_account_manager_prepare_async (priv->account_manager, NULL,
+      accounts_dialog_manager_ready_cb, dialog);
 
   empathy_conf_get_bool (empathy_conf_get (),
       EMPATHY_PREFS_IMPORT_ASKED, &import_asked);
@@ -1891,7 +1821,7 @@ empathy_accounts_dialog_init (EmpathyAccountsDialog *dialog)
 
 GtkWidget *
 empathy_accounts_dialog_show (GtkWindow *parent,
-    EmpathyAccount *selected_account)
+    TpAccount *selected_account)
 {
   EmpathyAccountsDialog *dialog;
   EmpathyAccountsDialogPriv *priv;
diff --git a/src/empathy-accounts-dialog.h b/src/empathy-accounts-dialog.h
index aa8f7c06b..2d9d60c2b 100644
--- a/src/empathy-accounts-dialog.h
+++ b/src/empathy-accounts-dialog.h
@@ -26,7 +26,7 @@
 
 #include <gtk/gtk.h>
 
-#include <libempathy/empathy-account.h>
+#include <telepathy-glib/account.h>
 
 G_BEGIN_DECLS
 
@@ -55,7 +55,7 @@ typedef struct {
 
 GType empathy_accounts_dialog_get_type (void);
 GtkWidget *empathy_accounts_dialog_show (GtkWindow *parent,
-    EmpathyAccount *selected_account);
+    TpAccount *selected_account);
 
 G_END_DECLS
 
diff --git a/src/empathy-chat-window.c b/src/empathy-chat-window.c
index 7b81d7a43..69469815e 100644
--- a/src/empathy-chat-window.c
+++ b/src/empathy-chat-window.c
@@ -35,13 +35,13 @@
 #include <glib/gi18n.h>
 #include <libnotify/notification.h>
 
+#include <telepathy-glib/account-manager.h>
 #include <telepathy-glib/util.h>
 
 #include <libempathy/empathy-contact.h>
 #include <libempathy/empathy-message.h>
 #include <libempathy/empathy-dispatcher.h>
 #include <libempathy/empathy-chatroom-manager.h>
-#include <libempathy/empathy-account-manager.h>
 #include <libempathy/empathy-utils.h>
 
 #include <libempathy-gtk/empathy-images.h>
@@ -434,7 +434,7 @@ chat_window_update_chat_tab (EmpathyChat *chat)
 	EmpathyContact        *remote_contact;
 	const gchar           *name;
 	const gchar           *id;
-	EmpathyAccount        *account;
+	TpAccount             *account;
 	const gchar           *subject;
 	const gchar           *status = NULL;
 	GtkWidget             *widget;
@@ -457,7 +457,7 @@ chat_window_update_chat_tab (EmpathyChat *chat)
 	remote_contact = empathy_chat_get_remote_contact (chat);
 
 	DEBUG ("Updating chat tab, name=%s, account=%s, subject=%s, remote_contact=%p",
-		name, empathy_account_get_unique_name (account), subject, remote_contact);
+		name, tp_proxy_get_object_path (account), subject, remote_contact);
 
 	/* Update tab image */
 	if (empathy_chat_get_tp_chat (chat) == NULL) {
@@ -501,7 +501,7 @@ chat_window_update_chat_tab (EmpathyChat *chat)
 	append_markup_printf (tooltip,
 			      "<b>%s</b><small> (%s)</small>",
 			      id,
-			      empathy_account_get_display_name (account));
+			      tp_account_get_display_name (account));
 
 	if (!EMP_STR_EMPTY (status)) {
 		append_markup_printf (tooltip, "\n<i>%s</i>", status);
@@ -596,7 +596,7 @@ chat_window_conv_activate_cb (GtkAction         *action,
 	is_room = empathy_chat_is_room (priv->current_chat);
 	if (is_room) {
 		const gchar *room;
-		EmpathyAccount   *account;
+		TpAccount   *account;
 		gboolean     found = FALSE;
 		EmpathyChatroom *chatroom;
 
@@ -645,7 +645,7 @@ chat_window_favorite_toggled_cb (GtkToggleAction   *toggle_action,
 {
 	EmpathyChatWindowPriv *priv = GET_PRIV (window);
 	gboolean               active;
-	EmpathyAccount        *account;
+	TpAccount             *account;
 	const gchar           *room;
 	EmpathyChatroom       *chatroom;
 
@@ -1346,15 +1346,18 @@ chat_window_drag_data_received (GtkWidget        *widget,
 	if (info == DND_DRAG_TYPE_CONTACT_ID) {
 		EmpathyChat           *chat = NULL;
 		EmpathyChatWindow     *old_window;
-		EmpathyAccount        *account = NULL;
-		EmpathyAccountManager *account_manager;
+		TpAccount             *account = NULL;
+		TpAccountManager      *account_manager;
 		const gchar           *id;
 		gchar                **strv;
 		const gchar           *account_id;
 		const gchar           *contact_id;
 
 		id = (const gchar*) gtk_selection_data_get_data (selection);
-		account_manager = empathy_account_manager_dup_singleton ();
+
+		/* FIXME: Perhaps should be sure that the account manager is
+		 * prepared before calling _ensure_account on it. */
+		account_manager = tp_account_manager_dup ();
 
 		DEBUG ("DND contact from roster with id:'%s'", id);
 
@@ -1363,7 +1366,7 @@ chat_window_drag_data_received (GtkWidget        *widget,
 			account_id = strv[0];
 			contact_id = strv[1];
 			account =
-				empathy_account_manager_get_account (account_manager, account_id);
+				tp_account_manager_ensure_account (account_manager, account_id);
 			if (account != NULL)
 				chat = empathy_chat_window_find_chat (account, contact_id);
 		}
@@ -1377,7 +1380,7 @@ chat_window_drag_data_received (GtkWidget        *widget,
 		if (!chat) {
 			TpConnection *connection;
 
-			connection = empathy_account_get_connection (account);
+			connection = tp_account_get_connection (account);
 
 			if (connection) {
 				empathy_dispatcher_chat_with_contact_id (
@@ -1855,7 +1858,7 @@ empathy_chat_window_has_focus (EmpathyChatWindow *window)
 }
 
 EmpathyChat *
-empathy_chat_window_find_chat (EmpathyAccount   *account,
+empathy_chat_window_find_chat (TpAccount   *account,
 			       const gchar *id)
 {
 	GList *l;
diff --git a/src/empathy-chat-window.h b/src/empathy-chat-window.h
index 6f3d21fca..1e4a001e5 100644
--- a/src/empathy-chat-window.h
+++ b/src/empathy-chat-window.h
@@ -31,7 +31,8 @@
 #include <glib-object.h>
 #include <gtk/gtk.h>
 
-#include <libempathy/empathy-account.h>
+#include <telepathy-glib/account.h>
+
 #include <libempathy-gtk/empathy-chat.h>
 
 G_BEGIN_DECLS
@@ -69,7 +70,7 @@ void               empathy_chat_window_move_chat      (EmpathyChatWindow *old_wi
 void               empathy_chat_window_switch_to_chat (EmpathyChatWindow *window,
 						       EmpathyChat       *chat);
 gboolean           empathy_chat_window_has_focus      (EmpathyChatWindow *window);
-EmpathyChat *      empathy_chat_window_find_chat      (EmpathyAccount   *account,
+EmpathyChat *      empathy_chat_window_find_chat      (TpAccount        *account,
 						       const gchar      *id);
 void               empathy_chat_window_present_chat   (EmpathyChat      *chat);
 
diff --git a/src/empathy-chatrooms-window.c b/src/empathy-chatrooms-window.c
index 4ec71ec49..278a1d686 100644
--- a/src/empathy-chatrooms-window.c
+++ b/src/empathy-chatrooms-window.c
@@ -308,7 +308,7 @@ chatrooms_window_model_refresh_data (EmpathyChatroomsWindow *window,
 	GtkTreeIter            iter;
 	GtkTreeViewColumn     *column;
 	EmpathyAccountChooser  *account_chooser;
-	EmpathyAccount        *account;
+	TpAccount             *account;
 	GList                 *chatrooms, *l;
 
 	view = GTK_TREE_VIEW (window->treeview);
@@ -506,7 +506,7 @@ chatrooms_window_chatroom_added_cb (EmpathyChatroomManager *manager,
 				    EmpathyChatroomsWindow *window)
 {
 	EmpathyAccountChooser *account_chooser;
-	EmpathyAccount       *account;
+	TpAccount             *account;
 
 	account_chooser = EMPATHY_ACCOUNT_CHOOSER (window->account_chooser);
 	account = empathy_account_chooser_dup_account (account_chooser);
diff --git a/src/empathy-event-manager.c b/src/empathy-event-manager.c
index c68458d69..f3eb2992d 100644
--- a/src/empathy-event-manager.c
+++ b/src/empathy-event-manager.c
@@ -24,11 +24,12 @@
 #include <string.h>
 #include <glib/gi18n.h>
 
+#include <telepathy-glib/account-manager.h>
 #include <telepathy-glib/util.h>
 #include <telepathy-glib/interfaces.h>
 
-#include <libempathy/empathy-account-manager.h>
 #include <libempathy/empathy-dispatcher.h>
+#include <libempathy/empathy-idle.h>
 #include <libempathy/empathy-tp-contact-factory.h>
 #include <libempathy/empathy-contact-manager.h>
 #include <libempathy/empathy-tp-chat.h>
@@ -918,13 +919,16 @@ event_manager_presence_changed_cb (EmpathyContactMonitor *monitor,
     TpConnectionPresenceType previous,
     EmpathyEventManager *manager)
 {
-  EmpathyAccount *account;
+  TpAccount *account;
   gchar *header = NULL;
   gboolean preference = FALSE;
+  EmpathyIdle *idle;
 
   account = empathy_contact_get_account (contact);
-  if (empathy_account_is_just_connected (account))
-    return;
+  idle = empathy_idle_dup_singleton ();
+
+  if (empathy_idle_account_is_just_connected (idle, account))
+    goto out;
 
   if (tp_connection_presence_type_cmp_availability (previous,
      TP_CONNECTION_PRESENCE_TYPE_OFFLINE) > 0)
@@ -960,6 +964,9 @@ event_manager_presence_changed_cb (EmpathyContactMonitor *monitor,
         }
     }
   g_free (header);
+
+out:
+  g_object_unref (idle);
 }
 
 
diff --git a/src/empathy-import-mc4-accounts.c b/src/empathy-import-mc4-accounts.c
index 0a72c4929..b4bca6fdb 100644
--- a/src/empathy-import-mc4-accounts.c
+++ b/src/empathy-import-mc4-accounts.c
@@ -24,11 +24,11 @@
 #include <glib.h>
 #include <glib/gi18n.h>
 #include <gconf/gconf-client.h>
+#include <telepathy-glib/account-manager.h>
 #include <telepathy-glib/util.h>
 #include <telepathy-glib/defs.h>
 #include <dbus/dbus-protocol.h>
 #include <gnome-keyring.h>
-#include <libempathy/empathy-account-manager.h>
 #include <libempathy/empathy-account-settings.h>
 #include <libempathy/empathy-connection-managers.h>
 
@@ -189,12 +189,12 @@ _move_contents (const gchar *old, const gchar *new)
 }
 
 static void
-_move_logs (EmpathyAccount *account, const gchar *account_name)
+_move_logs (TpAccount *account, const gchar *account_name)
 {
   gchar *old_path, *new_path, *escaped;
   const gchar *name;
 
-  name = empathy_account_get_unique_name (account);
+  name = tp_proxy_get_object_path (account);
   if (g_str_has_prefix (name, TP_ACCOUNT_OBJECT_PATH_BASE))
     name += strlen (TP_ACCOUNT_OBJECT_PATH_BASE);
 
@@ -215,7 +215,7 @@ _create_account_cb (GObject *source,
   GAsyncResult *result,
   gpointer user_data)
 {
-  EmpathyAccount *account;
+  TpAccount *account;
   GError *error = NULL;
   Misc *misc = (Misc *) user_data;
 
@@ -233,7 +233,7 @@ _create_account_cb (GObject *source,
 
   _move_logs (account, misc->account_name);
 
-  empathy_account_set_enabled_async (account,
+  tp_account_set_enabled_async (account,
       misc->enable, NULL, NULL);
 
   g_free (misc->account_name);
diff --git a/src/empathy-import-widget.c b/src/empathy-import-widget.c
index 2dc810b0a..5a0d82c8c 100644
--- a/src/empathy-import-widget.c
+++ b/src/empathy-import-widget.c
@@ -28,13 +28,12 @@
 
 #define DEBUG_FLAG EMPATHY_DEBUG_OTHER
 #include <libempathy/empathy-debug.h>
-#include <libempathy/empathy-account.h>
-#include <libempathy/empathy-account-manager.h>
 #include <libempathy/empathy-connection-managers.h>
 #include <libempathy/empathy-utils.h>
 
 #include <libempathy-gtk/empathy-ui-utils.h>
 
+#include <telepathy-glib/account-manager.h>
 #include <telepathy-glib/util.h>
 
 #include <glib/gi18n.h>
@@ -77,24 +76,12 @@ import_widget_account_id_in_list (GList *accounts,
 
   for (l = accounts; l; l = l->next)
     {
-      EmpathyAccount *account = l->data;
-      const gchar *account_string;
-      GValue *value;
-      gboolean result;
+      TpAccount *account = l->data;
       const GHashTable *parameters;
 
-      parameters = empathy_account_get_parameters (account);
-
-      value = g_hash_table_lookup ((GHashTable *) parameters, "account");
-
-      if (value == NULL)
-        continue;
-
-      account_string = g_value_get_string (value);
-
-      result = tp_strdiff (account_string, account_id);
+      parameters = tp_account_get_parameters (account);
 
-      if (!result)
+      if (!tp_strdiff (tp_asv_get_string (parameters, "account"), account_id))
         return TRUE;
     }
 
@@ -102,13 +89,24 @@ import_widget_account_id_in_list (GList *accounts,
 }
 
 static void
-import_widget_add_accounts_to_model (EmpathyImportWidget *self)
+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);
-  EmpathyAccountManager *manager = empathy_account_manager_dup_singleton ();
+  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;
+    }
 
   model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->treeview));
 
@@ -128,14 +126,13 @@ import_widget_add_accounts_to_model (EmpathyImportWidget *self)
 
       value = g_hash_table_lookup (data->settings, "account");
 
-      accounts = empathy_account_manager_dup_accounts (manager);
+      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_foreach (accounts, (GFunc) g_object_unref, NULL);
       g_list_free (accounts);
 
       gtk_list_store_append (GTK_LIST_STORE (model), &iter);
@@ -148,6 +145,17 @@ import_widget_add_accounts_to_model (EmpathyImportWidget *self)
           COL_ACCOUNT_DATA, data,
           -1);
     }
+}
+
+static void
+import_widget_add_accounts_to_model (EmpathyImportWidget *self)
+{
+  TpAccountManager *manager;
+
+  manager = tp_account_manager_dup ();
+
+  tp_account_manager_prepare_async (manager, NULL,
+      account_manager_prepared_cb, self);
 
   g_object_unref (manager);
 }
@@ -157,12 +165,12 @@ import_widget_create_account_cb (GObject *source,
   GAsyncResult *result,
   gpointer user_data)
 {
-  EmpathyAccount *account;
+  TpAccount *account;
   GError *error = NULL;
   EmpathyImportWidget *self = user_data;
 
-  account = empathy_account_manager_create_account_finish (
-    EMPATHY_ACCOUNT_MANAGER (source), result, &error);
+  account = tp_account_manager_create_account_finish (
+    TP_ACCOUNT_MANAGER (source), result, &error);
 
   if (account == NULL)
     {
@@ -181,12 +189,12 @@ static void
 import_widget_add_account (EmpathyImportWidget *self,
     EmpathyImportAccountData *data)
 {
-  EmpathyAccountManager *account_manager;
+  TpAccountManager *account_manager;
   gchar *display_name;
   GHashTable *properties;
   GValue *username;
 
-  account_manager = empathy_account_manager_dup_singleton ();
+  account_manager = tp_account_manager_dup ();
 
   DEBUG ("connection_manager: %s\n", data->connection_manager);
 
@@ -200,7 +208,7 @@ import_widget_add_account (EmpathyImportWidget *self,
 
   properties = g_hash_table_new (NULL, NULL);
 
-  empathy_account_manager_create_account_async (account_manager,
+  tp_account_manager_create_account_async (account_manager,
       (const gchar*) data->connection_manager, data->protocol, display_name,
       data->settings, properties, import_widget_create_account_cb,
       g_object_ref (self));
diff --git a/src/empathy-main-window.c b/src/empathy-main-window.c
index 83daac08d..a2f9dde13 100644
--- a/src/empathy-main-window.c
+++ b/src/empathy-main-window.c
@@ -27,9 +27,11 @@
 #include <gtk/gtk.h>
 #include <glib/gi18n.h>
 
+#include <telepathy-glib/account-manager.h>
+
 #include <libempathy/empathy-contact.h>
+#include <libempathy/empathy-idle.h>
 #include <libempathy/empathy-utils.h>
-#include <libempathy/empathy-account-manager.h>
 #include <libempathy/empathy-dispatcher.h>
 #include <libempathy/empathy-chatroom-manager.h>
 #include <libempathy/empathy-chatroom.h>
@@ -79,7 +81,7 @@
 typedef struct {
 	EmpathyContactListView  *list_view;
 	EmpathyContactListStore *list_store;
-	EmpathyAccountManager   *account_manager;
+	TpAccountManager        *account_manager;
 	EmpathyChatroomManager  *chatroom_manager;
 	EmpathyEventManager     *event_manager;
 	guint                    flash_timeout_id;
@@ -305,7 +307,7 @@ static void
 main_window_error_edit_clicked_cb (GtkButton         *button,
 				   EmpathyMainWindow *window)
 {
-	EmpathyAccount *account;
+	TpAccount *account;
 	GtkWidget *error_widget;
 
 	account = g_object_get_data (G_OBJECT (button), "account");
@@ -320,7 +322,7 @@ static void
 main_window_error_clear_clicked_cb (GtkButton         *button,
 				    EmpathyMainWindow *window)
 {
-	EmpathyAccount *account;
+	TpAccount *account;
 	GtkWidget *error_widget;
 
 	account = g_object_get_data (G_OBJECT (button), "account");
@@ -331,7 +333,7 @@ main_window_error_clear_clicked_cb (GtkButton         *button,
 
 static void
 main_window_error_display (EmpathyMainWindow *window,
-			   EmpathyAccount    *account,
+			   TpAccount         *account,
 			   const gchar       *message)
 {
 	GtkWidget *child;
@@ -352,7 +354,7 @@ main_window_error_display (EmpathyMainWindow *window,
 
 		/* Just set the latest error and return */
 		str = g_markup_printf_escaped ("<b>%s</b>\n%s",
-					       empathy_account_get_display_name (account),
+					       tp_account_get_display_name (account),
 					       message);
 		gtk_label_set_markup (GTK_LABEL (label), str);
 		g_free (str);
@@ -433,7 +435,7 @@ main_window_error_display (EmpathyMainWindow *window,
 	gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
 
 	str = g_markup_printf_escaped ("<b>%s</b>\n%s",
-				       empathy_account_get_display_name (account),
+				       tp_account_get_display_name (account),
 				       message);
 	gtk_label_set_markup (GTK_LABEL (label), str);
 	g_free (str);
@@ -460,18 +462,15 @@ main_window_error_display (EmpathyMainWindow *window,
 }
 
 static void
-main_window_update_status (EmpathyMainWindow *window, EmpathyAccountManager *manager)
+main_window_update_status (EmpathyMainWindow *window)
 {
-	int  connected;
-	int  connecting;
+	gboolean connected, connecting;
 	GList *l;
 
-	/* Count number of connected/connecting/disconnected accounts */
-	connected = empathy_account_manager_get_connected_accounts (manager);
-	connecting = empathy_account_manager_get_connecting_accounts (manager);
+	connected = empathy_account_manager_get_accounts_connected (&connecting);
 
 	/* Update the spinner state */
-	if (connecting > 0) {
+	if (connecting) {
 		ephy_spinner_start (EPHY_SPINNER (window->throbber));
 	} else {
 		ephy_spinner_stop (EPHY_SPINNER (window->throbber));
@@ -479,19 +478,20 @@ main_window_update_status (EmpathyMainWindow *window, EmpathyAccountManager *man
 
 	/* Update widgets sensibility */
 	for (l = window->actions_connected; l; l = l->next) {
-		gtk_action_set_sensitive (l->data, (connected > 0));
+		gtk_action_set_sensitive (l->data, connected);
 	}
 }
 
 static void
-main_window_connection_changed_cb (EmpathyAccountManager *manager,
-				   EmpathyAccount *account,
-				   TpConnectionStatusReason reason,
-				   TpConnectionStatus current,
-				   TpConnectionStatus previous,
+main_window_connection_changed_cb (TpAccount  *account,
+                                   guint       old_status,
+                                   guint       current,
+                                   guint       reason,
+                                   gchar      *dbus_error_name,
+                                   GHashTable *details,
 				   EmpathyMainWindow *window)
 {
-	main_window_update_status (window, manager);
+	main_window_update_status (window);
 
 	if (current == TP_CONNECTION_STATUS_DISCONNECTED &&
 	    reason != TP_CONNECTION_STATUS_REASON_REQUESTED) {
@@ -572,15 +572,17 @@ main_window_contact_presence_changed_cb (EmpathyContactMonitor *monitor,
 					 TpConnectionPresenceType previous,
 					 EmpathyMainWindow *window)
 {
-	EmpathyAccount *account;
-	gboolean should_play;
+  TpAccount *account;
+  gboolean should_play = FALSE;
+  EmpathyIdle *idle;
 
-	account = empathy_contact_get_account (contact);
-	should_play = !empathy_account_is_just_connected (account);
+  account = empathy_contact_get_account (contact);
+  idle = empathy_idle_dup_singleton ();
 
-	if (!should_play) {
-		return;
-	}
+  should_play = !empathy_idle_account_is_just_connected (idle, account);
+
+  if (!should_play)
+    goto out;
 
   if (tp_connection_presence_type_cmp_availability (previous,
      TP_CONNECTION_PRESENCE_TYPE_OFFLINE) > 0)
@@ -601,6 +603,9 @@ main_window_contact_presence_changed_cb (EmpathyContactMonitor *monitor,
         empathy_sound_play (GTK_WIDGET (window->window),
           EMPATHY_SOUND_CONTACT_CONNECTED);
     }
+
+out:
+  g_object_unref (idle);
 }
 
 static void
@@ -641,10 +646,6 @@ main_window_destroy_cb (GtkWidget         *widget,
 	/* Save user-defined accelerators. */
 	main_window_accels_save ();
 
-	g_signal_handlers_disconnect_by_func (window->account_manager,
-					      main_window_connection_changed_cb,
-					      window);
-
 	if (window->size_timeout_id) {
 		g_source_remove (window->size_timeout_id);
 	}
@@ -845,12 +846,12 @@ main_window_view_show_map_cb (GtkCheckMenuItem  *item,
 static void
 main_window_favorite_chatroom_join (EmpathyChatroom *chatroom)
 {
-	EmpathyAccount *account;
+	TpAccount      *account;
 	TpConnection   *connection;
 	const gchar    *room;
 
 	account = empathy_chatroom_get_account (chatroom);
-	connection = empathy_account_get_connection (account);
+	connection = tp_account_get_connection (account);
 	room = empathy_chatroom_get_room (chatroom);
 
 	if (connection != NULL) {
@@ -1121,12 +1122,27 @@ main_window_configure_event_cb (GtkWidget         *widget,
 }
 
 static void
-main_window_account_created_or_deleted_cb (EmpathyAccountManager  *manager,
-					   EmpathyAccount         *account,
-					   EmpathyMainWindow      *window)
+main_window_account_removed_cb (TpAccountManager  *manager,
+				TpAccount         *account,
+				EmpathyMainWindow *window)
 {
+	GList *a;
+
+	a = tp_account_manager_get_valid_accounts (manager);
+
 	gtk_action_set_sensitive (window->view_history,
-		empathy_account_manager_get_count (manager) > 0);
+		g_list_length (a) > 0);
+
+	g_list_free (a);
+}
+
+static void
+main_window_account_validity_changed_cb (TpAccountManager *manager,
+					 TpAccount *account,
+					 gboolean valid,
+					 EmpathyMainWindow *window)
+{
+	main_window_account_removed_cb (manager, account, window);
 }
 
 static void
@@ -1169,6 +1185,33 @@ empathy_main_window_get (void)
   return main_window != NULL ? main_window->window : NULL;
 }
 
+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);
+
+		g_signal_connect (account, "status-changed",
+				  G_CALLBACK (main_window_connection_changed_cb),
+				  window);
+	}
+	g_list_free (accounts);
+}
+
 GtkWidget *
 empathy_main_window_show (void)
 {
@@ -1250,11 +1293,10 @@ empathy_main_window_show (void)
 	gtk_action_set_visible (show_map_widget, FALSE);
 #endif
 
-	window->account_manager = empathy_account_manager_dup_singleton ();
+	window->account_manager = tp_account_manager_dup ();
 
-	g_signal_connect (window->account_manager,
-			  "account-connection-changed",
-			  G_CALLBACK (main_window_connection_changed_cb), window);
+	tp_account_manager_prepare_async (window->account_manager, NULL,
+					  account_manager_prepared_cb, window);
 
 	window->errors = g_hash_table_new_full (g_direct_hash,
 						g_direct_equal,
@@ -1352,13 +1394,13 @@ empathy_main_window_show (void)
 			  G_CALLBACK (main_window_event_removed_cb),
 			  window);
 
-	g_signal_connect (window->account_manager, "account-created",
-			  G_CALLBACK (main_window_account_created_or_deleted_cb),
+	g_signal_connect (window->account_manager, "account-validity-changed",
+			  G_CALLBACK (main_window_account_validity_changed_cb),
 			  window);
-	g_signal_connect (window->account_manager, "account-deleted",
-			  G_CALLBACK (main_window_account_created_or_deleted_cb),
+	g_signal_connect (window->account_manager, "account-removed",
+			  G_CALLBACK (main_window_account_removed_cb),
 			  window);
-	main_window_account_created_or_deleted_cb (window->account_manager, NULL, window);
+	main_window_account_removed_cb (window->account_manager, NULL, window);
 
 	l = empathy_event_manager_get_events (window->event_manager);
 	while (l) {
@@ -1404,7 +1446,7 @@ empathy_main_window_show (void)
 						 EMPATHY_PREFS_UI_SHOW_AVATARS,
 						 window);
 
-	main_window_update_status (window, window->account_manager);
+	main_window_update_status (window);
 
 	return window->window;
 }
diff --git a/src/empathy-new-chatroom-dialog.c b/src/empathy-new-chatroom-dialog.c
index 219be371d..8ea65adf2 100644
--- a/src/empathy-new-chatroom-dialog.c
+++ b/src/empathy-new-chatroom-dialog.c
@@ -354,7 +354,7 @@ static void
 new_chatroom_dialog_update_widgets (EmpathyNewChatroomDialog *dialog)
 {
 	EmpathyAccountChooser *account_chooser;
-	EmpathyAccount        *account;
+	TpAccount             *account;
 	const gchar           *protocol;
 	const gchar           *room;
 
@@ -364,7 +364,7 @@ new_chatroom_dialog_update_widgets (EmpathyNewChatroomDialog *dialog)
 	if (account == NULL)
 		return;
 
-	protocol = empathy_account_get_protocol (account);
+	protocol = tp_account_get_protocol (account);
 
 	gtk_entry_set_text (GTK_ENTRY (dialog->entry_server), "");
 
@@ -396,7 +396,7 @@ new_chatroom_dialog_account_changed_cb (GtkComboBox             *combobox,
 					EmpathyNewChatroomDialog *dialog)
 {
 	EmpathyAccountChooser *account_chooser;
-	EmpathyAccount        *account;
+	TpAccount             *account;
 	gboolean               listing = FALSE;
 	gboolean               expanded = FALSE;
 
diff --git a/src/empathy-status-icon.c b/src/empathy-status-icon.c
index a2a6f54fb..21cb2dd3d 100644
--- a/src/empathy-status-icon.c
+++ b/src/empathy-status-icon.c
@@ -32,11 +32,11 @@
 #include <libnotify/notification.h>
 #include <libnotify/notify.h>
 
+#include <telepathy-glib/account-manager.h>
 #include <telepathy-glib/util.h>
 
 #include <libempathy/empathy-utils.h>
 #include <libempathy/empathy-idle.h>
-#include <libempathy/empathy-account-manager.h>
 
 #include <libempathy-gtk/empathy-presence-chooser.h>
 #include <libempathy-gtk/empathy-conf.h>
@@ -60,7 +60,7 @@
 typedef struct {
 	GtkStatusIcon       *icon;
 	EmpathyIdle         *idle;
-	EmpathyAccountManager *account_manager;
+	TpAccountManager    *account_manager;
 	gboolean             showing_event_icon;
 	guint                blink_timeout;
 	EmpathyEventManager *event_manager;
@@ -511,20 +511,18 @@ status_icon_create_menu (EmpathyStatusIcon *icon)
 }
 
 static void
-status_icon_connection_changed_cb (EmpathyAccountManager *manager,
-				   EmpathyAccount *account,
-				   TpConnectionStatusReason reason,
-				   TpConnectionStatus current,
-				   TpConnectionStatus previous,
-				   EmpathyStatusIcon *icon)
+status_icon_status_changed_cb (TpAccount *account,
+			       TpConnectionStatus current,
+			       TpConnectionStatus previous,
+			       TpConnectionStatusReason reason,
+			       gchar *dbus_error_name,
+			       GHashTable *details,
+			       EmpathyStatusIcon *icon)
 {
 	EmpathyStatusIconPriv *priv = GET_PRIV (icon);
-	int connected_accounts;
 
-	/* Check for a connected account */
-	connected_accounts = empathy_account_manager_get_connected_accounts (manager);
-
-	gtk_action_set_sensitive (priv->new_message_item, connected_accounts > 0);
+	gtk_action_set_sensitive (priv->new_message_item,
+				  empathy_account_manager_get_accounts_connected (NULL));
 }
 
 static void
@@ -536,10 +534,6 @@ status_icon_finalize (GObject *object)
 		g_source_remove (priv->blink_timeout);
 	}
 
-	g_signal_handlers_disconnect_by_func (priv->account_manager,
-					      status_icon_connection_changed_cb,
-					      object);
-
 	if (priv->notification) {
 		notify_notification_close (priv->notification, NULL);
 		g_object_unref (priv->notification);
@@ -564,6 +558,31 @@ empathy_status_icon_class_init (EmpathyStatusIconClass *klass)
 }
 
 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) {
+		empathy_signal_connect_weak (l->data, "status-changed",
+					     G_CALLBACK (status_icon_status_changed_cb),
+					     G_OBJECT (icon));
+	}
+	g_list_free (list);
+}
+
+static void
 empathy_status_icon_init (EmpathyStatusIcon *icon)
 {
 	EmpathyStatusIconPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (icon,
@@ -572,13 +591,12 @@ empathy_status_icon_init (EmpathyStatusIcon *icon)
 
 	icon->priv = priv;
 	priv->icon = gtk_status_icon_new ();
-	priv->account_manager = empathy_account_manager_dup_singleton ();
+	priv->account_manager = tp_account_manager_dup ();
 	priv->idle = empathy_idle_dup_singleton ();
 	priv->event_manager = empathy_event_manager_dup_singleton ();
 
-	g_signal_connect (priv->account_manager,
-			  "account-connection-changed",
-			  G_CALLBACK (status_icon_connection_changed_cb), icon);
+	tp_account_manager_prepare_async (priv->account_manager, NULL,
+	    account_manager_prepared_cb, icon);
 
 	/* make icon listen and respond to MAIN_WINDOW_HIDDEN changes */
 	empathy_conf_notify_add (empathy_conf_get (),
diff --git a/src/empathy.c b/src/empathy.c
index 69210760e..72b691c16 100644
--- a/src/empathy.c
+++ b/src/empathy.c
@@ -38,6 +38,7 @@
 #include <libebook/e-book.h>
 #include <libnotify/notify.h>
 
+#include <telepathy-glib/account-manager.h>
 #include <telepathy-glib/dbus.h>
 #include <telepathy-glib/util.h>
 #include <telepathy-glib/connection-manager.h>
@@ -49,7 +50,6 @@
 #include <libempathy/empathy-chatroom-manager.h>
 #include <libempathy/empathy-account-settings.h>
 #include <libempathy/empathy-connectivity.h>
-#include <libempathy/empathy-account-manager.h>
 #include <libempathy/empathy-connection-managers.h>
 #include <libempathy/empathy-debugger.h>
 #include <libempathy/empathy-dispatcher.h>
@@ -105,16 +105,12 @@ dispatch_cb (EmpathyDispatcher *dispatcher,
       id = empathy_tp_chat_get_id (tp_chat);
       if (!EMP_STR_EMPTY (id))
         {
-          EmpathyAccountManager *manager;
           TpConnection *connection;
-          EmpathyAccount *account;
+          TpAccount *account;
 
-          manager = empathy_account_manager_dup_singleton ();
           connection = empathy_tp_chat_get_connection (tp_chat);
-          account = empathy_account_manager_get_account_for_connection (
-              manager, connection);
+          account = empathy_get_account_for_connection (connection);
           chat = empathy_chat_window_find_chat (account, id);
-          g_object_unref (manager);
         }
 
       if (chat)
@@ -155,11 +151,11 @@ dispatch_cb (EmpathyDispatcher *dispatcher,
     }
 }
 
-/* Salut account creation */
+/* Salut account creation. The TpAccountManager first argument
+ * must already be prepared when calling this function. */
 static gboolean
-should_create_salut_account (void)
+should_create_salut_account (TpAccountManager *manager)
 {
-  EmpathyAccountManager *manager;
   gboolean salut_created = FALSE;
   GList *accounts, *l;
 
@@ -174,20 +170,20 @@ should_create_salut_account (void)
       return FALSE;
     }
 
-  manager = empathy_account_manager_dup_singleton ();
-  accounts = empathy_account_manager_dup_accounts (manager);
+  accounts = tp_account_manager_get_valid_accounts (manager);
 
   for (l = accounts; l != NULL;  l = g_list_next (l))
     {
-      EmpathyAccount *account = EMPATHY_ACCOUNT (l->data);
+      TpAccount *account = TP_ACCOUNT (l->data);
 
-      if (!tp_strdiff (empathy_account_get_protocol (account), "local-xmpp"))
-        salut_created = TRUE;
-
-      g_object_unref (account);
+      if (!tp_strdiff (tp_account_get_protocol (account), "local-xmpp"))
+        {
+          salut_created = TRUE;
+          break;
+        }
     }
 
-  g_object_unref (manager);
+  g_list_free (accounts);
 
   if (salut_created)
     {
@@ -206,7 +202,7 @@ salut_account_created (GObject *source,
     gpointer user_data)
 {
   EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (source);
-  EmpathyAccount *account;
+  TpAccount *account;
   GError *error = NULL;
 
   if (!empathy_account_settings_apply_finish (settings, result, &error))
@@ -218,7 +214,7 @@ salut_account_created (GObject *source,
 
   account = empathy_account_settings_get_account (settings);
 
-  empathy_account_set_enabled_async (account, TRUE, NULL, NULL);
+  tp_account_set_enabled_async (account, TRUE, NULL, NULL);
   empathy_conf_set_bool (empathy_conf_get (),
       EMPATHY_PREFS_SALUT_ACCOUNT_CREATED,
       TRUE);
@@ -239,8 +235,12 @@ use_conn_notify_cb (EmpathyConf *conf,
 }
 
 static void
-create_salut_account_if_needed (EmpathyConnectionManagers *managers)
+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;
@@ -253,22 +253,28 @@ create_salut_account_if_needed (EmpathyConnectionManagers *managers)
   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 ())
-    return;
+  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");
-      return;
+      goto out;
     }
 
   protocol = tp_connection_manager_get_protocol (manager, "local-xmpp");
   if (protocol == NULL)
     {
       DEBUG ("Salut doesn't support local-xmpp!!");
-      return;
+      goto out;
     }
 
   DEBUG ("Trying to add a salut account...");
@@ -279,7 +285,7 @@ create_salut_account_if_needed (EmpathyConnectionManagers *managers)
       DEBUG ("Failed to get self econtact: %s",
           error ? error->message : "No error given");
       g_clear_error (&error);
-      return;
+      goto out;
     }
 
   settings = empathy_account_settings_new ("salut", "local-xmpp",
@@ -321,24 +327,39 @@ create_salut_account_if_needed (EmpathyConnectionManagers *managers)
   g_object_unref (settings);
   g_object_unref (contact);
   g_object_unref (book);
+
+ out:
+  g_object_unref (managers);
+}
+
+static void
+create_salut_account_if_needed (EmpathyConnectionManagers *managers)
+{
+  TpAccountManager *manager;
+
+  manager = tp_account_manager_dup ();
+
+  tp_account_manager_prepare_async (manager, NULL,
+      create_salut_account_am_ready_cb, g_object_ref (managers));
+
+  g_object_unref (manager);
 }
 
 static gboolean
-has_non_salut_accounts (EmpathyAccountManager *manager)
+has_non_salut_accounts (TpAccountManager *manager)
 {
   gboolean ret = FALSE;
   GList *accounts, *l;
 
-  accounts = empathy_account_manager_dup_accounts (manager);
+  accounts = tp_account_manager_get_valid_accounts (manager);
 
   for (l = accounts ; l != NULL; l = g_list_next (l))
     {
-      EmpathyAccount *account = EMPATHY_ACCOUNT (l->data);
-
-      if (tp_strdiff (empathy_account_get_protocol (l->data), "local-xmpp"))
-        ret = TRUE;
-
-      g_object_unref (account);
+      if (tp_strdiff (tp_account_get_protocol (l->data), "local-xmpp"))
+        {
+          ret = TRUE;
+          break;
+        }
     }
 
   g_list_free (accounts);
@@ -349,11 +370,13 @@ has_non_salut_accounts (EmpathyAccountManager *manager)
 static void
 maybe_show_account_assistant (void)
 {
-  EmpathyAccountManager *manager;
-  manager = empathy_account_manager_dup_singleton ();
+  TpAccountManager *manager;
+  manager = tp_account_manager_dup ();
 
   if (!has_non_salut_accounts (manager))
     empathy_account_assistant_show (GTK_WINDOW (empathy_main_window_get ()));
+
+  g_object_unref (manager);
 }
 
 static gboolean
@@ -450,7 +473,7 @@ migrate_config_to_xdg_dir (void)
 
 static void
 do_show_accounts_ui (GtkWindow *window,
-    EmpathyAccountManager *manager)
+    TpAccountManager *manager)
 {
 
   GtkWidget *ui;
@@ -466,12 +489,19 @@ do_show_accounts_ui (GtkWindow *window,
 }
 
 static void
-account_manager_ready_for_accounts_cb (EmpathyAccountManager *manager,
-    GParamSpec *spec,
+account_manager_ready_for_accounts_cb (GObject *source_object,
+    GAsyncResult *result,
     gpointer user_data)
 {
-  if (!empathy_account_manager_is_ready (manager))
-    return;
+  TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object);
+  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;
+    }
 
   do_show_accounts_ui (user_data, manager);
 }
@@ -480,24 +510,15 @@ static void
 show_accounts_ui (GtkWindow *window,
     gboolean force)
 {
-  EmpathyAccountManager *manager;
+  TpAccountManager *manager;
 
-  manager = empathy_account_manager_dup_singleton ();
-  if (empathy_account_manager_is_ready (manager))
-    {
-      if (force)
-        do_show_accounts_ui (window, manager);
-      else
-        maybe_show_account_assistant ();
-    }
-  else if (force)
-    {
-      /* Only if we we're forced to show the widget connect to ready, otherwise
-       * the initial readyness will cause the accounts ui to be shown when
-       * needed */
-      g_signal_connect (manager, "notify::ready",
-        G_CALLBACK (account_manager_ready_for_accounts_cb), window);
-    }
+  if (!force)
+    return;
+
+  manager = tp_account_manager_dup ();
+
+  tp_account_manager_prepare_async (manager, NULL,
+      account_manager_ready_for_accounts_cb, window);
 
   g_object_unref (manager);
 }
@@ -615,14 +636,22 @@ default_log_handler (const gchar *log_domain,
 #endif /* ENABLE_DEBUG */
 
 static void
-account_manager_ready_cb (EmpathyAccountManager *manager,
-    GParamSpec *spec,
+account_manager_ready_cb (GObject *source_object,
+    GAsyncResult *result,
     gpointer user_data)
 {
-  if (!empathy_account_manager_is_ready (manager))
-    return;
+  TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object);
+  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;
+    }
 
-  if (should_create_salut_account () || !empathy_import_mc4_has_imported ())
+  if (should_create_salut_account (manager)
+      || !empathy_import_mc4_has_imported ())
     {
       EmpathyConnectionManagers *managers;
       managers = empathy_connection_managers_dup_singleton ();
@@ -730,37 +759,48 @@ setup_dispatcher (void)
 }
 
 static void
-account_connection_notify_cb (EmpathyAccount *account,
-    GParamSpec *pspec,
+account_status_changed_cb (TpAccount *account,
+    guint old_status,
+    guint new_status,
+    guint reason,
+    gchar *dbus_error_name,
+    GHashTable *details,
     EmpathyChatroom *room)
 {
   TpConnection *conn;
 
-  conn = empathy_account_get_connection (account);
-
-  if (conn == NULL)
-    return;
+  conn = tp_account_get_connection (account);
 
   empathy_dispatcher_join_muc (conn,
       empathy_chatroom_get_room (room), NULL, NULL);
 }
 
 static void
-account_manager_chatroom_ready_cb (EmpathyAccountManager *account_manager,
-    GParamSpec *pspec,
-    EmpathyChatroomManager *chatroom_manager)
+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;
 
-  accounts = empathy_account_manager_dup_accounts (account_manager);
+  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))
     {
-      EmpathyAccount *account = EMPATHY_ACCOUNT (l->data);
+      TpAccount *account = TP_ACCOUNT (l->data);
       TpConnection *conn;
       GList *chatrooms, *p;
 
-      conn = empathy_account_get_connection (account);
+      conn = tp_account_get_connection (account);
 
       chatrooms = empathy_chatroom_manager_get_chatrooms (
           chatroom_manager, account);
@@ -774,8 +814,8 @@ account_manager_chatroom_ready_cb (EmpathyAccountManager *account_manager,
 
           if (conn == NULL)
             {
-              g_signal_connect (G_OBJECT (account), "notify::connection",
-                  G_CALLBACK (account_connection_notify_cb), room);
+              g_signal_connect (G_OBJECT (account), "status-changed",
+                  G_CALLBACK (account_status_changed_cb), room);
             }
           else
             {
@@ -787,29 +827,18 @@ account_manager_chatroom_ready_cb (EmpathyAccountManager *account_manager,
       g_list_free (chatrooms);
     }
 
-  g_list_foreach (accounts, (GFunc) g_object_unref, NULL);
   g_list_free (accounts);
 }
 
 static void
 chatroom_manager_ready_cb (EmpathyChatroomManager *chatroom_manager,
     GParamSpec *pspec,
-    EmpathyAccountManager *account_manager)
+    gpointer user_data)
 {
-  gboolean ready;
+  TpAccountManager *account_manager = user_data;
 
-  g_object_get (G_OBJECT (account_manager), "ready", &ready, NULL);
-
-  if (ready)
-    {
-      account_manager_chatroom_ready_cb (account_manager, NULL,
-          chatroom_manager);
-    }
-  else
-    {
-      g_signal_connect (account_manager, "notify::ready",
-          G_CALLBACK (account_manager_chatroom_ready_cb), chatroom_manager);
-    }
+  tp_account_manager_prepare_async (account_manager, NULL,
+      account_manager_chatroom_ready_cb, chatroom_manager);
 }
 
 int
@@ -820,7 +849,7 @@ main (int argc, char *argv[])
 #endif
   EmpathyStatusIcon *icon;
   EmpathyDispatcher *dispatcher;
-  EmpathyAccountManager *account_manager;
+  TpAccountManager *account_manager;
   EmpathyLogManager *log_manager;
   EmpathyChatroomManager *chatroom_manager;
   EmpathyCallFactory *call_factory;
@@ -923,7 +952,7 @@ main (int argc, char *argv[])
 
   if (account_dialog_only)
     {
-      account_manager = empathy_account_manager_dup_singleton ();
+      account_manager = tp_account_manager_dup ();
       show_accounts_ui (NULL, TRUE);
 
       gtk_main ();
@@ -955,9 +984,9 @@ main (int argc, char *argv[])
       empathy_idle_set_state (idle, TP_CONNECTION_PRESENCE_TYPE_AVAILABLE);
 
   /* account management */
-  account_manager = empathy_account_manager_dup_singleton ();
-  g_signal_connect (account_manager, "notify::ready",
-      G_CALLBACK (account_manager_ready_cb), NULL);
+  account_manager = tp_account_manager_dup ();
+  tp_account_manager_prepare_async (account_manager, NULL,
+      account_manager_ready_cb, NULL);
 
   /* Handle channels */
   dispatcher = setup_dispatcher ();
diff --git a/tests/check-empathy-chatroom-manager.c b/tests/check-empathy-chatroom-manager.c
index 5a3384fe4..dd0d93f52 100644
--- a/tests/check-empathy-chatroom-manager.c
+++ b/tests/check-empathy-chatroom-manager.c
@@ -5,6 +5,7 @@
 
 #include <gconf/gconf.h>
 #include <gconf/gconf-client.h>
+#include <telepathy-glib/account-manager.h>
 #include <telepathy-glib/util.h>
 #include <check.h>
 
@@ -13,7 +14,6 @@
 #include "check-empathy-helpers.h"
 
 #include <libempathy/empathy-chatroom-manager.h>
-#include <libempathy/empathy-account-manager.h>
 
 #define CHATROOM_SAMPLE "chatrooms-sample.xml"
 #define CHATROOM_FILE "chatrooms.xml"
diff --git a/tests/check-empathy-helpers.c b/tests/check-empathy-helpers.c
index 5fb8b4a35..d176d0abe 100644
--- a/tests/check-empathy-helpers.c
+++ b/tests/check-empathy-helpers.c
@@ -24,7 +24,7 @@
 #include <gconf/gconf.h>
 #include <gconf/gconf-client.h>
 
-#include <libempathy/empathy-account-manager.h>
+#include <telepathy-glib/account-manager.h>
 
 #include "check-helpers.h"
 #include "check-empathy-helpers.h"
diff --git a/tests/check-empathy-helpers.h b/tests/check-empathy-helpers.h
index 5544b80aa..665e7e256 100644
--- a/tests/check-empathy-helpers.h
+++ b/tests/check-empathy-helpers.h
@@ -20,12 +20,13 @@
 #define __CHECK_EMPATHY_HELPERS_H__
 
 #include <glib.h>
-#include <libempathy/empathy-account.h>
+
+#include <telepathy-glib/account.h>
 
 gchar * get_xml_file (const gchar *filename);
 gchar * get_user_xml_file (const gchar *filename);
 void copy_xml_file (const gchar *orig, const gchar *dest);
-EmpathyAccount * get_test_account (void);
-void destroy_test_account (EmpathyAccount *account);
+TpAccount * get_test_account (void);
+void destroy_test_account (TpAccount *account);
 
 #endif /* #ifndef __CHECK_EMPATHY_HELPERS_H__ */