+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Slimber/CLI/DummyMenulet.h>

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Slimber/Menulet.h>

+ public:

+ DummyMenulet() {

+ }

+ void clear() {

+ }

+ void addItem(const std::string&, const std::string&) {

+ }

+ void addAboutItem() {

+ }

+ void addRestartItem() {

+ }

+ void addExitItem() {

+ }

+ void addSeparator() {

+ }

+ void setIcon(const std::string&) {

+ }

+ "main.cpp",

+ "DummyMenulet.cpp",

+ ])

+ * Copyright (c) 2010-2016 Isode Limited.

+

+#include <Slimber/CLI/DummyMenulet.h>

+#include <Slimber/MainController.h>

+ SimpleEventLoop eventLoop;

+

+ DummyMenulet menulet;

+ MainController controller(&menulet, &eventLoop);

+ eventLoop.run();

+ return 0;

+ * Copyright (c) 2015-2016 Isode Limited.

+#include <Slimber/MainController.h>

+ CocoaMenulet* menulet;

+ MainController* main;

+ delete main;

+ delete menulet;

+ [super dealloc];

+ menulet = new CocoaMenulet();

+ main = new MainController(menulet, eventLoop);

+ * Copyright (c) 2010-2016 Isode Limited.

+

+ public:

+ CocoaMenulet();

+ virtual ~CocoaMenulet();

+

+ private:

+ virtual void clear();

+ virtual void addItem(const std::string& name, const std::string& icon);

+ virtual void addSeparator();

+ void setIcon(const std::string& icon);

+ virtual void addAboutItem();

+ virtual void addRestartItem();

+ virtual void addExitItem();

+

+ private:

+ NSStatusItem* statusItem;

+ NSMenu* menu;

+ CocoaAction* restartAction;

+ * Copyright (c) 2012-2016 Isode Limited.

+#include <Slimber/Cocoa/CocoaMenulet.h>

+#include <SwifTools/Cocoa/CocoaUtil.h>

+

+ restartAction = [[CocoaAction alloc] initWithFunction:

+ new boost::function<void()>(boost::ref(onRestartClicked))];

+ menu = [[NSMenu alloc] init];

+ statusItem = [[[NSStatusBar systemStatusBar]

+ statusItemWithLength: NSVariableStatusItemLength] retain];

+ [statusItem setHighlightMode: YES];

+ [statusItem setEnabled: YES];

+ [statusItem setToolTip: @"Slimber"];

+ [statusItem setMenu: menu];

+ [statusItem release];

+ [menu release];

+ [restartAction release];

+ NSString* path = [[NSBundle mainBundle] pathForResource: std2NSString(icon) ofType:@"png"];

+ NSImage* image = [[NSImage alloc] initWithContentsOfFile: path];

+ [statusItem setImage: image];

+ [image release];

+ while ([menu numberOfItems] > 0) {

+ [menu removeItemAtIndex: 0];

+ }

+ NSMenuItem* item = [[NSMenuItem alloc] initWithTitle: std2NSString(name)

+ action: nullptr keyEquivalent: @""];

+ if (!icon.empty()) {

+ NSString* path = [[NSBundle mainBundle] pathForResource: std2NSString(icon) ofType:@"png"];

+ NSImage* image = [[NSImage alloc] initWithContentsOfFile: path];

+ [item setImage: image];

+ [image release];

+ }

+ [menu addItem: item];

+ [item release];

+ NSMenuItem* item = [[NSMenuItem alloc] initWithTitle: @"About Slimber" action: @selector(orderFrontStandardAboutPanel:) keyEquivalent: @""];

+ [item setTarget: [NSApplication sharedApplication]];

+ [menu addItem: item];

+ [item release];

+ NSMenuItem* item = [[NSMenuItem alloc] initWithTitle:

+ @"Restart" action: @selector(doAction:) keyEquivalent: @""];

+ [item setTarget: restartAction];

+ [menu addItem: item];

+ [item release];

+ NSMenuItem* item = [[NSMenuItem alloc] initWithTitle: @"Exit" action: @selector(terminate:) keyEquivalent: @""];

+ [item setTarget: [NSApplication sharedApplication]];

+ [menu addItem: item];

+ [item release];

+ [menu addItem: [NSMenuItem separatorItem]];

+ "main.mm",

+ "CocoaController.mm",

+ "CocoaMenulet.mm",

+ ])

+ "MainMenu.nib",

+ "../Resources/Slimber.icns",

+ "../Resources/Credits.html",

+ "../Resources/Online.png",

+ "../Resources/Offline.png",

+ "../Resources/UsersOnline.png",

+ "../Resources/UsersOffline.png"

+ ]}, info = {

+ "NSMainNibFile" : "MainMenu",

+ "LSUIElement" : "1",

+ })

+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Slimber/Cocoa/main.h>

+

+ eventLoop = new Swift::CocoaEventLoop();

+ int result = NSApplicationMain(argc, const_cast<const char **>(argv));

+ delete eventLoop;

+ return result;

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Slimber/FileVCardCollection.h>

+

+#include <memory>

+#include <Swiften/Serializer/PayloadSerializers/VCardSerializer.h>

+std::shared_ptr<VCard> FileVCardCollection::getOwnVCard() const {

+ if (boost::filesystem::exists(vcardsPath / std::string("vcard.xml"))) {

+ ByteArray data;

+ readByteArrayFromFile(data, boost::filesystem::path(vcardsPath / std::string("vcard.xml")).string());

+

+ VCardParser parser;

+ PayloadParserTester tester(&parser);

+ tester.parse(byteArrayToString(data));

+ return std::dynamic_pointer_cast<VCard>(parser.getPayload());

+ }

+ else {

+ return std::make_shared<VCard>();

+ }

+void FileVCardCollection::setOwnVCard(std::shared_ptr<VCard> v) {

+ boost::filesystem::ofstream file(vcardsPath / std::string("vcard.xml"));

+ file << VCardSerializer().serializePayload(v);

+ file.close();

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+

+#include <Slimber/VCardCollection.h>

+ class FileVCardCollection : public VCardCollection {

+ public:

+ FileVCardCollection(boost::filesystem::path dir);

+ std::shared_ptr<VCard> getOwnVCard() const;

+ void setOwnVCard(std::shared_ptr<VCard> vcard);

+ private:

+ boost::filesystem::path vcardsPath;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Slimber/LinkLocalPresenceManager.h>

+#include <Swiften/Elements/RosterPayload.h>

+#include <Swiften/LinkLocal/LinkLocalServiceBrowser.h>

+ browser->onServiceAdded.connect(

+ boost::bind(&LinkLocalPresenceManager::handleServiceAdded, this, _1));

+ browser->onServiceChanged.connect(

+ boost::bind(&LinkLocalPresenceManager::handleServiceChanged, this, _1));

+ browser->onServiceRemoved.connect(

+ boost::bind(&LinkLocalPresenceManager::handleServiceRemoved, this, _1));

+ for (const auto& service : browser->getServices()) {

+ if (service.getJID() == j) {

+ return service;

+ }

+ }

+ return boost::optional<LinkLocalService>();

+ std::shared_ptr<RosterPayload> roster(new RosterPayload());

+ roster->addItem(getRosterItem(service));

+ onRosterChanged(roster);

+ onPresenceChanged(getPresence(service));

+ onPresenceChanged(getPresence(service));

+ std::shared_ptr<RosterPayload> roster(new RosterPayload());

+ roster->addItem(RosterItemPayload(service.getJID(), "", RosterItemPayload::Remove));

+ onRosterChanged(roster);

+std::shared_ptr<RosterPayload> LinkLocalPresenceManager::getRoster() const {

+ std::shared_ptr<RosterPayload> roster(new RosterPayload());

+ for (const auto& service : browser->getServices()) {

+ roster->addItem(getRosterItem(service));

+ }

+ return roster;

+std::vector<std::shared_ptr<Presence> > LinkLocalPresenceManager::getAllPresence() const {

+ std::vector<std::shared_ptr<Presence> > result;

+ for (const auto& service : browser->getServices()) {

+ result.push_back(getPresence(service));

+ }

+ return result;

+ return RosterItemPayload(service.getJID(), getRosterName(service), RosterItemPayload::Both);

+ LinkLocalServiceInfo info = service.getInfo();

+ if (!info.getNick().empty()) {

+ return info.getNick();

+ }

+ else if (!info.getFirstName().empty()) {

+ std::string result = info.getFirstName();

+ if (!info.getLastName().empty()) {

+ result += " " + info.getLastName();

+ }

+ return result;

+ }

+ else if (!info.getLastName().empty()) {

+ return info.getLastName();

+ }

+ return "";

+std::shared_ptr<Presence> LinkLocalPresenceManager::getPresence(const LinkLocalService& service) const {

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

+ presence->setFrom(service.getJID());

+ switch (service.getInfo().getStatus()) {

+ case LinkLocalServiceInfo::Available:

+ presence->setShow(StatusShow::Online);

+ break;

+ case LinkLocalServiceInfo::Away:

+ presence->setShow(StatusShow::Away);

+ break;

+ case LinkLocalServiceInfo::DND:

+ presence->setShow(StatusShow::DND);

+ break;

+ }

+ presence->setStatus(service.getInfo().getMessage());

+ return presence;

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+#include <string>

+

+#include <boost/signals2.hpp>

+ class LinkLocalService;

+ class LinkLocalServiceBrowser;

+ class RosterPayload;

+ class Presence;

+ class LinkLocalPresenceManager : public boost::signals2::trackable {

+ public:

+ LinkLocalPresenceManager(LinkLocalServiceBrowser*);

+ std::shared_ptr<RosterPayload> getRoster() const;

+ std::vector<std::shared_ptr<Presence> > getAllPresence() const;

+ boost::optional<LinkLocalService> getServiceForJID(const JID&) const;

+ boost::signals2::signal<void (std::shared_ptr<RosterPayload>)> onRosterChanged;

+ boost::signals2::signal<void (std::shared_ptr<Presence>)> onPresenceChanged;

+ private:

+ void handleServiceAdded(const LinkLocalService&);

+ void handleServiceChanged(const LinkLocalService&);

+ void handleServiceRemoved(const LinkLocalService&);

+ RosterItemPayload getRosterItem(const LinkLocalService& service) const;

+ std::string getRosterName(const LinkLocalService& service) const;

+ std::shared_ptr<Presence> getPresence(const LinkLocalService& service) const;

+ private:

+ LinkLocalServiceBrowser* browser;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Slimber/MainController.h>

+#include <Swiften/LinkLocal/DNSSD/PlatformDNSSDQuerierFactory.h>

+

+#include <Slimber/FileVCardCollection.h>

+#include <Slimber/Menulet.h>

+#include <Slimber/MenuletController.h>

+#include <Slimber/Server.h>

+

+#include <SwifTools/Application/PlatformApplicationPathProvider.h>

+ dnsSDQuerier = PlatformDNSSDQuerierFactory(eventLoop).createQuerier();

+ assert(dnsSDQuerier);

+ linkLocalServiceBrowser = new LinkLocalServiceBrowser(dnsSDQuerier);

+ linkLocalServiceBrowser->onServiceAdded.connect(

+ boost::bind(&MainController::handleServicesChanged, this));

+ linkLocalServiceBrowser->onServiceRemoved.connect(

+ boost::bind(&MainController::handleServicesChanged, this));

+ linkLocalServiceBrowser->onServiceChanged.connect(

+ boost::bind(&MainController::handleServicesChanged, this));

+ vCardCollection = new FileVCardCollection(

+ PlatformApplicationPathProvider("Slimber").getDataDir());

+ server = new Server(5222, 5562, linkLocalServiceBrowser, vCardCollection, eventLoop);

+ server->onStopped.connect(

+ boost::bind(&MainController::handleServerStopped, this, _1));

+ server->onSelfConnected.connect(

+ boost::bind(&MainController::handleSelfConnected, this, _1));

+ menuletController = new MenuletController(menulet);

+ menuletController->onRestartRequested.connect(boost::bind(

+ &MainController::handleRestartRequested, this));

+ start();

+ delete server;

+ delete menuletController;

+ delete vCardCollection;

+ linkLocalServiceBrowser->stop();

+ delete linkLocalServiceBrowser;

+ dnsSDQuerier->stop();

+ dnsSDQuerier->start();

+ linkLocalServiceBrowser->start();

+ handleSelfConnected(false);

+ handleServicesChanged();

+ server->start();

+ server->stop();

+ linkLocalServiceBrowser->stop();

+ dnsSDQuerier->stop();

+ if (b) {

+ menuletController->setXMPPStatus("You are logged in", MenuletController::Online);

+ }

+ else {

+ menuletController->setXMPPStatus("You are not logged in", MenuletController::Offline);

+ }

+ std::vector<std::string> names;

+ for (const auto& service : linkLocalServiceBrowser->getServices()) {

+ std::string description = service.getDescription();

+ if (description != service.getName()) {

+ description += " (" + service.getName() + ")";

+ }

+ names.push_back(description);

+ }

+ menuletController->setUserNames(names);

+ if (error) {

+ std::string message;

+ switch (error->getType()) {

+ case ServerError::C2SPortConflict:

+ message = std::string("Error: Port ") + boost::lexical_cast<std::string>(server->getClientToServerPort()) + std::string(" in use");

+ break;

+ case ServerError::C2SError:

+ message = std::string("Local connection server error");

+ break;

+ case ServerError::LinkLocalPortConflict:

+ message = std::string("Error: Port ") + boost::lexical_cast<std::string>(server->getLinkLocalPort()) + std::string(" in use");

+ break;

+ case ServerError::LinkLocalError:

+ message = std::string("External connection server error");

+ break;

+ }

+ menuletController->setXMPPStatus(message, MenuletController::Offline);

+ }

+ else {

+ menuletController->setXMPPStatus("XMPP Server Not Running", MenuletController::Offline);

+ }

+ stop();

+ start();

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+

+#include <Slimber/ServerError.h>

+ class DNSSDQuerier;

+ class LinkLocalServiceBrowser;

+ class VCardCollection;

+ class Server;

+ class EventLoop;

+ public:

+ MainController(Menulet* menulet, Swift::EventLoop* eventLoop);

+ virtual ~MainController();

+

+ private:

+ void handleSelfConnected(bool b);

+ void handleServicesChanged();

+ void handleServerStopped(boost::optional<Swift::ServerError> error);

+ void handleRestartRequested();

+

+ void start();

+ void stop();

+

+ private:

+ std::shared_ptr<Swift::DNSSDQuerier> dnsSDQuerier;

+ Swift::LinkLocalServiceBrowser* linkLocalServiceBrowser;

+ Swift::VCardCollection* vCardCollection;

+ Swift::Server* server;

+ MenuletController* menuletController;

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Slimber/Menulet.h>

+ * Copyright (c) 2010-2016 Isode Limited.

+

+#include <boost/signals2.hpp>

+ public:

+ virtual ~Menulet();

+ virtual void clear() = 0;

+ virtual void addItem(const std::string& name, const std::string& icon = std::string()) = 0;

+ virtual void addAboutItem() = 0;

+ virtual void addRestartItem() = 0;

+ virtual void addExitItem() = 0;

+ virtual void addSeparator() = 0;

+ virtual void setIcon(const std::string&) = 0;

+ boost::signals2::signal<void ()> onRestartClicked;

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Slimber/MenuletController.h>

+#include <Slimber/Menulet.h>

+MenuletController::MenuletController(Menulet* menulet) :

+ menulet(menulet), xmppStatus(Offline) {

+ menulet->onRestartClicked.connect(boost::ref(onRestartRequested));

+ update();

+ xmppStatus = status;

+ xmppStatusMessage = message;

+ update();

+ linkLocalUsers = users;

+ update();

+ menulet->clear();

+ if (linkLocalUsers.empty()) {

+ menulet->setIcon("UsersOffline");

+ menulet->addItem("No online users");

+ }

+ else {

+ menulet->setIcon("UsersOnline");

+ menulet->addItem("Online users:");

+ for (const auto& user : linkLocalUsers) {

+ menulet->addItem(std::string(" ") + user);

+ }

+ }

+ menulet->addSeparator();

+ menulet->addItem(xmppStatusMessage, (xmppStatus == Online ? "Online" : "Offline"));

+ menulet->addSeparator();

+ menulet->addAboutItem();

+ menulet->addSeparator();

+ menulet->addRestartItem();

+ menulet->addExitItem();

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <string>

+#include <boost/signals2.hpp>

+ public:

+ enum Status {

+ Online,

+ Offline

+ };

+

+ MenuletController(Menulet*);

+ virtual ~MenuletController();

+

+ void setXMPPStatus(const std::string& message, Status status);

+ void setUserNames(const std::vector<std::string>&);

+

+ boost::signals2::signal<void ()> onRestartRequested;

+

+ private:

+ void update();

+

+ private:

+ Menulet* menulet;

+ Status xmppStatus;

+ std::string xmppStatusMessage;

+ std::vector<std::string> linkLocalUsers;

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Slimber/Qt/QtAboutDialog.h>

+#include <QVBoxLayout>

+ setAttribute(Qt::WA_DeleteOnClose);

+ setWindowTitle("About Slimber");

+

+ QVBoxLayout* layout = new QVBoxLayout(this);

+

+ QLabel* iconLabel = new QLabel(this);

+ iconLabel->setPixmap(QPixmap(":/icons/Icon-128.png"));

+ iconLabel->setAlignment(Qt::AlignHCenter);

+ layout->addWidget(iconLabel);

+

+ QLabel* appNameLabel = new QLabel("<center><font size='+1'><b>" + QCoreApplication::applicationName() + "</b></font></center>", this);

+ layout->addWidget(appNameLabel);

+

+ QLabel* versionLabel = new QLabel(QString("<center><font size='-1'>Version ") + QCoreApplication::applicationVersion() + "</font></center>", this);

+ layout->addWidget(versionLabel);

+ QString buildString = QString("<center><font size='-1'>Built with: Qt version ") + QT_VERSION_STR;

+ buildString += QString("<br/>Running with Qt version ") + qVersion();

+ buildString += "</font></center>";

+ QLabel* buildLabel = new QLabel(buildString, this);

+ layout->addWidget(buildLabel);

+

+ setFixedSize(minimumSizeHint());

+ public:

+ QtAboutDialog();

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Slimber/Qt/QtMenulet.h>

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <QString>

+#include <QSystemTrayIcon>

+#include <Slimber/Menulet.h>

+#include <Slimber/Qt/QtAboutDialog.h>

+ Q_OBJECT

+ public:

+ QtMenulet() {

+ trayIcon.setIcon(QPixmap(":/icons/UsersOffline.png"));

+ trayIcon.setContextMenu(&menu);

+ trayIcon.show();

+ }

+ void clear() {

+ menu.clear();

+ }

+ void addItem(const std::string& name, const std::string& icon) {

+ menu.addAction(getIcon(icon), QString::fromUtf8(name.c_str()));

+ }

+ void addAboutItem() {

+ menu.addAction("About", this, SLOT(showAboutDialog()));

+ }

+ void addRestartItem() {

+ menu.addAction("Restart", this, SLOT(restart()));

+ }

+ void addExitItem() {

+ menu.addAction("Exit", qApp, SLOT(quit()));

+ }

+ void addSeparator() {

+ menu.addSeparator();

+ }

+ void setIcon(const std::string& icon) {

+ trayIcon.setIcon(getIcon(icon));

+ }

+ private:

+ QPixmap getIcon(const std::string& name) {

+ return QPixmap(":/icons/" + QString::fromUtf8(name.c_str()) + ".png");

+ }

+ private slots:

+ void showAboutDialog() {

+ if (aboutDialog) {

+ aboutDialog->raise();

+ aboutDialog->activateWindow();

+ }

+ else {

+ aboutDialog = new QtAboutDialog();

+ aboutDialog->show();

+ }

+ }

+ void restart() {

+ onRestartClicked();

+ }

+ private:

+ QMenu menu;

+ QSystemTrayIcon trayIcon;

+ QPointer<QtAboutDialog> aboutDialog;

+ myenv.MergeFlags(env["ICU_FLAGS"])

+ myenv.Append(CPPDEFINES = ["HAVE_ICU"])

+ myenv.MergeFlags(env["LIBIDN_FLAGS"])

+ myenv.Append(CPPDEFINES = ["HAVE_LIBIDN"])

+ qt_version = '5'

+ qt4modules += ['QtWidgets']

+ qt_version = '4'

+ myenv.Append(LINKFLAGS = ["/SUBSYSTEM:WINDOWS"])

+ myenv.Append(LIBS = "qtmain")

+ "main.cpp",

+ "QtMenulet.cpp",

+ "QtAboutDialog.cpp",

+ myenv.Qrc("Slimber.qrc"),

+ ]

+# myenv.RES("../resources/Windows/Slimber.rc")

+# sources += ["../resources/Windows/Slimber.res"]

+ slimberProgram = myenv.Program("Slimber", sources)

+ slimberProgram = myenv.Program("slimber", sources)

+ if "dist" in COMMAND_LINE_TARGETS or env.GetOption("clean") :

+ myenv.WindowsBundle("Slimber", resources = {}, qtlibs = ["QtCore4", "QtGui4"])

+ myenv.Append(NSIS_OPTIONS = [

+ "/DmsvccRedistributableDir=\"" + env["vcredist"] + "\"",

+ "/DbuildDate=" + datetime.date.today().strftime("%Y%m%d")

+ ])

+ #myenv.Nsis("../Packaging/nsis/slimber.nsi")

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <QSystemTrayIcon>

+

+#include <Slimber/MainController.h>

+#include <Slimber/Qt/QtMenulet.h>

+ QApplication app(argc, argv);

+ Swift::QtEventLoop eventLoop;

+ QCoreApplication::setApplicationName("Slimber");

+ QCoreApplication::setApplicationVersion(QString(buildVersion));

+ if (!QSystemTrayIcon::isSystemTrayAvailable()) {

+ return 1;

+ }

+ app.setQuitOnLastWindowClosed(false);

+ QtMenulet menulet;

+ MainController controller(&menulet, &eventLoop);

+ return app.exec();

+ if not env.get("HAVE_BONJOUR") and "Slimber" in env["PROJECTS"] :

+ env["PROJECTS"].remove("Slimber")

+ if not env.get("HAVE_AVAHI", False) and "Slimber" in env["PROJECTS"] :

+ env["PROJECTS"].remove("Slimber")

+ print "Bonjour missing. Not building Slimber."

+ print "Qt missing. Not building Slimber."

+ env["PROJECTS"].remove("Slimber")

+ if env["SCONS_STAGE"] == "flags" :

+ env["SLIMBER_FLAGS"] = {

+ "LIBPATH": [Dir(".")],

+ "LIBS": ["Slimber"]

+ }

+ if env["SCONS_STAGE"] == "build" :

+ myenv = env.Clone()

+ myenv.UseFlags(env["LIMBER_FLAGS"])

+ myenv.MergeFlags(env["BOOST_FLAGS"])

+ myenv.MergeFlags(env["SWIFTEN_FLAGS"])

+ myenv.MergeFlags(env["SWIFTEN_DEP_FLAGS"])

+ myenv.StaticLibrary("Slimber", [

+ "LinkLocalPresenceManager.cpp",

+ "FileVCardCollection.cpp",

+ "VCardCollection.cpp",

+ "Server.cpp",

+ "MainController.cpp",

+ "MenuletController.cpp",

+ "Menulet.cpp"

+ ])

+ env["SLIMBER_VERSION"] = "0.9.9." + datetime.date.today().strftime("%Y%m%d")

+ env.Append(UNITTEST_SOURCES = [

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

+ File("UnitTest/MenuletControllerTest.cpp")

+ ])

+ SConscript("CLI/SConscript")

+ if env["PLATFORM"] == "darwin" :

+ SConscript("Cocoa/SConscript")

+ else :

+ SConscript("Qt/SConscript")

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Slimber/Server.h>

+#include <cassert>

+

+

+#include <Swiften/Base/Log.h>

+#include <Swiften/Base/String.h>

+#include <Swiften/Elements/IQ.h>

+#include <Swiften/Elements/Presence.h>

+#include <Swiften/Elements/RosterPayload.h>

+#include <Swiften/Elements/ToplevelElement.h>

+#include <Swiften/Elements/VCard.h>

+#include <Swiften/LinkLocal/LinkLocalConnector.h>

+#include <Swiften/LinkLocal/LinkLocalServiceInfo.h>

+#include <Swiften/LinkLocal/OutgoingLinkLocalSession.h>

+#include <Swiften/Network/BoostConnection.h>

+#include <Swiften/Network/BoostConnectionServer.h>

+#include <Swiften/Network/Connection.h>

+#include <Swiften/Session/Session.h>

+#include <Swiften/Session/SessionTracer.h>

+

+#include <Limber/Server/ServerFromClientSession.h>

+#include <Limber/Server/UserRegistry.h>

+

+#include <Slimber/LinkLocalPresenceManager.h>

+#include <Slimber/VCardCollection.h>

+ int clientConnectionPort,

+ int linkLocalConnectionPort,

+ LinkLocalServiceBrowser* linkLocalServiceBrowser,

+ VCardCollection* vCardCollection,

+ EventLoop* eventLoop) :

+ linkLocalServiceRegistered(false),

+ rosterRequested(false),

+ clientConnectionPort(clientConnectionPort),

+ linkLocalConnectionPort(linkLocalConnectionPort),

+ linkLocalServiceBrowser(linkLocalServiceBrowser),

+ vCardCollection(vCardCollection),

+ eventLoop(eventLoop),

+ presenceManager(nullptr),

+ stopping(false) {

+ linkLocalServiceBrowser->onServiceRegistered.connect(

+ boost::bind(&Server::handleServiceRegistered, this, _1));

+ stop();

+ assert(!serverFromClientConnectionServer);

+ serverFromClientConnectionServer = BoostConnectionServer::create(

+ clientConnectionPort, boostIOServiceThread.getIOService(), eventLoop);

+ serverFromClientConnectionServerSignalConnections.push_back(

+ serverFromClientConnectionServer->onNewConnection.connect(

+ boost::bind(&Server::handleNewClientConnection, this, _1)));

+ serverFromClientConnectionServerSignalConnections.push_back(

+ serverFromClientConnectionServer->onStopped.connect(

+ boost::bind(&Server::handleClientConnectionServerStopped, this, _1)));

+

+ assert(!serverFromNetworkConnectionServer);

+ serverFromNetworkConnectionServer = BoostConnectionServer::create(

+ linkLocalConnectionPort, boostIOServiceThread.getIOService(), eventLoop);

+ serverFromNetworkConnectionServerSignalConnections.push_back(

+ serverFromNetworkConnectionServer->onNewConnection.connect(

+ boost::bind(&Server::handleNewLinkLocalConnection, this, _1)));

+ serverFromNetworkConnectionServerSignalConnections.push_back(

+ serverFromNetworkConnectionServer->onStopped.connect(

+ boost::bind(&Server::handleLinkLocalConnectionServerStopped, this, _1)));

+

+ assert(!presenceManager);

+ presenceManager = new LinkLocalPresenceManager(linkLocalServiceBrowser);

+ presenceManager->onRosterChanged.connect(

+ boost::bind(&Server::handleRosterChanged, this, _1));

+ presenceManager->onPresenceChanged.connect(

+ boost::bind(&Server::handlePresenceChanged, this, _1));

+

+ serverFromClientConnectionServer->start();

+ serverFromNetworkConnectionServer->start();

+ stop(boost::optional<ServerError>());

+ if (stopping) {

+ return;

+ }

+

+ stopping = true;

+

+ delete presenceManager;

+ presenceManager = nullptr;

+

+ if (serverFromClientSession) {

+ serverFromClientSession->finishSession();

+ }

+ serverFromClientSession.reset();

+ for (auto&& session : linkLocalSessions) {

+ session->finishSession();

+ }

+ linkLocalSessions.clear();

+ for (auto&& connector : connectors) {

+ connector->cancel();

+ }

+ connectors.clear();

+ tracers.clear();

+

+ if (serverFromNetworkConnectionServer) {

+ serverFromNetworkConnectionServer->stop();

+ for (auto&& connection : serverFromNetworkConnectionServerSignalConnections) {

+ connection.disconnect();

+ }

+ serverFromNetworkConnectionServerSignalConnections.clear();

+ serverFromNetworkConnectionServer.reset();

+ }

+ if (serverFromClientConnectionServer) {

+ serverFromClientConnectionServer->stop();

+ for (auto&& connection : serverFromClientConnectionServerSignalConnections) {

+ connection.disconnect();

+ }

+ serverFromClientConnectionServerSignalConnections.clear();

+ serverFromClientConnectionServer.reset();

+ }

+

+ stopping = false;

+ onStopped(e);

+void Server::handleNewClientConnection(std::shared_ptr<Connection> connection) {

+ if (serverFromClientSession) {

+ connection->disconnect();

+ }

+ serverFromClientSession = std::shared_ptr<ServerFromClientSession>(

+ new ServerFromClientSession(idGenerator.generateID(), connection,

+ &payloadParserFactories, &payloadSerializers, &xmlParserFactory, &userRegistry));

+ serverFromClientSession->setAllowSASLEXTERNAL();

+ serverFromClientSession->onSessionStarted.connect(

+ boost::bind(&Server::handleSessionStarted, this));

+ serverFromClientSession->onElementReceived.connect(

+ boost::bind(&Server::handleElementReceived, this, _1,

+ serverFromClientSession));

+ serverFromClientSession->onSessionFinished.connect(

+ boost::bind(&Server::handleSessionFinished, this,

+ serverFromClientSession));

+ //tracers.push_back(std::shared_ptr<SessionTracer>(

+ // new SessionTracer(serverFromClientSession)));

+ serverFromClientSession->startSession();

+ onSelfConnected(true);

+void Server::handleSessionFinished(std::shared_ptr<ServerFromClientSession>) {

+ serverFromClientSession.reset();

+ unregisterService();

+ selfJID = JID();

+ rosterRequested = false;

+ onSelfConnected(false);

+ lastPresence.reset();

+ if (linkLocalServiceRegistered) {

+ linkLocalServiceRegistered = false;

+ linkLocalServiceBrowser->unregisterService();

+ }

+void Server::handleElementReceived(std::shared_ptr<ToplevelElement> element, std::shared_ptr<ServerFromClientSession> session) {

+ std::shared_ptr<Stanza> stanza = std::dynamic_pointer_cast<Stanza>(element);

+ if (!stanza) {

+ return;

+ }

+

+ stanza->setFrom(session->getRemoteJID());

+ if (!stanza->getTo().isValid()) {

+ stanza->setTo(session->getLocalJID());

+ }

+

+ if (std::shared_ptr<Presence> presence = std::dynamic_pointer_cast<Presence>(stanza)) {

+ if (presence->getType() == Presence::Available) {

+ if (!linkLocalServiceRegistered) {

+ linkLocalServiceRegistered = true;

+ linkLocalServiceBrowser->registerService(

+ session->getRemoteJID().toBare().toString(),

+ linkLocalConnectionPort, getLinkLocalServiceInfo(presence));

+ }

+ else {

+ linkLocalServiceBrowser->updateService(

+ getLinkLocalServiceInfo(presence));

+ }

+ lastPresence = presence;

+ }

+ else {

+ unregisterService();

+ }

+ }

+ else if (!stanza->getTo().isValid() || stanza->getTo() == session->getLocalJID() || stanza->getTo() == session->getRemoteJID().toBare()) {

+ if (std::shared_ptr<IQ> iq = std::dynamic_pointer_cast<IQ>(stanza)) {

+ if (iq->getPayload<RosterPayload>()) {

+ if (iq->getType() == IQ::Get) {

+ session->sendElement(IQ::createResult(iq->getFrom(), iq->getID(), presenceManager->getRoster()));

+ rosterRequested = true;

+ for (const auto& presence : presenceManager->getAllPresence()) {

+ session->sendElement(presence);

+ }

+ }

+ else {

+ session->sendElement(IQ::createError(iq->getFrom(), iq->getID(), ErrorPayload::Forbidden, ErrorPayload::Cancel));

+ }

+ }

+ if (std::shared_ptr<VCard> vcard = iq->getPayload<VCard>()) {

+ if (iq->getType() == IQ::Get) {

+ session->sendElement(IQ::createResult(iq->getFrom(), iq->getID(), vCardCollection->getOwnVCard()));

+ }

+ else {

+ vCardCollection->setOwnVCard(vcard);

+ session->sendElement(IQ::createResult(iq->getFrom(), iq->getID()));

+ if (lastPresence) {

+ linkLocalServiceBrowser->updateService(getLinkLocalServiceInfo(lastPresence));

+ }

+ }

+ }

+ else {

+ session->sendElement(IQ::createError(iq->getFrom(), iq->getID(), ErrorPayload::FeatureNotImplemented, ErrorPayload::Cancel));

+ }

+ }

+ }

+ else {

+ JID toJID = stanza->getTo();

+ std::shared_ptr<Session> outgoingSession =

+ getLinkLocalSessionForJID(toJID);

+ if (outgoingSession) {

+ outgoingSession->sendElement(stanza);

+ }

+ else {

+ boost::optional<LinkLocalService> service =

+ presenceManager->getServiceForJID(toJID);

+ if (service) {

+ std::shared_ptr<LinkLocalConnector> connector =

+ getLinkLocalConnectorForJID(toJID);

+ if (!connector) {

+ connector = std::shared_ptr<LinkLocalConnector>(

+ new LinkLocalConnector(

+ *service,

+ linkLocalServiceBrowser->getQuerier(),

+ BoostConnection::create(boostIOServiceThread.getIOService(), eventLoop)));

+ connector->onConnectFinished.connect(

+ boost::bind(&Server::handleConnectFinished, this, connector, _1));

+ connectors.push_back(connector);

+ connector->connect();

+ }

+ connector->queueElement(element);

+ }

+ else {

+ session->sendElement(IQ::createError(

+ stanza->getFrom(), stanza->getID(),

+ ErrorPayload::RecipientUnavailable, ErrorPayload::Wait));

+ }

+ }

+ }

+void Server::handleNewLinkLocalConnection(std::shared_ptr<Connection> connection) {

+ std::shared_ptr<IncomingLinkLocalSession> session(

+ new IncomingLinkLocalSession(

+ selfJID, connection,

+ &payloadParserFactories, &payloadSerializers, &xmlParserFactory));

+ registerLinkLocalSession(session);

+void Server::handleLinkLocalSessionFinished(std::shared_ptr<Session> session) {

+ //std::cout << "Link local session from " << session->getRemoteJID() << " ended" << std::endl;

+ linkLocalSessions.erase(

+ std::remove(linkLocalSessions.begin(), linkLocalSessions.end(), session),

+ linkLocalSessions.end());

+void Server::handleLinkLocalElementReceived(std::shared_ptr<ToplevelElement> element, std::shared_ptr<Session> session) {

+ if (std::shared_ptr<Stanza> stanza = std::dynamic_pointer_cast<Stanza>(element)) {

+ JID fromJID = session->getRemoteJID();

+ if (!presenceManager->getServiceForJID(fromJID.toBare())) {

+ return; // TODO: Send error back

+ }

+ stanza->setFrom(fromJID);

+ serverFromClientSession->sendElement(stanza);

+ }

+void Server::handleConnectFinished(std::shared_ptr<LinkLocalConnector> connector, bool error) {

+ if (error) {

+ SWIFT_LOG(warning) << "Error connecting" << std::endl;

+ // TODO: Send back queued stanzas

+ }

+ else {

+ std::shared_ptr<OutgoingLinkLocalSession> outgoingSession(

+ new OutgoingLinkLocalSession(

+ selfJID, connector->getService().getJID(), connector->getConnection(),

+ &payloadParserFactories, &payloadSerializers, &xmlParserFactory));

+ for (const auto& element : connector->getQueuedElements()) {

+ outgoingSession->queueElement(element);

+ }

+ registerLinkLocalSession(outgoingSession);

+ }

+ connectors.erase(std::remove(connectors.begin(), connectors.end(), connector), connectors.end());

+void Server::registerLinkLocalSession(std::shared_ptr<Session> session) {

+ session->onSessionFinished.connect(

+ boost::bind(&Server::handleLinkLocalSessionFinished, this, session));

+ session->onElementReceived.connect(

+ boost::bind(&Server::handleLinkLocalElementReceived, this, _1, session));

+ linkLocalSessions.push_back(session);

+ //tracers.push_back(std::make_shared<SessionTracer>(session));

+ session->startSession();

+std::shared_ptr<Session> Server::getLinkLocalSessionForJID(const JID& jid) {

+ for (const auto& session : linkLocalSessions) {

+ if (session->getRemoteJID() == jid) {

+ return session;

+ }

+ }

+ return std::shared_ptr<Session>();

+std::shared_ptr<LinkLocalConnector> Server::getLinkLocalConnectorForJID(const JID& jid) {

+ for (const auto& connector : connectors) {

+ if (connector->getService().getJID() == jid) {

+ return connector;

+ }

+ }

+ return std::shared_ptr<LinkLocalConnector>();

+ selfJID = JID(service.getName());

+void Server::handleRosterChanged(std::shared_ptr<RosterPayload> roster) {

+ if (rosterRequested) {

+ assert(serverFromClientSession);

+ std::shared_ptr<IQ> iq = IQ::createRequest(

+ IQ::Set, serverFromClientSession->getRemoteJID(),

+ idGenerator.generateID(), roster);

+ iq->setFrom(serverFromClientSession->getRemoteJID().toBare());

+ serverFromClientSession->sendElement(iq);

+ }

+void Server::handlePresenceChanged(std::shared_ptr<Presence> presence) {

+ if (rosterRequested) {

+ serverFromClientSession->sendElement(presence);

+ }

+ if (e) {

+ if (*e == BoostConnectionServer::Conflict) {

+ stop(ServerError(ServerError::C2SPortConflict));

+ }

+ else {

+ stop(ServerError(ServerError::C2SError));

+ }

+ }

+ else {

+ stop();

+ }

+ if (e) {

+ if (*e == BoostConnectionServer::Conflict) {

+ stop(ServerError(ServerError::LinkLocalPortConflict));

+ }

+ else {

+ stop(ServerError(ServerError::LinkLocalError));

+ }

+ }

+ else {

+ stop();

+ }

+LinkLocalServiceInfo Server::getLinkLocalServiceInfo(std::shared_ptr<Presence> presence) {

+ LinkLocalServiceInfo info;

+ std::shared_ptr<VCard> vcard = vCardCollection->getOwnVCard();

+ if (!vcard->getFamilyName().empty() || !vcard->getGivenName().empty()) {

+ info.setFirstName(vcard->getGivenName());

+ info.setLastName(vcard->getFamilyName());

+ }

+ else if (!vcard->getFullName().empty()) {

+ std::pair<std::string,std::string> p = String::getSplittedAtFirst(vcard->getFullName(), ' ');

+ info.setFirstName(p.first);

+ info.setLastName(p.second);

+ }

+ if (!vcard->getNickname().empty()) {

+ info.setNick(vcard->getNickname());

+ }

+ if (!vcard->getPreferredEMailAddress().address.empty()) {

+ info.setEMail(vcard->getPreferredEMailAddress().address);

+ }

+ info.setMessage(presence->getStatus());

+ switch (presence->getShow()) {

+ case StatusShow::Online:

+ case StatusShow::None:

+ case StatusShow::FFC:

+ info.setStatus(LinkLocalServiceInfo::Available);

+ break;

+ case StatusShow::Away:

+ case StatusShow::XA:

+ info.setStatus(LinkLocalServiceInfo::Away);

+ break;

+ case StatusShow::DND:

+ info.setStatus(LinkLocalServiceInfo::DND);

+ break;

+ }

+ info.setPort(linkLocalConnectionPort);

+ return info;

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+#include <boost/optional.hpp>

+

+#include <Swiften/Base/IDGenerator.h>

+#include <Swiften/JID/JID.h>

+#include <Swiften/LinkLocal/LinkLocalServiceInfo.h>

+#include <Swiften/Network/BoostConnectionServer.h>

+#include <Swiften/Network/BoostIOServiceThread.h>

+#include <Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h>

+#include <Swiften/Parser/PlatformXMLParserFactory.h>

+#include <Swiften/Serializer/PayloadSerializers/FullPayloadSerializerCollection.h>

+

+#include <Limber/Server/ServerFromClientSession.h>

+#include <Limber/Server/UserRegistry.h>

+

+#include <Slimber/ServerError.h>

+ class DNSSDServiceID;

+

+ class VCardCollection;

+ class LinkLocalConnector;

+ class LinkLocalServiceBrowser;

+ class LinkLocalPresenceManager;

+ class BoostConnectionServer;

+ class SessionTracer;

+ class RosterPayload;

+ class Presence;

+ class EventLoop;

+

+ class Server {

+ public:

+ Server(

+ int clientConnectionPort,

+ int linkLocalConnectionPort,

+ LinkLocalServiceBrowser* browser,

+ VCardCollection* vCardCollection,

+ EventLoop* eventLoop);

+ ~Server();

+

+ void start();

+ void stop();

+

+ int getLinkLocalPort() const {

+ return linkLocalConnectionPort;

+ }

+

+ int getClientToServerPort() const {

+ return clientConnectionPort;

+ }

+

+ boost::signals2::signal<void (bool)> onSelfConnected;

+ boost::signals2::signal<void (boost::optional<ServerError>)> onStopped;

+

+ private:

+ void stop(boost::optional<ServerError>);

+

+ void handleNewClientConnection(std::shared_ptr<Connection> c);

+ void handleSessionStarted();

+ void handleSessionFinished(std::shared_ptr<ServerFromClientSession>);

+ void handleElementReceived(std::shared_ptr<ToplevelElement> element, std::shared_ptr<ServerFromClientSession> session);

+ void handleRosterChanged(std::shared_ptr<RosterPayload> roster);

+ void handlePresenceChanged(std::shared_ptr<Presence> presence);

+ void handleServiceRegistered(const DNSSDServiceID& service);

+ void handleNewLinkLocalConnection(std::shared_ptr<Connection> connection);

+ void handleLinkLocalSessionFinished(std::shared_ptr<Session> session);

+ void handleLinkLocalElementReceived(std::shared_ptr<ToplevelElement> element, std::shared_ptr<Session> session);

+ void handleConnectFinished(std::shared_ptr<LinkLocalConnector> connector, bool error);

+ void handleClientConnectionServerStopped(

+ boost::optional<BoostConnectionServer::Error>);

+ void handleLinkLocalConnectionServerStopped(

+ boost::optional<BoostConnectionServer::Error>);

+ std::shared_ptr<Session> getLinkLocalSessionForJID(const JID& jid);

+ std::shared_ptr<LinkLocalConnector> getLinkLocalConnectorForJID(const JID& jid);

+ void registerLinkLocalSession(std::shared_ptr<Session> session);

+ void unregisterService();

+ LinkLocalServiceInfo getLinkLocalServiceInfo(std::shared_ptr<Presence> presence);

+

+ private:

+ class DummyUserRegistry : public UserRegistry {

+ public:

+ DummyUserRegistry() {}

+

+ virtual bool isValidUserPassword(const JID&, const SafeByteArray&) const {

+ return true;

+ }

+ };

+

+ private:

+ IDGenerator idGenerator;

+ FullPayloadParserFactoryCollection payloadParserFactories;

+ FullPayloadSerializerCollection payloadSerializers;

+ BoostIOServiceThread boostIOServiceThread;

+ DummyUserRegistry userRegistry;

+ PlatformXMLParserFactory xmlParserFactory;

+ bool linkLocalServiceRegistered;

+ bool rosterRequested;

+ int clientConnectionPort;

+ int linkLocalConnectionPort;

+ LinkLocalServiceBrowser* linkLocalServiceBrowser;

+ VCardCollection* vCardCollection;

+ EventLoop* eventLoop;

+ LinkLocalPresenceManager* presenceManager;

+ bool stopping;

+ std::shared_ptr<BoostConnectionServer> serverFromClientConnectionServer;

+ std::vector<boost::signals2::connection> serverFromClientConnectionServerSignalConnections;

+ std::shared_ptr<ServerFromClientSession> serverFromClientSession;

+ std::shared_ptr<Presence> lastPresence;

+ JID selfJID;

+ std::shared_ptr<BoostConnectionServer> serverFromNetworkConnectionServer;

+ std::vector<boost::signals2::connection> serverFromNetworkConnectionServerSignalConnections;

+ std::vector< std::shared_ptr<Session> > linkLocalSessions;

+ std::vector< std::shared_ptr<LinkLocalConnector> > connectors;

+ std::vector< std::shared_ptr<SessionTracer> > tracers;

+ };

+ class ServerError {

+ public:

+ enum Type {

+ C2SPortConflict,

+ C2SError,

+ LinkLocalPortConflict,

+ LinkLocalError

+ };

+ ServerError(Type type, const std::string& message = std::string()) :

+ type(type), message(message) {

+ }

+ Type getType() const {

+ return type;

+ }

+ const std::string& getMessage() const {

+ return message;

+ }

+ private:

+ Type type;

+ std::string message;

+ };

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <map>

+

+#include <boost/bind.hpp>

+

+#include <Swiften/Elements/RosterPayload.h>

+#include <Swiften/EventLoop/DummyEventLoop.h>

+#include <Swiften/LinkLocal/DNSSD/DNSSDServiceID.h>

+#include <Swiften/LinkLocal/LinkLocalServiceBrowser.h>

+#include <Swiften/LinkLocal/LinkLocalServiceInfo.h>

+

+#include <Slimber/LinkLocalPresenceManager.h>

+ CPPUNIT_TEST_SUITE(LinkLocalPresenceManagerTest);

+ CPPUNIT_TEST(testConstructor);

+ CPPUNIT_TEST(testServiceAdded);

+ CPPUNIT_TEST(testServiceRemoved);

+ CPPUNIT_TEST(testServiceChanged);

+ CPPUNIT_TEST(testGetRoster);

+ CPPUNIT_TEST(testGetAllPresence);

+ CPPUNIT_TEST(testGetRoster_InfoWithNick);

+ CPPUNIT_TEST(testGetRoster_InfoWithFirstName);

+ CPPUNIT_TEST(testGetRoster_InfoWithLastName);

+ CPPUNIT_TEST(testGetRoster_InfoWithFirstAndLastName);

+ CPPUNIT_TEST(testGetRoster_NoInfo);

+ CPPUNIT_TEST(testGetServiceForJID);

+ CPPUNIT_TEST(testGetServiceForJID_NoMatch);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ eventLoop = new DummyEventLoop();

+ querier = std::make_shared<FakeDNSSDQuerier>("wonderland.lit", eventLoop);

+ browser = new LinkLocalServiceBrowser(querier);

+ browser->start();

+ }

+

+ void tearDown() {

+ browser->stop();

+ delete browser;

+ delete eventLoop;

+ }

+

+ void testConstructor() {

+ addService("alice@wonderland");

+ addService("rabbit@teaparty");

+ std::shared_ptr<LinkLocalPresenceManager> testling(createTestling());

+

+ CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(testling->getRoster()->getItems().size()));

+ CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(testling->getAllPresence().size()));

+ }

+

+ void testServiceAdded() {

+ std::shared_ptr<LinkLocalPresenceManager> testling(createTestling());

+

+ addService("alice@wonderland", "Alice");

+

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

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(rosterChanges[0]->getItems().size()));

+ boost::optional<RosterItemPayload> item = rosterChanges[0]->getItem(JID("alice@wonderland"));

+ CPPUNIT_ASSERT(item);

+ CPPUNIT_ASSERT_EQUAL(std::string("Alice"), item->getName());

+ CPPUNIT_ASSERT_EQUAL(RosterItemPayload::Both, item->getSubscription());

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

+ CPPUNIT_ASSERT(StatusShow::Online == presenceChanges[0]->getShow());

+ CPPUNIT_ASSERT(JID("alice@wonderland") == presenceChanges[0]->getFrom());

+ }

+

+ void testServiceRemoved() {

+ std::shared_ptr<LinkLocalPresenceManager> testling(createTestling());

+

+ addService("alice@wonderland");

+ removeService("alice@wonderland");

+

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

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(rosterChanges[1]->getItems().size()));

+ boost::optional<RosterItemPayload> item = rosterChanges[1]->getItem(JID("alice@wonderland"));

+ CPPUNIT_ASSERT(item);

+ CPPUNIT_ASSERT_EQUAL(RosterItemPayload::Remove, item->getSubscription());

+ }

+

+ void testServiceChanged() {

+ std::shared_ptr<LinkLocalPresenceManager> testling(createTestling());

+

+ addService("alice@wonderland");

+ updateServicePresence("alice@wonderland", LinkLocalServiceInfo::Away, "I'm Away");

+

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

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

+ CPPUNIT_ASSERT(StatusShow::Away == presenceChanges[1]->getShow());

+ CPPUNIT_ASSERT(JID("alice@wonderland") == presenceChanges[1]->getFrom());

+ CPPUNIT_ASSERT_EQUAL(std::string("I'm Away"), presenceChanges[1]->getStatus());

+ }

+

+ void testGetAllPresence() {

+ std::shared_ptr<LinkLocalPresenceManager> testling(createTestling());

+

+ addService("alice@wonderland");

+ addService("rabbit@teaparty");

+ updateServicePresence("rabbit@teaparty", LinkLocalServiceInfo::Away, "Partying");

+

+ std::vector<std::shared_ptr<Presence> > presences = testling->getAllPresence();

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

+ // The order doesn't matter

+ CPPUNIT_ASSERT(JID("rabbit@teaparty") == presences[0]->getFrom());

+ CPPUNIT_ASSERT(StatusShow::Away == presences[0]->getShow());

+ CPPUNIT_ASSERT(JID("alice@wonderland") == presences[1]->getFrom());

+ CPPUNIT_ASSERT(StatusShow::Online == presences[1]->getShow());

+ }

+

+ void testGetRoster() {

+ std::shared_ptr<LinkLocalPresenceManager> testling(createTestling());

+

+ addService("alice@wonderland", "Alice");

+ addService("rabbit@teaparty", "Rabbit");

+

+ std::shared_ptr<RosterPayload> roster = testling->getRoster();

+ CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(roster->getItems().size()));

+ boost::optional<RosterItemPayload> item;

+ item = roster->getItem(JID("alice@wonderland"));

+ CPPUNIT_ASSERT(item);

+ CPPUNIT_ASSERT_EQUAL(std::string("Alice"), item->getName());

+ CPPUNIT_ASSERT_EQUAL(RosterItemPayload::Both, item->getSubscription());

+ item = roster->getItem(JID("rabbit@teaparty"));

+ CPPUNIT_ASSERT(item);

+ CPPUNIT_ASSERT_EQUAL(std::string("Rabbit"), item->getName());

+ CPPUNIT_ASSERT_EQUAL(RosterItemPayload::Both, item->getSubscription());

+ }

+

+ void testGetRoster_InfoWithNick() {

+ std::shared_ptr<LinkLocalPresenceManager> testling(createTestling());

+

+ addService("alice@wonderland", "Alice", "Alice In", "Wonderland");

+

+ boost::optional<RosterItemPayload> item = testling->getRoster()->getItem(JID("alice@wonderland"));

+ CPPUNIT_ASSERT_EQUAL(std::string("Alice"), item->getName());

+ }

+

+ void testGetRoster_InfoWithFirstName() {

+ std::shared_ptr<LinkLocalPresenceManager> testling(createTestling());

+

+ addService("alice@wonderland", "", "Alice In", "");

+

+ boost::optional<RosterItemPayload> item = testling->getRoster()->getItem(JID("alice@wonderland"));

+ CPPUNIT_ASSERT_EQUAL(std::string("Alice In"), item->getName());

+ }

+

+ void testGetRoster_InfoWithLastName() {

+ std::shared_ptr<LinkLocalPresenceManager> testling(createTestling());

+

+ addService("alice@wonderland", "", "", "Wonderland");

+

+ boost::optional<RosterItemPayload> item = testling->getRoster()->getItem(JID("alice@wonderland"));

+ CPPUNIT_ASSERT_EQUAL(std::string("Wonderland"), item->getName());

+ }

+

+ void testGetRoster_InfoWithFirstAndLastName() {

+ std::shared_ptr<LinkLocalPresenceManager> testling(createTestling());

+

+ addService("alice@wonderland", "", "Alice In", "Wonderland");

+

+ boost::optional<RosterItemPayload> item = testling->getRoster()->getItem(JID("alice@wonderland"));

+ CPPUNIT_ASSERT_EQUAL(std::string("Alice In Wonderland"), item->getName());

+ }

+

+ void testGetRoster_NoInfo() {

+ std::shared_ptr<LinkLocalPresenceManager> testling(createTestling());

+

+ addService("alice@wonderland");

+

+ boost::optional<RosterItemPayload> item = testling->getRoster()->getItem(JID("alice@wonderland"));

+ CPPUNIT_ASSERT_EQUAL(std::string(""), item->getName());

+ }

+

+ void testGetServiceForJID() {

+ std::shared_ptr<LinkLocalPresenceManager> testling(createTestling());

+

+ addService("alice@wonderland");

+ addService("rabbit@teaparty");

+ addService("queen@garden");

+

+ boost::optional<LinkLocalService> service = testling->getServiceForJID(JID("rabbit@teaparty"));

+ CPPUNIT_ASSERT(service);

+ CPPUNIT_ASSERT_EQUAL(std::string("rabbit@teaparty"), service->getID().getName());

+ }

+

+ void testGetServiceForJID_NoMatch() {

+ std::shared_ptr<LinkLocalPresenceManager> testling(createTestling());

+

+ addService("alice@wonderland");

+ addService("queen@garden");

+

+ CPPUNIT_ASSERT(!testling->getServiceForJID(JID("rabbit@teaparty")));

+ }

+

+ private:

+ std::shared_ptr<LinkLocalPresenceManager> createTestling() {

+ std::shared_ptr<LinkLocalPresenceManager> testling(

+ new LinkLocalPresenceManager(browser));

+ testling->onRosterChanged.connect(boost::bind(

+ &LinkLocalPresenceManagerTest::handleRosterChanged, this, _1));

+ testling->onPresenceChanged.connect(boost::bind(

+ &LinkLocalPresenceManagerTest::handlePresenceChanged, this, _1));

+ return testling;

+ }

+

+ void addService(const std::string& name, const std::string& nickName = std::string(), const std::string& firstName = std::string(), const std::string& lastName = std::string()) {

+ DNSSDServiceID service(name, "local.");

+ LinkLocalServiceInfo info;

+ info.setFirstName(firstName);

+ info.setLastName(lastName);

+ info.setNick(nickName);

+ querier->setServiceInfo(service, DNSSDResolveServiceQuery::Result(name + "._presence._tcp.local", "rabbithole.local", 1234, info.toTXTRecord()));

+ querier->addService(service);

+ eventLoop->processEvents();

+ }

+

+ void removeService(const std::string& name) {

+ DNSSDServiceID service(name, "local.");

+ querier->removeService(DNSSDServiceID(name, "local."));

+ eventLoop->processEvents();

+ }

+

+ void updateServicePresence(const std::string& name, LinkLocalServiceInfo::Status status, const std::string& message) {

+ DNSSDServiceID service(name, "local.");

+ LinkLocalServiceInfo info;

+ info.setStatus(status);

+ info.setMessage(message);

+ querier->setServiceInfo(service, DNSSDResolveServiceQuery::Result(name + "._presence._tcp.local", "rabbithole.local", 1234, info.toTXTRecord()));

+ eventLoop->processEvents();

+ }

+

+ void handleRosterChanged(std::shared_ptr<RosterPayload> payload) {

+ rosterChanges.push_back(payload);

+ }

+

+ void handlePresenceChanged(std::shared_ptr<Presence> presence) {

+ presenceChanges.push_back(presence);

+ }

+

+ private:

+ DummyEventLoop* eventLoop;

+ std::shared_ptr<FakeDNSSDQuerier> querier;

+ LinkLocalServiceBrowser* browser;

+ std::vector< std::shared_ptr<RosterPayload> > rosterChanges;

+ std::vector< std::shared_ptr<Presence> > presenceChanges;

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Slimber/Menulet.h>

+#include <Slimber/MenuletController.h>

+ CPPUNIT_TEST_SUITE(MenuletControllerTest);

+ CPPUNIT_TEST(testConstructor);

+ CPPUNIT_TEST(testUpdate);

+ CPPUNIT_TEST(testSetXMPPStatus_Online);

+ CPPUNIT_TEST(testSetXMPPStatus_Offline);

+ CPPUNIT_TEST(testSetUserNames);

+ CPPUNIT_TEST(testSetUserNames_NoUsers);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ menulet = new FakeMenulet();

+ }

+

+ void tearDown() {

+ delete menulet;

+ }

+

+ void testConstructor() {

+ MenuletController testling(menulet);

+

+ CPPUNIT_ASSERT_EQUAL(8, static_cast<int>(menulet->items.size()));

+ size_t i = 0;

+ CPPUNIT_ASSERT_EQUAL(std::string("No online users"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string("-"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string("[Offline] "), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string("-"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string("*About*"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string("-"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string("*Restart*"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string("*Exit*"), menulet->items[i++]);

+ }

+

+ void testUpdate() {

+ MenuletController testling(menulet);

+

+ testling.setXMPPStatus("You are connected", MenuletController::Online);

+

+ CPPUNIT_ASSERT_EQUAL(8, static_cast<int>(menulet->items.size()));

+ size_t i = 0;

+ CPPUNIT_ASSERT_EQUAL(std::string("No online users"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string("-"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string("[Online] You are connected"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string("-"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string("*About*"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string("-"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string("*Restart*"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string("*Exit*"), menulet->items[i++]);

+ }

+

+ void testSetXMPPStatus_Online() {

+ MenuletController testling(menulet);

+

+ testling.setXMPPStatus("You are connected", MenuletController::Online);

+

+ size_t i = 0;

+ CPPUNIT_ASSERT_EQUAL(std::string("No online users"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string("-"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string("[Online] You are connected"), menulet->items[i++]);

+ }

+

+

+ void testSetXMPPStatus_Offline() {

+ MenuletController testling(menulet);

+

+ testling.setXMPPStatus("You are not connected", MenuletController::Offline);

+

+ size_t i = 0;

+ CPPUNIT_ASSERT_EQUAL(std::string("No online users"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string("-"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string("[Offline] You are not connected"), menulet->items[i++]);

+ }

+

+ void testSetUserNames() {

+ MenuletController testling(menulet);

+

+ std::vector<std::string> users;

+ users.push_back("Alice In Wonderland");

+ users.push_back("The Mad Hatter");

+ testling.setUserNames(users);

+

+ size_t i = 0;

+ CPPUNIT_ASSERT_EQUAL(std::string("Online users:"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string(" Alice In Wonderland"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string(" The Mad Hatter"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string("-"), menulet->items[i++]);

+ }

+

+ void testSetUserNames_NoUsers() {

+ MenuletController testling(menulet);

+

+ std::vector<std::string> users;

+ testling.setUserNames(users);

+

+ size_t i = 0;

+ CPPUNIT_ASSERT_EQUAL(std::string("No online users"), menulet->items[i++]);

+ CPPUNIT_ASSERT_EQUAL(std::string("-"), menulet->items[i++]);

+ }

+

+ private:

+ struct FakeMenulet : public Menulet {

+ virtual void clear() {

+ items.clear();

+ }

+

+ virtual void addItem(const std::string& name, const std::string& icon = std::string()) {

+ std::string result;

+ if (!icon.empty()) {

+ result += "[" + icon + "] ";

+ }

+ result += name;

+ items.push_back(result);

+ }

+

+ virtual void addAboutItem() {

+ items.push_back("*About*");

+ }

+

+ virtual void addRestartItem() {

+ items.push_back("*Restart*");

+ }

+

+ virtual void addExitItem() {

+ items.push_back("*Exit*");

+ }

+

+ virtual void addSeparator() {

+ items.push_back("-");

+ }

+

+ virtual void setIcon(const std::string& i) {

+ icon = i;

+ }

+

+ std::vector<std::string> items;

+ std::string icon;

+ };

+

+ FakeMenulet* menulet;

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <Slimber/VCardCollection.h>

+ * Copyright (c) 2010-2016 Isode Limited.

+#include <memory>

+ class VCardCollection {

+ public:

+ virtual ~VCardCollection();

+ virtual std::shared_ptr<VCard> getOwnVCard() const = 0;

+ virtual void setOwnVCard(std::shared_ptr<VCard> vcard) = 0;

+ };