libtransport.git Changeset - 353588c406a6

Changeset - 353588c406a6

Parent rev.

Child rev.

[Not reviewed]

0 5 0

Jan Kaluza - 13 years ago 2012-10-24 10:53:26
hanzz.k@gmail.com

Try to join the rooms after every reconnect, not only after first one

5 files changed with 63 insertions and 19 deletions:

include/transport/conversationmanager.h

include/transport/user.h

src/conversationmanager.cpp

src/tests/user.cpp

src/user.cpp

0 comments (0 inline, 0 general)

include/transport/conversationmanager.h

➞

Show inline comments

@@ @@ -24,62 +24,64 @@ @@
 #include <algorithm>
 #include <map>
 #include "Swiften/Swiften.h"
 namespace Transport {
 class Conversation;
 class User;
 class Component;
 /// Manages all Conversations of particular User.
 class ConversationManager {
 	public:
 		/// Creates new ConversationManager.
 		/// \param user User associated with this ConversationManager.
 		/// \param component Transport instance associated with this ConversationManager.
 		ConversationManager(User *user, Component *component);
 		/// Destructor.
 		virtual ~ConversationManager();
 		/// Returns user associated with this manager.
 		/// \return User
 		User *getUser() { return m_user; }
 		/// Returns component associated with this ConversationManager.
 		/// \return component associated with this ConversationManager.
 		Component *getComponent() { return m_component; }
 		/// Returns Conversation by its legacy network name (for example by UIN in case of ICQ).
 		/// \param name legacy network name.
 		/// \return Conversation or NULL.
 		Conversation *getConversation(const std::string &name);
 		/// Adds new Conversation to the manager.
 		/// \param conv Conversation.
 		void addConversation(Conversation *conv);
 		/// Removes Conversation from the manager.
 		/// \param conv Conversation.
 		void removeConversation(Conversation *conv);
 		void deleteAllConversations();
 		void resetResources();
 		void removeJID(const Swift::JID &jid);
 	private:
 		void handleMessageReceived(Swift::Message::ref message);
 		Component *m_component;
 		User *m_user;
 		std::map<std::string, Conversation *> m_convs;
 		friend class UserManager;
 };
+}

include/transport/user.h

➞

Show inline comments

@@ @@ -33,118 +33,118 @@ namespace Transport { @@
 class Component;
 class RosterManager;
 class ConversationManager;
 class UserManager;
 class PresenceOracle;
 struct UserInfo;
 /// Represents online XMPP user.
 class User : public Swift::EntityCapsProvider {
 	public:
 		/// Creates new User class.
 		/// \param jid XMPP JID associated with this user
 		/// \param userInfo UserInfo struct with informations needed to connect
 		/// this user to legacy network
 		/// \param component Component associated with this user
 		User(const Swift::JID &jid, UserInfo &userInfo, Component * component, UserManager *userManager);
 		/// Destroyes User.
 		virtual ~User();
 		/// Returns JID of XMPP user who is currently connected using this User class.
 		/// \return full JID
 		const Swift::JID &getJID();
 		/// Returns full JID which supports particular feature or invalid JID.
 		/// \param feature disco#info feature.
 		/// \return full JID which supports particular feature or invalid JID.
 		Swift::JID getJIDWithFeature(const std::string &feature);
 		Swift::DiscoInfo::ref getCaps(const Swift::JID &jid) const;
 		/// Returns UserInfo struct with informations needed to connect the legacy network.
 		/// \return UserInfo struct
 		UserInfo &getUserInfo() { return m_userInfo; }
 		RosterManager *getRosterManager() { return m_rosterManager; }
 		ConversationManager *getConversationManager() { return m_conversationManager; }
 		Component *getComponent() { return m_component; }
 		UserManager *getUserManager() { return m_userManager; }
 		void setData(void *data) { m_data = data; }
 		void *getData() { return m_data; }
 		/// Handles presence from XMPP JID associated with this user.
 		/// \param presence Swift::Presence.
 		void handlePresence(Swift::Presence::ref presence);
+		void handlePresence(Swift::Presence::ref presence, bool forceJoin = false);
 		void handleSubscription(Swift::Presence::ref presence);
 		void handleDiscoInfo(const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info);
 		time_t &getLastActivity() {
 			return m_lastActivity;
+		}
 		void updateLastActivity() {
 			m_lastActivity = time(NULL);
+		}
 		/// Returns language.
 		/// \return language
 		const char *getLang() { return "en"; }
 		void handleDisconnected(const std::string &error, Swift::SpectrumErrorPayload::Error e = Swift::SpectrumErrorPayload::CONNECTION_ERROR_OTHER_ERROR);
 		bool isReadyToConnect() {
 			return m_readyForConnect;
+		}
 		void setConnected(bool connected);
 		void sendCurrentPresence();
 		void setIgnoreDisconnect(bool ignoreDisconnect);
 		bool isConnected() {
 			return m_connected;
+		}
 		int getResourceCount() {
 			return m_resources;
+		}
 		boost::signal<void ()> onReadyToConnect;
 		boost::signal<void (Swift::Presence::ref presence)> onPresenceChanged;
 		boost::signal<void (const Swift::JID &who, const std::string &room, const std::string &nickname, const std::string &password)> onRoomJoined;
 		boost::signal<void (const std::string &room)> onRoomLeft;
 		boost::signal<void ()> onDisconnected;
 	private:
 		void onConnectingTimeout();
 		Swift::JID m_jid;
 		Component *m_component;
 		RosterManager *m_rosterManager;
 		UserManager *m_userManager;
 		ConversationManager *m_conversationManager;
 		Swift::EntityCapsManager *m_entityCapsManager;
 		PresenceOracle *m_presenceOracle;
 		UserInfo m_userInfo;
 		void *m_data;
 		bool m_connected;
 		bool m_readyForConnect;
 		bool m_ignoreDisconnect;
 		Swift::Timer::ref m_reconnectTimer;
 		boost::shared_ptr<Swift::Connection> connection;
 		time_t m_lastActivity;
 		std::map<Swift::JID, Swift::DiscoInfo::ref> m_legacyCaps;
 		std::vector<boost::shared_ptr<Swift::OutgoingFileTransfer> > m_filetransfers;
 		int m_resources;
 		int m_reconnectCounter;
-		std::vector<Swift::Presence::ref> m_joinedRooms;
+		std::list<Swift::Presence::ref> m_joinedRooms;
 };
+}

src/conversationmanager.cpp

➞

Show inline comments

@@ @@ -2,96 +2,105 @@ @@
  * XMPP - libpurple transport
+ *
  * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program 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 General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include "transport/conversationmanager.h"
 #include "transport/conversation.h"
 #include "transport/usermanager.h"
 #include "transport/buddy.h"
 #include "transport/factory.h"
 #include "transport/user.h"
 #include "transport/logging.h"
 #include "Swiften/Roster/SetRosterRequest.h"
 #include "Swiften/Elements/RosterPayload.h"
 #include "Swiften/Elements/RosterItemPayload.h"
 namespace Transport {
 DEFINE_LOGGER(logger, "ConversationManager");
 ConversationManager::ConversationManager(User *user, Component *component){
 	m_user = user;
 	m_component = component;
+}
 ConversationManager::~ConversationManager() {
 	while(!m_convs.empty()) {
 		LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Removing conversation " << (*m_convs.begin()).first);
 		(*m_convs.begin()).second->destroyRoom();
 		delete (*m_convs.begin()).second;
 		m_convs.erase(m_convs.begin());
+	}
+}
 void ConversationManager::deleteAllConversations() {
 	while(!m_convs.empty()) {
 		LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Removing conversation " << (*m_convs.begin()).first);
 		(*m_convs.begin()).second->destroyRoom();
 		delete (*m_convs.begin()).second;
 		m_convs.erase(m_convs.begin());
+	}
+}
 Conversation *ConversationManager::getConversation(const std::string &name) {
 	if (m_convs.find(name) != m_convs.end())
 		return m_convs[name];
 	if (name.find("/") == std::string::npos) {
 		return NULL;
+	}
 	// handle PMs
 	std::string room = name.substr(0, name.find("/"));
 	std::string nick = name.substr(name.find("/") + 1);
 	if (getConversation(room) == NULL) {
 		return NULL;
+	}
 	return getConversation(nick);
+}
 void ConversationManager::addConversation(Conversation *conv) {
 	m_convs[conv->getLegacyName()] = conv;
 	LOG4CXX_INFO(logger, m_user->getJID().toString() << ": Adding conversation " << conv->getLegacyName());
+}
 void ConversationManager::removeConversation(Conversation *conv) {
 	for (std::map<std::string, Conversation *>::const_iterator it = m_convs.begin(); it != m_convs.end(); it++) {
 		if ((*it).second->getRoom() == conv->getLegacyName()) {
 			(*it).second->setRoom("");
+		}
+	}
 	m_convs.erase(conv->getLegacyName());
+}
 void ConversationManager::resetResources() {
 	for (std::map<std::string, Conversation *>::const_iterator it = m_convs.begin(); it != m_convs.end(); it++) {
 		if ((*it).second->isMUC()) {
 			continue;
+		}
 		(*it).second->setJID(m_user->getJID().toBare());
+	}
+}
 void ConversationManager::removeJID(const Swift::JID &jid) {
 	for (std::map<std::string, Conversation *>::const_iterator it = m_convs.begin(); it != m_convs.end(); it++) {
 		(*it).second->removeJID(jid);
+	}
+}

src/tests/user.cpp

➞

Show inline comments

 #include "transport/userregistry.h"
 #include "transport/config.h"
 #include "transport/storagebackend.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/conversation.h"
 #include "transport/usermanager.h"
 #include "transport/localbuddy.h"
 #include <cppunit/TestFixture.h>
 #include <cppunit/extensions/HelperMacros.h>
 #include <Swiften/Swiften.h>
 #include <Swiften/EventLoop/DummyEventLoop.h>
 #include <Swiften/Server/Server.h>
 #include <Swiften/Network/DummyNetworkFactories.h>
 #include <Swiften/Network/DummyConnectionServer.h>
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Server/ServerFromClientSession.h"
 #include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"
 #include "basictest.h"
 using namespace Transport;
 class UserTest : public CPPUNIT_NS :: TestFixture, public BasicTest {
 	CPPUNIT_TEST_SUITE(UserTest);
 	CPPUNIT_TEST(sendCurrentPresence);
     CPPUNIT_TEST(handlePresence);
 	CPPUNIT_TEST(handlePresenceJoinRoom);
 	CPPUNIT_TEST(handlePresenceJoinRoomTwoResources);
 	CPPUNIT_TEST(handlePresenceLeaveRoom);
 	CPPUNIT_TEST(handlePresenceLeaveRoomTwoResources);
 	CPPUNIT_TEST(handlePresenceLeaveRoomTwoResourcesOneDisconnects);
 	CPPUNIT_TEST(leaveJoinedRoom);
 	CPPUNIT_TEST(joinRoomBeforeConnected);
 	CPPUNIT_TEST(handleDisconnected);
 	CPPUNIT_TEST(handleDisconnectedReconnect);
 	CPPUNIT_TEST(joinRoomHandleDisconnectedRejoin);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		std::string room;
 		std::string roomNickname;
 		std::string roomPassword;
 		bool readyToConnect;
 		bool disconnected;
 		Swift::Presence::ref changedPresence;
 		void setUp (void) {
 			disconnected = false;
 			readyToConnect = false;
 			changedPresence = Swift::Presence::ref();
 			room = "";
 			roomNickname = "";
 			roomPassword = "";
 			setMeUp();
 			userManager->onUserCreated.connect(boost::bind(&UserTest::handleUserCreated, this, _1));
 			connectUser();
 			received.clear();
+		}
 		void tearDown (void) {
 			received.clear();
 			if (!disconnected) {
 				disconnectUser();
+			}
 			tearMeDown();
+		}
 	void handleUserCreated(User *user) {
 		user->onReadyToConnect.connect(boost::bind(&UserTest::handleUserReadyToConnect, this, user));
 		user->onPresenceChanged.connect(boost::bind(&UserTest::handleUserPresenceChanged, this, user, _1));
 		user->onRoomJoined.connect(boost::bind(&UserTest::handleRoomJoined, this, user, _1, _2, _3, _4));
 		user->onRoomLeft.connect(boost::bind(&UserTest::handleRoomLeft, this, user, _1));
+	}
 	void handleUserReadyToConnect(User *user) {
 		readyToConnect = true;
+	}
 	void handleUserPresenceChanged(User *user, Swift::Presence::ref presence) {
 		changedPresence = presence;
+	}
 	void handleRoomJoined(User *user, const std::string &jid, const std::string &r, const std::string &nickname, const std::string &password) {
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		Conversation *conv = user->getConversationManager()->getConversation("#room");
 		CPPUNIT_ASSERT_EQUAL(1, (int) conv->getJIDs().size());
 		CPPUNIT_ASSERT_EQUAL(Swift::JID("user@localhost/resource2"), conv->getJIDs().front());
+	}
 	void leaveJoinedRoom() {
 		User *user = userManager->getUser("user@localhost");
 		handlePresenceJoinRoom();
 		CPPUNIT_ASSERT(user->getConversationManager()->getConversation("#room"));
 		received.clear();
 		handlePresenceLeaveRoom();
 		CPPUNIT_ASSERT(!user->getConversationManager()->getConversation("#room"));
+	}
 	void handleDisconnected() {
 		User *user = userManager->getUser("user@localhost");
 		user->handleDisconnected("Connection error", Swift::SpectrumErrorPayload::CONNECTION_ERROR_AUTHENTICATION_FAILED);
 		loop->processEvents();
 		CPPUNIT_ASSERT(streamEnded);
 		user = userManager->getUser("user@localhost");
 		CPPUNIT_ASSERT(!user);
 		CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 		Swift::Message *m = dynamic_cast<Swift::Message *>(getStanza(received[0]));
 		CPPUNIT_ASSERT_EQUAL(std::string("Connection error"), m->getBody());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::StreamError *>(received[1].get()));
 		CPPUNIT_ASSERT_EQUAL(std::string("Connection error"), dynamic_cast<Swift::StreamError *>(received[1].get())->getText());
 		disconnected = true;
+	}
 	void handleDisconnectedReconnect() {
 		readyToConnect = false;
 		User *user = userManager->getUser("user@localhost");
 		user->handleDisconnected("Connection error");
 		loop->processEvents();
 		CPPUNIT_ASSERT(!streamEnded);
 		user = userManager->getUser("user@localhost");
 		CPPUNIT_ASSERT(user);
 		CPPUNIT_ASSERT(readyToConnect);
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("localhost");
 		response->setFrom("user@localhost/resource");
 		injectPresence(response);
 		loop->processEvents();
+	}
 	void joinRoomBeforeConnected() {
 		User *user = userManager->getUser("user@localhost");
 		user->setConnected(false);
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("#room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		// no presence received in server mode, just disco#info
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		user->setConnected(true);
 		CPPUNIT_ASSERT_EQUAL(std::string("#room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string("hanzz"), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string("password"), roomPassword);
+	}
 	void joinRoomHandleDisconnectedRejoin() {
 		User *user = userManager->getUser("user@localhost");
 		handlePresenceJoinRoom();
 		handleDisconnectedReconnect();
 		room = "";
 		roomNickname = "";
 		roomPassword = "";
-		</i>
+		received.clear();
 		user->setConnected(true);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		CPPUNIT_ASSERT_EQUAL(std::string("#room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string("hanzz"), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string("password"), roomPassword);
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
+	}
 };
 CPPUNIT_TEST_SUITE_REGISTRATION (UserTest);

src/user.cpp

➞

Show inline comments

 void User::sendCurrentPresence() {
 	if (m_component->inServerMode()) {
 		return;
+	}
 	std::vector<Swift::Presence::ref> presences = m_presenceOracle->getAllPresence(m_jid);
 	foreach(Swift::Presence::ref presence, presences) {
 		if (presence->getType() == Swift::Presence::Unavailable) {
 			continue;
+		}
 		if (m_connected) {
 			Swift::Presence::ref highest = m_presenceOracle->getHighestPriorityPresence(m_jid.toBare());
 			if (highest) {
 				Swift::Presence::ref response = Swift::Presence::create(highest);
 				response->setTo(presence->getFrom());
 				response->setFrom(m_component->getJID());
 				m_component->getStanzaChannel()->sendPresence(response);
+			}
 			else {
 				Swift::Presence::ref response = Swift::Presence::create();
 				response->setTo(presence->getFrom());
 				response->setFrom(m_component->getJID());
 				response->setType(Swift::Presence::Unavailable);
 				m_component->getStanzaChannel()->sendPresence(response);
+			}
+		}
 		else {
 			Swift::Presence::ref response = Swift::Presence::create();
 			response->setTo(presence->getFrom());
 			response->setFrom(m_component->getJID());
 			response->setType(Swift::Presence::Unavailable);
 			response->setStatus("Connecting");
 			m_component->getStanzaChannel()->sendPresence(response);
+		}
+	}
+}
 void User::setConnected(bool connected) {
 	m_connected = connected;
 	m_reconnectCounter = 0;
 	setIgnoreDisconnect(false);
 	updateLastActivity();
 	sendCurrentPresence();
 	if (m_connected) {
 		BOOST_FOREACH(Swift::Presence::ref &presence, m_joinedRooms) {
 			handlePresence(presence);
+			handlePresence(presence, true);
+		}
 		m_joinedRooms.clear();
+	}
+}
 void User::handlePresence(Swift::Presence::ref presence) {
+void User::handlePresence(Swift::Presence::ref presence, bool forceJoin) {
 	int currentResourcesCount = m_presenceOracle->getAllPresence(m_jid).size();
 	m_conversationManager->resetResources();
 	LOG4CXX_INFO(logger, "PRESENCE " << presence->getFrom().toString() << " " << presence->getTo().toString());
 	if (!m_connected) {
 		// we are not connected to legacy network, so we should do it when disco#info arrive :)
 		if (m_readyForConnect == false) {
 			// Forward status message to legacy network, but only if it's sent from active resource
 // 					if (m_activeResource == presence->getFrom().getResource().getUTF8String()) {
 // 						forwardStatus(presenceShow, stanzaStatus);
 // 					}
 			boost::shared_ptr<Swift::CapsInfo> capsInfo = presence->getPayload<Swift::CapsInfo>();
 			if (capsInfo && capsInfo->getHash() == "sha-1") {
 				if (m_entityCapsManager->getCaps(presence->getFrom()) != Swift::DiscoInfo::ref()) {
 					LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");
 					m_readyForConnect = true;
 					onReadyToConnect();
+				}
 				else {
 					m_reconnectTimer->start();
+				}
+			}
 			else if (m_component->inServerMode()) {
 				LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");
 				m_readyForConnect = true;
 				onReadyToConnect();
+			}
 			else {
 				m_reconnectTimer->start();
+			}
+		}
+	}
 	bool isMUC = presence->getPayload<Swift::MUCPayload>() != NULL || *presence->getTo().getNode().c_str() == '#';
 	if (isMUC) {
 		if (presence->getType() == Swift::Presence::Unavailable) {
 			std::string room = Buddy::JIDToLegacyName(presence->getTo());
 			Conversation *conv = m_conversationManager->getConversation(room);
 			if (conv) {
 				conv->removeJID(presence->getFrom());
 				if (!conv->getJIDs().empty()) {
 					return;
+				}
+			}
 			LOG4CXX_INFO(logger, m_jid.toString() << ": Going to left room " << room);
 			onRoomLeft(room);
 			BOOST_FOREACH(Swift::Presence::ref &p, m_joinedRooms) {
 				if (p->getTo() == presence->getTo()) {
 					m_joinedRooms.remove(p);
 					break;
+				}
+			}
 			if (conv) {
 				m_conversationManager->removeConversation(conv);
 				delete conv;
+			}
+		}
 		else {
 			// force connection to legacy network to let backend to handle auto-join on connect.
 			if (!m_readyForConnect) {
 				LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");
 				m_readyForConnect = true;
 				onReadyToConnect();
+			}
 			std::string room = Buddy::JIDToLegacyName(presence->getTo());
 			if (!m_connected) {
 				LOG4CXX_INFO(logger, m_jid.toString() << ": Joining room " << room << " postponed, because use is not connected to legacy network yet.");
 				m_joinedRooms.push_back(presence);
 				return;
 			std::string password = "";
 			if (presence->getPayload<Swift::MUCPayload>() != NULL) {
 				password = presence->getPayload<Swift::MUCPayload>()->getPassword() ? *presence->getPayload<Swift::MUCPayload>()->getPassword() : "";
+			}
 			Conversation *conv = m_conversationManager->getConversation(room);
 			if (conv != NULL) {
 				if (std::find(conv->getJIDs().begin(), conv->getJIDs().end(), presence->getFrom()) != conv->getJIDs().end()) {
 					LOG4CXX_INFO(logger, m_jid.toString() << ": User has already tried to join room " << room << " as " << presence->getTo().getResource());
+				}
 				else {
 					conv->addJID(presence->getFrom());
 					conv->sendParticipants(presence->getFrom());
+				}
 				if (forceJoin) {
 					onRoomJoined(presence->getFrom(), room, presence->getTo().getResource(), password);
+				}
 				return;
+			}
 			LOG4CXX_INFO(logger, m_jid.toString() << ": Going to join room " << room << " as " << presence->getTo().getResource());
 			std::string password = "";
 			if (presence->getPayload<Swift::MUCPayload>() != NULL) {
 				password = presence->getPayload<Swift::MUCPayload>()->getPassword() ? *presence->getPayload<Swift::MUCPayload>()->getPassword() : "";
 			bool isInJoined = false;
 			BOOST_FOREACH(Swift::Presence::ref &p, m_joinedRooms) {
 				if (p->getTo() == presence->getTo()) {
 					isInJoined = true;
+				}
+			}
 			if (!isInJoined) {
 				m_joinedRooms.push_back(presence);
+			}
 			if (!m_connected) {
 				LOG4CXX_INFO(logger, m_jid.toString() << ": Joining room " << room << " postponed, because use is not connected to legacy network yet.");
 				return;
+			}
 			LOG4CXX_INFO(logger, m_jid.toString() << ": Going to join room " << room << " as " << presence->getTo().getResource());
 			conv = m_component->getFactory()->createConversation(m_conversationManager, room, true);
 			m_conversationManager->addConversation(conv);
 			conv->setNickname(presence->getTo().getResource());
 			conv->addJID(presence->getFrom());
 			onRoomJoined(presence->getFrom(), room, presence->getTo().getResource(), password);
+		}
 		return;
+	}
 	if (presence->getType() == Swift::Presence::Unavailable) {
 		m_conversationManager->removeJID(presence->getFrom());
+	}
 	// User wants to disconnect this resource
 	if (!m_component->inServerMode()) {
 		if (presence->getType() == Swift::Presence::Unavailable) {
 				// Send unavailable presences for online contacts
 				m_rosterManager->sendUnavailablePresences(presence->getFrom());
 				// Send unavailable presence for transport contact itself
 				Swift::Presence::ref response = Swift::Presence::create();
 				response->setTo(presence->getFrom());
 				response->setFrom(m_component->getJID());
 				response->setType(Swift::Presence::Unavailable);
 				m_component->getStanzaChannel()->sendPresence(response);
+		}
 		else {
 			sendCurrentPresence();
+		}
+	}
 	// This resource is new, so we have to send buddies presences
 	if (presence->getType() != Swift::Presence::Unavailable && currentResourcesCount != m_resources) {
 		m_rosterManager->sendCurrentPresences(presence->getFrom());
+	}
 	m_resources = currentResourcesCount;
 	// Change legacy network presence
 	if (m_readyForConnect) {
 		Swift::Presence::ref highest = m_presenceOracle->getHighestPriorityPresence(m_jid.toBare());
 		if (highest) {
 			Swift::Presence::ref response = Swift::Presence::create(highest);
 			response->setTo(m_jid);
 			response->setFrom(m_component->getJID());

0 comments (0 inline, 0 general)