account, priv->id, EMPATHY_DISPATCHER_NON_USER_ACTION);
break;
case TP_HANDLE_TYPE_ROOM:
- empathy_dispatcher_join_muc (tp_account_get_connection (account),
- priv->id, EMPATHY_DISPATCHER_NON_USER_ACTION);
+ empathy_dispatcher_join_muc (account, priv->id,
+ EMPATHY_DISPATCHER_NON_USER_ACTION);
break;
case TP_HANDLE_TYPE_NONE:
case TP_HANDLE_TYPE_LIST:
TpConnection *connection;
connection = empathy_tp_chat_get_connection (priv->tp_chat);
- empathy_dispatcher_join_muc (connection, rooms[i],
- gtk_get_current_event_time ());
+ empathy_dispatcher_join_muc (
+ empathy_get_account_for_connection (connection), rooms[i],
+ gtk_get_current_event_time ());
}
i++;
}
}
void
-empathy_dispatcher_join_muc (TpConnection *connection,
- const gchar *roomname,
- gint64 timestamp)
+empathy_dispatcher_join_muc (TpAccount *account,
+ const gchar *roomname,
+ gint64 timestamp)
{
EmpathyDispatcher *self;
EmpathyDispatcherPriv *priv;
ConnectionData *connection_data;
const gchar *names[] = { roomname, NULL };
TpProxyPendingCall *call;
+ TpConnection *connection;
- g_return_if_fail (TP_IS_CONNECTION (connection));
+ g_return_if_fail (TP_IS_ACCOUNT (account));
g_return_if_fail (!EMP_STR_EMPTY (roomname));
self = empathy_dispatcher_dup_singleton ();
priv = GET_PRIV (self);
+ connection = tp_account_get_connection (account);
+ if (connection == NULL)
+ return;
+
connection_data = g_hash_table_lookup (priv->connections, connection);
g_assert (connection_data != NULL);
gint64 timestamp);
/* Request a muc channel */
-void empathy_dispatcher_join_muc (TpConnection *connection,
+void empathy_dispatcher_join_muc (TpAccount *account,
const gchar *roomname,
gint64 timestamp);
g_queue_get_length (priv->queue));
}
-static void
-connection_ready_cb (TpConnection *connection,
- const GError *error,
- gpointer user_data)
-{
- ChatData *data = user_data;
- EmpathyChatManager *self = chat_manager_singleton;
- EmpathyChatManagerPriv *priv;
-
- /* Extremely unlikely to happen, but I don't really want to keep refs to the
- * chat manager in the ChatData structs as it'll then prevent the manager
- * from being finalized. */
- if (G_UNLIKELY (self == NULL))
- goto out;
-
- priv = GET_PRIV (self);
-
- /* FIXME: Once empathy_dispatcher_join_muc will take a TpAccount instead of
- * a TpConnection we won't have to prepare the connection any more. */
- if (error == NULL)
- {
- if (data->room)
- empathy_dispatcher_join_muc (connection, data->id,
- EMPATHY_DISPATCHER_NON_USER_ACTION);
- else
- empathy_dispatcher_chat_with_contact_id (
- empathy_get_account_for_connection (connection), data->id,
- EMPATHY_DISPATCHER_NON_USER_ACTION);
-
- g_signal_emit (self, signals[CHATS_CHANGED], 0,
- g_queue_get_length (priv->queue));
- }
- else
- {
- DEBUG ("Error readying connection, no chat: %s", error->message);
- }
-
-out:
- chat_data_free (data);
-}
-
void
empathy_chat_manager_undo_closed_chat (EmpathyChatManager *self)
{
EmpathyChatManagerPriv *priv = GET_PRIV (self);
ChatData *data;
- TpConnection *connection;
data = g_queue_pop_tail (priv->queue);
DEBUG ("Removing %s from queue and starting a chat with: %s",
data->room ? "room" : "contact", data->id);
- connection = tp_account_get_connection (data->account);
-
- if (connection != NULL)
- {
- tp_connection_call_when_ready (connection, connection_ready_cb, data);
- }
+ if (data->room)
+ empathy_dispatcher_join_muc (data->account, data->id,
+ EMPATHY_DISPATCHER_NON_USER_ACTION);
else
- {
- DEBUG ("No connection, no chat.");
- chat_data_free (data);
- }
+ empathy_dispatcher_chat_with_contact_id (data->account, data->id,
+ EMPATHY_DISPATCHER_NON_USER_ACTION);
+
+ g_signal_emit (self, signals[CHATS_CHANGED], 0,
+ g_queue_get_length (priv->queue));
+
+ chat_data_free (data);
}
guint
gint64 timestamp)
{
TpAccount *account;
- TpConnection *connection;
const gchar *room;
account = empathy_chatroom_get_account (chatroom);
- connection = tp_account_get_connection (account);
- g_assert (connection != NULL);
room = empathy_chatroom_get_room (chatroom);
DEBUG ("Requesting channel for '%s'", room);
- empathy_dispatcher_join_muc (connection, room, timestamp);
+ empathy_dispatcher_join_muc (account, room, timestamp);
}
typedef struct
new_chatroom_dialog_join (EmpathyNewChatroomDialog *dialog)
{
EmpathyAccountChooser *account_chooser;
- TpConnection *connection;
+ TpAccount *account;
const gchar *room;
const gchar *server = NULL;
gchar *room_name = NULL;
server = gtk_entry_get_text (GTK_ENTRY (dialog->entry_server));
account_chooser = EMPATHY_ACCOUNT_CHOOSER (dialog->account_chooser);
- connection = empathy_account_chooser_get_connection (account_chooser);
+ account = empathy_account_chooser_get_account (account_chooser);
if (!EMP_STR_EMPTY (server)) {
room_name = g_strconcat (room, "@", server, NULL);
g_strstrip (room_name);
DEBUG ("Requesting channel for '%s'", room_name);
- empathy_dispatcher_join_muc (connection, room_name,
+ empathy_dispatcher_join_muc (account, room_name,
gtk_get_current_event_time ());
g_free (room_name);
GHashTable *details,
EmpathyChatroom *room)
{
- TpConnection *conn;
-
- conn = tp_account_get_connection (account);
- if (conn == NULL)
+ if (new_status != TP_CONNECTION_STATUS_CONNECTED)
return;
- empathy_dispatcher_join_muc (conn,
+ empathy_dispatcher_join_muc (account,
empathy_chatroom_get_room (room), EMPATHY_DISPATCHER_NON_USER_ACTION);
}
}
else
{
- empathy_dispatcher_join_muc (conn,
+ empathy_dispatcher_join_muc (account,
empathy_chatroom_get_room (room),
EMPATHY_DISPATCHER_NON_USER_ACTION);
}