StoragesFactory* storagesFactory,

CertificateStorageFactory* certificateStorageFactory,

Dock* dock,

Notifier* notifier,

URIHandler* uriHandler,

IdleDetector* idleDetector,

bool useDelayForLatency,

bool eagleMode) :

eventLoop_(eventLoop),

networkFactories_(networkFactories),

uiFactory_(uiFactories),

storagesFactory_(storagesFactory),

certificateStorageFactory_(certificateStorageFactory),

settings_(settings),

uriHandler_(uriHandler),

idleDetector_(idleDetector),

loginWindow_(NULL) ,

useDelayForLatency_(useDelayForLatency),

eagleMode_(eagleMode),

ftOverview_(NULL) {

storages_ = NULL;

certificateStorage_ = NULL;

statusTracker_ = NULL;

presenceNotifier_ = NULL;

eventNotifier_ = NULL;

rosterController_ = NULL;

chatsManager_ = NULL;

eventWindowController_ = NULL;

profileController_ = NULL;

contactEditController_ = NULL;

userSearchControllerChat_ = NULL;

userSearchControllerAdd_ = NULL;

adHocManager_ = NULL;

quitRequested_ = false;

clientInitialized_ = false;

timeBeforeNextReconnect_ = -1;

dock_ = dock;

uiEventStream_ = new UIEventStream();

notifier_ = new TogglableNotifier(notifier);

eventController_ = new EventController();

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

systemTrayController_ = new SystemTrayController(eventController_, systemTray);

loginWindow_ = uiFactory_->createLoginWindow(uiEventStream_);

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

xmppURIController_ = new XMPPURIController(uriHandler_, uiEventStream_);

std::string selectedLoginJID = settings_->getStringSetting("lastLoginJID");

bool loginAutomatically = settings_->getBoolSetting("loginAutomatically", false);

std::string cachedPassword;

std::string cachedCertificate;

if (!eagleMode_) {

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

ProfileSettingsProvider profileSettings(profile, settings);

std::string password = eagleMode ? "" : 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);

}

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

discoInfoRequest->send();

client_->getVCardManager()->requestOwnVCard();

rosterController_->setEnabled(true);

profileController_->setAvailable(true);

contactEditController_->setAvailable(true);

/* Send presence later to catch all the incoming presences. */

sendPresence(statusTracker_->getNextPresence());

/* Enable chats last of all, so rejoining MUCs has the right sent presence */

chatsManager_->setOnline(true);

// notify world about current delivey receipt request setting state.

uiEventStream_->send(boost::make_shared<ToggleRequestDeliveryReceiptsUIEvent>(settings_->getBoolSetting(REQUEST_DELIVERYRECEIPTS, false)));

}

void MainController::handleEventQueueLengthChange(int count) {

dock_->setNumberOfPendingMessages(count);

}

void MainController::reconnectAfterError() {

if (reconnectTimer_) {

reconnectTimer_->stop();

}

performLoginFromCachedCredentials();

}

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

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

if (show == StatusShow::None) {

// Note: this is misleading, None doesn't mean unavailable on the wire.

presence->setType(Presence::Unavailable);

resetPendingReconnects();

myStatusLooksOnline_ = false;

}

else {

presence->setShow(show);

}

presence->setStatus(statusText);

statusTracker_->setRequestedPresence(presence);

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

profileSettings_->storeInt("lastShow", presence->getShow());

profileSettings_->storeString("lastStatus", presence->getStatus());

}

if (presence->getType() != Presence::Unavailable && !client_->isAvailable()) {

performLoginFromCachedCredentials();

} else {

sendPresence(presence);

}

}

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

rosterController_->getWindow()->setMyStatusType(presence->getShow());

rosterController_->getWindow()->setMyStatusText(presence->getStatus());

systemTrayController_->setMyStatusType(presence->getShow());

notifier_->setTemporarilyDisabled(presence->getShow() == StatusShow::DND);

// Add information and send

if (!vCardPhotoHash_.empty()) {

presence->updatePayload(boost::shared_ptr<VCardUpdate>(new VCardUpdate(vCardPhotoHash_)));

}

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

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

logout();

}

}

void MainController::handleInputIdleChanged(bool idle) {

if (!statusTracker_) {

//Haven't logged in yet.

return;

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));

if (!certificateFile_.empty()) {

client_->setCertificate(certificateFile_);

}

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;

clientOptions.forgetPassword = eagleMode_;

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

client_->connect(clientOptions);

}

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

if (eagleMode_) {

purgeCachedCredentials();

}

if (quitRequested_) {

resetClient();

loginWindow_->quit();

}

else if (error) {

std::string message;

std::string certificateErrorMessage;

switch(error->getType()) {

case ClientError::UnknownError: message = QT_TRANSLATE_NOOP("", "Unknown Error"); break;

case ClientError::DomainNameResolveError: message = QT_TRANSLATE_NOOP("", "Unable to find server"); break;

case ClientError::ConnectionError: message = QT_TRANSLATE_NOOP("", "Error connecting to server"); break;

case ClientError::ConnectionReadError: message = QT_TRANSLATE_NOOP("", "Error while receiving server data"); break;

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

case ClientError::XMLError: message = QT_TRANSLATE_NOOP("", "Error parsing server data"); break;

case ClientError::AuthenticationFailedError: message = QT_TRANSLATE_NOOP("", "Login/password invalid"); break;

case ClientError::CompressionFailedError: message = QT_TRANSLATE_NOOP("", "Error while compressing stream"); break;

case ClientError::ServerVerificationFailedError: message = QT_TRANSLATE_NOOP("", "Server verification failed"); break;

case ClientError::NoSupportedAuthMechanismsError: message = QT_TRANSLATE_NOOP("", "Authentication mechanisms not supported"); break;

case ClientError::UnexpectedElementError: message = QT_TRANSLATE_NOOP("", "Unexpected response"); break;

case ClientError::ResourceBindError: message = QT_TRANSLATE_NOOP("", "Error binding resource"); break;

case ClientError::SessionStartError: message = QT_TRANSLATE_NOOP("", "Error starting session"); break;

case ClientError::StreamError: message = QT_TRANSLATE_NOOP("", "Stream error"); break;

case ClientError::TLSError: message = QT_TRANSLATE_NOOP("", "Encryption error"); break;

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

case ClientError::ClientCertificateError: message = QT_TRANSLATE_NOOP("", "Certificate not authorized"); break;

case ClientError::UnknownCertificateError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Unknown certificate"); break;

case ClientError::CertificateExpiredError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate has expired"); break;

case ClientError::CertificateNotYetValidError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate is not yet valid"); break;

case ClientError::CertificateSelfSignedError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate is self-signed"); break;

case ClientError::CertificateRejectedError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate has been rejected"); break;

case ClientError::CertificateUntrustedError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate is not trusted"); break;

case ClientError::InvalidCertificatePurposeError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate cannot be used for encrypting your connection"); break;

case ClientError::CertificatePathLengthExceededError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate path length constraint exceeded"); break;

case ClientError::InvalidCertificateSignatureError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Invalid certificate signature"); break;

case ClientError::InvalidCAError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Invalid Certificate Authority"); break;

case ClientError::InvalidServerIdentityError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate does not match the host identity"); break;

}

bool forceReconnectAfterCertificateTrust = false;

if (!certificateErrorMessage.empty()) {

Certificate::ref certificate = certificateTrustChecker_->getLastCertificate();

if (loginWindow_->askUserToTrustCertificatePermanently(certificateErrorMessage, certificate)) {

certificateStorage_->addCertificate(certificate);

forceReconnectAfterCertificateTrust = true;

}

else {

message = QT_TRANSLATE_NOOP("", "Certificate error");

}

}

if (forceReconnectAfterCertificateTrust) {

performLoginFromCachedCredentials();

}

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

signOut();

loginWindow_->setMessage(message);

loginWindow_->setIsLoggingIn(false);

} else {

logout();

if (eagleMode_) {

message = str(format(QT_TRANSLATE_NOOP("", "Disconnected from %1%: %2%. To reconnect, Sign Out and provide your password again.")) % jid_.getDomain() % message);

} else {

if (lastDisconnectError_) {

message = str(format(QT_TRANSLATE_NOOP("", "Reconnect to %1% failed: %2%. Will retry in %3% seconds.")) % jid_.getDomain() % message % boost::lexical_cast<std::string>(timeBeforeNextReconnect_));

lastDisconnectError_->conclude();

} else {

message = str(format(QT_TRANSLATE_NOOP("", "Disconnected from %1%: %2%.")) % jid_.getDomain() % message);

}

lastDisconnectError_ = boost::shared_ptr<ErrorEvent>(new ErrorEvent(JID(jid_.getDomain()), message));

eventController_->handleIncomingEvent(lastDisconnectError_);

}

}

}

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

loginWindow_->setIsLoggingIn(false);

}

}

void MainController::setReconnectTimer() {

if (timeBeforeNextReconnect_ < 0) {

timeBeforeNextReconnect_ = 1;

} else {

timeBeforeNextReconnect_ = timeBeforeNextReconnect_ >= 150 ? 300 : timeBeforeNextReconnect_ * 2; // Randomly selected by roll of a die, as required by 3920bis

}

if (reconnectTimer_) {

reconnectTimer_->stop();

}

reconnectTimer_ = networkFactories_->getTimerFactory()->createTimer(timeBeforeNextReconnect_ * 1000);

reconnectTimer_->onTick.connect(boost::bind(&MainController::reconnectAfterError, this));

reconnectTimer_->start();

}

void MainController::handleCancelLoginRequest() {

signOut();

}

void MainController::signOut() {

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_;

std::string certificateFile_;

boost::shared_ptr<ErrorEvent> lastDisconnectError_;

bool useDelayForLatency_;

UserSearchController* userSearchControllerChat_;

UserSearchController* userSearchControllerAdd_;

int timeBeforeNextReconnect_;

Timer::ref reconnectTimer_;

StatusTracker* statusTracker_;

bool myStatusLooksOnline_;

bool quitRequested_;

static const int SecondsToWaitBeforeForceQuitting;

bool eagleMode_;

FileTransferOverview* ftOverview_;

};

}