12 files changed, 245 insertions, 96 deletions
diff --git a/Swift/Controllers/Chat/ChatController.cpp b/Swift/Controllers/Chat/ChatController.cpp
index bedc427..51c7349 100644
--- a/Swift/Controllers/Chat/ChatController.cpp
+++ b/Swift/Controllers/Chat/ChatController.cpp
@@ -69,11 +69,11 @@ ChatController::ChatController(const JID& self, StanzaChannel* stanzaChannel, IQ
        if (isInMUC) {
                startMessage = str(format(QT_TRANSLATE_NOOP("", "Starting chat with %1% in chatroom %2%")) % nick % contact.toBare().toString());
                theirPresence = presenceOracle->getLastPresence(contact);
        } else {
                startMessage = str(format(QT_TRANSLATE_NOOP("", "Starting chat with %1% - %2%")) % nick % contact.toBare().toString());
-                theirPresence = contact.isBare() ? presenceOracle->getHighestPriorityPresence(contact.toBare()) : presenceOracle->getLastPresence(contact);
+                theirPresence = contact.isBare() ? presenceOracle->getAccountPresence(contact) : presenceOracle->getLastPresence(contact);
        }
        Idle::ref idle;
        if (theirPresence && (idle = theirPresence->getPayload<Idle>())) {
                startMessage += str(format(QT_TRANSLATE_NOOP("", ", who has been idle since %1%")) % dateTimeToLocalString(idle->getSince()));
        }
@@ -141,11 +141,11 @@ void ChatController::setToJID(const JID& jid) {
        ChatControllerBase::setToJID(jid);
        Presence::ref presence;
        if (isInMUC_) {
                presence = presenceOracle_->getLastPresence(jid);
        } else {
-                presence = jid.isBare() ? presenceOracle_->getHighestPriorityPresence(jid.toBare()) : presenceOracle_->getLastPresence(jid);
+                presence = jid.isBare() ? presenceOracle_->getAccountPresence(jid.toBare()) : presenceOracle_->getLastPresence(jid);
        }
        chatStateNotifier_->setContactIsOnline(presence && presence->getType() == Presence::Available);
        handleBareJIDCapsChanged(toJID_);
 }
@@ -462,22 +462,22 @@ std::string ChatController::getStatusChangeString(boost::shared_ptr<Presence> pr
        }
        return response + ".";
 }
 void ChatController::handlePresenceChange(boost::shared_ptr<Presence> newPresence) {
-        bool me = false;
+        bool relevantPresence = false;
-        if (toJID_.isBare()) {
-                newPresence = presenceOracle_->getHighestPriorityPresence(toJID_);
+        if (toJID_.equals(newPresence->getFrom(), JID::WithoutResource)) {
-                if ((newPresence ? newPresence->getShow() : StatusShow::None) != lastShownStatus_) {
+                // Presence matches ChatController JID.
-                        me = true;
+                newPresence = presenceOracle_->getAccountPresence(toJID_);
-                }
+                relevantPresence = true;
-        } else if (toJID_.equals(newPresence->getFrom(), JID::WithResource)) {
-                me = true;
        }
-        if (!me) {
+        if (!relevantPresence) {
                return;
        }
        if (!newPresence) {
                newPresence = boost::make_shared<Presence>();
                newPresence->setType(Presence::Unavailable);
        }
        lastShownStatus_ = newPresence->getShow();
diff --git a/Swift/Controllers/Chat/ChatsManager.cpp b/Swift/Controllers/Chat/ChatsManager.cpp
index 343f490..8a06333 100644
--- a/Swift/Controllers/Chat/ChatsManager.cpp
+++ b/Swift/Controllers/Chat/ChatsManager.cpp
@@ -285,11 +285,11 @@ ChatListWindow::Chat ChatsManager::updateChatStatusAndAvatarHelper(const ChatLis
                }
        } else {
                if (avatarManager_) {
                        fixedChat.avatarPath = avatarManager_->getAvatarPath(fixedChat.jid);
                }
-                Presence::ref presence = presenceOracle_->getHighestPriorityPresence(fixedChat.jid.toBare());
+                Presence::ref presence = presenceOracle_->getAccountPresence(fixedChat.jid.toBare());
                fixedChat.statusType = presence ? presence->getShow() : StatusShow::None;
        }
        return fixedChat;
 }
@@ -407,11 +407,11 @@ ChatListWindow::Chat ChatsManager::createChatListChatItem(const JID& jid, const
                ChatController* controller = getChatControllerIfExists(jid, false);
                if (controller) {
                        unreadCount = controller->getUnreadCount();
                }
                JID bareishJID = mucRegistry_->isMUC(jid.toBare()) ? jid : jid.toBare();
-                Presence::ref presence = presenceOracle_->getHighestPriorityPresence(bareishJID);
+                Presence::ref presence = presenceOracle_->getAccountPresence(bareishJID);
                StatusShow::Type type = presence ? presence->getShow() : StatusShow::None;
                boost::filesystem::path avatarPath = avatarManager_ ? avatarManager_->getAvatarPath(bareishJID) : boost::filesystem::path();
                return ChatListWindow::Chat(bareishJID, nickResolver_->jidToNick(bareishJID), activity, unreadCount, type, avatarPath, false, privateMessage);
        }
 }
diff --git a/Swift/Controllers/Chat/UserSearchController.cpp b/Swift/Controllers/Chat/UserSearchController.cpp
index 454a110..291472f 100644
--- a/Swift/Controllers/Chat/UserSearchController.cpp
+++ b/Swift/Controllers/Chat/UserSearchController.cpp
@@ -303,11 +303,11 @@ Contact::ref UserSearchController::convertJIDtoContact(const JID& jid) {
                        contact->name = jid.toString();
                }
        }
        // presence lookup
-        Presence::ref presence = presenceOracle_->getHighestPriorityPresence(jid);
+        Presence::ref presence = presenceOracle_->getAccountPresence(jid);
        if (presence) {
                contact->statusType = presence->getShow();
        } else {
                contact->statusType = StatusShow::None;
        }
diff --git a/Swift/Controllers/ContactsFromXMPPRoster.cpp b/Swift/Controllers/ContactsFromXMPPRoster.cpp
index d3d7364..1cab9b1 100644
--- a/Swift/Controllers/ContactsFromXMPPRoster.cpp
+++ b/Swift/Controllers/ContactsFromXMPPRoster.cpp
@@ -3,20 +3,19 @@
 * Licensed under the simplified BSD license.
 * See Documentation/Licenses/BSD-simplified.txt for more information.
 */
 /*
- * Copyright (c) 2014 Isode Limited.
+ * Copyright (c) 2014-2015 Isode Limited.
 * All rights reserved.
 * See the COPYING file for more information.
 */
 #include <Swift/Controllers/ContactsFromXMPPRoster.h>
-#include <Swiften/Base/foreach.h>
 #include <Swiften/Avatars/AvatarManager.h>
+#include <Swiften/Base/foreach.h>
 #include <Swiften/Presence/PresenceOracle.h>
 #include <Swiften/Roster/XMPPRoster.h>
 #include <Swiften/Roster/XMPPRosterItem.h>
 namespace Swift {
@@ -30,11 +29,11 @@ ContactsFromXMPPRoster::~ContactsFromXMPPRoster() {
 std::vector<Contact::ref> ContactsFromXMPPRoster::getContacts(bool /*withMUCNicks*/) {
        std::vector<Contact::ref> results;
        std::vector<XMPPRosterItem> rosterItems = roster_->getItems();
        foreach(const XMPPRosterItem& rosterItem, rosterItems) {
                Contact::ref contact = boost::make_shared<Contact>(rosterItem.getName().empty() ? rosterItem.getJID().toString() : rosterItem.getName(), rosterItem.getJID(), StatusShow::None,"");
-                contact->statusType = presenceOracle_->getHighestPriorityPresence(contact->jid) ? presenceOracle_->getHighestPriorityPresence(contact->jid)->getShow() : StatusShow::None;
+                contact->statusType = presenceOracle_->getAccountPresence(contact->jid) ? presenceOracle_->getAccountPresence(contact->jid)->getShow() : StatusShow::None;
                contact->avatarPath = avatarManager_->getAvatarPath(contact->jid);
                results.push_back(contact);
        }
        return results;
 }
diff --git a/Swift/Controllers/Roster/ContactRosterItem.cpp b/Swift/Controllers/Roster/ContactRosterItem.cpp
index fd6d1cd..ae05aee 100644
--- a/Swift/Controllers/Roster/ContactRosterItem.cpp
+++ b/Swift/Controllers/Roster/ContactRosterItem.cpp
@@ -1,18 +1,19 @@
 /*
- * Copyright (c) 2010 Isode Limited.
+ * Copyright (c) 2010-2015 Isode Limited.
 * All rights reserved.
 * See the COPYING file for more information.
 */
 #include <Swift/Controllers/Roster/ContactRosterItem.h>
 #include <boost/date_time/posix_time/posix_time.hpp>
-#include <Swiften/Base/foreach.h>
 #include <Swiften/Base/DateTime.h>
+#include <Swiften/Base/foreach.h>
 #include <Swiften/Elements/Idle.h>
 #include <Swift/Controllers/Intl.h>
 #include <Swift/Controllers/Roster/GroupRosterItem.h>
 namespace Swift {
@@ -24,15 +25,15 @@ ContactRosterItem::ContactRosterItem(const JID& jid, const JID& displayJID, cons
 ContactRosterItem::~ContactRosterItem() {
 }
 StatusShow::Type ContactRosterItem::getStatusShow() const {
-        return shownPresence_ ? shownPresence_->getShow() : StatusShow::None;
+        return presence_ ? presence_->getShow() : StatusShow::None;
 }
 StatusShow::Type ContactRosterItem::getSimplifiedStatusShow() const {
-        switch (shownPresence_ ? shownPresence_->getShow() : StatusShow::None) {
+        switch (presence_ ? presence_->getShow() : StatusShow::None) {
                case StatusShow::Online: return StatusShow::Online;
                case StatusShow::Away: return StatusShow::Away;
                case StatusShow::XA: return StatusShow::Away;
                case StatusShow::FFC: return StatusShow::Online;
                case StatusShow::DND: return StatusShow::DND;
@@ -41,26 +42,26 @@ StatusShow::Type ContactRosterItem::getSimplifiedStatusShow() const {
        assert(false);
        return StatusShow::None;
 }
 std::string ContactRosterItem::getStatusText() const {
-        return shownPresence_ ? shownPresence_->getStatus() : "";
+        return presence_ ? presence_->getStatus() : "";
 }
 std::string ContactRosterItem::getIdleText() const {
-        Idle::ref idle = shownPresence_ ? shownPresence_->getPayload<Idle>() : Idle::ref();
+        Idle::ref idle = presence_ ? presence_->getPayload<Idle>() : Idle::ref();
        if (!idle || idle->getSince().is_not_a_date_time()) {
                return "";
        } else {
                return dateTimeToLocalString(idle->getSince());
        }
 }
 std::string ContactRosterItem::getOfflineSinceText() const {
-        if (offlinePresence_) {
+        if (presence_ && presence_->getType() == Presence::Unavailable) {
-                boost::optional<boost::posix_time::ptime> delay = offlinePresence_->getTimestamp();
+                boost::optional<boost::posix_time::ptime> delay = presence_->getTimestamp();
-                if (offlinePresence_->getType() == Presence::Unavailable && delay) {
+                if (delay) {
                        return dateTimeToLocalString(*delay);
                }
        }
        return "";
 }
@@ -86,46 +87,17 @@ const JID& ContactRosterItem::getDisplayJID() const {
 }
 typedef std::pair<std::string, boost::shared_ptr<Presence> > StringPresencePair;
-void ContactRosterItem::calculateShownPresence() {
-        shownPresence_ = offlinePresence_;
-        foreach (StringPresencePair presencePair, presences_) {
-                boost::shared_ptr<Presence> presence = presencePair.second;
-                if (!shownPresence_ || presence->getPriority() > shownPresence_->getPriority() || presence->getShow() < shownPresence_->getShow()) {
-                        shownPresence_ = presence;
-                }
-        }
-}
 void ContactRosterItem::clearPresence() {
-        presences_.clear();
+        presence_.reset();
-        calculateShownPresence();
        onDataChanged();
 }
 void ContactRosterItem::applyPresence(const std::string& resource, boost::shared_ptr<Presence> presence) {
-        if (offlinePresence_) {
+        presence_ = presence;
-                offlinePresence_ = boost::shared_ptr<Presence>();
-        }
-        if (presence->getType() == Presence::Unavailable) {
-                if (resource.empty()) {
-                        /* Unavailable from the bare JID means all resources are offline.*/
-                        presences_.clear();
-                } else {
-                        if (presences_.find(resource) != presences_.end()) {
-                                presences_.erase(resource);
-                        }
-                }
-                if (presences_.empty()) {
-                        offlinePresence_ = presence;
-                }
-        } else {
-                presences_[resource] = presence;
-        }
-        calculateShownPresence();
        onDataChanged();
 }
 const std::vector<std::string>& ContactRosterItem::getGroups() const {
        return groups_;
diff --git a/Swift/Controllers/Roster/ContactRosterItem.h b/Swift/Controllers/Roster/ContactRosterItem.h
index 54a6b60..ec04a8c 100644
--- a/Swift/Controllers/Roster/ContactRosterItem.h
+++ b/Swift/Controllers/Roster/ContactRosterItem.h
@@ -1,26 +1,26 @@
 /*
- * Copyright (c) 2010-2013 Isode Limited.
+ * Copyright (c) 2010-2015 Isode Limited.
 * All rights reserved.
 * See the COPYING file for more information.
 */
 #pragma once
-#include <map>
 #include <set>
 #include <string>
+#include <vector>
 #include <boost/bind.hpp>
 #include <boost/date_time/posix_time/ptime.hpp>
 #include <boost/filesystem/path.hpp>
 #include <boost/shared_ptr.hpp>
 #include <Swiften/Base/boost_bsignals.h>
+#include <Swiften/Elements/MUCOccupant.h>
 #include <Swiften/Elements/Presence.h>
 #include <Swiften/Elements/StatusShow.h>
-#include <Swiften/Elements/MUCOccupant.h>
 #include <Swiften/Elements/VCard.h>
 #include <Swiften/JID/JID.h>
 #include <Swift/Controllers/Roster/RosterItem.h>
@@ -54,16 +54,15 @@ class ContactRosterItem : public RosterItem {
                const boost::filesystem::path& getAvatarPath() const;
                const JID& getJID() const;
                void setDisplayJID(const JID& jid);
                const JID& getDisplayJID() const;
                void applyPresence(const std::string& resource, boost::shared_ptr<Presence> presence);
-                void clearPresence();
-                void calculateShownPresence();
                const std::vector<std::string>& getGroups() const;
                /** Only used so a contact can know about the groups it's in*/
                void addGroup(const std::string& group);
                void removeGroup(const std::string& group);
+                void clearPresence();
                MUCOccupant::Role getMUCRole() const;
                void setMUCRole(const MUCOccupant::Role& role);
                MUCOccupant::Affiliation getMUCAffiliation() const;
                void setMUCAffiliation(const MUCOccupant::Affiliation& affiliation);
@@ -83,13 +82,11 @@ class ContactRosterItem : public RosterItem {
        private:
                JID jid_;
                JID displayJID_;
                boost::posix_time::ptime lastAvailableTime_;
                boost::filesystem::path avatarPath_;
-                std::map<std::string, boost::shared_ptr<Presence> > presences_;
+                boost::shared_ptr<Presence> presence_;
-                boost::shared_ptr<Presence> offlinePresence_;
-                boost::shared_ptr<Presence> shownPresence_;
                std::vector<std::string> groups_;
                MUCOccupant::Role mucRole_;
                MUCOccupant::Affiliation mucAffiliation_;
                std::set<Feature> features_;
                BlockState blockState_;
diff --git a/Swift/Controllers/Roster/RosterController.cpp b/Swift/Controllers/Roster/RosterController.cpp
index 73efa43..751ca32 100644
--- a/Swift/Controllers/Roster/RosterController.cpp
+++ b/Swift/Controllers/Roster/RosterController.cpp
@@ -77,11 +77,10 @@ RosterController::RosterController(const JID& jid, XMPPRoster* xmppRoster, Avata
        xmppRoster_->onJIDAdded.connect(boost::bind(&RosterController::handleOnJIDAdded, this, _1));
        xmppRoster_->onJIDUpdated.connect(boost::bind(&RosterController::handleOnJIDUpdated, this, _1, _2, _3));
        xmppRoster_->onJIDRemoved.connect(boost::bind(&RosterController::handleOnJIDRemoved, this, _1));
        xmppRoster_->onRosterCleared.connect(boost::bind(&RosterController::handleRosterCleared, this));
        subscriptionManager_->onPresenceSubscriptionRequest.connect(boost::bind(&RosterController::handleSubscriptionRequest, this, _1, _2));
-        presenceOracle_->onPresenceChange.connect(boost::bind(&RosterController::handleIncomingPresence, this, _1));
        uiEventConnection_ = uiEventStream->onUIEvent.connect(boost::bind(&RosterController::handleUIEvent, this, _1));
        vcardManager_->onOwnVCardChanged.connect(boost::bind(&RosterController::handleOwnVCardChanged, this, _1));
        avatarManager_->onAvatarChanged.connect(boost::bind(&RosterController::handleAvatarChanged, this, _1));
        presenceOracle_->onPresenceChange.connect(boost::bind(&RosterController::handlePresenceChanged, this, _1));
@@ -332,11 +331,12 @@ void RosterController::handleRosterSetError(ErrorPayload::ref error, boost::shar
 void RosterController::handleIncomingPresence(Presence::ref newPresence) {
        if (newPresence->getType() == Presence::Error) {
                return;
        }
-        roster_->applyOnItems(SetPresence(newPresence));
+        Presence::ref accountPresence = presenceOracle_->getAccountPresence(newPresence->getFrom().toBare());
+        roster_->applyOnItems(SetPresence(accountPresence));
 }
 void RosterController::handleSubscriptionRequest(const JID& jid, const std::string& message) {
        if (xmppRoster_->containsJID(jid) && (xmppRoster_->getSubscriptionStateForJID(jid) == RosterItemPayload::To || xmppRoster_->getSubscriptionStateForJID(jid) == RosterItemPayload::Both)) {
                subscriptionManager_->confirmSubscription(jid);
@@ -378,10 +378,13 @@ void RosterController::handleAvatarChanged(const JID& jid) {
 void RosterController::handlePresenceChanged(Presence::ref presence) {
        if (presence->getFrom().equals(myJID_, JID::WithResource)) {
                ownContact_->applyPresence(std::string(), presence);
                mainWindow_->setMyContactRosterItem(ownContact_);
        }
+        else {
+                handleIncomingPresence(presence);
+        }
 }
 boost::optional<XMPPRosterItem> RosterController::getItem(const JID& jid) const {
        return xmppRoster_->getItem(jid);
 }
diff --git a/Swift/Controllers/Roster/UnitTest/RosterControllerTest.cpp b/Swift/Controllers/Roster/UnitTest/RosterControllerTest.cpp
index 9320af1..d774e6d 100644
--- a/Swift/Controllers/Roster/UnitTest/RosterControllerTest.cpp
+++ b/Swift/Controllers/Roster/UnitTest/RosterControllerTest.cpp
@@ -192,43 +192,56 @@ class RosterControllerTest : public CppUnit::TestFixture {
        void testUnavailablePresence() {
                std::vector<std::string> groups;
                groups.push_back("testGroup1");
                JID from("test@testdomain.com");
                xmppRoster_->addContact(from, "name", groups, RosterItemPayload::Both);
                Presence::ref lowPresence(new Presence());
                lowPresence->setFrom(withResource(from, "bob"));
                lowPresence->setPriority(2);
+                lowPresence->setShow(StatusShow::Away);
                lowPresence->setStatus("Not here");
+                Presence::ref lowPresenceOffline(new Presence());
+                lowPresenceOffline->setFrom(withResource(from, "bob"));
+                lowPresenceOffline->setStatus("Signing out");
+                lowPresenceOffline->setType(Presence::Unavailable);
                Presence::ref highPresence(new Presence());
                highPresence->setFrom(withResource(from, "bert"));
                highPresence->setPriority(10);
                highPresence->setStatus("So totally here");
                Presence::ref highPresenceOffline(new Presence());
                highPresenceOffline->setFrom(withResource(from, "bert"));
                highPresenceOffline->setType(Presence::Unavailable);
-                Presence::ref lowPresenceOffline(new Presence());
-                lowPresenceOffline->setFrom(withResource(from, "bob"));
-                lowPresenceOffline->setStatus("Signing out");
-                lowPresenceOffline->setType(Presence::Unavailable);
                stanzaChannel_->onPresenceReceived(lowPresence);
+                Presence::ref accountPresence = presenceOracle_->getAccountPresence(from);
+                CPPUNIT_ASSERT_EQUAL(StatusShow::Away, accountPresence->getShow());
                stanzaChannel_->onPresenceReceived(highPresence);
+                accountPresence = presenceOracle_->getAccountPresence(from);
+                CPPUNIT_ASSERT_EQUAL(StatusShow::Online, accountPresence->getShow());
                stanzaChannel_->onPresenceReceived(highPresenceOffline);
+                // After this, the roster should show the low presence.
                ContactRosterItem* item = dynamic_cast<ContactRosterItem*>(dynamic_cast<GroupRosterItem*>(CHILDREN[0])->getChildren()[0]);
                CPPUNIT_ASSERT(item);
-                /* A verification that if the test fails, it's the RosterController, not the PresenceOracle. */
-                Presence::ref high = presenceOracle_->getHighestPriorityPresence(from);
+                Presence::ref low = presenceOracle_->getAccountPresence(from);
-                CPPUNIT_ASSERT_EQUAL(Presence::Available, high->getType());
-                CPPUNIT_ASSERT_EQUAL(lowPresence->getStatus(), high->getStatus());
+                CPPUNIT_ASSERT_EQUAL(Presence::Available, low->getType());
-                CPPUNIT_ASSERT_EQUAL(StatusShow::Online, item->getStatusShow());
+                CPPUNIT_ASSERT_EQUAL(lowPresence->getStatus(), low->getStatus());
+                CPPUNIT_ASSERT_EQUAL(lowPresence->getShow(), item->getStatusShow());
                CPPUNIT_ASSERT_EQUAL(lowPresence->getStatus(), item->getStatusText());
                stanzaChannel_->onPresenceReceived(lowPresenceOffline);
                item = dynamic_cast<ContactRosterItem*>(dynamic_cast<GroupRosterItem*>(CHILDREN[0])->getChildren()[0]);
                CPPUNIT_ASSERT(item);
                /* A verification that if the test fails, it's the RosterController, not the PresenceOracle. */
-                high = presenceOracle_->getHighestPriorityPresence(from);
+                low = presenceOracle_->getHighestPriorityPresence(from);
-                CPPUNIT_ASSERT_EQUAL(Presence::Unavailable, high->getType());
+                CPPUNIT_ASSERT_EQUAL(Presence::Unavailable, low->getType());
-                CPPUNIT_ASSERT_EQUAL(lowPresenceOffline->getStatus(), high->getStatus());
+                CPPUNIT_ASSERT_EQUAL(lowPresenceOffline->getStatus(), low->getStatus());
                CPPUNIT_ASSERT_EQUAL(StatusShow::None, item->getStatusShow());
                CPPUNIT_ASSERT_EQUAL(lowPresenceOffline->getStatus(), item->getStatusText());
        }
                void testAdd() {
diff --git a/Swiften/Parser/PayloadParsers/UnitTest/JingleParserTest.cpp b/Swiften/Parser/PayloadParsers/UnitTest/JingleParserTest.cpp
index 05aaedf..56143ef 100644
--- a/Swiften/Parser/PayloadParsers/UnitTest/JingleParserTest.cpp
+++ b/Swiften/Parser/PayloadParsers/UnitTest/JingleParserTest.cpp
@@ -11,20 +11,19 @@
 */
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
-#include <Swiften/Parser/PayloadParsers/UnitTest/PayloadsParserTester.h>
+#include <Swiften/Base/DateTime.h>
-#include <Swiften/Elements/JinglePayload.h>
+#include <Swiften/Elements/JingleFileTransferDescription.h>
+#include <Swiften/Elements/JingleFileTransferHash.h>
 #include <Swiften/Elements/JingleIBBTransportPayload.h>
+#include <Swiften/Elements/JinglePayload.h>
 #include <Swiften/Elements/JingleS5BTransportPayload.h>
-#include <Swiften/Elements/JingleFileTransferDescription.h>
 #include <Swiften/Elements/StreamInitiationFileInfo.h>
-#include <Swiften/Elements/JingleFileTransferHash.h>
+#include <Swiften/Parser/PayloadParsers/UnitTest/PayloadsParserTester.h>
-#include <Swiften/Base/DateTime.h>
 #include <Swiften/StringCodecs/Base64.h>
-#include <Swiften/Base/Log.h>
 using namespace Swift;
 class JingleParserTest : public CppUnit::TestFixture {
                CPPUNIT_TEST_SUITE(JingleParserTest);
@@ -411,11 +410,10 @@ class JingleParserTest : public CppUnit::TestFixture {
                        CPPUNIT_ASSERT_EQUAL(std::string("VS2nSZMIUsaa5dIUHTdmsQ=="), Base64::encode(hash->getFileInfo().getHash("sha-1").get()));
                }
                
                // http://xmpp.org/extensions/xep-0234.html#example-10
                void testParse_Xep0234_Example10() {
-                        Log::setLogLevel(Log::debug);
                        PayloadsParserTester parser;
                        CPPUNIT_ASSERT(parser.parse(
                                "<jingle xmlns='urn:xmpp:jingle:1'\n"
                                "        action='session-initiate'\n"
                                "        initiator='romeo@montague.lit/orchard'\n"
diff --git a/Swiften/Presence/PresenceOracle.cpp b/Swiften/Presence/PresenceOracle.cpp
index e4129fb..8623529 100644
--- a/Swiften/Presence/PresenceOracle.cpp
+++ b/Swiften/Presence/PresenceOracle.cpp
@@ -4,13 +4,17 @@
 * See the COPYING file for more information.
 */
 #include <Swiften/Presence/PresenceOracle.h>
+#include <queue>
 #include <boost/bind.hpp>
+#include <Swiften/Base/foreach.h>
 #include <Swiften/Client/StanzaChannel.h>
+#include <Swiften/Elements/StatusShow.h>
 #include <Swiften/Roster/XMPPRoster.h>
 namespace Swift {
 PresenceOracle::PresenceOracle(StanzaChannel* stanzaChannel, XMPPRoster* roster) : stanzaChannel_(stanzaChannel), xmppRoster_(roster) {
@@ -104,10 +108,95 @@ std::vector<Presence::ref> PresenceOracle::getAllPresence(const JID& bareJID) co
                results.push_back(current);
        }
        return results;
 }
+struct PresenceAccountCmp {
+        static int preferenceFromStatusShow(StatusShow::Type showType) {
+                switch (showType) {
+                        case StatusShow::FFC:
+                                return 5;
+                        case StatusShow::Online:
+                                return 4;
+                        case StatusShow::DND:
+                                return 3;
+                        case StatusShow::Away:
+                                return 2;
+                        case StatusShow::XA:
+                                return 1;
+                        case StatusShow::None:
+                                return 0;
+                }
+                assert(false);
+                return -1;
+        }
+        bool operator()(const Presence::ref& a, const Presence::ref& b) {
+                int aPreference = preferenceFromStatusShow(a->getShow());
+                int bPreference = preferenceFromStatusShow(b->getShow());
+                if (aPreference != bPreference) {
+                        return aPreference < bPreference;
+                }
+                if (a->getPriority() != b->getPriority()) {
+                        return a->getPriority() < b->getPriority();
+                }
+                return a->getFrom().getResource() < b->getFrom().getResource();
+        }
+};
+typedef std::priority_queue<Presence::ref, std::vector<Presence::ref>, PresenceAccountCmp> PresenceAccountPriorityQueue;
+Presence::ref PresenceOracle::getActivePresence(const std::vector<Presence::ref> presences) {
+        Presence::ref accountPresence;
+        PresenceAccountPriorityQueue online;
+        PresenceAccountPriorityQueue away;
+        PresenceAccountPriorityQueue offline;
+        foreach(Presence::ref presence, presences) {
+                switch (presence->getShow()) {
+                        case StatusShow::Online:
+                                online.push(presence);
+                                break;
+                        case StatusShow::Away:
+                                away.push(presence);
+                                break;
+                        case StatusShow::FFC:
+                                online.push(presence);
+                                break;
+                        case StatusShow::XA:
+                                away.push(presence);
+                                break;
+                        case StatusShow::DND:
+                                away.push(presence);
+                                break;
+                        case StatusShow::None:
+                                offline.push(presence);
+                                break;
+                }
+        }
+        if (!online.empty()) {
+                accountPresence = online.top();
+        }
+        else if (!away.empty()) {
+                accountPresence = away.top();
+        }
+        else if (!offline.empty()) {
+                accountPresence = offline.top();
+        }
+        return accountPresence;
+}
+Presence::ref PresenceOracle::getAccountPresence(const JID& jid) const {
+        Presence::ref accountPresence;
+        std::vector<Presence::ref> allPresences = getAllPresence(jid.toBare());
+        accountPresence = getActivePresence(allPresences);
+        return accountPresence;
+}
 Presence::ref PresenceOracle::getHighestPriorityPresence(const JID& bareJID) const {
        PresencesMap::const_iterator i = entries_.find(bareJID);
        if (i == entries_.end()) {
                return Presence::ref();
        }
diff --git a/Swiften/Presence/PresenceOracle.h b/Swiften/Presence/PresenceOracle.h
index f312506..a010e8e 100644
--- a/Swiften/Presence/PresenceOracle.h
+++ b/Swiften/Presence/PresenceOracle.h
@@ -15,19 +15,52 @@
 namespace Swift {
        class StanzaChannel;
        class XMPPRoster;
+        /**
+         * The PresenceOracle class observes all received presence stanzas for
+         * the \ref StanzaChannel class passed in the constructor and maintains a
+         * cache.
+         */
        class SWIFTEN_API PresenceOracle {
                public:
                        PresenceOracle(StanzaChannel* stanzaChannel, XMPPRoster* roster);
                        ~PresenceOracle();
                        Presence::ref getLastPresence(const JID&) const;
                        Presence::ref getHighestPriorityPresence(const JID& bareJID) const;
                        std::vector<Presence::ref> getAllPresence(const JID& bareJID) const;
+                        /**
+                         * \brief Returns the relevant presence for a list of resource presences.
+                         *
+                         * It only takes the presence show type into account. Priorities are
+                         * ignored as various clients set them to arbitrary values unrelated
+                         * to actual end point availability.
+                         *
+                         * The presences of the resources are group by availablilty and sorted
+                         * by show type in the following order:
+                         *
+                         * -# Online
+                         *    -# Free for Chat
+                         *    -# Available
+                         * -# Away
+                         *    -# DND
+                         *    -# Extended Away
+                         *    -# Away
+                         * -# Offline
+                         *    -# Unavailable
+                         */
+                        static Presence::ref getActivePresence(const std::vector<Presence::ref> presences);
+                        /**
+                         * \brief This considers all online resources of a bare JID and returns
+                         * the value returned by \ref getActivePresence when passing this list.
+                         */
+                        Presence::ref getAccountPresence(const JID& jid) const;
                public:
                        boost::signal<void (Presence::ref)> onPresenceChange;
                private:
                        void handleIncomingPresence(Presence::ref presence);
diff --git a/Swiften/Presence/UnitTest/PresenceOracleTest.cpp b/Swiften/Presence/UnitTest/PresenceOracleTest.cpp
index 85dcca9..6d16d80 100644
--- a/Swiften/Presence/UnitTest/PresenceOracleTest.cpp
+++ b/Swiften/Presence/UnitTest/PresenceOracleTest.cpp
@@ -26,10 +26,11 @@ class PresenceOracleTest : public CppUnit::TestFixture {
                CPPUNIT_TEST(testReconnectResetsPresences);
                CPPUNIT_TEST(testHighestPresenceSingle);
                CPPUNIT_TEST(testHighestPresenceMultiple);
                CPPUNIT_TEST(testHighestPresenceGlobal);
                CPPUNIT_TEST(testHighestPresenceChangePriority);
+                CPPUNIT_TEST(testGetActivePresence);
                CPPUNIT_TEST_SUITE_END();
        public:
                void setUp() {
                        stanzaChannel_ = new DummyStanzaChannel();
@@ -50,19 +51,19 @@ class PresenceOracleTest : public CppUnit::TestFixture {
                        delete xmppRoster_;
                        delete stanzaChannel_;
                }
                void testHighestPresenceSingle() {
-                                        JID bareJID("alice@wonderland.lit");
+                        JID bareJID("alice@wonderland.lit");
-                                        Presence::ref fiveOn = makeOnline("blah", 5);
+                        Presence::ref fiveOn = makeOnline("blah", 5);
-                                        Presence::ref fiveOff = makeOffline("/blah");
+                        Presence::ref fiveOff = makeOffline("/blah");
-                                        CPPUNIT_ASSERT_EQUAL(Presence::ref(), oracle_->getHighestPriorityPresence(bareJID));
+                        CPPUNIT_ASSERT_EQUAL(Presence::ref(), oracle_->getHighestPriorityPresence(bareJID));
-                                        stanzaChannel_->onPresenceReceived(fiveOn);
+                        stanzaChannel_->onPresenceReceived(fiveOn);
-                                        CPPUNIT_ASSERT_EQUAL(fiveOn, oracle_->getHighestPriorityPresence(bareJID));
+                        CPPUNIT_ASSERT_EQUAL(fiveOn, oracle_->getHighestPriorityPresence(bareJID));
-                                        stanzaChannel_->onPresenceReceived(fiveOff);
+                        stanzaChannel_->onPresenceReceived(fiveOff);
-                                        CPPUNIT_ASSERT_EQUAL(fiveOff, oracle_->getHighestPriorityPresence(bareJID));
+                        CPPUNIT_ASSERT_EQUAL(fiveOff, oracle_->getHighestPriorityPresence(bareJID));
-                                }
+                }
                void testHighestPresenceMultiple() {
                        JID bareJID("alice@wonderland.lit");
                        Presence::ref fiveOn = makeOnline("blah", 5);
                        Presence::ref fiveOff = makeOffline("/blah");
@@ -149,12 +150,56 @@ class PresenceOracleTest : public CppUnit::TestFixture {
                        stanzaChannel_->setAvailable(false);
                        stanzaChannel_->setAvailable(true);
                        CPPUNIT_ASSERT(!oracle_->getLastPresence(user1));
                }
+                void testGetActivePresence() {
+                        {
+                                std::vector<Presence::ref> presenceList;
+                                presenceList.push_back(createPresence("alice@wonderland.lit/resourceA", 10, Presence::Available, StatusShow::Away));
+                                presenceList.push_back(createPresence("alice@wonderland.lit/resourceB", 5, Presence::Available, StatusShow::Online));
+                                CPPUNIT_ASSERT_EQUAL(StatusShow::Online, PresenceOracle::getActivePresence(presenceList)->getShow());
+                        }
+                        {
+                                std::vector<Presence::ref> presenceList;
+                                presenceList.push_back(createPresence("alice@wonderland.lit/resourceA", 10, Presence::Available, StatusShow::Away));
+                                presenceList.push_back(createPresence("alice@wonderland.lit/resourceB", 5, Presence::Available, StatusShow::DND));
+                                CPPUNIT_ASSERT_EQUAL(StatusShow::DND, PresenceOracle::getActivePresence(presenceList)->getShow());
+                        }
+                        {
+                                std::vector<Presence::ref> presenceList;
+                                presenceList.push_back(createPresence("alice@wonderland.lit/resourceA", 0, Presence::Available, StatusShow::Online));
+                                presenceList.push_back(createPresence("alice@wonderland.lit/resourceB", 0, Presence::Available, StatusShow::DND));
+                                CPPUNIT_ASSERT_EQUAL(StatusShow::Online, PresenceOracle::getActivePresence(presenceList)->getShow());
+                        }
+                        {
+                                std::vector<Presence::ref> presenceList;
+                                presenceList.push_back(createPresence("alice@wonderland.lit/resourceA", 1, Presence::Available, StatusShow::Online));
+                                presenceList.push_back(createPresence("alice@wonderland.lit/resourceB", 0, Presence::Available, StatusShow::Online));
+                                CPPUNIT_ASSERT_EQUAL(JID("alice@wonderland.lit/resourceA"), PresenceOracle::getActivePresence(presenceList)->getFrom());
+                        }
+                }
        
        private:
+                Presence::ref createPresence(const JID &jid, int priority, Presence::Type type, const StatusShow::Type& statusShow) {
+                        Presence::ref presence = boost::make_shared<Presence>();
+                        presence->setFrom(jid);
+                        presence->setPriority(priority);
+                        presence->setType(type);
+                        presence->setShow(statusShow);
+                        return presence;
+                }
                Presence::ref makeOnline(const std::string& resource, int priority) {
                        Presence::ref presence(new Presence());
                        presence->setPriority(priority);
                        presence->setFrom(JID("alice@wonderland.lit/" + resource));
                        return presence;