From 1b2d23c160b4c120a364ff9e86b54e2d8caeaaa4 Mon Sep 17 00:00:00 2001 From: dknn Date: Sun, 8 Jul 2012 22:27:27 +0200 Subject: Screen sharing managing diff --git a/Swiften/Client/Client.cpp b/Swiften/Client/Client.cpp index 1a6c64b..c16d3b1 100644 --- a/Swiften/Client/Client.cpp +++ b/Swiften/Client/Client.cpp @@ -30,6 +30,7 @@ #include #include #include +#include #ifndef SWIFT_EXPERIMENTAL_FT #include #endif @@ -69,6 +70,7 @@ Client::Client(const JID& jid, const SafeString& password, NetworkFactories* net jingleSessionManager = new JingleSessionManager(getIQRouter()); fileTransferManager = NULL; + screenSharingManager = NULL; whiteboardSessionManager = NULL; #ifdef SWIFT_EXPERIMENTAL_WB @@ -120,7 +122,9 @@ void Client::setSoftwareVersion(const std::string& name, const std::string& vers void Client::handleConnected() { #ifdef SWIFT_EXPERIMENTAL_FT - fileTransferManager = new FileTransferManagerImpl(getJID(), jingleSessionManager, getIQRouter(), getEntityCapsProvider(), presenceOracle, getNetworkFactories()->getConnectionFactory(), getNetworkFactories()->getConnectionServerFactory(), getNetworkFactories()->getTimerFactory(), getNetworkFactories()->getNATTraverser()); + NetworkFactories *nf = getNetworkFactories(); + fileTransferManager = new FileTransferManagerImpl(getJID(), jingleSessionManager, getIQRouter(), getEntityCapsProvider(), presenceOracle, nf->getConnectionFactory(), nf->getConnectionServerFactory(), nf->getTimerFactory(), nf->getNATTraverser()); + screenSharingManager = new ScreenSharingManagerImpl(getJID(), jingleSessionManager, getIQRouter(), nf->getUDPSocketFactory(), nf->getTimerFactory()); #else fileTransferManager = new DummyFileTransferManager(); #endif @@ -164,6 +168,11 @@ void Client::setAlwaysTrustCertificates() { setCertificateTrustChecker(blindCertificateTrustChecker); } +ScreenSharingManager *Client::getScreenSharingManager() const +{ + return screenSharingManager; +} + NickManager* Client::getNickManager() const { return nickManager; } diff --git a/Swiften/Client/Client.h b/Swiften/Client/Client.h index 126572a..fde994e 100644 --- a/Swiften/Client/Client.h +++ b/Swiften/Client/Client.h @@ -37,6 +37,7 @@ namespace Swift { class JingleSessionManager; class FileTransferManager; class WhiteboardSessionManager; + class ScreenSharingManager; /** * Provides the core functionality for writing XMPP client software. @@ -153,6 +154,14 @@ namespace Swift { void setAlwaysTrustCertificates(); WhiteboardSessionManager* getWhiteboardSessionManager() const; + + /** + * Returns a ScreenSharingManager for the client. This is only available after the onConnected + * signal has been fired. + * + * WARNING: Screen sharing will only work if Swiften is built in 'experimental' mode. + */ + ScreenSharingManager* getScreenSharingManager() const; public: /** @@ -188,6 +197,7 @@ namespace Swift { JingleSessionManager* jingleSessionManager; FileTransferManager* fileTransferManager; BlindCertificateTrustChecker* blindCertificateTrustChecker; + ScreenSharingManager *screenSharingManager; WhiteboardSessionManager* whiteboardSessionManager; }; } diff --git a/Swiften/ScreenSharing/IncomingScreenSharing.cpp b/Swiften/ScreenSharing/IncomingScreenSharing.cpp new file mode 100644 index 0000000..d5ee56e --- /dev/null +++ b/Swiften/ScreenSharing/IncomingScreenSharing.cpp @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2012 Yoann Blein + * Licensed under the simplified BSD license. + * See Documentation/Licenses/BSD-simplified.txt for more information. + */ + +#include + +#include +#include +#include +#include + +namespace Swift { + +IncomingScreenSharing::IncomingScreenSharing(boost::shared_ptr session, UDPSocketFactory* udpSocketFactory, + boost::shared_ptr content) + : ScreenSharing(session, udpSocketFactory), + initialContent(content) +{ + onStateChange(ScreenSharing::WaitingForAccept); +} + +IncomingScreenSharing::~IncomingScreenSharing() +{ +} + +void IncomingScreenSharing::cancel() +{ + session->sendTerminate(JinglePayload::Reason::Cancel); + clientSocket->close(); + onStateChange(ScreenSharing::Canceled); +} + +void IncomingScreenSharing::accept() +{ + JingleRawUDPTransportPayload::ref transport = boost::make_shared(); + addBestCandidate(transport); + // TODO: create a valid description instead of copying the initator's one + session->sendAccept(getContentID(), initialContent->getDescriptions().front(), transport); + + JingleRawUDPTransportPayload::ref initialTransport = initialContent->getTransport(); + clientSocket = udpSocketFactory->createUDPSocket(); + clientSocket->connect(initialTransport->getCandidates().front().hostAddressPort); + // Send a empty packet to let the server know about us + SafeByteArray data(1, 0); + clientSocket->send(data); + + onStateChange(ScreenSharing::Connecting); +} + +JingleContentID IncomingScreenSharing::getContentID() const +{ + return JingleContentID(initialContent->getName(), initialContent->getCreator()); +} + +} diff --git a/Swiften/ScreenSharing/IncomingScreenSharing.h b/Swiften/ScreenSharing/IncomingScreenSharing.h new file mode 100644 index 0000000..a9850fd --- /dev/null +++ b/Swiften/ScreenSharing/IncomingScreenSharing.h @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2012 Yoann Blein + * Licensed under the simplified BSD license. + * See Documentation/Licenses/BSD-simplified.txt for more information. + */ + +#pragma once + +#include +#include + +namespace Swift { + class JingleContentPayload; + + class IncomingScreenSharing : public ScreenSharing + { + public: + typedef boost::shared_ptr ref; + + public: + IncomingScreenSharing(boost::shared_ptr session, UDPSocketFactory* udpSocketFactory, + boost::shared_ptr content); + virtual ~IncomingScreenSharing(); + + virtual void cancel(); + + void accept(); + + private: + JingleContentID getContentID() const; + + private: + boost::shared_ptr initialContent; + }; +} diff --git a/Swiften/ScreenSharing/IncomingScreenSharingManager.cpp b/Swiften/ScreenSharing/IncomingScreenSharingManager.cpp new file mode 100644 index 0000000..7706c0a --- /dev/null +++ b/Swiften/ScreenSharing/IncomingScreenSharingManager.cpp @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2012 Yoann Blein + * Licensed under the simplified BSD license. + * See Documentation/Licenses/BSD-simplified.txt for more information. + */ + +#include + +#include +#include +#include +#include + +#include + +namespace Swift { + +IncomingScreenSharingManager::IncomingScreenSharingManager(JingleSessionManager* jingleSessionManager, IQRouter* router, UDPSocketFactory* udpSocketFactory) + : jingleSessionManager(jingleSessionManager), router(router), udpSocketFactory(udpSocketFactory) +{ + jingleSessionManager->addIncomingSessionHandler(this); +} + +IncomingScreenSharingManager::~IncomingScreenSharingManager() +{ + jingleSessionManager->removeIncomingSessionHandler(this); +} + +bool IncomingScreenSharingManager::handleIncomingJingleSession(Swift::JingleSession::ref session, const std::vector& contents, const Swift::JID& /*recipient*/) +{ + JingleContentPayload::ref content = Jingle::getContentWithDescription(contents); + if (!content) + return false; + + // Check transport + // Check description + // Create IncomingScreenSharing + + onIncomingScreenSharing(boost::make_shared(session, udpSocketFactory, content)); + + return true; +} + +} diff --git a/Swiften/ScreenSharing/IncomingScreenSharingManager.h b/Swiften/ScreenSharing/IncomingScreenSharingManager.h new file mode 100644 index 0000000..3563a87 --- /dev/null +++ b/Swiften/ScreenSharing/IncomingScreenSharingManager.h @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2012 Yoann Blein + * Licensed under the simplified BSD license. + * See Documentation/Licenses/BSD-simplified.txt for more information. + */ + +#pragma once + +#include + +namespace Swift { + class IncomingScreenSharing; + class IQRouter; + class JingleSessionManager; + class UDPSocketFactory; + + class IncomingScreenSharingManager : public IncomingJingleSessionHandler { + public: + IncomingScreenSharingManager(JingleSessionManager* jingleSessionManager, IQRouter* router, UDPSocketFactory* udpSocketFactory); + virtual ~IncomingScreenSharingManager(); + + public: + boost::signal)> onIncomingScreenSharing; + + private: + bool handleIncomingJingleSession(JingleSession::ref session, const std::vector& contents, const JID& /*recipient*/); + + private: + JingleSessionManager* jingleSessionManager; + IQRouter* router; + UDPSocketFactory *udpSocketFactory; + }; +} diff --git a/Swiften/ScreenSharing/OutgoingScreenSharing.cpp b/Swiften/ScreenSharing/OutgoingScreenSharing.cpp new file mode 100644 index 0000000..3aa460c --- /dev/null +++ b/Swiften/ScreenSharing/OutgoingScreenSharing.cpp @@ -0,0 +1,105 @@ +/* + * Copyright (c) 2012 Yoann Blein + * Licensed under the simplified BSD license. + * See Documentation/Licenses/BSD-simplified.txt for more information. + */ + +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Swift { + +OutgoingScreenSharing::OutgoingScreenSharing(boost::shared_ptr session, UDPSocketFactory* udpSocketFactory, TimerFactory* timerFactory) + : ScreenSharing(session, udpSocketFactory), + contentID(JingleContentID(idGenerator.generateID(), JingleContentPayload::InitiatorCreator)), canceled(false), + sessionAccepted(false), socketConnected(false), timerFactory(timerFactory) +{ +} + +OutgoingScreenSharing::~OutgoingScreenSharing() +{ +} + +void OutgoingScreenSharing::cancel() +{ + canceled = true; + session->sendTerminate(JinglePayload::Reason::Cancel); + + onStateChange(ScreenSharing::Canceled); +} + +void OutgoingScreenSharing::start() +{ + //onStateChange(ScreenSharing::WaitingForStart); + SWIFT_LOG(debug) << "Screen sharing: start" << std::endl; + + JingleRTPDescription::ref desc = boost::make_shared(JingleRTPDescription::Video); + desc->addPayloadType(RTPPayloadType(98, "VP8", 90000)); + + JingleRawUDPTransportPayload::ref transport = boost::make_shared(); + addBestCandidate(transport); + + session->sendInitiate(contentID, desc, transport); + onStateChange(ScreenSharing::WaitingForAccept); + + serverSocket->onConnected.connect(boost::bind(&OutgoingScreenSharing::handleSocketConnected, this)); + serverSocket->connectToFirstIncoming(); +} + +void OutgoingScreenSharing::handleSocketConnected() +{ + SWIFT_LOG(debug) << "Screen sharing: UDP socket connected" << std::endl; + + if (canceled) + return; + + socketConnected = true; + if (sessionAccepted) + startRTPSession(); +} + +void OutgoingScreenSharing::handleSessionAcceptReceived(const JingleContentID& /*id*/, boost::shared_ptr /*desc*/, boost::shared_ptr /*transport*/) +{ + SWIFT_LOG(debug) << "Screen sharing: accepted" << std::endl; + + if (canceled) + return; + + sessionAccepted = true; + if (socketConnected) { + startRTPSession(); + } else { + connectionTimer = timerFactory->createTimer(1000); + connectionTimer->onTick.connect(boost::bind(&OutgoingScreenSharing::handleConnectionFailed, this)); + connectionTimer->start(); + onStateChange(ScreenSharing::Connecting); + } +} + +void OutgoingScreenSharing::handleConnectionFailed() +{ + SWIFT_LOG(debug) << "Screen sharing: unable to connect" << std::endl; + + session->sendTerminate(JinglePayload::Reason::ConnectivityError); + canceled = true; + + onStateChange(ScreenSharing::Failed); +} + +void OutgoingScreenSharing::startRTPSession() +{ + SWIFT_LOG(debug) << "Screen sharing: accepted and connect, start screen sharing" << std::endl; + + // Session accepted and socket connected, we can start the rtp session +} + +} diff --git a/Swiften/ScreenSharing/OutgoingScreenSharing.h b/Swiften/ScreenSharing/OutgoingScreenSharing.h new file mode 100644 index 0000000..d93b476 --- /dev/null +++ b/Swiften/ScreenSharing/OutgoingScreenSharing.h @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2012 Yoann Blein + * Licensed under the simplified BSD license. + * See Documentation/Licenses/BSD-simplified.txt for more information. + */ + +#pragma once + +#include +#include + +namespace Swift { + class ConnectivityManager; + class JingleDescription; + class JingleTransportPayload; + class TimerFactory; + class Timer; + + class OutgoingScreenSharing : public ScreenSharing { + public: + typedef boost::shared_ptr ref; + + public: + OutgoingScreenSharing(boost::shared_ptr session, UDPSocketFactory* udpSocketFactory, TimerFactory* timerFactory); + virtual ~OutgoingScreenSharing(); + + virtual void cancel(); + + void start(); + + private: + void handleSocketConnected(); + void handleSessionAcceptReceived(const JingleContentID& /*id*/, boost::shared_ptr /*desc*/, boost::shared_ptr /*transport*/); + void handleConnectionFailed(); + void startRTPSession(); + + private: + JingleContentID contentID; + bool canceled; + bool sessionAccepted; + bool socketConnected; + + TimerFactory* timerFactory; + boost::shared_ptr connectionTimer; + }; +} diff --git a/Swiften/ScreenSharing/OutgoingScreenSharingManager.cpp b/Swiften/ScreenSharing/OutgoingScreenSharingManager.cpp new file mode 100644 index 0000000..43096ae --- /dev/null +++ b/Swiften/ScreenSharing/OutgoingScreenSharingManager.cpp @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2012 Yoann Blein + * Licensed under the simplified BSD license. + * See Documentation/Licenses/BSD-simplified.txt for more information. + */ + +#include +#include +#include +#include + +namespace Swift { + +OutgoingScreenSharingManager::OutgoingScreenSharingManager(JingleSessionManager* jingleSessionManager,IQRouter* router, + UDPSocketFactory *udpSocketFactory, TimerFactory* timerFactory) + : jsManager(jingleSessionManager), iqRouter(router), udpSocketFactory(udpSocketFactory), timerFactory(timerFactory) +{ +} + +boost::shared_ptr OutgoingScreenSharingManager::createOutgoingScreenSharing(const JID& from, const JID& to) +{ + JingleSessionImpl::ref jingleSession = boost::make_shared(from, to, idGenerator.generateID(), iqRouter); + assert(jingleSession); + jsManager->registerOutgoingSession(from, jingleSession); + + return boost::make_shared(jingleSession, udpSocketFactory, timerFactory); +} + +} diff --git a/Swiften/ScreenSharing/OutgoingScreenSharingManager.h b/Swiften/ScreenSharing/OutgoingScreenSharingManager.h new file mode 100644 index 0000000..de21d5a --- /dev/null +++ b/Swiften/ScreenSharing/OutgoingScreenSharingManager.h @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2012 Yoann Blein + * Licensed under the simplified BSD license. + * See Documentation/Licenses/BSD-simplified.txt for more information. + */ + +#pragma once + +#include +#include +#include + +namespace Swift { + class OutgoingScreenSharing; + class JingleSessionManager; + class IQRouter; + class UDPSocketFactory; + class TimerFactory; + + class OutgoingScreenSharingManager { + public: + OutgoingScreenSharingManager(JingleSessionManager* jingleSessionManager, IQRouter* router, + UDPSocketFactory* udpSocketFactory, TimerFactory* timerFactory); + + boost::shared_ptr createOutgoingScreenSharing(const JID& from, const JID& to); + + private: + IDGenerator idGenerator; + + JingleSessionManager* jsManager; + IQRouter* iqRouter; + UDPSocketFactory *udpSocketFactory; + TimerFactory* timerFactory; + }; +} diff --git a/Swiften/ScreenSharing/SConscript b/Swiften/ScreenSharing/SConscript index cc757a5..6504541 100644 --- a/Swiften/ScreenSharing/SConscript +++ b/Swiften/ScreenSharing/SConscript @@ -6,7 +6,13 @@ sources = [ "VP8RTPPacketizer.cpp", "VP8Decoder.cpp", "VP8RTPParser.cpp", - ] + "ScreenSharing.cpp", + "OutgoingScreenSharing.cpp", + "OutgoingScreenSharingManager.cpp", + "IncomingScreenSharing.cpp", + "IncomingScreenSharingManager.cpp", + "ScreenSharingManagerImpl.cpp", + ] objects = swiften_env.SwiftenObject(sources) diff --git a/Swiften/ScreenSharing/ScreenSharing.cpp b/Swiften/ScreenSharing/ScreenSharing.cpp new file mode 100644 index 0000000..fc7f672 --- /dev/null +++ b/Swiften/ScreenSharing/ScreenSharing.cpp @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2012 Yoann Blein + * Licensed under the simplified BSD license. + * See Documentation/Licenses/BSD-simplified.txt for more information. + */ + +#include + +#include +#include +#include + +#include +#include + +namespace Swift { + +ScreenSharing::ScreenSharing(boost::shared_ptr session, UDPSocketFactory* udpSocketFactory) + : session(session), udpSocketFactory(udpSocketFactory) +{ +} + +ScreenSharing::~ScreenSharing() +{ +} + +bool ScreenSharing::addBestCandidate(boost::shared_ptr transport) +{ + // TODO: NAT traversal + + JingleRawUDPTransportPayload::Candidate candidate; + candidate.cid = idGenerator.generateID(); + candidate.component = 1; + candidate.generation = 0; + + PlatformNetworkEnvironment env; + std::vector interfaces = env.getNetworkInterfaces(); + + // Find the first ip which is not loopback + foreach (const NetworkInterface& interface, interfaces) { + if (!interface.isLoopback()) { // exclude loopback + candidate.hostAddressPort = HostAddressPort(interface.getAddresses().front(), listeningPort); + candidate.type = JingleRawUDPTransportPayload::Candidate::Host; + transport->addCandidate(candidate); + + serverSocket = udpSocketFactory->createUDPSocket(); + serverSocket->bind(listeningPort); + + return true; + } + } + + // else loopback for self sharing + if (!interfaces.empty()) { + candidate.hostAddressPort = HostAddressPort(interfaces.front().getAddresses().front(), listeningPort); + candidate.type = JingleRawUDPTransportPayload::Candidate::Host; + transport->addCandidate(candidate); + + serverSocket = udpSocketFactory->createUDPSocket(); + serverSocket->bind(listeningPort); + + return true; + } + + return false; +} + +} diff --git a/Swiften/ScreenSharing/ScreenSharing.h b/Swiften/ScreenSharing/ScreenSharing.h new file mode 100644 index 0000000..1f6f753 --- /dev/null +++ b/Swiften/ScreenSharing/ScreenSharing.h @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2012 Yoann Blein + * Licensed under the simplified BSD license. + * See Documentation/Licenses/BSD-simplified.txt for more information. + */ + +#pragma once + +#include +#include + +#include + +namespace Swift { + class JingleSession; + class JingleRawUDPTransportPayload; + class UDPSocketFactory; + class UDPSocket; + + class ScreenSharing { + public: + typedef boost::shared_ptr ref; + + enum SCState { + Canceled, + Failed, + Finished, + Negotiating, + Connecting, + BroadCasting, + Receiving, + WaitingForStart, + WaitingForAccept, + }; + + public: + ScreenSharing(boost::shared_ptr session, UDPSocketFactory* udpSocketFactory); + virtual ~ScreenSharing(); + + virtual void cancel() = 0; + + public: + boost::signal onStateChange; + + protected: + bool addBestCandidate(boost::shared_ptr transport); + + protected: + static const int listeningPort = 28888; + + IDGenerator idGenerator; + boost::shared_ptr serverSocket; + boost::shared_ptr clientSocket; + + boost::shared_ptr session; + UDPSocketFactory* udpSocketFactory; + + }; +} diff --git a/Swiften/ScreenSharing/ScreenSharingManager.h b/Swiften/ScreenSharing/ScreenSharingManager.h new file mode 100644 index 0000000..a527402 --- /dev/null +++ b/Swiften/ScreenSharing/ScreenSharingManager.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2012 Yoann Blein + * Licensed under the simplified BSD license. + * See Documentation/Licenses/BSD-simplified.txt for more information. + */ + +#pragma once + +//#include +#include +#include + +namespace Swift { + class IncomingScreenSharing; + class OutgoingScreenSharing; + class JID; + + class ScreenSharingManager { + public: + virtual ~ScreenSharingManager() {} + + virtual boost::shared_ptr createOutgoingScreenSharing(const JID& to) = 0; + + boost::signal)> onIncomingScreenSharing; + }; +} diff --git a/Swiften/ScreenSharing/ScreenSharingManagerImpl.cpp b/Swiften/ScreenSharing/ScreenSharingManagerImpl.cpp new file mode 100644 index 0000000..4b88581 --- /dev/null +++ b/Swiften/ScreenSharing/ScreenSharingManagerImpl.cpp @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2012 Yoann Blein + * Licensed under the simplified BSD license. + * See Documentation/Licenses/BSD-simplified.txt for more information. + */ + +#include + +#include +#include + +namespace Swift { + +ScreenSharingManagerImpl::ScreenSharingManagerImpl(const JID& ownFullJID, JingleSessionManager *jingleSessionManager, IQRouter *iqRouter, + UDPSocketFactory* udpSocketFactory, TimerFactory* timerFactory) + : ownJID(ownFullJID)/*, jingleSM(jingleSessionManager), iqRouter(iqRouter), udpSocketFactory(udpSocketFactory), timerFactory(timerFactory)*/ +{ + incomingSSManager = new IncomingScreenSharingManager(jingleSessionManager, iqRouter, udpSocketFactory); + outgoingSSManager = new OutgoingScreenSharingManager(jingleSessionManager, iqRouter, udpSocketFactory, timerFactory); + + incomingSSManager->onIncomingScreenSharing.connect(onIncomingScreenSharing); +} + +ScreenSharingManagerImpl::~ScreenSharingManagerImpl() +{ +} + +boost::shared_ptr ScreenSharingManagerImpl::createOutgoingScreenSharing(const JID &to) +{ + JID receipient = to; + + if (receipient.isBare()) { + //boost::optional fullJID = highestPriorityJIDSupportingFileTransfer(receipient); + //if (fullJID.is_initialized()) { + // receipient = fullJID.get(); + //} else { + return boost::shared_ptr(); + //} + } + + return outgoingSSManager->createOutgoingScreenSharing(ownJID, receipient); +} + +} diff --git a/Swiften/ScreenSharing/ScreenSharingManagerImpl.h b/Swiften/ScreenSharing/ScreenSharingManagerImpl.h new file mode 100644 index 0000000..0075630 --- /dev/null +++ b/Swiften/ScreenSharing/ScreenSharingManagerImpl.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2012 Yoann Blein + * Licensed under the simplified BSD license. + * See Documentation/Licenses/BSD-simplified.txt for more information. + */ + +#pragma once + +#include +#include + +namespace Swift { + class IncomingScreenSharingManager; + class OutgoingScreenSharingManager; + class JingleSessionManager; + class IQRouter; + class UDPSocketFactory; + class TimerFactory; + + class ScreenSharingManagerImpl : public ScreenSharingManager { + public: + ScreenSharingManagerImpl(const JID& ownFullJID, JingleSessionManager* jingleSessionManager, IQRouter *iqRouter, + UDPSocketFactory* udpSocketFactory, TimerFactory* timerFactory); + virtual ~ScreenSharingManagerImpl(); + + virtual boost::shared_ptr createOutgoingScreenSharing(const JID& to); + + private: + IncomingScreenSharingManager* incomingSSManager; + OutgoingScreenSharingManager* outgoingSSManager; + + JID ownJID; + +// JingleSessionManager* jingleSM; +// IQRouter* iqRouter; +// BoostUDPSocketFactory* udpSocketFactory; +// TimerFactory* timerFactory; + }; +} -- cgit v0.10.2-6-g49f6