+ 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"])