+ Context(const boost::function<void()>& callback) : callback(new boost::function<void()>(callback)) {}

+ boost::function<void()>* callback;

+ void processNotification(CFPropertyListRef growlContext, bool activateCallback) {

+ if (activateCallback) {

+ (*context.callback)();

+ }

+ delete context.callback;

+ }

+

+ void notificationClicked(CFPropertyListRef growlContext) {

+ processNotification(growlContext, true);

+ void notificationTimedout(CFPropertyListRef growlContext) {

+ processNotification(growlContext, false);

+/*

+ * 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 "SwifTools/Notifier/Notifier.h"

+#include "Swiften/Base/ByteArray.h"

+

+namespace Swift {

+ class LoggingNotifier : public Notifier {

+ public:

+ virtual void showMessage(Type type, const String& subject, const String& description, const ByteArray& picture, boost::function<void()> callback) {

+ notifications.push_back(Notification(type, subject, description, picture, callback));

+ }

+

+ struct Notification {

+ Notification(Type type, const String& subject, const String& description, const ByteArray& picture, boost::function<void()> callback) : type(type), subject(subject), description(description), picture(picture), callback(callback) {}

+ Type type;

+ String subject;

+ String description;

+ ByteArray picture;

+ boost::function<void()> callback;

+ };

+

+ std::vector<Notification> notifications;

+ };

+}

+ presenceOracle_->onPresenceChange.connect(boost::bind(&ChatController::handlePresenceChange, this, _1));

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

+ chatStateTracker_->handlePresenceChange(newPresence);

+ if (newStatusChangeString != lastStatusChangeString_) {

+ lastStatusChangeString_ = newStatusChangeString;

+ void handlePresenceChange(boost::shared_ptr<Presence> newPresence);

+ String lastStatusChangeString_;

+ presenceOracle_->onPresenceChange.connect(boost::bind(&ChatsManager::handlePresenceChange, this, _1));

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

+ void handlePresenceChange(boost::shared_ptr<Presence> newPresence);

+ xmppRoster_ = new XMPPRoster();

+ presenceOracle_->onPresenceChange(jid1Offline);

+ presenceOracle_->onPresenceChange(jid1Offline);

+ presenceOracle_->onPresenceChange(jid2Offline);

+ XMPPRoster* xmppRoster_;

+#include "Swiften/Network/BoostTimerFactory.h"

+#include "Swift/Controllers/PresenceNotifier.h"

+#include "Swift/Controllers/UIEvents/RequestChatUIEvent.h"

+

+ statusTracker_ = NULL;

+ client_ = NULL;

+ presenceSender_ = NULL;

+ xmppRoster_ = NULL;

+ avatarManager_ = NULL;

+ capsManager_ = NULL;

+ entityCapsManager_ = NULL;

+ presenceNotifier_ = NULL;

+ nickResolver_ = NULL;

+ chatsManager_ = NULL;

+ eventWindowController_ = NULL;

+

+ delete mucSearchController_;

+ mucSearchController_ = NULL;

+ delete discoResponder_;

+ discoResponder_ = NULL;

+ delete clientVersionResponder_;

+ clientVersionResponder_ = NULL;

+ delete eventWindowController_;

+ eventWindowController_ = NULL;

+ delete xmppRosterController_;

+ xmppRosterController_ = NULL;

+ delete rosterController_;

+ rosterController_ = NULL;

+ delete presenceNotifier_;

+ presenceNotifier_ = NULL;

+ delete xmppRoster_;

+ xmppRoster_ = NULL;

+ delete mucRegistry_;

+ mucRegistry_ = NULL;

+ delete presenceOracle_;

+ presenceOracle_ = NULL;

+ rosterController_ = new RosterController(jid_, xmppRoster_, avatarManager_, mainWindowFactory_, nickResolver_, presenceOracle_, presenceSender_, eventController_, uiEventStream_, client_->getIQRouter());

+ presenceOracle_ = new PresenceOracle(client_);

+ mucRegistry_ = new MUCRegistry();

+ xmppRoster_ = new XMPPRoster();

+ vcardManager_ = new VCardManager(jid_, client_->getIQRouter(), getVCardStorageForProfile(jid_));

+ vcardManager_->onVCardChanged.connect(boost::bind(&MainController::handleVCardReceived, this, _1, _2));

+ avatarManager_ = new AvatarManagerImpl(vcardManager_, client_, avatarStorage_, mucRegistry_);

+ capsManager_ = new CapsManager(capsStorage_, client_, client_->getIQRouter());

+ entityCapsManager_ = new EntityCapsManager(capsManager_, client_);

+ presenceNotifier_ = new PresenceNotifier(client_, notifier_, mucRegistry_, avatarManager_, xmppRoster_, presenceOracle_, &timerFactory_);

+ presenceNotifier_->onNotificationActivated.connect(boost::bind(&MainController::handleNotificationClicked, this, _1));

+void MainController::handleNotificationClicked(const JID& jid) {

+ assert(chatsManager_);

+ uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(jid)));

+}

+

+ class PresenceNotifier;

+ void handleNotificationClicked(const JID& jid);

+ PresenceNotifier* presenceNotifier_;

+ XMPPRoster* xmppRoster_;;

+NickResolver::NickResolver(const JID& ownJID, XMPPRoster* xmppRoster, VCardManager* vcardManager, MUCRegistry* mucRegistry) : ownJID_(ownJID) {

+ NickResolver(const JID& ownJID, XMPPRoster* xmppRoster, VCardManager* vcardManager, MUCRegistry* mucRegistry);

+ XMPPRoster* xmppRoster_;

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include "Swift/Controllers/PresenceNotifier.h"

+

+#include <boost/bind.hpp>

+

+#include "Swiften/Client/StanzaChannel.h"

+#include "Swiften/Base/ByteArray.h"

+#include "Swiften/MUC/MUCRegistry.h"

+#include "Swiften/Roster/XMPPRoster.h"

+#include "Swiften/Presence/PresenceOracle.h"

+#include "Swiften/Network/TimerFactory.h"

+

+namespace Swift {

+

+PresenceNotifier::PresenceNotifier(StanzaChannel* stanzaChannel, Notifier* notifier, const MUCRegistry* mucRegistry, AvatarManager* avatarManager, const XMPPRoster* roster, const PresenceOracle* presenceOracle, TimerFactory* timerFactory) : stanzaChannel(stanzaChannel), notifier(notifier), mucRegistry(mucRegistry), avatarManager(avatarManager), roster(roster), presenceOracle(presenceOracle), timerFactory(timerFactory) {

+ justInitialized = true;

+ inQuietPeriod = false;

+ stanzaChannel->onPresenceReceived.connect(boost::bind(&PresenceNotifier::handlePresenceReceived, this, _1));

+ stanzaChannel->onAvailableChanged.connect(boost::bind(&PresenceNotifier::handleStanzaChannelAvailableChanged, this, _1));

+ setInitialQuietPeriodMS(3000);

+}

+

+PresenceNotifier::~PresenceNotifier() {

+ if (timer) {

+ timer->stop();

+ timer->onTick.disconnect(boost::bind(&PresenceNotifier::handleTimerTick, this));

+ timer.reset();

+ }

+ stanzaChannel->onAvailableChanged.disconnect(boost::bind(&PresenceNotifier::handleStanzaChannelAvailableChanged, this, _1));

+ stanzaChannel->onPresenceReceived.disconnect(boost::bind(&PresenceNotifier::handlePresenceReceived, this, _1));

+}

+

+void PresenceNotifier::handlePresenceReceived(boost::shared_ptr<Presence> presence) {

+ JID from = presence->getFrom();

+

+ if (mucRegistry->isMUC(from.toBare())) {

+ return;

+ }

+

+ if (justInitialized) {

+ justInitialized = false;

+ if (timer) {

+ inQuietPeriod = true;

+ }

+ }

+

+ if (inQuietPeriod) {

+ timer->stop();

+ timer->start();

+ return;

+ }

+

+ std::set<JID>::iterator i = availableUsers.find(from);

+ if (presence->isAvailable()) {

+ if (i != availableUsers.end()) {

+ showNotification(from, Notifier::ContactStatusChange);

+ }

+ else {

+ showNotification(from, Notifier::ContactAvailable);

+ availableUsers.insert(from);

+ }

+ }

+ else {

+ if (i != availableUsers.end()) {

+ showNotification(from, Notifier::ContactUnavailable);

+ availableUsers.erase(i);

+ }

+ }

+}

+

+void PresenceNotifier::handleStanzaChannelAvailableChanged(bool available) {

+ if (available) {

+ availableUsers.clear();

+ justInitialized = true;

+ if (timer) {

+ timer->stop();

+ }

+ }

+}

+

+void PresenceNotifier::showNotification(const JID& jid, Notifier::Type type) {

+ String name = roster->getNameForJID(jid);

+ if (name.isEmpty()) {

+ name = jid.toBare().toString();

+ }

+ String title = name + " (" + getStatusType(jid) + ")";

+ String message = getStatusMessage(jid);

+ notifier->showMessage(type, title, message, avatarManager->getAvatar(jid), boost::bind(&PresenceNotifier::handleNotificationActivated, this, jid));

+}

+

+void PresenceNotifier::handleNotificationActivated(JID jid) {

+ onNotificationActivated(jid);

+}

+

+String PresenceNotifier::getStatusType(const JID& jid) const {

+ Presence::ref presence = presenceOracle->getLastPresence(jid);

+ if (presence) {

+ return StatusShow::typeToFriendlyName(presence->getShow());

+ }

+ else {

+ return "Unavailable";

+ }

+}

+

+String PresenceNotifier::getStatusMessage(const JID& jid) const {

+ Presence::ref presence = presenceOracle->getLastPresence(jid);

+ if (presence) {

+ return presence->getStatus();

+ }

+ else {

+ return String();

+ }

+}

+

+void PresenceNotifier::setInitialQuietPeriodMS(int ms) {

+ if (timer) {

+ timer->stop();

+ timer->onTick.disconnect(boost::bind(&PresenceNotifier::handleTimerTick, this));

+ timer.reset();

+ }

+ if (ms > 0) {

+ timer = timerFactory->createTimer(ms);

+ timer->onTick.connect(boost::bind(&PresenceNotifier::handleTimerTick, this));

+ }

+}

+

+void PresenceNotifier::handleTimerTick() {

+ inQuietPeriod = false;

+ timer->stop();

+}

+

+

+}

+/*

+ * 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 <boost/shared_ptr.hpp>

+#include <set>

+

+#include "Swiften/Base/boost_bsignals.h"

+#include "Swiften/Elements/Presence.h"

+#include "Swiften/JID/JID.h"

+#include "SwifTools/Notifier/Notifier.h"

+#include "Swiften/Avatars/AvatarManager.h"

+#include "Swiften/Network/Timer.h"

+

+namespace Swift {

+ class TimerFactory;

+ class StanzaChannel;

+ class MUCRegistry;

+ class XMPPRoster;

+ class PresenceOracle;

+

+ class PresenceNotifier {

+ public:

+ PresenceNotifier(StanzaChannel* stanzaChannel, Notifier* notifier, const MUCRegistry* mucRegistry, AvatarManager* avatarManager, const XMPPRoster* roster, const PresenceOracle* presenceOracle, TimerFactory* timerFactory);

+ ~PresenceNotifier();

+

+ void setInitialQuietPeriodMS(int ms);

+

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

+

+ private:

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

+ void handleStanzaChannelAvailableChanged(bool);

+ void handleNotificationActivated(JID jid);

+ void handleTimerTick();

+ String getStatusType(const JID&) const;

+ String getStatusMessage(const JID&) const;

+

+ private:

+ void showNotification(const JID& jid, Notifier::Type type);

+

+ private:

+ StanzaChannel* stanzaChannel;

+ Notifier* notifier;

+ const MUCRegistry* mucRegistry;

+ AvatarManager* avatarManager;

+ const XMPPRoster* roster;

+ const PresenceOracle* presenceOracle;

+ TimerFactory* timerFactory;

+ boost::shared_ptr<Timer> timer;

+ bool justInitialized;

+ bool inQuietPeriod;

+ std::set<JID> availableUsers;

+ };

+}

+

+#include "Swiften/Presence/PresenceSender.h"

+RosterController::RosterController(const JID& jid, XMPPRoster* xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, PresenceSender* presenceSender, EventController* eventController, UIEventStream* uiEventStream, IQRouter* iqRouter)

+ presenceSender_ = presenceSender;

+ presenceOracle_->onPresenceChange.connect(boost::bind(&RosterController::handleIncomingPresence, this, _1));

+ presenceSender_->requestSubscription(addContactEvent->getJID());

+void RosterController::handleIncomingPresence(boost::shared_ptr<Presence> newPresence) {

+ presenceSender_->confirmSubscription(jid);

+ presenceSender_->confirmSubscription(event->getJID());

+ presenceSender_->requestSubscription(event->getJID());

+ presenceSender_->cancelSubscription(event->getJID());

+ class PresenceSender;

+ RosterController(const JID& jid, XMPPRoster* xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, PresenceSender* presenceSender, EventController* eventController, UIEventStream* uiEventStream, IQRouter* iqRouter_);

+ void handleIncomingPresence(boost::shared_ptr<Presence> newPresence);

+ XMPPRoster* xmppRoster_;

+ PresenceSender* presenceSender_;

+ "PresenceNotifier.cpp",

+ File("UnitTest/PresenceNotifierTest.cpp"),

+ xmppRoster_ = new XMPPRoster();

+ XMPPRoster* xmppRoster_;

+/*

+ * 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 <vector>

+#include <boost/bind.hpp>

+

+#include "Swift/Controllers/PresenceNotifier.h"

+#include "SwifTools/Notifier/LoggingNotifier.h"

+#include "Swiften/Client/DummyStanzaChannel.h"

+#include "Swiften/MUC/MUCRegistry.h"

+#include "Swiften/Roster/XMPPRoster.h"

+#include "Swiften/Presence/PresenceOracle.h"

+#include "Swiften/Avatars/DummyAvatarManager.h"

+#include "Swiften/Network/DummyTimerFactory.h"

+

+using namespace Swift;

+

+class PresenceNotifierTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(PresenceNotifierTest);

+ CPPUNIT_TEST(testReceiveFirstPresenceCreatesAvailableNotification);

+ CPPUNIT_TEST(testReceiveSecondPresenceCreatesStatusChangeNotification);

+ CPPUNIT_TEST(testReceiveUnavailablePresenceAfterAvailablePresenceCreatesUnavailableNotification);

+ CPPUNIT_TEST(testReceiveUnavailablePresenceWithoutAvailableDoesNotCreateNotification);

+ CPPUNIT_TEST(testReceiveAvailablePresenceAfterUnavailableCreatesAvailableNotification);

+ CPPUNIT_TEST(testReceiveAvailablePresenceAfterReconnectCreatesAvailableNotification);

+ CPPUNIT_TEST(testReceiveAvailablePresenceFromMUCDoesNotCreateNotification);

+ CPPUNIT_TEST(testNotificationSubjectContainsNameForJIDInRoster);

+ CPPUNIT_TEST(testNotificationSubjectContainsJIDForJIDNotInRoster);

+ CPPUNIT_TEST(testNotificationSubjectContainsStatus);

+ CPPUNIT_TEST(testNotificationMessageContainsStatusMessage);

+ CPPUNIT_TEST(testNotificationPicture);

+ CPPUNIT_TEST(testNotificationActivationEmitsSignal);

+ CPPUNIT_TEST(testReceiveFirstPresenceWithQuietPeriodDoesNotNotify);

+ CPPUNIT_TEST(testReceiveFirstPresenceWithQuietPeriodDoesNotCountAsQuietPeriod);

+ CPPUNIT_TEST(testReceivePresenceDuringQuietPeriodDoesNotNotify);

+ CPPUNIT_TEST(testReceivePresenceDuringQuietPeriodResetsTimer);

+ CPPUNIT_TEST(testReceivePresenceAfterQuietPeriodNotifies);

+ CPPUNIT_TEST(testReceiveFirstPresenceAfterReconnectWithQuietPeriodDoesNotNotify);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ stanzaChannel = new DummyStanzaChannel();

+ notifier = new LoggingNotifier();

+ mucRegistry = new MUCRegistry();

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

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

+ avatarManager = new DummyAvatarManager();

+ roster = new XMPPRoster();

+ presenceOracle = new PresenceOracle(stanzaChannel);

+ timerFactory = new DummyTimerFactory();

+ }

+

+ void tearDown() {

+ delete presenceOracle;

+ delete roster;

+ delete avatarManager;

+ delete mucRegistry;

+ delete notifier;

+ delete stanzaChannel;

+ }

+

+ void testReceiveFirstPresenceCreatesAvailableNotification() {

+ std::auto_ptr<PresenceNotifier> testling = createNotifier();

+

+ sendPresence(user1, StatusShow::Online);

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));

+ CPPUNIT_ASSERT_EQUAL(Notifier::ContactAvailable, notifier->notifications[0].type);

+ }

+

+ void testReceiveSecondPresenceCreatesStatusChangeNotification() {

+ std::auto_ptr<PresenceNotifier> testling = createNotifier();

+ sendPresence(user1, StatusShow::Away);

+ notifier->notifications.clear();

+

+ sendPresence(user1, StatusShow::Online);

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));

+ CPPUNIT_ASSERT_EQUAL(Notifier::ContactStatusChange, notifier->notifications[0].type);

+ }

+

+ void testReceiveUnavailablePresenceAfterAvailablePresenceCreatesUnavailableNotification() {

+ std::auto_ptr<PresenceNotifier> testling = createNotifier();

+ sendPresence(user1, StatusShow::Away);

+ notifier->notifications.clear();

+

+ sendUnavailablePresence(user1);

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));

+ CPPUNIT_ASSERT_EQUAL(Notifier::ContactUnavailable, notifier->notifications[0].type);

+ }

+

+ void testReceiveUnavailablePresenceWithoutAvailableDoesNotCreateNotification() {

+ std::auto_ptr<PresenceNotifier> testling = createNotifier();

+

+ sendUnavailablePresence(user1);

+

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));

+ }

+

+ void testReceiveAvailablePresenceAfterUnavailableCreatesAvailableNotification() {

+ std::auto_ptr<PresenceNotifier> testling = createNotifier();

+ sendPresence(user1, StatusShow::Away);

+ sendUnavailablePresence(user1);

+ notifier->notifications.clear();

+

+ sendPresence(user1, StatusShow::Away);

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));

+ CPPUNIT_ASSERT_EQUAL(Notifier::ContactAvailable, notifier->notifications[0].type);

+ }

+

+ void testReceiveAvailablePresenceAfterReconnectCreatesAvailableNotification() {

+ std::auto_ptr<PresenceNotifier> testling = createNotifier();

+ sendPresence(user1, StatusShow::Away);

+ stanzaChannel->setAvailable(false);

+ stanzaChannel->setAvailable(true);

+ notifier->notifications.clear();

+

+ sendPresence(user1, StatusShow::Away);

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));

+ CPPUNIT_ASSERT_EQUAL(Notifier::ContactAvailable, notifier->notifications[0].type);

+ }

+

+ void testReceiveAvailablePresenceFromMUCDoesNotCreateNotification() {

+ std::auto_ptr<PresenceNotifier> testling = createNotifier();

+ mucRegistry->addMUC(JID("teaparty@wonderland.lit"));

+

+ sendPresence(JID("teaparty@wonderland.lit/Alice"), StatusShow::Away);

+

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));

+ }

+

+ void testNotificationPicture() {

+ std::auto_ptr<PresenceNotifier> testling = createNotifier();

+ avatarManager->avatars[user1] = ByteArray("abcdef");

+

+ sendPresence(user1, StatusShow::Online);

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));

+ CPPUNIT_ASSERT_EQUAL(ByteArray("abcdef"), notifier->notifications[0].picture);

+ }

+

+ void testNotificationActivationEmitsSignal() {

+ std::auto_ptr<PresenceNotifier> testling = createNotifier();

+

+ sendPresence(user1, StatusShow::Online);

+ CPPUNIT_ASSERT(notifier->notifications[0].callback);

+ notifier->notifications[0].callback();

+

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

+ CPPUNIT_ASSERT_EQUAL(user1, activatedNotifications[0]);

+ }

+

+ void testNotificationSubjectContainsNameForJIDInRoster() {

+ std::auto_ptr<PresenceNotifier> testling = createNotifier();

+ roster->addContact(user1.toBare(), "User 1", std::vector<String>(), RosterItemPayload::Both);

+

+ sendPresence(user1, StatusShow::Online);

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));

+ CPPUNIT_ASSERT(notifier->notifications[0].subject.contains("User 1"));

+ }

+

+ void testNotificationSubjectContainsJIDForJIDNotInRoster() {

+ std::auto_ptr<PresenceNotifier> testling = createNotifier();

+

+ sendPresence(user1, StatusShow::Online);

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));

+ CPPUNIT_ASSERT(notifier->notifications[0].subject.contains(user1.toBare().toString()));

+ }

+

+ void testNotificationSubjectContainsStatus() {

+ std::auto_ptr<PresenceNotifier> testling = createNotifier();

+

+ sendPresence(user1, StatusShow::Away);

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));

+ CPPUNIT_ASSERT(notifier->notifications[0].subject.contains("Away"));

+ }

+

+ void testNotificationMessageContainsStatusMessage() {

+ std::auto_ptr<PresenceNotifier> testling = createNotifier();

+

+ sendPresence(user1, StatusShow::Away);

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));

+ CPPUNIT_ASSERT(notifier->notifications[0].description.contains("Status Message"));

+ }

+

+ void testReceiveFirstPresenceWithQuietPeriodDoesNotNotify() {

+ std::auto_ptr<PresenceNotifier> testling = createNotifier();

+ testling->setInitialQuietPeriodMS(10);

+

+ sendPresence(user1, StatusShow::Online);

+

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));

+ }

+

+ void testReceivePresenceDuringQuietPeriodDoesNotNotify() {

+ std::auto_ptr<PresenceNotifier> testling = createNotifier();

+ testling->setInitialQuietPeriodMS(10);

+

+ sendPresence(user1, StatusShow::Online);

+ timerFactory->setTime(1);

+ sendPresence(user2, StatusShow::Away);

+

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));

+ }

+

+ void testReceivePresenceDuringQuietPeriodResetsTimer() {

+ std::auto_ptr<PresenceNotifier> testling = createNotifier();

+ testling->setInitialQuietPeriodMS(10);

+

+ sendPresence(user1, StatusShow::Online);

+ timerFactory->setTime(9);

+ sendPresence(user2, StatusShow::Away);

+ timerFactory->setTime(18);

+ sendPresence(user1, StatusShow::Away);

+

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));

+ }

+

+ void testReceivePresenceAfterQuietPeriodNotifies() {

+ std::auto_ptr<PresenceNotifier> testling = createNotifier();

+ testling->setInitialQuietPeriodMS(10);

+

+ sendPresence(user1, StatusShow::Online);

+ timerFactory->setTime(11);

+ sendPresence(user2, StatusShow::Away);

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));

+ }

+

+ void testReceiveFirstPresenceWithQuietPeriodDoesNotCountAsQuietPeriod() {

+ std::auto_ptr<PresenceNotifier> testling = createNotifier();

+ testling->setInitialQuietPeriodMS(10);

+

+ timerFactory->setTime(11);

+ sendPresence(user1, StatusShow::Away);

+

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));

+ }

+

+ void testReceiveFirstPresenceAfterReconnectWithQuietPeriodDoesNotNotify() {

+ std::auto_ptr<PresenceNotifier> testling = createNotifier();

+ testling->setInitialQuietPeriodMS(10);

+ sendPresence(user1, StatusShow::Online);

+ timerFactory->setTime(15);

+ notifier->notifications.clear();

+

+ stanzaChannel->setAvailable(false);

+ stanzaChannel->setAvailable(true);

+ sendPresence(user1, StatusShow::Online);

+ timerFactory->setTime(21);

+ sendPresence(user2, StatusShow::Online);

+

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));

+ }

+

+

+ private:

+ std::auto_ptr<PresenceNotifier> createNotifier() {

+ std::auto_ptr<PresenceNotifier> result(new PresenceNotifier(stanzaChannel, notifier, mucRegistry, avatarManager, roster, presenceOracle, timerFactory));

+ result->onNotificationActivated.connect(boost::bind(&PresenceNotifierTest::handleNotificationActivated, this, _1));

+ result->setInitialQuietPeriodMS(0);

+ return result;

+ }

+

+ void sendPresence(const JID& jid, StatusShow::Type type) {

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

+ presence->setFrom(jid);

+ presence->setShow(type);

+ presence->setStatus("Status Message");

+ stanzaChannel->onPresenceReceived(presence);

+ }

+

+ void sendUnavailablePresence(const JID& jid) {

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

+ presence->setType(Presence::Unavailable);

+ presence->setFrom(jid);

+ stanzaChannel->onPresenceReceived(presence);

+ }

+

+ void handleNotificationActivated(const JID& j) {

+ activatedNotifications.push_back(j);

+ }

+

+ private:

+ DummyStanzaChannel* stanzaChannel;

+ LoggingNotifier* notifier;

+ MUCRegistry* mucRegistry;

+ DummyAvatarManager* avatarManager;

+ XMPPRoster* roster;

+ PresenceOracle* presenceOracle;

+ DummyTimerFactory* timerFactory;

+ JID user1;

+ JID user2;

+ std::vector<JID> activatedNotifications;

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(PresenceNotifierTest);

+#include "Swiften/Presence/PresenceSender.h"

+

+ xmppRoster_ = new XMPPRoster();

+ presenceSender_ = new PresenceSender(stanzaChannel_);

+ rosterController_ = new RosterController(jid_, xmppRoster_, avatarManager_, mainWindowFactory_, nickResolver_, presenceOracle_, presenceSender_, eventController_, uiEventStream_, router_);

+ delete presenceSender_;

+ XMPPRoster* xmppRoster_;

+ PresenceSender* presenceSender_;

+ xmppRoster_ = new XMPPRoster();

+ XMPPRoster* xmppRoster_;

+XMPPRosterController::XMPPRosterController(IQRouter* iqRouter, XMPPRoster* xmppRoster) : iqRouter_(iqRouter), rosterPushResponder_(iqRouter), xmppRoster_(xmppRoster) {

+ XMPPRosterController(IQRouter *iqRouter, XMPPRoster* xmppRoster);

+ XMPPRoster* xmppRoster_;

+ if env["HAVE_GROWL"] :

+ frameworks.append(env["GROWL_FRAMEWORK"])

+#include "Swiften/Base/ByteArray.h"

+ virtual ByteArray getAvatar(const JID&) const = 0;

+#include "Swiften/Base/ByteArray.h"

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

+ String hash = combinedAvatarProvider.getAvatarHash(jid);

+ if (!hash.isEmpty()) {

+ return avatarStorage->getAvatar(hash);

+ }

+ return ByteArray();

+}

+ virtual ByteArray getAvatar(const JID&) const;

+/*

+ * 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 <map>

+

+#include "Swiften/Avatars/AvatarManager.h"

+

+namespace Swift {

+ class DummyAvatarManager : public AvatarManager {

+ public:

+ virtual boost::filesystem::path getAvatarPath(const JID&) const {

+ return boost::filesystem::path();

+ }

+

+ virtual ByteArray getAvatar(const JID& jid) const {

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

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

+ return i->second;

+ }

+ else {

+ return ByteArray();

+ }

+ }

+

+ std::map<JID, ByteArray> avatars;

+ };

+}

+

+ virtual ByteArray getAvatar(const JID&) const {

+ return ByteArray();

+ }

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

+ void handlePresenceChange(boost::shared_ptr<Presence> newPresence);

+ DummyTimer(int timeout, DummyTimerFactory* factory) : timeout(timeout), factory(factory), isRunning(false), startTime(~0) {

+ startTime = factory->currentTime;

+

+ int getAlarmTime() const {

+ return startTime + timeout;

+ }

+ DummyTimerFactory* factory;

+ int startTime;

+ boost::shared_ptr<DummyTimer> timer(new DummyTimer(milliseconds, this));

+ foreach(boost::shared_ptr<DummyTimer> timer, timers) {

+ if (timer->getAlarmTime() > currentTime && timer->getAlarmTime() <= time && timer->isRunning) {

+ timer->onTick();

+

+namespace Swift {

+ stanzaChannel_->onAvailableChanged.connect(boost::bind(&PresenceOracle::handleStanzaChannelAvailableChanged, this, _1));

+PresenceOracle::~PresenceOracle() {

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

+ stanzaChannel_->onAvailableChanged.disconnect(boost::bind(&PresenceOracle::handleStanzaChannelAvailableChanged, this, _1));

+void PresenceOracle::handleStanzaChannelAvailableChanged(bool available) {

+ if (available) {

+ entries_.clear();

+ }

+ }

+ else {

+ onPresenceChange(presence);

+Presence::ref PresenceOracle::getLastPresence(const JID& jid) const {

+ PresencesMap::const_iterator i = entries_.find(jid.toBare());

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

+ return Presence::ref();

+ }

+ PresenceMap presenceMap = i->second;

+ PresenceMap::const_iterator j = presenceMap.find(jid);

+ if (j != presenceMap.end()) {

+ return j->second;

+ }

+ else {

+ return Presence::ref();

+ }

+}

+

+

+#include <map>

+

+ class PresenceOracle {

+ public:

+ PresenceOracle(StanzaChannel* stanzaChannel);

+ ~PresenceOracle();

+

+ Presence::ref getLastPresence(const JID&) const;

+

+ public:

+ boost::signal<void (boost::shared_ptr<Presence>)> onPresenceChange;

+ boost::signal<void (const JID&, const String&)> onPresenceSubscriptionRequest;

+

+ private:

+ void handleIncomingPresence(boost::shared_ptr<Presence> presence);

+ void handleStanzaChannelAvailableChanged(bool);

+

+ private:

+ typedef std::map<JID, Presence::ref> PresenceMap;

+ typedef std::map<JID, PresenceMap> PresencesMap;

+ PresencesMap entries_;

+ StanzaChannel* stanzaChannel_;

+ };

+void PresenceSender::cancelSubscription(const JID& jid) {

+ boost::shared_ptr<Presence> stanza(new Presence());

+ stanza->setType(Presence::Unsubscribed);

+ stanza->setTo(jid);

+ channel->sendPresence(stanza);

+}

+

+void PresenceSender::confirmSubscription(const JID& jid) {

+ boost::shared_ptr<Presence> stanza(new Presence());

+ stanza->setType(Presence::Subscribed);

+ stanza->setTo(jid);

+ channel->sendPresence(stanza);

+}

+

+

+void PresenceSender::requestSubscription(const JID& jid) {

+ boost::shared_ptr<Presence> stanza(new Presence());

+ stanza->setType(Presence::Subscribe);

+ stanza->setTo(jid);

+ channel->sendPresence(stanza);

+}

+

+ void cancelSubscription(const JID& jid);

+ void confirmSubscription(const JID& jid);

+ void requestSubscription(const JID& jid);

+

+class PresenceOracleTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST(testReceivePresence);

+ CPPUNIT_TEST(testReceivePresenceFromDifferentResources);

+ CPPUNIT_TEST(testReconnectResetsPresences);

+ oracle_->onPresenceChange.connect(boost::bind(&PresenceOracleTest::handlePresenceChange, this, _1));

+ oracle_->onPresenceSubscriptionRequest.connect(boost::bind(&PresenceOracleTest::handlePresenceSubscriptionRequest, this, _1, _2));

+ user1 = JID("user1@foo.com/Foo");

+ user1alt = JID("user1@foo.com/Bar");

+ user2 = JID("user2@bar.com/Bar");

+ void testReceivePresence() {

+ boost::shared_ptr<Presence> sentPresence(createPresence(user1));

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

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

+ CPPUNIT_ASSERT_EQUAL(sentPresence, changes[0]);

+ CPPUNIT_ASSERT_EQUAL(sentPresence, oracle_->getLastPresence(user1));

+ void testReceivePresenceFromDifferentResources() {

+ boost::shared_ptr<Presence> sentPresence1(createPresence(user1));

+ boost::shared_ptr<Presence> sentPresence2(createPresence(user1alt));

+ CPPUNIT_ASSERT_EQUAL(sentPresence1, oracle_->getLastPresence(user1));

+ CPPUNIT_ASSERT_EQUAL(sentPresence2, oracle_->getLastPresence(user1alt));

+

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

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

+ CPPUNIT_ASSERT_EQUAL(sentJID, subscriptionRequests[0].jid);

+ CPPUNIT_ASSERT_EQUAL(reasonText, subscriptionRequests[0].reason);

+ }

+

+ void testReconnectResetsPresences() {

+ boost::shared_ptr<Presence> sentPresence(createPresence(user1));

+ stanzaChannel_->onPresenceReceived(sentPresence);

+ stanzaChannel_->setAvailable(false);

+ stanzaChannel_->setAvailable(true);

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

+

+ private:

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

+ changes.push_back(newPresence);

+ }

+

+ void handlePresenceSubscriptionRequest(const JID& jid, const String& reason) {

+ SubscriptionRequestInfo subscriptionRequest;

+ subscriptionRequest.jid = jid;

+ subscriptionRequest.reason = reason;

+ subscriptionRequests.push_back(subscriptionRequest);

+ }

+

+ boost::shared_ptr<Presence> createPresence(const JID& jid) {

+ boost::shared_ptr<Presence> sentPresence(new Presence("blarb"));

+ sentPresence->setFrom(jid);

+ return sentPresence;

+ }

+

+ private:

+ struct SubscriptionRequestInfo {

+ JID jid;

+ String reason;

+ };

+ PresenceOracle* oracle_;

+ DummyStanzaChannel* stanzaChannel_;

+ std::vector<Presence::ref> changes;

+ std::vector<SubscriptionRequestInfo> subscriptionRequests;

+ JID user1;

+ JID user1alt;

+ JID user2;

+

+XMPPRoster::XMPPRoster() {

+}

+

+String XMPPRoster::getNameForJID(const JID& jid) const {

+ std::map<JID, XMPPRosterItem>::const_iterator i = entries_.find(jid.toBare());

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

+ return i->second.name;

+ }

+ else {

+ return "";

+ }

+#pragma once

+ class XMPPRoster {

+ public:

+ XMPPRoster();

+

+ void addContact(const JID& jid, const String& name, const std::vector<String>& groups, const RosterItemPayload::Subscription subscription);

+ void removeContact(const JID& jid);

+ void clear();

+

+ bool containsJID(const JID& jid);

+ RosterItemPayload::Subscription getSubscriptionStateForJID(const JID& jid);

+ String getNameForJID(const JID& jid) const;

+ const std::vector<String>& getGroupsForJID(const JID& jid);

+

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

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

+ boost::signal<void (const JID&, const String&, const std::vector<String>&)> onJIDUpdated;

+ boost::signal<void ()> onRosterCleared;

+

+ private:

+ struct XMPPRosterItem {

+ JID jid;

+ String name;

+ std::vector<String> groups;

+ RosterItemPayload::Subscription subscription;

+ };

+ std::map<JID, XMPPRosterItem> entries_;

+ };