sess->addClient(socket);
}
+void Core::setupInternalClientSession(SignalProxy *proxy) {
+ UserId uid = 3; // FIXME!!!11
+ // Find or create session for validated user
+ SessionThread *sess;
+ if(sessions.contains(uid))
+ sess = sessions[uid];
+ else
+ sess = createSession(uid);
+ sess->addClient(proxy);
+}
+
SessionThread *Core::createSession(UserId uid, bool restore) {
if(sessions.contains(uid)) {
quWarning() << "Calling createSession() when a session for the user already exists!";
class CoreSession;
class SessionThread;
+class SignalProxy;
class Storage;
struct NetworkInfo;
/** \note This method is threadsafe.
*/
void syncStorage();
-
+ void setupInternalClientSession(SignalProxy *proxy);
signals:
//! Sent when a BufferInfo is updated in storage.
void bufferInfoUpdated(UserId user, const BufferInfo &info);
void CoreSession::networkStateRequested() {
}
-void CoreSession::addClient(QObject *dev) { // this is QObject* so we can use it in signal connections
- QIODevice *device = qobject_cast<QIODevice *>(dev);
+void CoreSession::addClient(QIODevice *device) {
if(!device) {
quError() << "Invoking CoreSession::addClient with a QObject that is not a QIODevice!";
} else {
}
}
+void CoreSession::addClient(SignalProxy *proxy) {
+ signalProxy()->addPeer(proxy);
+ emit sessionState(sessionState());
+}
+
void CoreSession::removeClient(QIODevice *iodev) {
QTcpSocket *socket = qobject_cast<QTcpSocket *>(iodev);
if(socket)
public slots:
void networkStateRequested();
- void addClient(QObject *socket);
+ void addClient(QIODevice *device);
+ void addClient(SignalProxy *proxy);
void connectToNetwork(NetworkId);
void disconnectFromNetwork(NetworkId id);
signals:
void initialized();
+ void sessionState(const QVariant &);
//void msgFromGui(uint netid, QString buf, QString message);
void displayMsg(Message message);
#include <QMutexLocker>
#include "sessionthread.h"
-
+#include "signalproxy.h"
#include "coresession.h"
-SessionThread::SessionThread(UserId uid, bool restoreState, QObject *parent) : QThread(parent) {
- _user = uid;
- _session = 0;
- _sessionInitialized = false;
- _restoreState = restoreState,
- connect(this, SIGNAL(initialized()), this, SLOT(setSessionInitialized()));
+SessionThread::SessionThread(UserId uid, bool restoreState, QObject *parent)
+ : QThread(parent),
+ _session(0),
+ _user(uid),
+ _sessionInitialized(false),
+ _restoreState(restoreState)
+{
+ connect(this, SIGNAL(initialized()), this, SLOT(setSessionInitialized()));
}
SessionThread::~SessionThread() {
void SessionThread::setSessionInitialized() {
_sessionInitialized = true;
- foreach(QIODevice *socket, clientQueue) {
- addClientToSession(socket);
+ foreach(QObject *peer, clientQueue) {
+ addClientToSession(peer);
}
clientQueue.clear();
}
-void SessionThread::addClient(QIODevice *socket) {
+void SessionThread::addClient(QObject *peer) {
if(isSessionInitialized()) {
- addClientToSession(socket);
+ addClientToSession(peer);
} else {
- clientQueue.append(socket);
+ clientQueue.append(peer);
+ }
+}
+
+void SessionThread::addClientToSession(QObject *peer) {
+ QIODevice *socket = qobject_cast<QIODevice *>(peer);
+ if(socket) {
+ addRemoteClientToSession(socket);
+ return;
+ }
+
+ SignalProxy *proxy = qobject_cast<SignalProxy *>(peer);
+ if(proxy) {
+ addInternalClientToSession(proxy);
+ return;
}
+
+ qWarning() << "SessionThread::addClient() received neither QIODevice nor SignalProxy as peer!" << peer;
}
-void SessionThread::addClientToSession(QIODevice *socket) {
+void SessionThread::addRemoteClientToSession(QIODevice *socket) {
socket->setParent(0);
socket->moveToThread(session()->thread());
- if(!QMetaObject::invokeMethod(session(), "addClient", Q_ARG(QObject *, socket))) {
- qWarning() << qPrintable(tr("Could not initialize session!"));
- socket->close();
- }
+ emit addRemoteClient(socket);
+}
+
+void SessionThread::addInternalClientToSession(SignalProxy *proxy) {
+ emit addInternalClient(proxy);
}
void SessionThread::run() {
_session = new CoreSession(user(), _restoreState);
+ connect(this, SIGNAL(addRemoteClient(QIODevice *)), _session, SLOT(addClient(QIODevice *)));
+ connect(this, SIGNAL(addInternalClient(SignalProxy *)), _session, SLOT(addClient(SignalProxy *)));
emit initialized();
exec();
delete _session;
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
-#ifndef _SESSIONTHREAD_H_
-#define _SESSIONTHREAD_H_
+#ifndef SESSIONTHREAD_H
+#define SESSIONTHREAD_H
#include <QMutex>
#include <QThread>
class CoreSession;
class QIODevice;
+class SignalProxy;
class SessionThread : public QThread {
Q_OBJECT
- public:
- SessionThread(UserId user, bool restoreState, QObject *parent = 0);
- ~SessionThread();
+public:
+ SessionThread(UserId user, bool restoreState, QObject *parent = 0);
+ ~SessionThread();
- void run();
+ void run();
- CoreSession *session();
- UserId user();
+ CoreSession *session();
+ UserId user();
- public slots:
- void addClient(QIODevice *socket);
+public slots:
+ void addClient(QObject *peer);
- private slots:
- void setSessionInitialized();
+private slots:
+ void setSessionInitialized();
- signals:
- void initialized();
- void shutdown();
+signals:
+ void initialized();
+ void shutdown();
- private:
- CoreSession *_session;
- UserId _user;
- QList<QIODevice *> clientQueue;
- bool _sessionInitialized;
- bool _restoreState;
+ void addRemoteClient(QIODevice *);
+ void addInternalClient(SignalProxy *);
- bool isSessionInitialized();
- void addClientToSession(QIODevice *socket);
+private:
+ CoreSession *_session;
+ UserId _user;
+ QList<QObject *> clientQueue;
+ bool _sessionInitialized;
+ bool _restoreState;
+
+ bool isSessionInitialized();
+ void addClientToSession(QObject *peer);
+ void addRemoteClientToSession(QIODevice *socket);
+ void addInternalClientToSession(SignalProxy *proxy);
};
#endif