+#include <Swift/Controllers/FileTransfer/FileTransferController.h>

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

+#include <Swift/Controllers/UIEvents/UIEventStream.h>

+#include <Swift/Controllers/UIEvents/SendFileUIEvent.h>

+

+ : ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController, timerFactory, entityCapsProvider), eventStream_(eventStream) {

+ chatWindow_->onFileTransferStart.connect(boost::bind(&ChatController::handleFileTransferStart, this, _1, _2));

+ chatWindow_->onFileTransferAccept.connect(boost::bind(&ChatController::handleFileTransferAccept, this, _1, _2));

+ chatWindow_->onFileTransferCancel.connect(boost::bind(&ChatController::handleFileTransferCancel, this, _1));

+ chatWindow_->onSendFileRequest.connect(boost::bind(&ChatController::handleSendFileRequest, this, _1));

+void ChatController::handleNewFileTransferController(FileTransferController* ftc) {

+ std::string nick = senderDisplayNameFromMessage(ftc->getOtherParty());

+ std::string ftID = ftc->setChatWindow(chatWindow_, nick);

+

+ ftControllers[ftID] = ftc;

+}

+

+void ChatController::handleFileTransferCancel(std::string id) {

+ std::cout << "handleFileTransferCancel(" << id << ")" << std::endl;

+ if (ftControllers.find(id) != ftControllers.end()) {

+ ftControllers[id]->cancel();

+ } else {

+ std::cerr << "unknown file transfer UI id" << std::endl;

+ }

+}

+

+void ChatController::handleFileTransferStart(std::string id, std::string description) {

+ std::cout << "handleFileTransferStart(" << id << ", " << description << ")" << std::endl;

+ if (ftControllers.find(id) != ftControllers.end()) {

+ ftControllers[id]->start(description);

+ } else {

+ std::cerr << "unknown file transfer UI id" << std::endl;

+ }

+}

+

+void ChatController::handleFileTransferAccept(std::string id, std::string filename) {

+ std::cout << "handleFileTransferAccept(" << id << ", " << filename << ")" << std::endl;

+ if (ftControllers.find(id) != ftControllers.end()) {

+ ftControllers[id]->accept(filename);

+ } else {

+ std::cerr << "unknown file transfer UI id" << std::endl;

+ }

+}

+

+void ChatController::handleSendFileRequest(std::string filename) {

+ std::cout << "ChatController::handleSendFileRequest(" << filename << ")" << std::endl;

+ eventStream_->send(boost::make_shared<SendFileUIEvent>(getToJID(), filename));

+}

+

+#include <map>

+#include <string>

+

+ class FileTransferController;

+ virtual void handleNewFileTransferController(FileTransferController* ftc);

+ void handleFileTransferCancel(std::string /* id */);

+ void handleFileTransferStart(std::string /* id */, std::string /* description */);

+ void handleFileTransferAccept(std::string /* id */, std::string /* filename */);

+ void handleSendFileRequest(std::string filename);

+

+ UIEventStream* eventStream_;

+

+ std::map<std::string, FileTransferController*> ftControllers;

+#include <Swift/Controllers/FileTransfer/FileTransferController.h>

+#include <Swift/Controllers/FileTransfer/FileTransferOverview.h>

+ ProfileSettingsProvider* settings,

+ FileTransferOverview* ftOverview) :

+ mucManager(mucManager),

+ ftOverview_(ftOverview) {

+ ftOverview_->onNewFileTransferController.connect(boost::bind(&ChatsManager::handleNewFileTransferController, this, _1));

+void ChatsManager::handleNewFileTransferController(FileTransferController* ftc) {

+ ChatController* chatController = getChatControllerOrCreate(ftc->getOtherParty());

+ chatController->handleNewFileTransferController(ftc);

+ chatController->activateChatWindow();

+}

+

+ class FileTransferOverview;

+ class FileTransferController;

+

+ ChatsManager(JID jid, StanzaChannel* stanzaChannel, IQRouter* iqRouter, EventController* eventController, ChatWindowFactory* chatWindowFactory, JoinMUCWindowFactory* joinMUCWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, PresenceSender* presenceSender, UIEventStream* uiEventStream, ChatListWindowFactory* chatListWindowFactory, bool useDelayForLatency, TimerFactory* timerFactory, MUCRegistry* mucRegistry, EntityCapsProvider* entityCapsProvider, MUCManager* mucManager, MUCSearchWindowFactory* mucSearchWindowFactory, ProfileSettingsProvider* settings, FileTransferOverview* ftOverview);

+ void handleNewFileTransferController(FileTransferController*);

+ FileTransferOverview* ftOverview_;

+#include <boost/bind.hpp>

+

+#include "Swiften/Jingle/JingleSessionManager.h"

+#include "Swiften/FileTransfer/UnitTest/DummyFileTransferManager.h"

+#include "Swift/Controllers/FileTransfer/FileTransferOverview.h"

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

+ ftManager_ = new DummyFileTransferManager();

+ ftOverview_ = new FileTransferOverview(ftManager_);

+ manager_ = new ChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, joinMUCWindowFactory_, nickResolver_, presenceOracle_, directedPresenceSender_, uiEventStream_, chatListWindowFactory_, true, NULL, mucRegistry_, entityCapsManager_, mucManager_, mucSearchWindowFactory_, profileSettings_, ftOverview_);

+ //delete chatListWindowFactory

+ delete ftOverview_;

+ delete ftManager_;

+ FileTransferOverview* ftOverview_;

+ FileTransferManager* ftManager_;

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "FileTransferController.h"

+#include "Swiften/FileTransfer/OutgoingJingleFileTransfer.h"

+#include "Swiften/FileTransfer/FileTransferManager.h"

+#include <Swiften/FileTransfer/FileReadBytestream.h>

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

+#include <boost/bind.hpp>

+#include "Swift/Controllers/UIInterfaces/ChatWindow.h"

+

+#include <boost/smart_ptr/make_shared.hpp>

+

+namespace Swift {

+

+FileTransferController::FileTransferController(const JID& receipient, const std::string& filename, FileTransferManager* fileTransferManager) :

+ sending(true), otherParty(receipient), filename(filename), ftManager(fileTransferManager), ftProgressInfo(0), chatWindow(0), currentState(FileTransfer::State::WaitingForStart) {

+

+}

+

+FileTransferController::FileTransferController(IncomingFileTransfer::ref transfer) :

+ sending(false), otherParty(transfer->getSender()), filename(transfer->filename), transfer(transfer), ftManager(0), ftProgressInfo(0), chatWindow(0), currentState(FileTransfer::State::WaitingForStart) {

+

+}

+

+FileTransferController::~FileTransferController() {

+ delete ftProgressInfo;

+}

+

+const JID &FileTransferController::getOtherParty() const {

+ return otherParty;

+}

+

+std::string FileTransferController::setChatWindow(ChatWindow* wnd, std::string nickname) {

+ chatWindow = wnd;

+ if (sending) {

+ uiID = wnd->addFileTransfer("me", true, filename, boost::filesystem::file_size(boost::filesystem::path(filename)));

+ } else {

+ uiID = wnd->addFileTransfer(nickname, false, filename, transfer->fileSizeInBytes);

+ }

+ return uiID;

+}

+

+void FileTransferController::setReceipient(const JID& receipient) {

+ this->otherParty = receipient;

+}

+

+bool FileTransferController::isIncoming() const {

+ return !sending;

+}

+

+FileTransfer::State FileTransferController::getState() const {

+ return currentState;

+}

+

+int FileTransferController::getProgress() const {

+ return ftProgressInfo ? ftProgressInfo->getPercentage() : 0;

+}

+

+boost::uintmax_t FileTransferController::getSize() const {

+ if (transfer) {

+ return transfer->fileSizeInBytes;

+ } else {

+ return 0;

+ }

+}

+

+void FileTransferController::start(std::string& description) {

+ std::cout << "FileTransferController::start" << std::endl;

+ fileReadStream = boost::make_shared<FileReadBytestream>(boost::filesystem::path(filename));

+ OutgoingFileTransfer::ref outgoingTransfer = ftManager->createOutgoingFileTransfer(otherParty, boost::filesystem::path(filename), description, fileReadStream);

+ if (outgoingTransfer) {

+ ftProgressInfo = new FileTransferProgressInfo(outgoingTransfer->fileSizeInBytes);

+ ftProgressInfo->onProgressPercentage.connect(boost::bind(&FileTransferController::handleProgressPercentageChange, this, _1));

+ outgoingTransfer->onStateChange.connect(boost::bind(&FileTransferController::handleFileTransferStateChange, this, _1));

+ outgoingTransfer->onProcessedBytes.connect(boost::bind(&FileTransferProgressInfo::setBytesProcessed, ftProgressInfo, _1));

+ outgoingTransfer->start();

+ transfer = outgoingTransfer;

+ } else {

+ std::cerr << "File transfer not supported!" << std::endl;

+ }

+}

+

+void FileTransferController::accept(std::string& file) {

+ std::cout << "FileTransferController::accept" << std::endl;

+ IncomingFileTransfer::ref incomingTransfer = boost::dynamic_pointer_cast<IncomingFileTransfer>(transfer);

+ if (incomingTransfer) {

+ fileWriteStream = boost::make_shared<FileWriteBytestream>(boost::filesystem::path(file));

+

+ ftProgressInfo = new FileTransferProgressInfo(transfer->fileSizeInBytes);

+ ftProgressInfo->onProgressPercentage.connect(boost::bind(&FileTransferController::handleProgressPercentageChange, this, _1));

+ transfer->onStateChange.connect(boost::bind(&FileTransferController::handleFileTransferStateChange, this, _1));

+ transfer->onProcessedBytes.connect(boost::bind(&FileTransferProgressInfo::setBytesProcessed, ftProgressInfo, _1));

+ incomingTransfer->accept(fileWriteStream);

+ } else {

+ std::cerr << "Expected an incoming transfer in this situation!" << std::endl;

+ }

+}

+

+void FileTransferController::cancel() {

+ if (transfer) {

+ transfer->cancel();

+ } else {

+ chatWindow->setFileTransferStatus(uiID, ChatWindow::Canceled);

+ }

+}

+

+void FileTransferController::handleFileTransferStateChange(FileTransfer::State state) {

+ currentState = state;

+ onStateChage();

+ switch(state.state) {

+ case FileTransfer::State::Negotiating:

+ chatWindow->setFileTransferStatus(uiID, ChatWindow::Negotiating);

+ return;

+ case FileTransfer::State::Transferring:

+ chatWindow->setFileTransferStatus(uiID, ChatWindow::Transferring);

+ return;

+ case FileTransfer::State::Canceled:

+ chatWindow->setFileTransferStatus(uiID, ChatWindow::Canceled);

+ return;

+ case FileTransfer::State::Finished:

+ chatWindow->setFileTransferStatus(uiID, ChatWindow::Finished);

+ if (fileWriteStream) {

+ fileWriteStream->close();

+ }

+ return;

+ case FileTransfer::State::Failed:

+ chatWindow->setFileTransferStatus(uiID, ChatWindow::FTFailed);

+ return;

+ case FileTransfer::State::WaitingForAccept:

+ chatWindow->setFileTransferStatus(uiID, ChatWindow::WaitingForAccept);

+ return;

+ case FileTransfer::State::WaitingForStart:

+ return;

+ }

+ std::cerr << "Unhandled FileTransfer::State!" << std::endl;

+}

+

+void FileTransferController::handleProgressPercentageChange(int percentage) {

+ onProgressChange();

+ chatWindow->setFileTransferProgress(uiID, percentage);

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <string>

+

+#include <boost/shared_ptr.hpp>

+

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

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

+#include <Swiften/FileTransfer/IncomingFileTransfer.h>

+#include <Swiften/FileTransfer/FileReadBytestream.h>

+#include <Swiften/FileTransfer/FileWriteBytestream.h>

+#include <Swift/Controllers/FileTransfer/FileTransferProgressInfo.h>

+

+namespace Swift {

+

+class FileTransferManager;

+class ChatWindow;

+

+class FileTransferController {

+public:

+ /**

+ * For outgoing file transfers. It'll create a file transfer via FileTransferManager as soon as the descriptive information is available.

+ */

+ FileTransferController(const JID&, const std::string&, FileTransferManager*);

+

+ /**

+ * For incoming file transfers.

+ */

+ FileTransferController(IncomingFileTransfer::ref transfer);

+ ~FileTransferController();

+

+ std::string setChatWindow(ChatWindow*, std::string nickname);

+ void setReceipient(const JID& otherParty);

+

+ void start(std::string& description);

+ void accept(std::string& file);

+ void cancel();

+

+ const JID &getOtherParty() const;

+ bool isIncoming() const;

+ FileTransfer::State getState() const;

+ int getProgress() const;

+ boost::uintmax_t getSize() const;

+

+ boost::signal<void ()> onStateChage;

+ boost::signal<void ()> onProgressChange;

+

+private:

+ void handleFileTransferStateChange(FileTransfer::State);

+ void handleProgressPercentageChange(int percentage);

+

+private:

+ bool sending;

+ JID otherParty;

+ std::string filename;

+ FileTransfer::ref transfer;

+ boost::shared_ptr<FileReadBytestream> fileReadStream;

+ boost::shared_ptr<FileWriteBytestream> fileWriteStream;

+ FileTransferManager* ftManager;

+ FileTransferProgressInfo* ftProgressInfo;

+ ChatWindow* chatWindow;

+ std::string uiID;

+ FileTransfer::State currentState;

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "FileTransferOverview.h"

+

+#include <boost/bind.hpp>

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

+

+#include <Swiften/FileTransfer/FileTransferManager.h>

+

+namespace Swift {

+

+FileTransferOverview::FileTransferOverview(FileTransferManager* ftm) : fileTransferManager(ftm) {

+ fileTransferManager->onIncomingFileTransfer.connect(boost::bind(&FileTransferOverview::handleIncomingFileTransfer, this, _1));

+}

+

+FileTransferOverview::~FileTransferOverview() {

+

+}

+

+void FileTransferOverview::sendFile(const JID& jid, const std::string& filename) {

+ FileTransferController* controller = new FileTransferController(jid, filename, fileTransferManager);

+ fileTransfers.push_back(controller);

+

+ onNewFileTransferController(controller);

+}

+

+void FileTransferOverview::handleIncomingFileTransfer(IncomingFileTransfer::ref transfer) {

+ FileTransferController* controller = new FileTransferController(transfer);

+ fileTransfers.push_back(controller);

+ onNewFileTransferController(controller);

+}

+

+const std::vector<FileTransferController*>& FileTransferOverview::getFileTransfers() const {

+ return fileTransfers;

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <vector>

+

+#include "Swift/Controllers/FileTransfer/FileTransferController.h"

+

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

+

+namespace Swift {

+

+class ChatsManager;

+class FileTransferManager;

+

+class FileTransferOverview {

+public:

+ FileTransferOverview(FileTransferManager*);

+ ~FileTransferOverview();

+

+ void sendFile(const JID&, const std::string&);

+ const std::vector<FileTransferController*>& getFileTransfers() const;

+

+ boost::signal<void (FileTransferController*)> onNewFileTransferController;

+

+private:

+ void handleIncomingFileTransfer(IncomingFileTransfer::ref transfer);

+

+private:

+ std::vector<FileTransferController*> fileTransfers;

+ FileTransferManager *fileTransferManager;

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "FileTransferProgressInfo.h"

+

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

+

+namespace Swift {

+

+FileTransferProgressInfo::FileTransferProgressInfo(boost::uintmax_t completeBytes) : completeBytes(completeBytes), completedBytes(0), percentage(0) {

+ onProgressPercentage(0);

+}

+

+void FileTransferProgressInfo::setBytesProcessed(int processedBytes) {

+ int oldPercentage = int(double(completedBytes) / double(completeBytes) * 100.0);

+ completedBytes += processedBytes;

+ int newPercentage = int(double(completedBytes) / double(completeBytes) * 100.0);

+ if (oldPercentage != newPercentage) {

+ onProgressPercentage(newPercentage);

+ }

+ percentage = newPercentage;

+}

+

+int FileTransferProgressInfo::getPercentage() const {

+ return percentage;

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

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

+

+namespace Swift {

+

+class FileTransferProgressInfo {

+public:

+ FileTransferProgressInfo(boost::uintmax_t completeBytes);

+

+public:

+ void setBytesProcessed(int processedBytes);

+

+ int getPercentage() const;

+ boost::signal<void (int)> onProgressPercentage;

+

+private:

+ boost::uintmax_t completeBytes;

+ boost::uintmax_t completedBytes;

+ int percentage;

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "SOCKS5BytestreamProxyFinder.h"

+

+#include <boost/smart_ptr/make_shared.hpp>

+#include <boost/bind.hpp>

+

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

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

+#include <Swiften/Queries/GenericRequest.h>

+#include <Swiften/Queries/IQRouter.h>

+

+namespace Swift {

+

+SOCKS5BytestreamProxyFinder::SOCKS5BytestreamProxyFinder(const JID& service, IQRouter *iqRouter) : iqRouter(iqRouter) {

+ serviceWalker = boost::make_shared<DiscoServiceWalker>(service, iqRouter);

+ serviceWalker->onServiceFound.connect(boost::bind(&SOCKS5BytestreamProxyFinder::handleServiceFound, this, _1, _2));

+}

+

+void SOCKS5BytestreamProxyFinder::start() {

+ serviceWalker->beginWalk();

+}

+

+void SOCKS5BytestreamProxyFinder::sendBytestreamQuery(const JID& jid) {

+ S5BProxyRequest::ref proxyRequest = boost::make_shared<S5BProxyRequest>();

+ boost::shared_ptr<GenericRequest<S5BProxyRequest> > request = boost::make_shared<GenericRequest<S5BProxyRequest> >(IQ::Get, jid, proxyRequest, iqRouter);

+ request->onResponse.connect(boost::bind(&SOCKS5BytestreamProxyFinder::handleProxyResponse, this, _1, _2));

+ request->send();

+}

+

+void SOCKS5BytestreamProxyFinder::handleServiceFound(const JID& jid, boost::shared_ptr<DiscoInfo> discoInfo) {

+ if (discoInfo->hasFeature(DiscoInfo::Bytestream)) {

+ sendBytestreamQuery(jid);

+ }

+}

+

+void SOCKS5BytestreamProxyFinder::handleProxyResponse(boost::shared_ptr<S5BProxyRequest> request, ErrorPayload::ref error) {

+ if (error) {

+ SWIFT_LOG(debug) << "ERROR" << std::endl;

+ } else {

+ if (request) {

+ onProxyFound(request);

+ } else {

+ //assert(false);

+ }

+ }

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+

+#include <Swift/Controllers/DiscoServiceWalker.h>

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

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

+

+namespace Swift {

+

+class JID;

+class IQRouter;

+

+class SOCKS5BytestreamProxyFinder {

+public:

+ SOCKS5BytestreamProxyFinder(const JID& service, IQRouter *iqRouter);

+ void start();

+

+ boost::signal<void(boost::shared_ptr<S5BProxyRequest>)> onProxyFound;

+

+private:

+ void sendBytestreamQuery(const JID&);

+

+ void handleServiceFound(const JID&, boost::shared_ptr<DiscoInfo>);

+ void handleProxyResponse(boost::shared_ptr<S5BProxyRequest>, ErrorPayload::ref);

+private:

+ boost::shared_ptr<DiscoServiceWalker> serviceWalker;

+ IQRouter* iqRouter;

+ std::vector<boost::shared_ptr<GenericRequest<S5BProxyRequest> > > requests;

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "Swift/Controllers/FileTransferListController.h"

+

+#include <boost/bind.hpp>

+

+#include "Swift/Controllers/UIInterfaces/FileTransferListWidgetFactory.h"

+#include "Swift/Controllers/UIEvents/RequestFileTransferListUIEvent.h"

+

+namespace Swift {

+

+FileTransferListController::FileTransferListController(UIEventStream* uiEventStream, FileTransferListWidgetFactory* fileTransferListWidgetFactory) : fileTransferListWidgetFactory(fileTransferListWidgetFactory), fileTransferListWidget(NULL), fileTransferOverview(0) {

+ uiEventStream->onUIEvent.connect(boost::bind(&FileTransferListController::handleUIEvent, this, _1));

+}

+

+FileTransferListController::~FileTransferListController() {

+ delete fileTransferListWidget;

+}

+

+void FileTransferListController::setFileTransferOverview(FileTransferOverview *overview) {

+ fileTransferOverview = overview;

+ if (fileTransferListWidget) {

+ fileTransferListWidget->setFileTransferOverview(fileTransferOverview);

+ }

+}

+

+void FileTransferListController::handleUIEvent(boost::shared_ptr<UIEvent> rawEvent) {

+ boost::shared_ptr<RequestFileTransferListUIEvent> event = boost::dynamic_pointer_cast<RequestFileTransferListUIEvent>(rawEvent);

+ if (event != NULL) {

+ if (fileTransferListWidget == NULL) {

+ fileTransferListWidget = fileTransferListWidgetFactory->createFileTransferListWidget();

+ if (fileTransferOverview) {

+ fileTransferListWidget->setFileTransferOverview(fileTransferOverview);

+ }

+ }

+ fileTransferListWidget->show();

+ fileTransferListWidget->activate();

+ }

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+

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

+

+namespace Swift {

+

+class FileTransferListWidgetFactory;

+class FileTransferListWidget;

+class FileTransferOverview;

+

+class FileTransferListController {

+public:

+ FileTransferListController(UIEventStream* uiEventStream, FileTransferListWidgetFactory* fileTransferListWidgetFactory);

+ ~FileTransferListController();

+

+ void setFileTransferOverview(FileTransferOverview* overview);

+

+private:

+ void handleUIEvent(boost::shared_ptr<UIEvent> event);

+

+private:

+ FileTransferListWidgetFactory* fileTransferListWidgetFactory;

+ FileTransferListWidget* fileTransferListWidget;

+ FileTransferOverview* fileTransferOverview;

+};

+

+}

+#include "Swift/Controllers/FileTransferListController.h"

+#include <Swift/Controllers/FileTransfer/FileTransferOverview.h>

+#include <Swiften/FileTransfer/FileTransferManager.h>

+#include <Swiften/Client/ClientXMLTracer.h>

+ eagleMode_(eagleMode),

+ ftOverview_(NULL) {

+ fileTransferListController_ = new FileTransferListController(uiEventStream_, uiFactory_);

+

+ delete fileTransferListController_;

+ delete s5bProxyFinder_;

+ s5bProxyFinder_ = NULL;

+ delete ftOverview_;

+ ftOverview_ = NULL;

+ srand(time(NULL));

+ int randomPort = 10000 + rand() % 10000;

+ client_->getFileTransferManager()->startListeningOnPort(randomPort);

+ s5bProxyFinder_ = new SOCKS5BytestreamProxyFinder(client_->getJID().getDomain(), client_->getIQRouter());

+ s5bProxyFinder_->onProxyFound.connect(boost::bind(&FileTransferManager::addS5BProxy, client_->getFileTransferManager(), _1));

+ s5bProxyFinder_->start();

+ ftOverview_ = new FileTransferOverview(client_->getFileTransferManager());

+ fileTransferListController_->setFileTransferOverview(ftOverview_);

+ rosterController_ = new RosterController(jid_, client_->getRoster(), client_->getAvatarManager(), uiFactory_, client_->getNickManager(), client_->getNickResolver(), client_->getPresenceOracle(), client_->getSubscriptionManager(), eventController_, uiEventStream_, client_->getIQRouter(), settings_, client_->getEntityCapsProvider(), ftOverview_);

+ chatsManager_ = new ChatsManager(jid_, client_->getStanzaChannel(), client_->getIQRouter(), eventController_, uiFactory_, uiFactory_, client_->getNickResolver(), client_->getPresenceOracle(), client_->getPresenceSender(), uiEventStream_, uiFactory_, useDelayForLatency_, networkFactories_->getTimerFactory(), client_->getMUCRegistry(), client_->getEntityCapsProvider(), client_->getMUCManager(), uiFactory_, profileSettings_, ftOverview_);

+

+ discoInfo.addFeature(DiscoInfo::JingleFeature);

+ discoInfo.addFeature(DiscoInfo::JingleFTFeature);

+ discoInfo.addFeature(DiscoInfo::JingleTransportsIBBFeature);

+ discoInfo.addFeature(DiscoInfo::JingleTransportsS5BFeature);

+#include "Swift/Controllers/FileTransfer/SOCKS5BytestreamProxyFinder.h"

+#include "Swiften/Client/ClientXMLTracer.h"

+ class FileTransferListController;

+ class FileTransferOverview;

+ FileTransferListController* fileTransferListController_;

+ FileTransferOverview* ftOverview_;

+ SOCKS5BytestreamProxyFinder* s5bProxyFinder_;

+void ContactRosterItem::setSupportedFeatures(const std::set<Feature>& features) {

+ features_ = features;

+}

+

+bool ContactRosterItem::supportsFeature(const Feature feat) const {

+ return features_.find(feat) != features_.end();

+}

+

+#include <set>

+ enum Feature {

+ FileTransferFeature,

+ };

+

+ public:

+

+ void setSupportedFeatures(const std::set<Feature>& features);

+ bool supportsFeature(Feature feat) const;

+ std::set<Feature> features_;

+#include <set>

+void Roster::setAvailableFeatures(const JID& jid, const std::set<ContactRosterItem::Feature>& features) {

+ if (itemMap_[fullJIDMapping_ ? jid : jid.toBare()].empty()) return;

+ foreach(ContactRosterItem* item, itemMap_[fullJIDMapping_ ? jid : jid.toBare()]) {

+ item->setSupportedFeatures(features);

+ }

+}

+

+ ContactRosterItem *item = new ContactRosterItem(jid, displayJID, name, group);

+#include <Swift/Controllers/Roster/ContactRosterItem.h>

+ void setAvailableFeatures(const JID& jid, const std::set<ContactRosterItem::Feature>& features);

+

+#include "Swift/Controllers/UIEvents/SendFileUIEvent.h"

+#include <Swiften/FileTransfer/FileTransferManager.h>

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

+#include <Swiften/Disco/EntityCapsManager.h>

+#include <Swiften/Jingle/JingleSessionManager.h>

+RosterController::RosterController(const JID& jid, XMPPRoster* xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, NickManager* nickManager, NickResolver* nickResolver, PresenceOracle* presenceOracle, SubscriptionManager* subscriptionManager, EventController* eventController, UIEventStream* uiEventStream, IQRouter* iqRouter, SettingsProvider* settings, EntityCapsProvider* entityCapsManager, FileTransferOverview* fileTransferOverview)

+ : myJID_(jid), xmppRoster_(xmppRoster), mainWindowFactory_(mainWindowFactory), mainWindow_(mainWindowFactory_->createMainWindow(uiEventStream)), roster_(new Roster()), offlineFilter_(new OfflineRosterFilter()), nickManager_(nickManager), nickResolver_(nickResolver), uiEventStream_(uiEventStream), entityCapsManager_(entityCapsManager), ftOverview_(fileTransferOverview) {

+ assert(fileTransferOverview);

+

+ entityCapsManager_->onCapsChanged.connect(boost::bind(&RosterController::handleOnCapsChanged, this, _1));

+RosterController::~RosterController() {

+

+

+ else if (boost::shared_ptr<SendFileUIEvent> sendFileEvent = boost::dynamic_pointer_cast<SendFileUIEvent>(event)) {

+ //TODO add send file dialog to ChatView of receipient jid

+ ftOverview_->sendFile(sendFileEvent->getJID(), sendFileEvent->getFilename());

+ }

+void RosterController::handleOnCapsChanged(const JID& jid) {

+ DiscoInfo::ref info = entityCapsManager_->getCaps(jid);

+ if (info) {

+ std::set<ContactRosterItem::Feature> features;

+ if (info->hasFeature(DiscoInfo::JingleFeature) && info->hasFeature(DiscoInfo::JingleFTFeature) && info->hasFeature(DiscoInfo::JingleTransportsIBBFeature)) {

+ features.insert(ContactRosterItem::FileTransferFeature);

+ }

+ roster_->setAvailableFeatures(jid, features);

+ }

+}

+

+#include <set>

+#include "Swift/Controllers/FileTransfer/FileTransferOverview.h"

+ class EntityCapsProvider;

+ class FileTransferManager;

+

+ RosterController(const JID& jid, XMPPRoster* xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, NickManager* nickManager, NickResolver* nickResolver, PresenceOracle* presenceOracle, SubscriptionManager* subscriptionManager, EventController* eventController, UIEventStream* uiEventStream, IQRouter* iqRouter_, SettingsProvider* settings, EntityCapsProvider* entityCapsProvider, FileTransferOverview* fileTransferOverview);

+ void handleOnCapsChanged(const JID& jid);

+ EntityCapsProvider* entityCapsManager_;

+ FileTransferOverview* ftOverview_;

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+#include <Swiften/Disco/EntityCapsManager.h>

+#include <Swiften/Disco/CapsProvider.h>

+#include <Swiften/Jingle/JingleSessionManager.h>

+#include <Swiften/FileTransfer/UnitTest/DummyFileTransferManager.h>

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

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

+class DummyCapsProvider : public CapsProvider {

+ DiscoInfo::ref getCaps(const std::string&) const {return DiscoInfo::ref(new DiscoInfo());}

+};

+

+ capsProvider_ = new DummyCapsProvider();

+ entityCapsManager_ = new EntityCapsManager(capsProvider_, stanzaChannel_);

+ jingleSessionManager_ = new JingleSessionManager(router_);

+

+ ftManager_ = new DummyFileTransferManager();

+ ftOverview_ = new FileTransferOverview(ftManager_);

+ rosterController_ = new RosterController(jid_, xmppRoster_, avatarManager_, mainWindowFactory_, nickManager_, nickResolver_, presenceOracle_, subscriptionManager_, eventController_, uiEventStream_, router_, settings_, entityCapsManager_, ftOverview_);

+ delete ftManager_;

+ delete jingleSessionManager_;

+

+ DummyCapsProvider* capsProvider_;

+ EntityCapsManager* entityCapsManager_;

+ JingleSessionManager* jingleSessionManager_;

+ FileTransferManager* ftManager_;

+ FileTransferOverview* ftOverview_;

+ "FileTransfer/FileTransferController.cpp",

+ "FileTransfer/FileTransferOverview.cpp",

+ "FileTransfer/FileTransferProgressInfo.cpp",

+ "FileTransfer/SOCKS5BytestreamProxyFinder.cpp",

+ "FileTransferListController.cpp",

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <Swift/Controllers/UIEvents/UIEvent.h>

+

+namespace Swift {

+

+class RequestFileTransferListUIEvent : public UIEvent {

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <string>

+

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

+#include <Swift/Controllers/UIEvents/UIEvent.h>

+

+namespace Swift {

+ class SendFileUIEvent : public UIEvent {

+ public:

+ typedef boost::shared_ptr<SendFileUIEvent> ref;

+

+ SendFileUIEvent(const JID& jid, const std::string& filename) : jid(jid), filename(filename) {

+ }

+

+ const JID& getJID() const {

+ return jid;

+ }

+

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

+ return filename;

+ }

+

+ private:

+ JID jid;

+ std::string filename;

+ };

+}

+ class FileTransferController;

+ enum FileTransferState {WaitingForAccept, Negotiating, Transferring, Canceled, Finished, FTFailed};

+

+ // File transfer related stuff

+ virtual std::string addFileTransfer(const std::string& senderName, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes) = 0;

+ virtual void setFileTransferProgress(std::string, const int percentageDone) = 0;

+ virtual void setFileTransferStatus(std::string, const FileTransferState state, const std::string& msg = "") = 0;

+

+ // File transfer related

+ boost::signal<void (std::string /* id */)> onFileTransferCancel;

+ boost::signal<void (std::string /* id */, std::string /* description */)> onFileTransferStart;

+ boost::signal<void (std::string /* id */, std::string /* path */)> onFileTransferAccept;

+ boost::signal<void (std::string /* path */)> onSendFileRequest;

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+namespace Swift {

+

+class FileTransferOverview;

+

+class FileTransferListWidget {

+public:

+ virtual ~FileTransferListWidget() {}

+

+ virtual void show() = 0;

+ virtual void activate() = 0;

+

+ virtual void setFileTransferOverview(FileTransferOverview*) = 0;

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include "Swift/Controllers/UIInterfaces/FileTransferListWidget.h"

+

+namespace Swift {

+

+class FileTransferListWidgetFactory {

+public:

+ virtual ~FileTransferListWidgetFactory() {}

+

+ virtual FileTransferListWidget* createFileTransferListWidget() = 0;

+};

+

+}

+#include <Swift/Controllers/UIInterfaces/FileTransferListWidgetFactory.h>

+ public XMLConsoleWidgetFactory,

+ public AdHocCommandWindowFactory,

+ public FileTransferListWidgetFactory {

+ // File transfer related stuff

+ virtual std::string addFileTransfer(const std::string& /*senderName*/, bool /*senderIsSelf*/,const std::string& /*filename*/, const boost::uintmax_t /*sizeInBytes*/) { return 0; };

+ virtual void setFileTransferProgress(std::string /*id*/, const int /*alreadyTransferedBytes*/) { };

+ virtual void setFileTransferStatus(std::string /*id*/, const FileTransferState /*state*/, const std::string& /*msg*/) { };

+

+ void setAvailableOccupantActions(const std::vector<OccupantAction>&/* actions*/) {}