Added the UML to git. Made the state classes of their own and fixed networking.

diff --git a/docs/xbmcnetmoviesremote.zargo b/docs/xbmcnetmoviesremote.zargo
new file mode 100644 (file)
index 0000000..77504bc
Binary files /dev/null and b/docs/xbmcnetmoviesremote.zargo differ

diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 8fcae21..320f7fd 100644 (file)
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -27,21 +27,21 @@
 #endif // Q_OS_SYMBIAN && ORIENTATIONLOCK
 
 MainWindow::MainWindow(QWidget *parent)
-    : QMainWindow(parent), ui(new Ui::MainWindow)
+    : QMainWindow(parent), m_ui(new Ui::MainWindow)
 {
-    ui->setupUi(this);
+    m_ui->setupUi(this);
 
     createStates();
     createTransitions();
     createConnections();
 
-    stateMachine.setInitialState(disconnectedState);
-    QTimer::singleShot(0, &stateMachine, SLOT(start()));
+    m_stateMachine.setInitialState(m_disconnectedState);
+    QTimer::singleShot(0, &m_stateMachine, SLOT(start()));
 }
 
 MainWindow::~MainWindow()
 {
-    delete ui;
+    delete m_ui;
 }
 
 void MainWindow::setOrientation(ScreenOrientation orientation)
@@ -102,56 +102,148 @@ void MainWindow::on_actionSetup_triggered()
     }
 }
 
-void MainWindow::connectToServer()
+void MainWindow::createStates()
 {
+    m_disconnectedState = new DisconnectedState(m_ui->networkButton, &m_serverSocket, &m_stateMachine);
+    m_connectingState = new ConnectingState(m_ui->networkButton, &m_serverSocket, &m_stateMachine);
+    m_connectedState = new ConnectedState(m_ui->networkButton, &m_serverSocket, &m_stateMachine);
+    m_disconnectingState = new DisconnectingState(m_ui->networkButton, &m_serverSocket, &m_stateMachine);
+}
+
+void MainWindow::createTransitions()
+{
+    m_disconnectedState->addTransition(m_ui->networkButton, SIGNAL(clicked()), m_connectingState);
+
+    m_connectingState->addTransition(m_connectingState, SIGNAL(connected()), m_connectedState);
+    m_connectingState->addTransition(m_connectingState, SIGNAL(failed()), m_disconnectedState);
+
+    m_connectedState->addTransition(m_ui->networkButton, SIGNAL(clicked()), m_disconnectingState);
+    m_connectedState->addTransition(m_connectedState, SIGNAL(disconnected()), m_disconnectedState);
+
+    m_disconnectingState->addTransition(m_disconnectingState, SIGNAL(disconnected()), m_disconnectedState);
+}
+
+void MainWindow::createConnections()
+{
+}
+
+/////////////////////////////////////////////////////////////////////
+//
+DisconnectedState::DisconnectedState(QAbstractButton *button, QTcpSocket* socket, QState *parent)
+    : QState(parent), m_socket(socket)
+{
+    assignProperty(button, "text", "Connect");
+    assignProperty(button, "enabled", true);
+}
+
+void DisconnectedState::onEntry(QEvent */*event*/)
+{
+    qDebug("DisconnectedState::onEntry");
+}
+
+void DisconnectedState::onExit(QEvent */*event*/)
+{
+    qDebug("DisconnectedState::onExit");
+}
+
+/////////////////////////////////////////////////////////////////////
+//
+ConnectingState::ConnectingState(QAbstractButton *button, QTcpSocket* socket, QState *parent)
+    : QState(parent), m_socket(socket)
+{
+    assignProperty(button, "text", "Connecting");
+    assignProperty(button, "enabled", false);
+}
+
+void ConnectingState::onEntry(QEvent */*event*/)
+{
+    qDebug("ConnectingState::onEntry");
+
+    connect(m_socket, SIGNAL(connected()), this, SIGNAL(connected()));
+    connect(m_socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(onSocketError(QAbstractSocket::SocketError)));
+
     // TODO: we asume the socket is not already connected
     // TODO: we should add code to do nothing if the connection is ok, or close and open a new one if the server or port changed
     QSettings settings;
 
-    serverSocket.connectToHost(settings.value(SETUP_XBMC_SERVER, SETUP_XBMC_SERVER_DEFAULT).toString(),
-                               settings.value(SETUP_XBMC_PORT, SETUP_XBMC_PORT_DEFAULT).toInt());
+    m_socket->connectToHost(settings.value(SETUP_XBMC_SERVER, SETUP_XBMC_SERVER_DEFAULT).toString(),
+                            settings.value(SETUP_XBMC_PORT, SETUP_XBMC_PORT_DEFAULT).toInt());
 }
 
-void MainWindow::disconnectFromServer()
+void ConnectingState::onExit(QEvent */*event*/)
 {
-    serverSocket.disconnectFromHost();
+    disconnect(m_socket, 0, this, 0);
+    qDebug("ConnectingState::onExit");
 }
 
-void MainWindow::createStates()
+void ConnectingState::onSocketError(QAbstractSocket::SocketError)
 {
-    disconnectedState = new QState(&stateMachine);
-    disconnectedState->assignProperty(ui->networkButton, "text", "Connect");
-    disconnectedState->assignProperty(ui->networkButton, "enabled", true);
+    qDebug("ConnectingState::onSocketError: %s", qPrintable(m_socket->errorString()));
+    emit failed();
+}
 
-    connectedState = new QState(&stateMachine);
+/////////////////////////////////////////////////////////////////////
+//
+ConnectedState::ConnectedState(QAbstractButton *button, QTcpSocket* socket, QState *parent)
+    : QState(parent), m_socket(socket)
+{
+    assignProperty(button, "text", "Disconnect");
+    assignProperty(button, "enabled", true);
 
-    connectingState = new QState(connectedState);
-    connectingState->assignProperty(ui->networkButton, "text", "Connecting");
-    connectingState->assignProperty(ui->networkButton, "enabled", false);
+}
 
-    normalState = new QState(connectedState);
-    normalState->assignProperty(ui->networkButton, "text", "Disconnect");
-    normalState->assignProperty(ui->networkButton, "enabled", true);
+void ConnectedState::onEntry(QEvent */*event*/)
+{
+    qDebug("ConnectedState::onEntry");
 
-    disconnectingState = new QState(connectedState);
-    disconnectingState->assignProperty(ui->networkButton, "text", "Disconnecting");
-    disconnectingState->assignProperty(ui->networkButton, "enabled", false);
+    connect(m_socket, SIGNAL(disconnected()), this, SIGNAL(disconnected()));
+    connect(m_socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(onSocketError(QAbstractSocket::SocketError)));
 }
 
-void MainWindow::createTransitions()
+void ConnectedState::onExit(QEvent */*event*/)
+{
+    disconnect(m_socket, 0, this, 0);
+    qDebug("ConnectedState::onExit");
+}
+
+void ConnectedState::onSocketError(QAbstractSocket::SocketError)
+{
+    qDebug("ConnectedState::onSocketError: %s", qPrintable(m_socket->errorString()));
+}
+
+/////////////////////////////////////////////////////////////////////
+//
+DisconnectingState::DisconnectingState(QAbstractButton *button, QTcpSocket* socket, QState *parent)
+    : QState(parent), m_socket(socket)
+{
+    assignProperty(button, "text", "Disconnecting");
+    assignProperty(button, "enabled", false);
+}
+
+void DisconnectingState::onEntry(QEvent */*event*/)
 {
-    disconnectedState->addTransition(ui->networkButton, SIGNAL(clicked()), connectingState);
+    qDebug("DisconnectingState::onEntry");
 
-    connectedState->addTransition(&serverSocket, SIGNAL(disconnected()), disconnectedState);
+    connect(m_socket, SIGNAL(disconnected()), this, SIGNAL(disconnected()));
+    connect(m_socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(onSocketError(QAbstractSocket::SocketError)));
 
-    connectingState->addTransition(&serverSocket, SIGNAL(connected()), normalState);
-    connectingState->addTransition(&serverSocket, SIGNAL(error(QAbstractSocket::SocketError)), disconnectedState);
+    if (m_socket->state() != QTcpSocket::UnconnectedState) {
+        qDebug("DisconnectingState::disconnectFromHost");
+        m_socket->disconnectFromHost();
+    }
+    else {
+        qDebug("DisconnectingState::disconnect");
+        QTimer::singleShot(0, this, SIGNAL(disconnected()));
+    }
+}
 
-    normalState->addTransition(ui->networkButton, SIGNAL(clicked()), disconnectingState);
+void DisconnectingState::onExit(QEvent */*event*/)
+{
+    disconnect(m_socket, 0, this, 0);
+    qDebug("DisconnectingState::onExit");
 }
 
-void MainWindow::createConnections()
+void DisconnectingState::onSocketError(QAbstractSocket::SocketError)
 {
-    connect(connectingState, SIGNAL(entered()), this, SLOT(connectToServer()));
-    connect(disconnectingState, SIGNAL(entered()), this, SLOT(disconnectFromServer()));
+    qDebug("DisconnectingState::onSocketError: %s", qPrintable(m_socket->errorString()));
 }

diff --git a/src/mainwindow.h b/src/mainwindow.h
index 4db21b3..e8c488c 100644 (file)
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -11,14 +11,81 @@
 #define MAINWINDOW_H
 
 #include <QtGui/QMainWindow>
-#include <QtNetwork/QTcpSocket>
+#include <QTcpSocket>
 #include <QStateMachine>
 #include <QState>
+#include <QAbstractButton>
 
 namespace Ui {
     class MainWindow;
 }
 
+class DisconnectedState : public QState
+{
+public:
+    DisconnectedState(QAbstractButton* button, QTcpSocket* socket, QState* parent = 0);
+
+protected:
+    void onEntry(QEvent *event);
+    void onExit(QEvent *event);
+    QTcpSocket* m_socket;
+};
+
+class ConnectingState : public QState
+{
+    Q_OBJECT
+public:
+    ConnectingState(QAbstractButton* button, QTcpSocket* socket, QState* parent = 0);
+
+signals:
+    void connected();
+    void failed();
+
+private slots:
+    void onSocketError(QAbstractSocket::SocketError err);
+
+protected:
+    void onEntry(QEvent *event);
+    void onExit(QEvent *event);
+    QTcpSocket* m_socket;
+};
+
+class ConnectedState : public QState
+{
+    Q_OBJECT
+public:
+    ConnectedState(QAbstractButton* button, QTcpSocket* socket, QState* parent = 0);
+
+private slots:
+    void onSocketError(QAbstractSocket::SocketError err);
+
+signals:
+    void disconnected();
+
+protected:
+    void onEntry(QEvent *event);
+    void onExit(QEvent *event);
+    QTcpSocket* m_socket;
+};
+
+class DisconnectingState : public QState
+{
+    Q_OBJECT
+public:
+    DisconnectingState(QAbstractButton* button, QTcpSocket* socket, QState* parent = 0);
+
+signals:
+    void disconnected();
+
+private slots:
+    void onSocketError(QAbstractSocket::SocketError err);
+
+protected:
+    void onEntry(QEvent *event);
+    void onExit(QEvent *event);
+    QTcpSocket* m_socket;
+};
+
 class MainWindow : public QMainWindow
 {
     Q_OBJECT
@@ -36,10 +103,6 @@ public:
     void showExpanded();
 
 private slots:
-    // manual connected slots
-    void connectToServer();
-    void disconnectFromServer();
-
     // auto-connected slots
     void on_actionSetup_triggered();
 
@@ -50,15 +113,15 @@ private:
     void createTransitions();
     void createConnections();
 
-    QTcpSocket serverSocket;
-    Ui::MainWindow *ui;
+    QTcpSocket m_serverSocket;
+    Ui::MainWindow *m_ui;
+
+    QStateMachine m_stateMachine;
 
-    QStateMachine stateMachine;
-    QState* disconnectedState;
-    QState* connectedState;
-    QState* disconnectingState;
-    QState* normalState;
-    QState* connectingState;
+    DisconnectedState* m_disconnectedState;
+    ConnectingState* m_connectingState;
+    ConnectedState* m_connectedState;
+    DisconnectingState* m_disconnectingState;
 };
 
 #endif // MAINWINDOW_H