#ifdef SWIFT_EXPERIMENTAL_FT

NetworkFactories *nf = getNetworkFactories();

fileTransferManager = new FileTransferManagerImpl(getJID(), jingleSessionManager, getIQRouter(), getEntityCapsProvider(), presenceOracle, nf->getConnectionFactory(), nf->getConnectionServerFactory(), nf->getTimerFactory(), nf->getNATTraverser());

#else

fileTransferManager = new DummyFileTransferManager();

#endif

namespace Swift {

TimerFactory* timerFactory, IQRouter* iqRouter, boost::shared_ptr<JingleContentPayload> content)

initialContent(content), parser(0), decoder(0), lastMouveMoveEvent(InputEventPayload::Event::MouseMove),

inputEventPayload(boost::make_shared<InputEventPayload>()), eventSendingTimer(timerFactory->createTimer(500)),

iqRouter(iqRouter)

decoder = new VP8Decoder;

parser = new VP8RTPParser(decoder);

rtpSession->onIncomingPacket.connect(boost::bind(&VP8RTPParser::newPayloadReceived, parser, _1, _2, _3));

decoder->onNewImageAvailable.connect(boost::bind(&IncomingScreenSharing::handleNewImageAvailable, this, _1));

}

return JingleContentID(initialContent->getName(), initialContent->getCreator());

}

void IncomingScreenSharing::handleNewImageAvailable(const Image& image)

{

onStateChange(ScreenSharing::Receiving);

typedef boost::shared_ptr<IncomingScreenSharing> ref;

public:

TimerFactory* timerFactory, IQRouter* iqRouter, boost::shared_ptr<JingleContentPayload> content);

virtual ~IncomingScreenSharing();

private:

JingleContentID getContentID() const;

void handleNewImageAvailable(const Image& image);

void handleEventSendingTimerTick();

void addLastMouseMoveIfDifferent();

namespace Swift {

UDPSocketFactory* udpSocketFactory, TimerFactory* timerFactory)

{

jingleSessionManager->addIncomingSessionHandler(this);

}

// Check description

// Create IncomingScreenSharing

return true;

}

class JingleSessionManager;

class UDPSocketFactory;

class TimerFactory;

class IncomingScreenSharingManager : public IncomingJingleSessionHandler {

public:

virtual ~IncomingScreenSharingManager();

public:

private:

JingleSessionManager* jingleSessionManager;

IQRouter* iqRouter;

UDPSocketFactory *udpSocketFactory;

TimerFactory* timerFactory;

};

namespace Swift {

timerFactory(timerFactory), recipient(toJID), contentID(JingleContentID(idGenerator.generateID(), JingleContentPayload::InitiatorCreator)),

canceled(false), sessionAccepted(false), socketConnected(false), encoder(0), packetizer(0)

{

void OutgoingScreenSharing::addImage(const Image &image)

{

encoder->encodeImage(image);

}

encoder = new VP8Encoder(packetizer, width, height);

packetizer->onNewPayloadReady.connect(boost::bind(&OutgoingScreenSharing::handleNewPayloadReady, this, _1, _2));

rtpSession->onRPSIFeedback.connect(boost::bind(&VP8Encoder::handleRPSIFeedback, static_cast<VP8Encoder*>(encoder), _1));

onReady();

onStateChange(ScreenSharing::BroadCasting);

}

typedef boost::shared_ptr<OutgoingScreenSharing> ref;

public:

virtual ~OutgoingScreenSharing();

virtual void cancel();

namespace Swift {

{

}

assert(jingleSession);

jsManager->registerOutgoingSession(from, jingleSession);

}

}

class IQRouter;

class UDPSocketFactory;

class TimerFactory;

class OutgoingScreenSharingManager {

public:

OutgoingScreenSharingManager(JingleSessionManager* jingleSessionManager, IQRouter* router,

boost::shared_ptr<OutgoingScreenSharing> createOutgoingScreenSharing(const JID& from, const JID& recipient);

JingleSessionManager* jsManager;

IQRouter* iqRouter;

UDPSocketFactory *udpSocketFactory;

TimerFactory* timerFactory;

};

/*

*/

#include <Swiften/ScreenSharing/ReferencePictureSelection.h>

send_refresh(false) {

}

// Assume RPSI is signaled with 7 bits.

SWIFT_LOG(debug) << "ReceivedRPSI: " << rpsi_picture_id << ", " << last_sent_ref_picture_id_ << std::endl;

if ((rpsi_picture_id & 127) == (last_sent_ref_picture_id_ & 127)) {

}

}

send_refresh = true;

}

int flags = 0;

// We can't refresh the decoder until we have established the key frame.

if (send_refresh/* && received_ack_*/) {

/*

*/

#pragma once

public:

ReferencePictureSelection();

void refFrameSent(int picture_id);

private:

#include <Swiften/Network/UDPSocketFactory.h>

#include <Swiften/ScreenSharing/RTPSession.h>

#include <Swiften/Jingle/JingleSession.h>

#include <boost/bind.hpp>

namespace Swift {

{

jingleSession->onSessionTerminateReceived.connect(boost::bind(&ScreenSharing::handleSessionTerminateReceived, this, _1));

}

serverSocket = udpSocketFactory->createUDPSocket();

SWIFT_LOG(debug) << "Screen sharing: Addresses available: " << std::endl;

foreach (const NetworkInterface& interface, interfaces) {

SWIFT_LOG(debug) << "\tInterface: " << interface.getName() << std::endl;

SWIFT_LOG(debug) << "\t\t" << addr.getRawAddress().to_string() << std::endl;

}

}

std::string scopeLinkBeginning("fe80");

foreach (const NetworkInterface& interface, interfaces) {

}

}

return false;

}

class UDPSocketFactory;

class UDPSocket;

class RTPSession;

class ScreenSharing {

public:

};

public:

virtual ~ScreenSharing();

virtual void cancel() = 0;

boost::shared_ptr<JingleSession> jingleSession;

UDPSocketFactory* udpSocketFactory;

};

}

#include <Swiften/ScreenSharing/OutgoingScreenSharingManager.h>

#include <Swiften/ScreenSharing/OutgoingScreenSharing.h>

#include <Swiften/ScreenSharing/InputEventResponder.h>

#include <boost/foreach.hpp>

ScreenSharingManagerImpl::ScreenSharingManagerImpl(const JID& ownFullJID, JingleSessionManager *jingleSessionManager, IQRouter *iqRouter,

UDPSocketFactory* udpSocketFactory, TimerFactory* timerFactory, PresenceOracle* presenceOrable,

{

responder = new InputEventResponder(this, iqRouter);

responder->start();

delete responder;

delete incomingSSManager;

delete outgoingSSManager;

}

boost::shared_ptr<OutgoingScreenSharing> ScreenSharingManagerImpl::createOutgoingScreenSharing(const JID &to)

class EntityCapsProvider;

class InputEventResponder;

class InputEventPayload;

class ScreenSharingManagerImpl : public ScreenSharingManager {

public:

ScreenSharingManagerImpl(const JID& ownFullJID, JingleSessionManager* jingleSessionManager, IQRouter* iqRouter,

UDPSocketFactory* udpSocketFactory, TimerFactory* timerFactory, PresenceOracle* presenceOrable,

virtual ~ScreenSharingManagerImpl();

virtual boost::shared_ptr<OutgoingScreenSharing> createOutgoingScreenSharing(const JID& to);

InputEventResponder* responder;

JID ownJID;

std::vector< boost::shared_ptr<OutgoingScreenSharing> > outgoingSharings;

EntityCapsProvider* capsProvider;

PresenceOracle* presenceOracle;

};

}