void Client::handleConnected() {

#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

discoManager->handleConnected();

const std::string DiscoInfo::JingleTransportsS5BFeature = std::string("urn:xmpp:jingle:transports:s5b:1");

const std::string DiscoInfo::Bytestream = std::string("http://jabber.org/protocol/bytestreams");

const std::string DiscoInfo::MessageDeliveryReceiptsFeature = std::string("urn:xmpp:receipts");

const std::string DiscoInfo::WhiteboardFeature = std::string("http://swift.im/whiteboard");

bool DiscoInfo::Identity::operator<(const Identity& other) const {

if (category_ == other.category_) {

if (type_ == other.type_) {

static const std::string JingleTransportsS5BFeature;

static const std::string Bytestream;

static const std::string MessageDeliveryReceiptsFeature;

static const std::string WhiteboardFeature;

class Identity {

public:

Identity(const std::string& name, const std::string& category = "client", const std::string& type = "pc", const std::string& lang = "") : name_(name), category_(category), type_(type), lang_(lang) {

#include <Swiften/Jingle/JingleSession.h>

#include <Swiften/Network/UDPSocket.h>

#include <Swiften/Network/TimerFactory.h>

#include <Swiften/Network/Timer.h>

#include <boost/bind.hpp>

namespace Swift {

OutgoingScreenSharing::OutgoingScreenSharing(boost::shared_ptr<JingleSession> session, UDPSocketFactory* udpSocketFactory, TimerFactory* timerFactory)

: ScreenSharing(session, udpSocketFactory),

contentID(JingleContentID(idGenerator.generateID(), JingleContentPayload::InitiatorCreator)), canceled(false),

{

}

OutgoingScreenSharing::~OutgoingScreenSharing()

{

//onStateChange(ScreenSharing::WaitingForStart);

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

JingleRTPDescription::ref desc = boost::make_shared<JingleRTPDescription>(JingleRTPDescription::Video);

JingleRawUDPTransportPayload::ref transport = boost::make_shared<JingleRawUDPTransportPayload>();

addBestCandidate(transport);

}

void OutgoingScreenSharing::handleSocketConnected()

{

if (canceled)

return;

socketConnected = true;

if (sessionAccepted)

startRTPSession();

}

void OutgoingScreenSharing::handleSessionAcceptReceived(const JingleContentID& /*id*/, boost::shared_ptr<JingleDescription> /*desc*/, boost::shared_ptr<JingleTransportPayload> /*transport*/)

{

if (canceled)

return;

sessionAccepted = true;

if (socketConnected) {

startRTPSession();

}

void OutgoingScreenSharing::startRTPSession()

{

// Session accepted and socket connected, we can start the rtp session

}

}

#pragma once

#include <Swiften/ScreenSharing/ScreenSharing.h>

#include <Swiften/Jingle/JingleContentID.h>

namespace Swift {

class ConnectivityManager;

class JingleDescription;

class JingleTransportPayload;

class TimerFactory;

class Timer;

class OutgoingScreenSharing : public ScreenSharing {

public:

typedef boost::shared_ptr<OutgoingScreenSharing> ref;

JingleContentID contentID;

bool canceled;

bool sessionAccepted;

bool socketConnected;

TimerFactory* timerFactory;

boost::shared_ptr<Timer> connectionTimer;

};

#include <boost/shared_ptr.hpp>

namespace Swift {

class UDPSocket;

class RTPSession {

public:

typedef boost::shared_ptr<RTPSession> ref;

public:

virtual ~RTPSession() {}

virtual void poll() = 0;

virtual void checkIncomingPackets() = 0;

virtual void sendPacket(const SafeByteArray& data, int timestampinc, bool marker = false) = 0;

virtual void injectData(const SafeByteArray& data) = 0;

#include <Swiften/ScreenSharing/RTPException.h>

#include <Swiften/Network/BoostUDPSocket.h>

#include <Swiften/Base/boost_bsignals.h>

#include <boost/algorithm/string/split.hpp>

#include <boost/algorithm/string/classification.hpp>

#include <boost/lexical_cast.hpp>

#include <rtpsessionparams.h>

namespace Swift {

}

}

jrtplib::RTPExternalTransmissionParams transparams(&sender, 0);

jrtplib::RTPSessionParams sessparams;

// IMPORTANT: The local timestamp unit MUST be set, otherwise RTCP Sender Report info will be calculated wrong

checkError(session.Create(sessparams, &transparams, jrtplib::RTPTransmitter::ExternalProto));

packetInjecter = static_cast<jrtplib::RTPExternalTransmissionInfo*>(session.GetTransmissionInfo())->GetPacketInjector();

}

void RTPSessionImpl::poll()

{

}

void RTPSessionImpl::sendPacket(const SafeByteArray& data, int timestampinc, bool marker)

{

poll();

}

void RTPSessionImpl::injectData(const SafeByteArray& data)

{

injectData(*data);

}

{

// Split address

std::vector<std::string> subStrings;

std::string ipAddress = hostAddressPort.getAddress().toString();

uint8_t ipNumbers[4];

for (int i = 0; i < std::min(4, (int)subStrings.size()); ++i)

ipNumbers[i] = boost::numeric_cast<uint8_t>(boost::lexical_cast<int>(subStrings[i]));

}

}

#pragma once

#include <Swiften/ScreenSharing/RTPSession.h>

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wunused-parameter"

#include <rtpsession.h>

#include <rtpexternaltransmitter.h>

#include <rtpipv4address.h>

namespace Swift {

};

class RTPSessionImpl : public RTPSession {

public:

typedef boost::shared_ptr<RTPSession> ref;

public:

virtual ~RTPSessionImpl();

virtual void poll();

virtual void checkIncomingPackets();

virtual void sendPacket(const SafeByteArray &data, int timestampinc, bool marker = false);

virtual void injectData(const SafeByteArray &data);

virtual void stop(int maxWaitMs = 100);

private:

void handleDataRead(boost::shared_ptr<SafeByteArray> data);

private:

boost::shared_ptr<UDPSocket> udpSocket;

jrtplib::RTPIPv4Address jRTPRemotePeer;

Sender sender;

jrtplib::RTPExternalPacketInjecter *packetInjecter;

};

}

// Find the first ip which is not loopback

foreach (const NetworkInterface& interface, interfaces) {

if (!interface.isLoopback()) { // exclude loopback

candidate.type = JingleRawUDPTransportPayload::Candidate::Host;

transport->addCandidate(candidate);

return true;

}

}

// else loopback for self sharing

if (!interfaces.empty()) {

candidate.type = JingleRawUDPTransportPayload::Candidate::Host;

transport->addCandidate(candidate);

return true;

}

return false;

protected:

bool addBestCandidate(boost::shared_ptr<JingleRawUDPTransportPayload> transport);

protected:

IDGenerator idGenerator;

boost::shared_ptr<UDPSocket> serverSocket;

boost::shared_ptr<UDPSocket> clientSocket;

*/

#include <Swiften/ScreenSharing/ScreenSharingManagerImpl.h>

#include <Swiften/ScreenSharing/IncomingScreenSharingManager.h>

#include <Swiften/ScreenSharing/OutgoingScreenSharingManager.h>

namespace Swift {

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

{

incomingSSManager = new IncomingScreenSharingManager(jingleSessionManager, iqRouter, udpSocketFactory);

outgoingSSManager = new OutgoingScreenSharingManager(jingleSessionManager, iqRouter, udpSocketFactory, timerFactory);

}

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

{

}

}

}

class JingleSessionManager;

class IQRouter;

class UDPSocketFactory;

class TimerFactory;

class ScreenSharingManagerImpl : public ScreenSharingManager {

public:

virtual ~ScreenSharingManagerImpl();

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

private:

IncomingScreenSharingManager* incomingSSManager;

OutgoingScreenSharingManager* outgoingSSManager;

JID ownJID;

// JingleSessionManager* jingleSM;

// IQRouter* iqRouter;

// BoostUDPSocketFactory* udpSocketFactory;

// TimerFactory* timerFactory;

};

}