Presence::ref theirPresence;

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());

}

Idle::ref idle;

if (theirPresence && (idle = theirPresence->getPayload<Idle>())) {

startMessage += str(format(QT_TRANSLATE_NOOP("", ", who has been idle since %1%")) % dateTimeToLocalString(idle->getSince()));

}

startMessage += ": " + statusShowTypeToFriendlyName(theirPresence ? theirPresence->getShow() : StatusShow::None);

chatStateNotifier_->setContact(jid);

ChatControllerBase::setToJID(jid);

Presence::ref presence;

if (isInMUC_) {

presence = presenceOracle_->getLastPresence(jid);

} else {

}

chatStateNotifier_->setContactIsOnline(presence && presence->getType() == Presence::Available);

handleBareJIDCapsChanged(toJID_);

}

void ChatController::setAvailableServerFeatures(boost::shared_ptr<DiscoInfo> info) {

response += " (" + presence->getStatus() + ")";

}

return response + ".";

}

void ChatController::handlePresenceChange(boost::shared_ptr<Presence> newPresence) {

}

return;

}

if (!newPresence) {

newPresence = boost::make_shared<Presence>();

newPresence->setType(Presence::Unavailable);

}

lastShownStatus_ = newPresence->getShow();

fixedChat.statusType = StatusShow::Online;

}

} else {

if (avatarManager_) {

fixedChat.avatarPath = avatarManager_->getAvatarPath(fixedChat.jid);

}

fixedChat.statusType = presence ? presence->getShow() : StatusShow::None;

}

return fixedChat;

}

void ChatsManager::loadRecents() {

} else {

ChatController* controller = getChatControllerIfExists(jid, false);

if (controller) {

unreadCount = controller->getUnreadCount();

}

JID bareishJID = mucRegistry_->isMUC(jid.toBare()) ? jid : jid.toBare();

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);

}

}

} else {

contact->name = jid.toString();

}

}

// presence lookup

if (presence) {

contact->statusType = presence->getShow();

} else {

contact->statusType = StatusShow::None;

}

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/Controllers/ContactsFromXMPPRoster.h>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Presence/PresenceOracle.h>

#include <Swiften/Roster/XMPPRoster.h>

#include <Swiften/Roster/XMPPRosterItem.h>

namespace Swift {

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->avatarPath = avatarManager_->getAvatarPath(contact->jid);

results.push_back(contact);

}

return results;

}

/*

* 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/DateTime.h>

#include <Swiften/Elements/Idle.h>

#include <Swift/Controllers/Intl.h>

#include <Swift/Controllers/Roster/GroupRosterItem.h>

namespace Swift {

}

ContactRosterItem::~ContactRosterItem() {

}

StatusShow::Type ContactRosterItem::getStatusShow() const {

}

StatusShow::Type ContactRosterItem::getSimplifiedStatusShow() const {

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;

case StatusShow::None: return StatusShow::None;

}

assert(false);

return StatusShow::None;

}

std::string ContactRosterItem::getStatusText() const {

}

std::string ContactRosterItem::getIdleText() const {

if (!idle || idle->getSince().is_not_a_date_time()) {

return "";

} else {

return dateTimeToLocalString(idle->getSince());

}

}

std::string ContactRosterItem::getOfflineSinceText() const {

return dateTimeToLocalString(*delay);

}

}

return "";

}

return displayJID_;

}

typedef std::pair<std::string, boost::shared_ptr<Presence> > StringPresencePair;

void ContactRosterItem::clearPresence() {

onDataChanged();

}

void ContactRosterItem::applyPresence(const std::string& resource, boost::shared_ptr<Presence> presence) {

onDataChanged();

}

const std::vector<std::string>& ContactRosterItem::getGroups() const {

return groups_;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <set>

#include <string>

#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/Presence.h>

#include <Swiften/Elements/StatusShow.h>

#include <Swiften/Elements/VCard.h>

#include <Swiften/JID/JID.h>

#include <Swift/Controllers/Roster/RosterItem.h>

namespace Swift {

void setAvatarPath(const boost::filesystem::path& path);

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);

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);

MUCOccupant::Role getMUCRole() const;

void setMUCRole(const MUCOccupant::Role& role);

MUCOccupant::Affiliation getMUCAffiliation() const;

void setMUCAffiliation(const MUCOccupant::Affiliation& affiliation);

std::string getMUCAffiliationText() const;

private:

JID jid_;

JID displayJID_;

boost::posix_time::ptime lastAvailableTime_;

boost::filesystem::path avatarPath_;

std::vector<std::string> groups_;

MUCOccupant::Role mucRole_;

MUCOccupant::Affiliation mucAffiliation_;

std::set<Feature> features_;

BlockState blockState_;

VCard::ref vcard_;

signOutConnection_ = mainWindow_->onSignOutRequest.connect(boost::bind(boost::ref(onSignOutRequest)));

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));

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));

mainWindow_->setMyAvatarPath(pathToString(avatarManager_->getAvatarPath(myJID_.toBare())));

}

void RosterController::handleIncomingPresence(Presence::ref newPresence) {

if (newPresence->getType() == Presence::Error) {

return;

}

}

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);

return;

void RosterController::handlePresenceChanged(Presence::ref presence) {

if (presence->getFrom().equals(myJID_, JID::WithResource)) {

ownContact_->applyPresence(std::string(), presence);

mainWindow_->setMyContactRosterItem(ownContact_);

}

}

boost::optional<XMPPRosterItem> RosterController::getItem(const JID& jid) const {

return xmppRoster_->getItem(jid);

}

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->setStatus("Not here");

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);

stanzaChannel_->onPresenceReceived(lowPresence);

stanzaChannel_->onPresenceReceived(highPresence);

stanzaChannel_->onPresenceReceived(highPresenceOffline);

ContactRosterItem* item = dynamic_cast<ContactRosterItem*>(dynamic_cast<GroupRosterItem*>(CHILDREN[0])->getChildren()[0]);

CPPUNIT_ASSERT(item);

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. */

CPPUNIT_ASSERT_EQUAL(StatusShow::None, item->getStatusShow());

CPPUNIT_ASSERT_EQUAL(lowPresenceOffline->getStatus(), item->getStatusText());

}

void testAdd() {

std::vector<std::string> groups;

* See the COPYING file for more information.

*/

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Elements/JingleIBBTransportPayload.h>

#include <Swiften/Elements/JingleS5BTransportPayload.h>

#include <Swiften/Elements/StreamInitiationFileInfo.h>

#include <Swiften/StringCodecs/Base64.h>

using namespace Swift;

class JingleParserTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(JingleParserTest);

CPPUNIT_TEST(testParse_Xep0166_Example3);

CPPUNIT_ASSERT(hash);

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() {

PayloadsParserTester parser;

CPPUNIT_ASSERT(parser.parse(

"<jingle xmlns='urn:xmpp:jingle:1'\n"

" action='session-initiate'\n"

" initiator='romeo@montague.lit/orchard'\n"

" sid='uj3b2'>\n"

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Presence/PresenceOracle.h>

#include <boost/bind.hpp>

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/Roster/XMPPRoster.h>

namespace Swift {

PresenceOracle::PresenceOracle(StanzaChannel* stanzaChannel, XMPPRoster* roster) : stanzaChannel_(stanzaChannel), xmppRoster_(roster) {

stanzaChannel_->onPresenceReceived.connect(boost::bind(&PresenceOracle::handleIncomingPresence, this, _1));

Presence::ref current = j->second;

results.push_back(current);

}

return results;

}

Presence::ref PresenceOracle::getHighestPriorityPresence(const JID& bareJID) const {

PresencesMap::const_iterator i = entries_.find(bareJID);

if (i == entries_.end()) {

return Presence::ref();

}

PresenceMap presenceMap = i->second;

#include <Swiften/Elements/Presence.h>

namespace Swift {

class StanzaChannel;

class XMPPRoster;

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;

public:

boost::signal<void (Presence::ref)> onPresenceChange;

private:

void handleIncomingPresence(Presence::ref presence);

void handleStanzaChannelAvailableChanged(bool);

CPPUNIT_TEST(testSubscriptionRequest);

CPPUNIT_TEST(testReconnectResetsPresences);

CPPUNIT_TEST(testHighestPresenceSingle);

CPPUNIT_TEST(testHighestPresenceMultiple);

CPPUNIT_TEST(testHighestPresenceGlobal);

CPPUNIT_TEST(testHighestPresenceChangePriority);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

stanzaChannel_ = new DummyStanzaChannel();

xmppRoster_ = new XMPPRosterImpl();

delete oracle_;

delete xmppRoster_;

delete stanzaChannel_;

}

void testHighestPresenceSingle() {

void testHighestPresenceMultiple() {

JID bareJID("alice@wonderland.lit");

Presence::ref fiveOn = makeOnline("blah", 5);

Presence::ref fiveOff = makeOffline("/blah");

Presence::ref tenOn = makeOnline("bert", 10);

stanzaChannel_->onPresenceReceived(sentPresence);

stanzaChannel_->setAvailable(false);

stanzaChannel_->setAvailable(true);

CPPUNIT_ASSERT(!oracle_->getLastPresence(user1));

}

private:

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;

}