#include <boost/bind.hpp>

#include <Swiften/Avatars/VCardUpdateAvatarManager.h>

#include <Swiften/Avatars/VCardAvatarManager.h>

#include <Swiften/Avatars/AvatarStorage.h>

#include <Swiften/Avatars/OfflineAvatarManager.h>

#include <Swiften/Base/ByteArray.h>

namespace Swift {

AvatarManagerImpl::AvatarManagerImpl(VCardManager* vcardManager, StanzaChannel* stanzaChannel, AvatarStorage* avatarStorage, CryptoProvider* crypto, MUCRegistry* mucRegistry) : avatarStorage(avatarStorage) {

vcardUpdateAvatarManager = new VCardUpdateAvatarManager(vcardManager, stanzaChannel, avatarStorage, crypto, mucRegistry);

combinedAvatarProvider.addProvider(vcardUpdateAvatarManager);

vcardAvatarManager = new VCardAvatarManager(vcardManager, avatarStorage, crypto, mucRegistry);

combinedAvatarProvider.addProvider(vcardAvatarManager);

offlineAvatarManager = new OfflineAvatarManager(avatarStorage);

combinedAvatarProvider.addProvider(offlineAvatarManager);

combinedAvatarProvider.onAvatarChanged.connect(boost::bind(&AvatarManagerImpl::handleCombinedAvatarChanged, this, _1));

}

AvatarManagerImpl::~AvatarManagerImpl() {

combinedAvatarProvider.onAvatarChanged.disconnect(boost::bind(&AvatarManagerImpl::handleCombinedAvatarChanged, this, _1));

combinedAvatarProvider.removeProvider(offlineAvatarManager);

delete offlineAvatarManager;

combinedAvatarProvider.removeProvider(vcardAvatarManager);

delete vcardAvatarManager;

combinedAvatarProvider.removeProvider(vcardUpdateAvatarManager);

delete vcardUpdateAvatarManager;

}

boost::filesystem::path AvatarManagerImpl::getAvatarPath(const JID& jid) const {

}

return boost::filesystem::path();

}

ByteArray AvatarManagerImpl::getAvatar(const JID& jid) const {

}

return ByteArray();

}

void AvatarManagerImpl::handleCombinedAvatarChanged(const JID& jid) {

onAvatarChanged(jid);

}

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Base/boost_bsignals.h>

namespace Swift {

class JID;

class SWIFTEN_API AvatarProvider {

public:

virtual ~AvatarProvider();

boost::signal<void (const JID&)> onAvatarChanged;

};

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Avatars/CombinedAvatarProvider.h>

#include <algorithm>

#include <boost/bind.hpp>

#include <Swiften/Base/Log.h>

namespace Swift {

return getCombinedAvatarAndCache(jid);

}

void CombinedAvatarProvider::addProvider(AvatarProvider* provider) {

provider->onAvatarChanged.connect(boost::bind(&CombinedAvatarProvider::handleAvatarChanged, this, _1));

providers.push_back(provider);

}

void CombinedAvatarProvider::removeProvider(AvatarProvider* provider) {

std::vector<AvatarProvider*>::iterator i = std::remove(providers.begin(), providers.end(), provider);

for(std::vector<AvatarProvider*>::iterator j = i; j < providers.end(); ++j) {

provider->onAvatarChanged.disconnect(boost::bind(&CombinedAvatarProvider::handleAvatarChanged, this, _1));

}

providers.erase(i, providers.end());

}

void CombinedAvatarProvider::handleAvatarChanged(const JID& jid) {

std::string oldHash;

std::map<JID, std::string>::const_iterator i = avatars.find(jid);

if (i != avatars.end()) {

oldHash = i->second;

}

if (newHash != oldHash) {

SWIFT_LOG(debug) << "Avatar changed: " << jid << ": " << oldHash << " -> " << newHash << std::endl;

onAvatarChanged(jid);

}

}

SWIFT_LOG(debug) << "JID: " << jid << std::endl;

hash = providers[i]->getAvatarHash(jid);

SWIFT_LOG(debug) << "Provider " << providers[i] << ": " << hash << std::endl;

}

return hash;

}

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <vector>

#include <map>

#include <Swiften/Base/API.h>

#include <Swiften/Avatars/AvatarProvider.h>

#include <Swiften/JID/JID.h>

namespace Swift {

class SWIFTEN_API CombinedAvatarProvider : public AvatarProvider {

public:

void addProvider(AvatarProvider*);

void removeProvider(AvatarProvider*);

private:

void handleAvatarChanged(const JID&);

private:

std::vector<AvatarProvider*> providers;

mutable std::map<JID, std::string> avatars;

};

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Avatars/OfflineAvatarManager.h>

#include <boost/bind.hpp>

#include <Swiften/Avatars/AvatarStorage.h>

namespace Swift {

OfflineAvatarManager::OfflineAvatarManager(AvatarStorage* avatarStorage) : avatarStorage(avatarStorage) {

}

OfflineAvatarManager::~OfflineAvatarManager() {

}

return avatarStorage->getAvatarForJID(jid);

}

void OfflineAvatarManager::setAvatar(const JID& jid, const std::string& hash) {

if (getAvatarHash(jid) != hash) {

avatarStorage->setAvatarForJID(jid, hash);

onAvatarChanged(jid);

}

}

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <Swiften/Avatars/AvatarProvider.h>

namespace Swift {

class AvatarStorage;

class OfflineAvatarManager : public AvatarProvider {

public:

OfflineAvatarManager(AvatarStorage*);

~OfflineAvatarManager();

void setAvatar(const JID&, const std::string& hash);

private:

AvatarStorage* avatarStorage;

};

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <boost/bind.hpp>

#include <Swiften/JID/JID.h>

#include <string>

#include <Swiften/Avatars/CombinedAvatarProvider.h>

using namespace Swift;

class CombinedAvatarProviderTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(CombinedAvatarProviderTest);

CPPUNIT_TEST(testGetAvatarWithNoAvatarProviderReturnsEmpty);

CPPUNIT_TEST(testGetAvatarWithSingleAvatarProvider);

CPPUNIT_TEST(testGetAvatarWithMultipleAvatarProviderReturnsFirstAvatar);

CPPUNIT_TEST(testGetAvatarWithMultipleAvatarProviderAndFailingFirstProviderReturnsSecondAvatar);

CPPUNIT_TEST(testProviderUpdateTriggersChange);

CPPUNIT_TEST(testProviderUpdateWithoutChangeDoesNotTriggerChange);

CPPUNIT_TEST(testProviderSecondUpdateTriggersChange);

CPPUNIT_TEST(testProviderUpdateWithAvatarDisappearingTriggersChange);

CPPUNIT_TEST(testProviderUpdateAfterAvatarDisappearedTriggersChange);

CPPUNIT_TEST(testProviderUpdateAfterGetDoesNotTriggerChange);

CPPUNIT_TEST(testProviderUpdateBareJIDAfterGetFullJID);

CPPUNIT_TEST(testRemoveProviderDisconnectsUpdates);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

avatarProvider1 = new DummyAvatarProvider();

avatarProvider2 = new DummyAvatarProvider();

user1 = JID("user1@bar.com/bla");

user2 = JID("user2@foo.com/baz");

avatarHash1 = "ABCDEFG";

avatarHash2 = "XYZU";

avatarHash3 = "IDGH";

}

void tearDown() {

delete avatarProvider1;

delete avatarProvider2;

}

void testGetAvatarWithNoAvatarProviderReturnsEmpty() {

boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

}

void testGetAvatarWithSingleAvatarProvider() {

boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

avatarProvider1->avatars[user1] = avatarHash1;

testling->addProvider(avatarProvider1);

}

void testGetAvatarWithMultipleAvatarProviderReturnsFirstAvatar() {

boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

avatarProvider1->avatars[user1] = avatarHash1;

avatarProvider2->avatars[user1] = avatarHash2;

testling->addProvider(avatarProvider1);

testling->addProvider(avatarProvider2);

}

void testGetAvatarWithMultipleAvatarProviderAndFailingFirstProviderReturnsSecondAvatar() {

boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

avatarProvider2->avatars[user1] = avatarHash2;

testling->addProvider(avatarProvider1);

testling->addProvider(avatarProvider2);

}

void testProviderUpdateTriggersChange() {

boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

testling->addProvider(avatarProvider1);

avatarProvider1->avatars[user1] = avatarHash1;

avatarProvider1->onAvatarChanged(user1);

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(changes.size()));

CPPUNIT_ASSERT_EQUAL(user1, changes[0]);

}

void testProviderUpdateWithoutChangeDoesNotTriggerChange() {

boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

testling->addProvider(avatarProvider1);

testling->addProvider(avatarProvider2);

avatarProvider1->avatars[user1] = avatarHash1;

avatarProvider1->onAvatarChanged(user1);

changes.clear();

avatarProvider2->avatars[user1] = avatarHash2;

avatarProvider2->onAvatarChanged(user1);

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(changes.size()));

}

void testProviderSecondUpdateTriggersChange() {

boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

testling->addProvider(avatarProvider1);

avatarProvider1->avatars[user1] = avatarHash1;

avatarProvider1->onAvatarChanged(user1);

changes.clear();

avatarProvider1->avatars[user1] = avatarHash2;

avatarProvider1->onAvatarChanged(user1);

void testProviderUpdateAfterGetDoesNotTriggerChange() {

boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

testling->addProvider(avatarProvider1);

avatarProvider1->avatars[user1] = avatarHash1;

testling->getAvatarHash(user1);

avatarProvider1->onAvatarChanged(user1);

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(changes.size()));

}

void testRemoveProviderDisconnectsUpdates() {

boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

testling->addProvider(avatarProvider1);

testling->addProvider(avatarProvider2);

testling->removeProvider(avatarProvider1);

avatarProvider1->avatars[user1] = avatarHash1;

avatarProvider2->avatars[user1] = avatarHash2;

avatarProvider1->onAvatarChanged(user1);

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(changes.size()));

}

void testProviderUpdateBareJIDAfterGetFullJID() {

boost::shared_ptr<CombinedAvatarProvider> testling(createProvider());

avatarProvider1->useBare = true;

testling->addProvider(avatarProvider1);

avatarProvider1->avatars[user1.toBare()] = avatarHash1;

testling->getAvatarHash(user1);

avatarProvider1->avatars[user1.toBare()] = avatarHash2;

avatarProvider1->onAvatarChanged(user1.toBare());

}

private:

boost::shared_ptr<CombinedAvatarProvider> createProvider() {

boost::shared_ptr<CombinedAvatarProvider> result(new CombinedAvatarProvider());

result->onAvatarChanged.connect(boost::bind(&CombinedAvatarProviderTest::handleAvatarChanged, this, _1));

return result;

}

void handleAvatarChanged(const JID& jid) {

changes.push_back(jid);

}

private:

struct DummyAvatarProvider : public AvatarProvider {

DummyAvatarProvider() : useBare(false) {

}

JID actualJID = useBare ? jid.toBare() : jid;

std::map<JID, std::string>::const_iterator i = avatars.find(actualJID);

if (i != avatars.end()) {

return i->second;

}

else {

}

}

bool useBare;

std::map<JID, std::string> avatars;

};

DummyAvatarProvider* avatarProvider1;

DummyAvatarProvider* avatarProvider2;

JID user1;

JID user2;

std::string avatarHash1;

std::string avatarHash2;

std::string avatarHash3;

std::vector<JID> changes;

};

CPPUNIT_TEST_SUITE_REGISTRATION(CombinedAvatarProviderTest);

CPPUNIT_TEST(testVCardUpdateTriggersUpdate);

CPPUNIT_TEST(testGetAvatarHashKnownAvatarUnknownVCard);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

crypto = boost::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

ownJID = JID("foo@fum.com/bum");

stanzaChannel = new DummyStanzaChannel();

stanzaChannel->setAvailable(true);

iqRouter = new IQRouter(stanzaChannel);

mucRegistry = new DummyMUCRegistry();

avatarStorage = new AvatarMemoryStorage();

vcardStorage = new VCardMemoryStorage(crypto.get());

vcardManager = new VCardManager(ownJID, iqRouter, vcardStorage);

avatar1 = createByteArray("abcdefg");

avatar1Hash = Hexify::hexify(crypto->getSHA1Hash(avatar1));

user1 = JID("user1@bar.com/bla");

user2 = JID("user2@foo.com/baz");

}

void tearDown() {

delete vcardManager;

delete vcardStorage;

delete avatarStorage;

delete mucRegistry;

delete iqRouter;

delete stanzaChannel;

}

void testGetAvatarHashKnownAvatar() {

boost::shared_ptr<VCardAvatarManager> testling = createManager();

storeVCardWithPhoto(user1.toBare(), avatar1);

avatarStorage->addAvatar(avatar1Hash, avatar1);

}

void testGetAvatarHashEmptyAvatar() {

boost::shared_ptr<VCardAvatarManager> testling = createManager();

storeEmptyVCard(user1.toBare());

}

void testGetAvatarHashUnknownAvatarKnownVCardStoresAvatar() {

boost::shared_ptr<VCardAvatarManager> testling = createManager();

storeVCardWithPhoto(user1.toBare(), avatar1);

CPPUNIT_ASSERT(avatarStorage->hasAvatar(avatar1Hash));

CPPUNIT_ASSERT_EQUAL(avatar1, avatarStorage->getAvatar(avatar1Hash));

}

void testGetAvatarHashUnknownAvatarUnknownVCard() {

boost::shared_ptr<VCardAvatarManager> testling = createManager();

}

void testGetAvatarHashKnownAvatarUnknownVCard() {

boost::shared_ptr<VCardAvatarManager> testling = createManager();

avatarStorage->setAvatarForJID(user1, avatar1Hash);

}

void testVCardUpdateTriggersUpdate() {

boost::shared_ptr<VCardAvatarManager> testling = createManager();

vcardManager->requestVCard(user1);

sendVCardResult();

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(changes.size()));

}

private:

boost::shared_ptr<VCardAvatarManager> createManager() {

boost::shared_ptr<VCardAvatarManager> result(new VCardAvatarManager(vcardManager, avatarStorage, crypto.get(), mucRegistry));

result->onAvatarChanged.connect(boost::bind(&VCardAvatarManagerTest::handleAvatarChanged, this, _1));

return result;

}

void storeVCardWithPhoto(const JID& jid, const ByteArray& avatar) {

VCard::ref vcard(new VCard());

vcard->setPhoto(avatar);

vcardStorage->setVCard(jid, vcard);

}

void storeEmptyVCard(const JID& jid) {

VCard::ref vcard(new VCard());

vcardStorage->setVCard(jid, vcard);

}

void handleAvatarChanged(const JID& jid) {

changes.push_back(jid);

}

void sendVCardResult() {

VCard::ref vcard(new VCard());

mucRegistry = new DummyMUCRegistry();

avatarStorage = new AvatarMemoryStorage();

vcardStorage = new VCardMemoryStorage(crypto.get());

vcardManager = new VCardManager(ownJID, iqRouter, vcardStorage);

avatar1 = createByteArray("abcdefg");

avatar1Hash = Hexify::hexify(crypto->getSHA1Hash(avatar1));

user1 = JID("user1@bar.com/bla");

user2 = JID("user2@foo.com/baz");

}

void tearDown() {

delete vcardManager;

delete vcardStorage;

delete avatarStorage;

delete mucRegistry;

delete iqRouter;

delete stanzaChannel;

}

void testUpdate_NewHashNewVCardRequestsVCard() {

boost::shared_ptr<VCardUpdateAvatarManager> testling = createManager();

stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(stanzaChannel->sentStanzas.size()));

CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<VCard>(0, user1.toBare(), IQ::Get));

}

void testUpdate_NewHashStoresAvatarAndEmitsNotificationOnVCardReceive() {

boost::shared_ptr<VCardUpdateAvatarManager> testling = createManager();

stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

stanzaChannel->onIQReceived(createVCardResult(avatar1));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(changes.size()));

CPPUNIT_ASSERT_EQUAL(user1.toBare(), changes[0]);

CPPUNIT_ASSERT(avatarStorage->hasAvatar(avatar1Hash));

CPPUNIT_ASSERT_EQUAL(avatar1, avatarStorage->getAvatar(avatar1Hash));

}

void testUpdate_KnownHash() {

boost::shared_ptr<VCardUpdateAvatarManager> testling = createManager();

stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

stanzaChannel->onIQReceived(createVCardResult(avatar1));

changes.clear();

stanzaChannel->sentStanzas.clear();

stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(stanzaChannel->sentStanzas.size()));

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(changes.size()));

}

void testUpdate_KnownHashFromDifferentUserDoesNotRequestVCardButTriggersNotification() {

boost::shared_ptr<VCardUpdateAvatarManager> testling = createManager();

stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

stanzaChannel->onIQReceived(createVCardResult(avatar1));

changes.clear();

stanzaChannel->sentStanzas.clear();

stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user2, avatar1Hash));

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(stanzaChannel->sentStanzas.size()));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(changes.size()));

CPPUNIT_ASSERT_EQUAL(user2.toBare(), changes[0]);

}

void testVCardWithEmptyPhoto() {

boost::shared_ptr<VCardUpdateAvatarManager> testling = createManager();

vcardManager->requestVCard(JID("foo@bar.com"));

stanzaChannel->onIQReceived(createVCardResult(ByteArray()));

CPPUNIT_ASSERT(!avatarStorage->hasAvatar(Hexify::hexify(crypto->getSHA1Hash(ByteArray()))));

}

void testStanzaChannelReset_ClearsHash() {

boost::shared_ptr<VCardUpdateAvatarManager> testling = createManager();

stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

stanzaChannel->onIQReceived(createVCardResult(avatar1));

changes.clear();

stanzaChannel->sentStanzas.clear();

stanzaChannel->setAvailable(false);

stanzaChannel->setAvailable(true);

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(changes.size()));

CPPUNIT_ASSERT_EQUAL(user1.toBare(), changes[0]);

}

void testStanzaChannelReset_ReceiveHashAfterResetUpdatesHash() {

boost::shared_ptr<VCardUpdateAvatarManager> testling = createManager();

stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

stanzaChannel->onIQReceived(createVCardResult(avatar1));

changes.clear();

stanzaChannel->sentStanzas.clear();

stanzaChannel->setAvailable(false);

stanzaChannel->setAvailable(true);

stanzaChannel->onPresenceReceived(createPresenceWithPhotoHash(user1, avatar1Hash));

CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(changes.size()));

CPPUNIT_ASSERT_EQUAL(user1.toBare(), changes[1]);

}

private:

boost::shared_ptr<VCardUpdateAvatarManager> createManager() {

boost::shared_ptr<VCardUpdateAvatarManager> result(new VCardUpdateAvatarManager(vcardManager, stanzaChannel, avatarStorage, crypto.get(), mucRegistry));

result->onAvatarChanged.connect(boost::bind(&VCardUpdateAvatarManagerTest::handleAvatarChanged, this, _1));

return result;

}

boost::shared_ptr<Presence> createPresenceWithPhotoHash(const JID& jid, const std::string& hash) {

boost::shared_ptr<Presence> presence(new Presence());

presence->setFrom(jid);

presence->addPayload(boost::make_shared<VCardUpdate>(hash));

return presence;

}

IQ::ref createVCardResult(const ByteArray& avatar) {

VCard::ref vcard(new VCard());

if (!avatar.empty()) {

vcard->setPhoto(avatar);

}

return IQ::createResult(JID("baz@fum.com"), stanzaChannel->sentStanzas[0]->getTo(), stanzaChannel->sentStanzas[0]->getID(), vcard);

}

void handleAvatarChanged(const JID& jid) {

changes.push_back(jid);

}

private:

struct DummyMUCRegistry : public MUCRegistry {

bool isMUC(const JID& jid) const { return std::find(mucs_.begin(), mucs_.end(), jid) != mucs_.end(); }

std::vector<JID> mucs_;

};

JID ownJID;

/*

* Copyright (c) 2010-2013 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Avatars/VCardAvatarManager.h>

#include <boost/bind.hpp>

#include <Swiften/Elements/VCard.h>

#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/StringCodecs/Hexify.h>

#include <Swiften/Avatars/AvatarStorage.h>

#include <Swiften/MUC/MUCRegistry.h>

#include <Swiften/VCards/VCardManager.h>

#include <Swiften/Base/Log.h>

namespace Swift {

VCardAvatarManager::VCardAvatarManager(VCardManager* vcardManager, AvatarStorage* avatarStorage, CryptoProvider* crypto, MUCRegistry* mucRegistry) : vcardManager_(vcardManager), avatarStorage_(avatarStorage), crypto_(crypto), mucRegistry_(mucRegistry) {

vcardManager_->onVCardChanged.connect(boost::bind(&VCardAvatarManager::handleVCardChanged, this, _1));

}

void VCardAvatarManager::handleVCardChanged(const JID& from) {

// We don't check whether the avatar actually changed. Direct use of this

// manager could cause unnecessary updates, but in practice, this will be

// caught by the wrapping CombinedAvatarManager anyway.

onAvatarChanged(from);

}

JID avatarJID = getAvatarJID(jid);

std::string hash = vcardManager_->getPhotoHash(avatarJID);

if (!hash.empty()) {

if (!avatarStorage_->hasAvatar(hash)) {

VCard::ref vCard = vcardManager_->getVCard(avatarJID);

if (vCard) {

std::string newHash = Hexify::hexify(crypto_->getSHA1Hash(vCard->getPhoto()));

if (newHash != hash) {

// Shouldn't happen, but sometimes seem to. Might be fixed if we

// move to a safer backend.

SWIFT_LOG(warning) << "Inconsistent vCard photo hash cache";

hash = newHash;

}

avatarStorage_->addAvatar(hash, vCard->getPhoto());

}

else {

// Can happen if the cache is inconsistent.

hash = "";

}

}

}

return hash;

}

JID VCardAvatarManager::getAvatarJID(const JID& jid) const {

JID bareFrom = jid.toBare();

return (mucRegistry_ && mucRegistry_->isMUC(bareFrom)) ? jid : bareFrom;

}

}

/*

* Copyright (c) 2010-2013 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Avatars/AvatarProvider.h>

#include <Swiften/JID/JID.h>

namespace Swift {

class MUCRegistry;

class AvatarStorage;

class VCardManager;

class CryptoProvider;

class SWIFTEN_API VCardAvatarManager : public AvatarProvider {

public:

VCardAvatarManager(VCardManager*, AvatarStorage*, CryptoProvider* crypto, MUCRegistry* = NULL);

private:

void handleVCardChanged(const JID& from);

JID getAvatarJID(const JID& o) const;

private:

VCardManager* vcardManager_;

AvatarStorage* avatarStorage_;

CryptoProvider* crypto_;

MUCRegistry* mucRegistry_;

};

}

}

}

void VCardUpdateAvatarManager::handleVCardChanged(const JID& from, VCard::ref vCard) {

if (!vCard) {

SWIFT_LOG(debug) << "Missing element: " << from << ": null vcard payload" << std::endl;

return;

}

if (vCard->getPhoto().empty()) {

setAvatarHash(from, "");

}

else {

std::string hash = Hexify::hexify(crypto_->getSHA1Hash(vCard->getPhoto()));

if (!avatarStorage_->hasAvatar(hash)) {

avatarStorage_->addAvatar(hash, vCard->getPhoto());

}

setAvatarHash(from, hash);

}

}

void VCardUpdateAvatarManager::setAvatarHash(const JID& from, const std::string& hash) {

SWIFT_LOG(debug) << "Updating hash: " << from << " -> " << hash << std::endl;

avatarHashes_[from] = hash;

onAvatarChanged(from);

}

/*

void VCardUpdateAvatarManager::setAvatar(const JID& jid, const ByteArray& avatar) {

std::string hash = Hexify::hexify(SHA1::getHash(avatar));

avatarStorage_->addAvatar(hash, avatar);

setAvatarHash(getAvatarJID(jid), hash);

}

*/

std::map<JID, std::string>::const_iterator i = avatarHashes_.find(getAvatarJID(jid));

if (i != avatarHashes_.end()) {

return i->second;

}

else {

}

}

JID VCardUpdateAvatarManager::getAvatarJID(const JID& jid) const {

JID bareFrom = jid.toBare();

return (mucRegistry_ && mucRegistry_->isMUC(bareFrom)) ? jid : bareFrom;

}

void VCardUpdateAvatarManager::handleStanzaChannelAvailableChanged(bool available) {

if (available) {

std::map<JID, std::string> oldAvatarHashes;

avatarHashes_.swap(oldAvatarHashes);

for(std::map<JID, std::string>::const_iterator i = oldAvatarHashes.begin(); i != oldAvatarHashes.end(); ++i) {

onAvatarChanged(i->first);

}

}

}

}

/*

* Copyright (c) 2010-2013 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <map>

#include <Swiften/Base/API.h>

#include <Swiften/Avatars/AvatarProvider.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Elements/VCard.h>

#include <Swiften/Elements/ErrorPayload.h>

namespace Swift {

class MUCRegistry;

class AvatarStorage;

class StanzaChannel;

class VCardManager;

class CryptoProvider;

class SWIFTEN_API VCardUpdateAvatarManager : public AvatarProvider, public boost::bsignals::trackable {

public:

VCardUpdateAvatarManager(VCardManager*, StanzaChannel*, AvatarStorage*, CryptoProvider* crypto, MUCRegistry* = NULL);

private:

void handlePresenceReceived(boost::shared_ptr<Presence>);

void handleStanzaChannelAvailableChanged(bool);

void handleVCardChanged(const JID& from, VCard::ref);

void setAvatarHash(const JID& from, const std::string& hash);

JID getAvatarJID(const JID& o) const;

private:

VCardManager* vcardManager_;

AvatarStorage* avatarStorage_;

CryptoProvider* crypto_;

MUCRegistry* mucRegistry_;

std::map<JID, std::string> avatarHashes_;

};

}

env.MergeFlags(env["GCONF_FLAGS"])

if myenv["SWIFTEN_DLL"] :

if myenv["PLATFORM"] == "posix" :

myenv.Append(LINKFLAGS = ["-Wl,-soname,libSwiften.so.$SWIFTEN_VERSION_MAJOR"])

myenv["SHLIBSUFFIX"] = ""

elif myenv["PLATFORM"] == "darwin" :

myenv.Append(LINKFLAGS = ["-Wl,-install_name,${SHLIBPREFIX}Swiften.${SWIFTEN_VERSION_MAJOR}${SHLIBSUFFIX}", "-Wl,-compatibility_version,${SWIFTEN_VERSION_MAJOR}.${SWIFTEN_VERSION_MINOR}", "-Wl,-current_version,${SWIFTEN_VERSION_MAJOR}.${SWIFTEN_VERSION_MINOR}"])

elif myenv["PLATFORM"] == "win32" :

res_env = myenv.Clone()

res_env.Append(CPPDEFINES = [

("SWIFTEN_LIBRARY_FILE", "\"\\\"${SWIFTEN_LIBRARY_FILE}\\\"\""),

("SWIFTEN_COPYRIGHT_YEAR", "\"\\\"2010-%s\\\"\"" % str(time.localtime()[0])),

("SWIFTEN_VERSION_MAJOR", "${SWIFTEN_VERSION_MAJOR}"),

("SWIFTEN_VERSION_MINOR", "${SWIFTEN_VERSION_MINOR}"),

("SWIFTEN_VERSION_PATCH", "${SWIFTEN_VERSION_PATCH}"),

])

res = res_env.RES("Swiften.rc")

# For some reason, SCons isn't picking up the dependency correctly

# Adding it explicitly until i figure out why

res_env.Depends(res, "Version.h")

sources += res

swiften_lib = myenv.SwiftenLibrary(swiften_env["SWIFTEN_LIBRARY_FILE"], sources + swiften_env["SWIFTEN_OBJECTS"])

def symlink(env, target, source) :

if os.path.exists(str(target[0])) :

os.unlink(str(target[0]))

os.symlink(source[0].get_contents(), str(target[0]))

for alias in myenv["SWIFTEN_LIBRARY_ALIASES"] :

myenv.Command(myenv.File(alias), [myenv.Value(swiften_lib[0].name), swiften_lib[0]], symlink)

env.Append(UNITTEST_SOURCES = [

File("Avatars/UnitTest/VCardUpdateAvatarManagerTest.cpp"),

File("Avatars/UnitTest/VCardAvatarManagerTest.cpp"),

File("Avatars/UnitTest/CombinedAvatarProviderTest.cpp"),

File("Base/UnitTest/IDGeneratorTest.cpp"),

File("Base/UnitTest/SimpleIDGeneratorTest.cpp"),

File("Base/UnitTest/StringTest.cpp"),

File("Base/UnitTest/DateTimeTest.cpp"),

File("Base/UnitTest/ByteArrayTest.cpp"),

File("Base/UnitTest/URLTest.cpp"),

File("Base/UnitTest/PathTest.cpp"),

File("Chat/UnitTest/ChatStateNotifierTest.cpp"),

# File("Chat/UnitTest/ChatStateTrackerTest.cpp"),

File("Client/UnitTest/ClientSessionTest.cpp"),

File("Client/UnitTest/NickResolverTest.cpp"),

File("Client/UnitTest/ClientBlockListManagerTest.cpp"),

File("Compress/UnitTest/ZLibCompressorTest.cpp"),

File("Compress/UnitTest/ZLibDecompressorTest.cpp"),

File("Component/UnitTest/ComponentHandshakeGeneratorTest.cpp"),

File("Component/UnitTest/ComponentConnectorTest.cpp"),

File("Component/UnitTest/ComponentSessionTest.cpp"),

File("Disco/UnitTest/CapsInfoGeneratorTest.cpp"),

File("Disco/UnitTest/CapsManagerTest.cpp"),

File("Disco/UnitTest/EntityCapsManagerTest.cpp"),

File("Disco/UnitTest/JIDDiscoInfoResponderTest.cpp"),

File("Disco/UnitTest/DiscoInfoResponderTest.cpp"),

File("Elements/UnitTest/IQTest.cpp"),

File("Elements/UnitTest/StanzaTest.cpp"),

File("Elements/UnitTest/FormTest.cpp"),

File("EventLoop/UnitTest/EventLoopTest.cpp"),

File("EventLoop/UnitTest/SimpleEventLoopTest.cpp"),

# File("History/UnitTest/SQLiteHistoryManagerTest.cpp"),

File("JID/UnitTest/JIDTest.cpp"),

File("LinkLocal/UnitTest/LinkLocalConnectorTest.cpp"),

File("LinkLocal/UnitTest/LinkLocalServiceBrowserTest.cpp"),

File("LinkLocal/UnitTest/LinkLocalServiceInfoTest.cpp"),

File("LinkLocal/UnitTest/LinkLocalServiceTest.cpp"),

File("MUC/UnitTest/MUCTest.cpp"),

File("MUC/UnitTest/MockMUC.cpp"),