notifier_ = new TogglableNotifier(notifier);

notifier_->setPersistentEnabled(settings_->getSetting(SettingConstants::SHOW_NOTIFICATIONS));

eventController_ = new EventController();

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

systemTrayController_ = new SystemTrayController(eventController_, systemTray);

loginWindow_ = uiFactory_->createLoginWindow(uiEventStream_);

loginWindow_->setShowNotificationToggle(!notifier->isExternallyConfigured());

soundEventController_ = new SoundEventController(eventController_, soundPlayer, settings);

xmppURIController_ = new XMPPURIController(uriHandler_, uiEventStream_);

std::string selectedLoginJID = settings_->getSetting(SettingConstants::LAST_LOGIN_JID);

bool loginAutomatically = settings_->getSetting(SettingConstants::LOGIN_AUTOMATICALLY);

std::string cachedPassword;

std::string cachedCertificate;

bool eagle = settings_->getSetting(SettingConstants::FORGET_PASSWORDS);

if (!eagle) {

foreach (std::string profile, settings->getAvailableProfiles()) {

ProfileSettingsProvider profileSettings(profile, settings);

std::string password = profileSettings.getStringSetting("pass");

std::string certificate = profileSettings.getStringSetting("certificate");

std::string jid = profileSettings.getStringSetting("jid");

loginWindow_->addAvailableAccount(jid, password, certificate);

if (jid == selectedLoginJID) {

cachedPassword = password;

cachedCertificate = certificate;

}

}

loginWindow_->selectUser(selectedLoginJID);

loginWindow_->setLoginAutomatically(loginAutomatically);

}

loginWindow_->onPurgeSavedLoginRequest.connect(boost::bind(&MainController::handlePurgeSavedLoginRequest, this, _1));

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

loginWindow_->onQuitRequest.connect(boost::bind(&MainController::handleQuitRequest, this));

idleDetector_->setIdleTimeSeconds(settings->getSetting(SettingConstants::IDLE_TIMEOUT));

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

xmlConsoleController_ = new XMLConsoleController(uiEventStream_, uiFactory_);

fileTransferListController_ = new FileTransferListController(uiEventStream_, uiFactory_);

settings_->onSettingChanged.connect(boost::bind(&MainController::handleSettingChanged, this, _1));

if (loginAutomatically) {

profileSettings_ = new ProfileSettingsProvider(selectedLoginJID, settings_);

} else {

profileSettings_ = NULL;

}

}

MainController::~MainController() {

idleDetector_->onIdleChanged.disconnect(boost::bind(&MainController::handleInputIdleChanged, this, _1));

purgeCachedCredentials();

//setManagersOffline();

eventController_->disconnectAll();

resetClient();

delete fileTransferListController_;

delete xmlConsoleController_;

delete xmppURIController_;

delete soundEventController_;

delete systemTrayController_;

delete eventController_;

delete notifier_;

delete uiEventStream_;

}

void MainController::purgeCachedCredentials() {

safeClear(password_);

}

void MainController::resetClient() {

purgeCachedCredentials();

resetCurrentError();

resetPendingReconnects();

vCardPhotoHash_.clear();

delete contactEditController_;

contactEditController_ = NULL;

delete profileController_;

}

client_->getPresenceSender()->sendPresence(presence);

if (presence->getType() == Presence::Unavailable) {

logout();

}

}

void MainController::handleInputIdleChanged(bool idle) {

if (!statusTracker_) {

//Haven't logged in yet.

return;

}

if (settings_->getSetting(SettingConstants::IDLE_GOES_OFFLINE)) {

if (idle) {

logout();

}

}

else {

if (idle) {

if (statusTracker_->goAutoAway()) {

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

sendPresence(statusTracker_->getNextPresence());

}

}

} else {

if (statusTracker_->goAutoUnAway()) {

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

sendPresence(statusTracker_->getNextPresence());

}

}

}

}

}

jid_ = JID(username);

if (!jid_.isValid() || jid_.getNode().empty()) {

loginWindow_->setMessage(QT_TRANSLATE_NOOP("", "User address invalid. User address should be of the form 'alice@wonderland.lit'"));

loginWindow_->setIsLoggingIn(false);

} else {

loginWindow_->setMessage("");

loginWindow_->setIsLoggingIn(true);

profileSettings_ = new ProfileSettingsProvider(username, settings_);

if (!settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

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

profileSettings_->storeString("pass", (remember || loginAutomatically) ? password : "");

settings_->storeSetting(SettingConstants::LAST_LOGIN_JID, username);

settings_->storeSetting(SettingConstants::LOGIN_AUTOMATICALLY, loginAutomatically);

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

}

password_ = password;

performLoginFromCachedCredentials();

}

}

void MainController::handlePurgeSavedLoginRequest(const std::string& username) {

settings_->removeProfile(username);

loginWindow_->removeAvailableAccount(username);

}

void MainController::performLoginFromCachedCredentials() {

if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS) && password_.empty()) {

/* Then we can't try to login again. */

return;

}

/* If we logged in with a bare JID, and we have a full bound JID, re-login with the

* bound JID to try and keep dynamically assigned resources */

JID clientJID = jid_;

if (boundJID_.isValid() && jid_.isBare() && boundJID_.toBare() == jid_) {

clientJID = boundJID_;

}

if (!statusTracker_) {

statusTracker_ = new StatusTracker();

}

if (!clientInitialized_) {

storages_ = storagesFactory_->createStorages(jid_.toBare());

certificateStorage_ = certificateStorageFactory_->createCertificateStorage(jid_.toBare());

certificateTrustChecker_ = new CertificateStorageTrustChecker(certificateStorage_);

client_ = boost::make_shared<Swift::Client>(clientJID, createSafeByteArray(password_.c_str()), networkFactories_, storages_);

clientInitialized_ = true;

client_->setCertificateTrustChecker(certificateTrustChecker_);

client_->onDataRead.connect(boost::bind(&XMLConsoleController::handleDataRead, xmlConsoleController_, _1));

client_->onDataWritten.connect(boost::bind(&XMLConsoleController::handleDataWritten, xmlConsoleController_, _1));

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

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

client_->setSoftwareVersion(CLIENT_NAME, buildVersion);

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

presenceNotifier_ = new PresenceNotifier(client_->getStanzaChannel(), notifier_, client_->getMUCRegistry(), client_->getAvatarManager(), client_->getNickResolver(), client_->getPresenceOracle(), networkFactories_->getTimerFactory());

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

eventNotifier_ = new EventNotifier(eventController_, notifier_, client_->getAvatarManager(), client_->getNickResolver());

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

}

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

presence->setShow(static_cast<StatusShow::Type>(profileSettings_->getIntSetting("lastShow", StatusShow::Online)));

presence->setStatus(profileSettings_->getStringSetting("lastStatus"));

statusTracker_->setRequestedPresence(presence);

} else {

/* In case we're in the middle of another login, make sure they don't overlap */

client_->disconnect();

}

systemTrayController_->setConnecting();

if (rosterController_) {

rosterController_->getWindow()->setConnecting();

}

ClientOptions clientOptions;

bool eagle = settings_->getSetting(SettingConstants::FORGET_PASSWORDS);

clientOptions.forgetPassword = eagle;

clientOptions.useTLS = eagle ? ClientOptions::RequireTLS : ClientOptions::UseTLSWhenAvailable;

/*if (clientJID.getDomain() == "doomsong.co.uk") {

clientOptions.boshURL = URL("https", "channels.doomsong.co.uk", 11443, "http-bind/");

clientOptions.boshHTTPConnectProxyURL = URL("http", "squidproxy.doomsong.co.uk", 8123, "");

}*/

client_->connect(clientOptions);

}

void MainController::handleDisconnected(const boost::optional<ClientError>& error) {

if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

purgeCachedCredentials();

}

if (quitRequested_) {

resetClient();

loginWindow_->quit();

}

else if (error) {

std::string message;

std::string certificateErrorMessage;

class MUCSearchController;

class UserSearchController;

class StatusTracker;

class Dock;

class Storages;

class StoragesFactory;

class NetworkFactories;

class URIHandler;

class XMPPURIController;

class AdHocManager;

class AdHocCommandWindowFactory;

class FileTransferOverview;

class MainController {

public:

MainController(

EventLoop* eventLoop,

NetworkFactories* networkFactories,

UIFactory* uiFactories,

SettingsProvider *settings,

SystemTray* systemTray,

SoundPlayer* soundPlayer,

StoragesFactory* storagesFactory,

CertificateStorageFactory* certificateStorageFactory,

Dock* dock,

Notifier* notifier,

URIHandler* uriHandler,

IdleDetector* idleDetector,

bool useDelayForLatency);

~MainController();

private:

void resetClient();

void handleConnected();

void handleCancelLoginRequest();

void handleQuitRequest();

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

void handleDisconnected(const boost::optional<ClientError>& error);

void handleServerDiscoInfoResponse(boost::shared_ptr<DiscoInfo>, ErrorPayload::ref);

void handleEventQueueLengthChange(int count);

void handleVCardReceived(const JID& j, VCard::ref vCard);

void handleSettingChanged(const std::string& settingPath);

void handlePurgeSavedLoginRequest(const std::string& username);

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

void handleInputIdleChanged(bool);

void logout();

void signOut();

void setReconnectTimer();

void resetPendingReconnects();

void resetCurrentError();

void performLoginFromCachedCredentials();

void reconnectAfterError();

void setManagersOffline();

void handleNotificationClicked(const JID& jid);

void handleForceQuit();

void purgeCachedCredentials();

private:

EventLoop* eventLoop_;

NetworkFactories* networkFactories_;

UIFactory* uiFactory_;

StoragesFactory* storagesFactory_;

Storages* storages_;

CertificateStorageFactory* certificateStorageFactory_;

CertificateStorage* certificateStorage_;

CertificateStorageTrustChecker* certificateTrustChecker_;

bool clientInitialized_;

boost::shared_ptr<Client> client_;

SettingsProvider *settings_;

ProfileSettingsProvider* profileSettings_;

Dock* dock_;

URIHandler* uriHandler_;

IdleDetector* idleDetector_;

TogglableNotifier* notifier_;

PresenceNotifier* presenceNotifier_;

EventNotifier* eventNotifier_;

RosterController* rosterController_;

EventController* eventController_;

EventWindowController* eventWindowController_;

AdHocManager* adHocManager_;

LoginWindow* loginWindow_;

UIEventStream* uiEventStream_;

XMLConsoleController* xmlConsoleController_;

FileTransferListController* fileTransferListController_;

ChatsManager* chatsManager_;

ProfileController* profileController_;

ContactEditController* contactEditController_;

JID jid_;

JID boundJID_;

SystemTrayController* systemTrayController_;

SoundEventController* soundEventController_;

XMPPURIController* xmppURIController_;

std::string vCardPhotoHash_;

std::string password_;

boost::shared_ptr<ErrorEvent> lastDisconnectError_;

bool useDelayForLatency_;

UserSearchController* userSearchControllerChat_;

UserSearchController* userSearchControllerAdd_;

int timeBeforeNextReconnect_;

Timer::ref reconnectTimer_;

StatusTracker* statusTracker_;

bool myStatusLooksOnline_;

bool quitRequested_;

bool offlineRequested_;

static const int SecondsToWaitBeforeForceQuitting;

FileTransferOverview* ftOverview_;

};

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <string>

#include <Swiften/TLS/Certificate.h>

namespace Swift {

class MainWindow;

class LoginWindow {

public:

virtual ~LoginWindow() {};

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

virtual void morphInto(MainWindow *mainWindow) = 0;

virtual void loggedOut() = 0;

virtual void setShowNotificationToggle(bool) = 0;

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

virtual void setIsLoggingIn(bool loggingIn) = 0;

virtual void addAvailableAccount(const std::string& defaultJID, const std::string& defaultPassword, const std::string& defaultCertificate) = 0;

virtual void removeAvailableAccount(const std::string& jid) = 0;

virtual void setLoginAutomatically(bool loginAutomatically) = 0;

virtual void quit() = 0;

/** Blocking request whether a cert should be permanently trusted.*/

virtual bool askUserToTrustCertificatePermanently(const std::string& message, Certificate::ref) = 0;

boost::signal<void ()> onCancelLoginRequest;

boost::signal<void ()> onQuitRequest;

boost::signal<void (const std::string&)> onPurgeSavedLoginRequest;

};

}