#include "Swift/Controllers/MainController.h"

#include <boost/bind.hpp>

#include <boost/lexical_cast.hpp>

#include <boost/shared_ptr.hpp>

#include <stdlib.h>

#include "Swiften/Application/Application.h"

#include "Swiften/Application/ApplicationMessageDisplay.h"

#include "Swift/Controllers/ChatController.h"

#include "Swift/Controllers/ChatWindowFactory.h"

#include "Swift/Controllers/EventController.h"

#include "Swift/Controllers/UIInterfaces/LoginWindow.h"

#include "Swift/Controllers/UIInterfaces/LoginWindowFactory.h"

#include "Swift/Controllers/MainWindow.h"

#include "Swift/Controllers/MainWindowFactory.h"

#include "Swift/Controllers/MUCController.h"

#include "Swift/Controllers/NickResolver.h"

#include "Swift/Controllers/ProfileSettingsProvider.h"

#include "Swift/Controllers/RosterController.h"

#include "Swift/Controllers/SoundEventController.h"

#include "Swift/Controllers/SoundPlayer.h"

#include "Swift/Controllers/SystemTray.h"

#include "Swift/Controllers/SystemTrayController.h"

#include "Swift/Controllers/XMLConsoleController.h"

#include "Swift/Controllers/XMPPRosterController.h"

#include "Swift/Controllers/UIInterfaces/XMLConsoleWidgetFactory.h"

#include "Swift/Controllers/UIEvents/UIEventStream.h"

#include "Swiften/Base/foreach.h"

#include "Swiften/Base/String.h"

#include "Swiften/Client/Client.h"

#include "Swiften/Presence/PresenceSender.h"

#include "Swiften/Elements/Presence.h"

#include "Swiften/Elements/VCardUpdate.h"

#include "Swiften/Queries/Responders/SoftwareVersionResponder.h"

#include "Swiften/Roster/TreeWidgetFactory.h"

#include "Swiften/Settings/SettingsProvider.h"

#include "Swiften/Elements/DiscoInfo.h"

#include "Swiften/Queries/Responders/DiscoInfoResponder.h"

#include "Swiften/Disco/CapsInfoGenerator.h"

#include "Swiften/Queries/Requests/GetDiscoInfoRequest.h"

#include "Swiften/Queries/Requests/GetVCardRequest.h"

#include "Swiften/Avatars/AvatarFileStorage.h"

#include "Swiften/Avatars/AvatarManager.h"

#include "Swiften/StringCodecs/SHA1.h"

#include "Swiften/StringCodecs/Hexify.h"

namespace Swift {

static const String CLIENT_NAME = "Swift";

static const String CLIENT_VERSION = "0.3";

static const String CLIENT_NODE = "http://swift.im";

MainController::MainController(ChatWindowFactory* chatWindowFactory, MainWindowFactory *mainWindowFactory, LoginWindowFactory *loginWindowFactory, TreeWidgetFactory *treeWidgetFactory, SettingsProvider *settings, Application* application, SystemTray* systemTray, SoundPlayer* soundPlayer, XMLConsoleWidgetFactory* xmlConsoleWidgetFactory)

: timerFactory_(&boostIOServiceThread_.getIOService()), idleDetector_(&idleQuerier_, &timerFactory_, 100), client_(NULL), presenceSender_(NULL), chatWindowFactory_(chatWindowFactory), mainWindowFactory_(mainWindowFactory), loginWindowFactory_(loginWindowFactory), treeWidgetFactory_(treeWidgetFactory), settings_(settings), xmppRosterController_(NULL), rosterController_(NULL), loginWindow_(NULL), clientVersionResponder_(NULL), nickResolver_(NULL), discoResponder_(NULL) {

application_ = application;

presenceOracle_ = NULL;

avatarManager_ = NULL;

uiEventStream_ = new UIEventStream();

avatarStorage_ = new AvatarFileStorage(application_->getAvatarDir());

eventController_ = new EventController();

eventController_->onEventQueueLengthChange.connect(boost::bind(&MainController::handleEventQueueLengthChange, this, _1));

systemTrayController_ = new SystemTrayController(eventController_, systemTray);

soundEventController_ = new SoundEventController(eventController_, soundPlayer, settings->getBoolSetting("playSounds", true));

loginWindow_ = loginWindowFactory_->createLoginWindow(uiEventStream_);

foreach (String profile, settings->getAvailableProfiles()) {

ProfileSettingsProvider* profileSettings = new ProfileSettingsProvider(profile, settings);

loginWindow_->addAvailableAccount(profileSettings->getStringSetting("jid"), profileSettings->getStringSetting("pass"), profileSettings->getStringSetting("certificate"));

delete profileSettings;

}

loginWindow_->selectUser(settings_->getStringSetting("lastLoginJID"));

loginWindow_->onLoginRequest.connect(boost::bind(&MainController::handleLoginRequest, this, _1, _2, _3, _4));

loginWindow_->onCancelLoginRequest.connect(boost::bind(&MainController::handleCancelLoginRequest, this));

idleDetector_.setIdleTimeSeconds(600);

idleDetector_.onIdleChanged.connect(boost::bind(&MainController::handleInputIdleChanged, this, _1));

xmlConsoleController_ = new XMLConsoleController(uiEventStream_, xmlConsoleWidgetFactory);

}

MainController::~MainController() {

delete systemTrayController_;

delete soundEventController_;

delete avatarStorage_;

delete xmlConsoleController_;

delete uiEventStream_;

resetClient();

}

void MainController::resetClient() {

serverDiscoInfo_ = boost::shared_ptr<DiscoInfo>();

xmppRoster_ = boost::shared_ptr<XMPPRoster>();

delete presenceOracle_;

presenceOracle_ = NULL;

delete nickResolver_;

nickResolver_ = NULL;

delete avatarManager_;

avatarManager_ = NULL;

delete rosterController_;

rosterController_ = NULL;

delete xmppRosterController_;

xmppRosterController_ = NULL;

delete clientVersionResponder_;

clientVersionResponder_ = NULL;

delete discoResponder_;

discoResponder_ = NULL;

delete presenceSender_;

presenceSender_ = NULL;

delete client_;

client_ = NULL;

}

void MainController::handleConnected() {

//FIXME: this freshLogin thing is temporary so I can see what's what before I split into a seperate method.

bool freshLogin = rosterController_ == NULL;

if (freshLogin) {

serverDiscoInfo_ = boost::shared_ptr<DiscoInfo>(new DiscoInfo());

xmppRoster_ = boost::shared_ptr<XMPPRoster>(new XMPPRoster());

presenceOracle_ = new PresenceOracle(client_);

lastSentPresence_ = boost::shared_ptr<Presence>();

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

rosterController_ = new RosterController(jid_, xmppRoster_, avatarManager_, mainWindowFactory_, treeWidgetFactory_, nickResolver_);

rosterController_->onChangeStatusRequest.connect(boost::bind(&MainController::handleChangeStatusRequest, this, _1, _2));

rosterController_->onSignOutRequest.connect(boost::bind(&MainController::signOut, this));

xmppRosterController_ = new XMPPRosterController(client_, xmppRoster_);

xmppRosterController_->requestRoster();

clientVersionResponder_ = new SoftwareVersionResponder(CLIENT_NAME, CLIENT_VERSION, client_);

loginWindow_->morphInto(rosterController_->getWindow());

DiscoInfo discoInfo;

discoInfo.addIdentity(DiscoInfo::Identity(CLIENT_NAME, "client", "pc"));

discoInfo.addFeature("urn:xmpp:sec-label:0");

capsInfo_ = boost::shared_ptr<CapsInfo>(new CapsInfo(CapsInfoGenerator(CLIENT_NODE).generateCapsInfo(discoInfo)));

discoResponder_ = new DiscoInfoResponder(client_);

discoResponder_->setDiscoInfo(discoInfo);

discoResponder_->setDiscoInfo(capsInfo_->getNode() + "#" + capsInfo_->getVersion(), discoInfo);

serverDiscoInfo_ = boost::shared_ptr<DiscoInfo>(new DiscoInfo());

}

boost::shared_ptr<GetDiscoInfoRequest> discoInfoRequest(new GetDiscoInfoRequest(JID(), client_));

discoInfoRequest->onResponse.connect(boost::bind(&MainController::handleServerDiscoInfoResponse, this, _1, _2));

discoInfoRequest->send();

boost::shared_ptr<GetVCardRequest> vCardRequest(new GetVCardRequest(JID(), client_));

vCardRequest->onResponse.connect(boost::bind(&MainController::handleOwnVCardReceived, this, _1, _2));

vCardRequest->send();

//Send presence last to catch all the incoming presences.

boost::shared_ptr<Presence> initialPresence;

if (queuedPresence_.get() != NULL) {

initialPresence = queuedPresence_;

} else {

initialPresence = boost::shared_ptr<Presence>(new Presence());

}

initialPresence->addPayload(capsInfo_);

setManagersEnabled(true);

sendPresence(initialPresence);

}

void MainController::handleEventQueueLengthChange(int count) {

application_->getApplicationMessageDisplay()->setMessage(count == 0 ? "" : boost::lexical_cast<std::string>(count).c_str());

}

void MainController::reconnectAfterError() {

performLoginFromCachedCredentials();

sendPresence(queuedPresence_);

}

preIdlePresence_ = lastSentPresence_;

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

presence->setShow(StatusShow::Away);

presence->setStatus("Auto-away");

sendPresence(presence);

}

else {

if (client_) {

sendPresence(preIdlePresence_);

} else {

queuedPresence_ = preIdlePresence_;

}

}

}

void MainController::handleIncomingPresence(boost::shared_ptr<Presence> presence) {

//FIXME: subscribe, subscribed

rosterController_->handleIncomingPresence(presence);

}

void MainController::handleLoginRequest(const String &username, const String &password, const String& certificateFile, bool remember) {

loginWindow_->setMessage("");

ProfileSettingsProvider* profileSettings = new ProfileSettingsProvider(username, settings_);

profileSettings->storeString("jid", username);

profileSettings->storeString("certificate", certificateFile);

profileSettings->storeString("pass", remember ? password : "");

settings_->storeString("lastLoginJID", username);

loginWindow_->addAvailableAccount(profileSettings->getStringSetting("jid"), profileSettings->getStringSetting("pass"), profileSettings->getStringSetting("certificate"));

delete profileSettings;

jid_ = JID(username);

password_ = password;

certificateFile_ = certificateFile;

performLoginFromCachedCredentials();

}

void MainController::performLoginFromCachedCredentials() {

if (!client_) {

client_ = new Swift::Client(jid_, password_);

presenceSender_ = new PresenceSender(client_);

client_->onDataRead.connect(boost::bind(

&XMLConsoleController::handleDataRead, xmlConsoleController_, _1));

client_->onDataWritten.connect(boost::bind(

&XMLConsoleController::handleDataWritten, xmlConsoleController_, _1));

if (!certificateFile_.isEmpty()) {

client_->setCertificate(certificateFile_);

}

client_->onError.connect(boost::bind(&MainController::handleError, this, _1));

client_->onConnected.connect(boost::bind(&MainController::handleConnected, this));

}

client_->connect();

}

void MainController::handleError(const ClientError& error) {

String message;

switch(error.getType()) {

case ClientError::UnknownError: message = "Unknown Error"; break;

case ClientError::DomainNameResolveError: message = "Unable to find server"; break;

case ClientError::ConnectionError: message = "Error connecting to server"; break;

case ClientError::ConnectionReadError: message = "Error while receiving server data"; break;

case ClientError::ConnectionWriteError: message = "Error while sending data to the server"; break;

case ClientError::XMLError: message = "Error parsing server data"; break;

case ClientError::AuthenticationFailedError: message = "Login/password invalid"; break;

case ClientError::CompressionFailedError: message = "Error while compressing stream"; break;

case ClientError::ServerVerificationFailedError: message = "Server verification failed"; break;

case ClientError::NoSupportedAuthMechanismsError: message = "Authentication mechanisms not supported"; break;

case ClientError::UnexpectedElementError: message = "Unexpected response"; break;

case ClientError::ResourceBindError: message = "Error binding resource"; break;

case ClientError::SessionStartError: message = "Error starting session"; break;

case ClientError::TLSError: message = "Encryption error"; break;

case ClientError::ClientCertificateLoadError: message = "Error loading certificate (Invalid password?)"; break;

case ClientError::ClientCertificateError: message = "Certificate not authorized"; break;

}

if (!rosterController_) { //hasn't been logged in yet

signOut();

loginWindow_->setMessage(message);

}

logout();

if (rosterController_) {

//reconnectAfterError();

}

}

void MainController::handleCancelLoginRequest() {

signOut();

}

void MainController::signOut() {

logout();

loginWindow_->loggedOut();

delete rosterController_;

rosterController_ = NULL;

resetClient();

}

void MainController::logout() {

if (client_ && client_->isAvailable()) {

client_->disconnect();

}

if (rosterController_) {

rosterController_->getWindow()->setMyStatusType(StatusShow::None);

rosterController_->getWindow()->setMyStatusText("");

}

setManagersEnabled(false);

}

void MainController::setManagersEnabled(bool enabled) {

if (rosterController_) {

rosterController_->setEnabled(enabled);

}

}

void MainController::handleServerDiscoInfoResponse(boost::shared_ptr<DiscoInfo> info, const boost::optional<ErrorPayload>& error) {

if (!error) {

serverDiscoInfo_ = info;

}

}

void MainController::handleOwnVCardReceived(boost::shared_ptr<VCard> vCard, const boost::optional<ErrorPayload>& error) {

if (!error && !vCard->getPhoto().isEmpty()) {

vCardPhotoHash_ = Hexify::hexify(SHA1::getHash(vCard->getPhoto()));

if (lastSentPresence_) {

sendPresence(lastSentPresence_);

}

avatarManager_->setAvatar(jid_, vCard->getPhoto());

}

}

}

#pragma once

#include <boost/signals.hpp>

#include <boost/shared_ptr.hpp>

#include <vector>

#include "Swiften/Network/BoostIOServiceThread.h"

#include "Swiften/Network/BoostTimerFactory.h"

#include "SwifTools/Idle/PlatformIdleQuerier.h"

#include "SwifTools/Idle/ActualIdleDetector.h"

#include "Swiften/Base/String.h"

#include "Swiften/Client/ClientError.h"

#include "Swiften/JID/JID.h"

#include "Swiften/Elements/VCard.h"

#include "Swiften/Elements/DiscoInfo.h"

#include "Swiften/Elements/ErrorPayload.h"

#include "Swiften/Elements/Presence.h"

#include "Swiften/Settings/SettingsProvider.h"

#include "Swiften/Elements/CapsInfo.h"

#include "Swiften/Roster/XMPPRoster.h"

namespace Swift {

class AvatarStorage;

class Application;

class Client;

class ChatWindowFactory;

class ChatController;

class EventController;

class MainWindowFactory;

class MainWindow;

class NickResolver;

class RosterController;

class XMPPRosterController;

class PresenceSender;

class DiscoInfoResponder;

class AvatarManager;

class LoginWindow;

class EventLoop;

class SoftwareVersionResponder;

class LoginWindowFactory;

class TreeWidgetFactory;

class MUCController;

class PresenceOracle;

class SystemTray;

class SystemTrayController;

class SoundEventController;

class SoundPlayer;

class XMLConsoleController;

class UIEventStream;

class XMLConsoleWidgetFactory;

public:

MainController(ChatWindowFactory* chatWindowFactory, MainWindowFactory *mainWindowFactory, LoginWindowFactory *loginWindowFactory, TreeWidgetFactory* treeWidgetFactory, SettingsProvider *settings, Application* application, SystemTray* systemTray, SoundPlayer* soundPlayer, XMLConsoleWidgetFactory* xmlConsoleWidgetFactory);

~MainController();

private:

void resetClient();

void handleConnected();

void handleLoginRequest(const String& username, const String& password, const String& certificateFile, bool remember);

void handleCancelLoginRequest();

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

void handleChangeStatusRequest(StatusShow::Type show, const String &statusText);

void handleError(const ClientError& error);

void handleServerDiscoInfoResponse(boost::shared_ptr<DiscoInfo>, const boost::optional<ErrorPayload>&);

void handleEventQueueLengthChange(int count);

void handleOwnVCardReceived(boost::shared_ptr<VCard> vCard, const boost::optional<ErrorPayload>& error);

void sendPresence(boost::shared_ptr<Presence> presence);

void handleInputIdleChanged(bool);

void logout();

void signOut();

void performLoginFromCachedCredentials();

void reconnectAfterError();

void setManagersEnabled(bool enabled);

BoostIOServiceThread boostIOServiceThread_;

BoostTimerFactory timerFactory_;

PlatformIdleQuerier idleQuerier_;

ActualIdleDetector idleDetector_;

Client* client_;

PresenceSender* presenceSender_;

ChatWindowFactory* chatWindowFactory_;

MainWindowFactory* mainWindowFactory_;

LoginWindowFactory* loginWindowFactory_;

TreeWidgetFactory* treeWidgetFactory_;

SettingsProvider *settings_;

Application* application_;

AvatarStorage* avatarStorage_;

ChatController* chatController_;

XMPPRosterController* xmppRosterController_;

RosterController* rosterController_;

EventController* eventController_;

LoginWindow* loginWindow_;

SoftwareVersionResponder* clientVersionResponder_;

NickResolver* nickResolver_;

DiscoInfoResponder* discoResponder_;

UIEventStream* uiEventStream_;

XMLConsoleController* xmlConsoleController_;

boost::shared_ptr<CapsInfo> capsInfo_;

boost::shared_ptr<DiscoInfo> serverDiscoInfo_;

boost::shared_ptr<XMPPRoster> xmppRoster_;;

JID jid_;

PresenceOracle* presenceOracle_;

SystemTrayController* systemTrayController_;

SoundEventController* soundEventController_;

AvatarManager* avatarManager_;

boost::shared_ptr<Presence> lastSentPresence_;

boost::shared_ptr<Presence> preIdlePresence_;

String vCardPhotoHash_;

boost::shared_ptr<Presence> queuedPresence_;

String password_;

String certificateFile_;

};

}

#include "Swift/Controllers/RosterController.h"

#include <boost/bind.hpp>

#include "Swiften/Base/foreach.h"

#include "Swift/Controllers/MainWindow.h"

#include "Swift/Controllers/MainWindowFactory.h"

#include "Swift/Controllers/NickResolver.h"

#include "Swiften/Queries/Requests/GetRosterRequest.h"

#include "Swiften/EventLoop/MainEventLoop.h"

#include "Swiften/Roster/Roster.h"

#include "Swiften/Roster/SetPresence.h"

#include "Swiften/Roster/AppearOffline.h"

#include "Swiften/Roster/SetAvatar.h"

#include "Swiften/Roster/OfflineRosterFilter.h"

#include "Swiften/Roster/OpenChatRosterAction.h"

#include "Swiften/Roster/TreeWidgetFactory.h"

#include "Swiften/Roster/XMPPRoster.h"

namespace Swift {

/**

* The controller does not gain ownership of these parameters.

*/

RosterController::RosterController(const JID& jid, boost::shared_ptr<XMPPRoster> xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, TreeWidgetFactory* treeWidgetFactory, NickResolver* nickResolver)

: myJID_(jid), xmppRoster_(xmppRoster), mainWindowFactory_(mainWindowFactory), treeWidgetFactory_(treeWidgetFactory), mainWindow_(mainWindowFactory_->createMainWindow()), roster_(new Roster(mainWindow_->getTreeWidget(), treeWidgetFactory_)), offlineFilter_(new OfflineRosterFilter()) {

roster_->addFilter(offlineFilter_);

mainWindow_->onJoinMUCRequest.connect(boost::bind(&RosterController::handleJoinMUCRequest, this, _1, _2));

mainWindow_->onChangeStatusRequest.connect(boost::bind(&RosterController::handleChangeStatusRequest, this, _1, _2));

mainWindow_->onShowOfflineToggled.connect(boost::bind(&RosterController::handleShowOfflineToggled, this, _1));

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

roster_->onUserAction.connect(boost::bind(&RosterController::handleUserAction, this, _1));

xmppRoster_->onJIDAdded.connect(boost::bind(&RosterController::handleOnJIDAdded, this, _1));

xmppRoster_->onJIDUpdated.connect(boost::bind(&RosterController::handleOnJIDUpdated, this, _1, _2, _3));

xmppRoster_->onJIDRemoved.connect(boost::bind(&RosterController::handleOnJIDRemoved, this, _1));

avatarManager_ = NULL;

setAvatarManager(avatarManager);

setNickResolver(nickResolver);

}

RosterController::~RosterController() {

delete offlineFilter_;

}

void RosterController::setNickResolver(NickResolver* nickResolver) {

nickResolver_ = nickResolver;

if (nickResolver_ != NULL) {

mainWindow_->setMyName(nickResolver_->jidToNick(myJID_));

}

}

void RosterController::setAvatarManager(AvatarManager* avatarManager) {

if (avatarManager_ != NULL) {

//FIXME: disconnect old signal;

}

avatarManager_ = avatarManager;

if (avatarManager != NULL) {

avatarManager_->onAvatarChanged.connect(boost::bind(&RosterController::handleAvatarChanged, this, _1, _2));

mainWindow_->setMyAvatarPath(avatarManager_->getAvatarPath(myJID_).string());

}

}

void RosterController::setEnabled(bool enabled) {

if (!enabled) {

roster_->applyOnItems(AppearOffline());

}

}

void RosterController::handleShowOfflineToggled(bool state) {

if (state) {

roster_->removeFilter(offlineFilter_);

} else {

roster_->addFilter(offlineFilter_);

foreach(const String& group, groups) {

roster_->addContact(jid, name, group);

}

} else {

roster_->addContact(jid, name, "Contacts");

}

}

void RosterController::handleOnJIDRemoved(const JID& jid) {

roster_->removeContact(jid);

}

void RosterController::handleOnJIDUpdated(const JID& jid, const String& oldName, const std::vector<String> oldGroups) {

if (oldName != xmppRoster_->getNameForJID(jid)) {

handleOnJIDAdded(jid);

return;

}

std::vector<String> groups = xmppRoster_->getGroupsForJID(jid);

String name = xmppRoster_->getNameForJID(jid);

String contactsGroup = "Contacts";

if (groups.empty()) {

groups.push_back(contactsGroup);

}

foreach(const String& group, groups) {

if (std::find(oldGroups.begin(), oldGroups.end(), jid) == oldGroups.end()) {

roster_->addContact(jid, xmppRoster_->getNameForJID(jid), group);

}

}

foreach(const String& group, oldGroups) {

if (std::find(groups.begin(), groups.end(), group) == groups.end()) {

roster_->removeContactFromGroup(jid, group);

}

}

}

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

roster_->applyOnItems(SetPresence(presence));

}

void RosterController::handleAvatarChanged(const JID& jid, const String&) {

String path = avatarManager_->getAvatarPath(jid).string();

roster_->applyOnItems(SetAvatar(jid, path));

if (jid.equals(myJID_, JID::WithoutResource)) {

mainWindow_->setMyAvatarPath(path);

}

}

void RosterController::handleJoinMUCRequest(const JID &muc, const String &nick) {

onJoinMUCRequest(JID(muc), nick);

}

}

Import("env")

env["SWIFT_CONTROLLERS_FLAGS"] = {

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

"LIBS": ["SwiftControllers"]

}

myenv = env.Clone()

myenv.MergeFlags(env["BOOST_FLAGS"])

myenv.StaticLibrary("SwiftControllers", [

"ChatController.cpp",

"ChatControllerBase.cpp",

"MainController.cpp",

"NickResolver.cpp",

"RosterController.cpp",

"XMPPRosterController.cpp",

"MUCController.cpp",

"EventController.cpp",

"SoundEventController.cpp",

"SystemTrayController.cpp",

"XMLConsoleController.cpp",

"UIEvents/UIEvent.cpp",

"UIInterfaces/XMLConsoleWidget.cpp",

"PreviousStatusStore.cpp",

])

env.Append(UNITTEST_SOURCES = [

File("UnitTest/NickResolverTest.cpp"),

File("UnitTest/RosterControllerTest.cpp"),

File("UnitTest/XMPPRosterControllerTest.cpp"),

File("UnitTest/PreviousStatusStoreTest.cpp"),

])