Move connection creation to DeviceConnectionManager.

Calling openConnection will return an open connection or nullptr.
Deleting the connection will close it.

SerialPort now uses this under the hood, while still presenting
the QSerialPort-compatible interface.

oscar/SleepLib/deviceconnection.cpp

@@ -293,6 +293,7 @@ template<typename T> QXmlStreamReader & operator>>(QXmlStreamReader & xml, QList
     return xml;
 }
 
+// We use this extra CRTP templating so that concrete event subclasses require as little code as possible.
 template <typename Derived>
 class XmlReplayBase : public XmlReplayEvent
 {
@@ -372,6 +373,75 @@ void DeviceConnectionManager::replay(QFile* file)
     }
 }
 
+DeviceConnection* DeviceConnectionManager::openConnection(const QString & type, const QString & name)
+{
+    if (!s_factories.contains(type)) {
+        qWarning() << "Unknown device connection type:" << type;
+        return nullptr;
+    }
+    if (m_connections[type].contains(name)) {
+        qWarning() << type << "connection to" << name << "already open";
+        return nullptr;
+    }
+
+    DeviceConnection* conn = s_factories[type](name, m_record, m_replay);
+    if (conn) {
+        if (conn->open()) {
+            m_connections[type][name] = conn;
+        } else {
+            qWarning().noquote() << "unable to open" << type << "connection to" << name;
+            delete conn;
+            conn = nullptr;
+        }
+    } else {
+        qWarning() << "unable to create" << type << "connection to" << name;
+    }
+    // TODO: record event
+    return conn;
+}
+
+void DeviceConnectionManager::connectionClosed(DeviceConnection* conn)
+{
+    Q_ASSERT(conn);
+    const QString & type = conn->type();
+    const QString & name = conn->name();
+
+    Q_ASSERT(s_factories.contains(type));
+    if (m_connections[type].contains(name)) {
+        if (m_connections[type][name] == conn) {
+            m_connections[type].remove(name);
+        } else {
+            qWarning() << type << "connection to" << name << "not created by openConnection!";
+        }
+    } else {
+        qWarning() << type << "connection to" << name << "missing";
+    }
+    // TODO: record event
+}
+
+// Temporary convenience function for code that still supports only serial ports.
+SerialPortConnection* DeviceConnectionManager::openSerialPortConnection(const QString & portName)
+{
+    return dynamic_cast<SerialPortConnection*>(getInstance().openConnection(SerialPortConnection::TYPE, portName));
+}
+
+
+QHash<QString,DeviceConnection::FactoryMethod> DeviceConnectionManager::s_factories;
+
+bool DeviceConnectionManager::registerClass(const QString & type, DeviceConnection::FactoryMethod factory)
+{
+    if (s_factories.contains(type)) {
+        qWarning() << "Connection class already registered for type" << type;
+        return false;
+    }
+    s_factories[type] = factory;
+    return true;
+}
+
+#define REGISTER_DEVICECONNECTION(type, T) \
+const QString T::TYPE = type; \
+const bool T::registered = DeviceConnectionManager::registerClass(T::TYPE, T::createInstance); \
+DeviceConnection* T::createInstance(const QString & name, XmlRecorder* record, XmlReplay* replay) { return static_cast<DeviceConnection*>(new T(name, record, replay)); }
 
 // MARK: -
 // MARK: Device manager events
@@ -520,7 +590,17 @@ bool SerialPortInfo::operator==(const SerialPortInfo & other) const
 
 
 // MARK: -
-// MARK: Serial port connection
+// MARK: Device connection base class
+
+DeviceConnection::DeviceConnection(const QString & name, XmlRecorder* record, XmlReplay* replay)
+    : m_name(name), m_record(record), m_replay(replay), m_opened(false)
+{
+}
+
+DeviceConnection::~DeviceConnection()
+{
+}
+
 
 // TODO: log these to XML stream
 
@@ -591,44 +671,43 @@ QXmlStreamWriter & operator<<(QXmlStreamWriter & xml, const ConnectionEvent & ev
 }
 
 
-SerialPortConnection::SerialPortConnection(const QString & name)
-    : m_portName(name)
-{
-    connect(&m_port, SIGNAL(readyRead()), this, SLOT(onReadyRead()));
-}
+// MARK: -
+// MARK: Serial port connection
 
-// TODO: temporary method for legacy compatibility
-SerialPortConnection::SerialPortConnection()
+REGISTER_DEVICECONNECTION("serial", SerialPortConnection);
+
+SerialPortConnection::SerialPortConnection(const QString & name, XmlRecorder* record, XmlReplay* replay)
+    : DeviceConnection(name, record, replay)
 {
     connect(&m_port, SIGNAL(readyRead()), this, SLOT(onReadyRead()));
 }
 
 SerialPortConnection::~SerialPortConnection()
 {
+    if (m_opened) {
+        close();
+        DeviceConnectionManager::getInstance().connectionClosed(this);
+    }
     disconnect(&m_port, SIGNAL(readyRead()), this, SLOT(onReadyRead()));
 }
 
-// TODO: temporary method for legacy compatibility
-void SerialPortConnection::setPortName(const QString &name)
+bool SerialPortConnection::open()
 {
-    Q_ASSERT(m_portName.isEmpty());
-    m_portName = name;
-}
-
-// TODO: This will eventually be open(), the constructor will be given the name, and the mode will always be ReadWrite
-bool SerialPortConnection::open(QIODevice::OpenMode mode)
-{
-    Q_ASSERT(mode == QSerialPort::ReadWrite);
+    if (m_opened) {
+        qWarning() << "serial connection to" << m_name << "already opened";
+        return false;
+    }
     ConnectionEvent event("openConnection");
     event.set("type", "serial");
-    event.set("port", m_portName);
+    event.set("name", m_name);
 
-    m_port.setPortName(m_portName);
-    checkResult(m_port.open(mode), event);
+    m_port.setPortName(m_name);
+    checkResult(m_port.open(QSerialPort::ReadWrite), event);
 
     // TODO: send this event back to manager to log
     qDebug().noquote() << event;
 
+    m_opened = event.ok();
     return event.ok();
 }
 
@@ -754,7 +833,7 @@ void SerialPortConnection::close()
 {
     ConnectionEvent event("closeConnection");
     event.set("type", "serial");
-    event.set("port", m_portName);
+    event.set("name", m_name);
 
     // TODO: the separate connection stream will have an enclosing "connection" tag with these
     // attributes. The main device connection manager stream will log this openConnection/
@@ -773,6 +852,9 @@ void SerialPortConnection::onReadyRead()
     ConnectionEvent event("readyRead");
 
     // TODO: Most of the playback API reponds to the caller. How do we replay port-driven events?
+    // Probably add an ordered linked list of events, a peekNextEvent, getNextEvent(void),
+    // and event->replay() method that calls the appropriate method. (May as well have the
+    // destructor walk the links list rather than the per-type lists.)
     qDebug().noquote() << event;
 
     emit readyRead();
@@ -801,3 +883,107 @@ void SerialPortConnection::checkError(ConnectionEvent & event) const
         event.set("error", error);
     }
 }
+
+
+// MARK: -
+// MARK: SerialPort legacy class
+
+SerialPort::SerialPort()
+{
+}
+
+SerialPort::~SerialPort()
+{
+    if (m_conn) {
+        close();
+    }
+}
+
+void SerialPort::setPortName(const QString &name)
+{
+    m_portName = name;
+}
+
+bool SerialPort::open(QIODevice::OpenMode mode)
+{
+    Q_ASSERT(!m_conn);
+    Q_ASSERT(mode == QSerialPort::ReadWrite);
+    m_conn = DeviceConnectionManager::openSerialPortConnection(m_portName);
+    if (m_conn) {
+        connect(m_conn, SIGNAL(readyRead()), this, SLOT(onReadyRead()));
+    }
+    return m_conn != nullptr;
+}
+
+bool SerialPort::setBaudRate(qint32 baudRate, QSerialPort::Directions directions)
+{
+    Q_ASSERT(m_conn);
+    return m_conn->setBaudRate(baudRate, directions);
+}
+
+bool SerialPort::setDataBits(QSerialPort::DataBits dataBits)
+{
+    Q_ASSERT(m_conn);
+    return m_conn->setDataBits(dataBits);
+}
+
+bool SerialPort::setParity(QSerialPort::Parity parity)
+{
+    Q_ASSERT(m_conn);
+    return m_conn->setParity(parity);
+}
+
+bool SerialPort::setStopBits(QSerialPort::StopBits stopBits)
+{
+    Q_ASSERT(m_conn);
+    return m_conn->setStopBits(stopBits);
+}
+
+bool SerialPort::setFlowControl(QSerialPort::FlowControl flowControl)
+{
+    Q_ASSERT(m_conn);
+    return m_conn->setFlowControl(flowControl);
+}
+
+bool SerialPort::clear(QSerialPort::Directions directions)
+{
+    Q_ASSERT(m_conn);
+    return m_conn->clear(directions);
+}
+
+qint64 SerialPort::bytesAvailable() const
+{
+    Q_ASSERT(m_conn);
+    return m_conn->bytesAvailable();
+}
+
+qint64 SerialPort::read(char *data, qint64 maxSize)
+{
+    Q_ASSERT(m_conn);
+    return m_conn->read(data, maxSize);
+}
+
+qint64 SerialPort::write(const char *data, qint64 maxSize)
+{
+    Q_ASSERT(m_conn);
+    return m_conn->write(data, maxSize);
+}
+
+bool SerialPort::flush()
+{
+    Q_ASSERT(m_conn);
+    return m_conn->flush();
+}
+
+void SerialPort::close()
+{
+    Q_ASSERT(m_conn);
+    disconnect(m_conn, SIGNAL(readyRead()), this, SLOT(onReadyRead()));
+    delete m_conn;  // this will close the connection
+    m_conn = nullptr;
+}
+
+void SerialPort::onReadyRead()
+{
+    emit readyRead();
+}

oscar/SleepLib/deviceconnection.h

@@ -19,6 +19,34 @@
 #include <QXmlStreamReader>
 #include <QXmlStreamWriter>
 
+class XmlRecorder;
+class XmlReplay;
+
+class DeviceConnection : public QObject
+{
+    Q_OBJECT
+
+protected:
+    DeviceConnection(const QString & name, XmlRecorder* record, XmlReplay* replay);
+
+    const QString & m_name;
+    XmlRecorder* m_record;
+    XmlReplay* m_replay;
+    bool m_opened;
+
+    virtual bool open() = 0;
+    friend class DeviceConnectionManager;
+
+public:
+    // See DeviceConnectionManager::openConnection() to create connections.
+    virtual ~DeviceConnection();
+    virtual const QString & type() const = 0;
+    const QString & name() const { return m_name; }
+
+    typedef DeviceConnection* (*FactoryMethod)(const QString & name, XmlRecorder* record, XmlReplay* replay);
+};
+
+
 class DeviceConnectionManager : public QObject
 {
     Q_OBJECT
@@ -26,8 +54,8 @@ class DeviceConnectionManager : public QObject
 private:
     DeviceConnectionManager();
     
-    class XmlRecorder* m_record;
-    class XmlReplay* m_replay;
+    XmlRecorder* m_record;
+    XmlReplay* m_replay;
 
     QList<class SerialPortInfo> replayAvailablePorts();
     QList<SerialPortInfo> m_serialPorts;
@@ -35,8 +63,12 @@ private:
         m_serialPorts.clear();
     }
 
+    QHash<QString,QHash<QString,DeviceConnection*>> m_connections;
+
 public:
     static DeviceConnectionManager & getInstance();
+    class DeviceConnection* openConnection(const QString & type, const QString & name);
+    static class SerialPortConnection* openSerialPortConnection(const QString & portName);  // temporary
 
     QList<class SerialPortInfo> getAvailablePorts();
     // TODO: method to start a polling thread that maintains the list of ports
@@ -47,11 +79,14 @@ public:
     void replay(class QFile* stream);
     void replay(const QString & string);
 
-};
+    // DeviceConnection subclasses registration
+protected:
+    static QHash<QString,DeviceConnection::FactoryMethod> s_factories;
+public:
+    static bool registerClass(const QString & type, DeviceConnection::FactoryMethod factory);
+    static class DeviceConnection* createInstance(const QString & type);
 
-class DeviceConnection : public QObject
-{
-    Q_OBJECT
+    void connectionClosed(DeviceConnection* conn);
 };
 
 // TODO: This class may eventually be internal to a DeviceConnection class,
@@ -63,10 +98,52 @@ class SerialPortConnection : public DeviceConnection
 
 private:
     QSerialPort m_port;
-    QString m_portName;
     void checkResult(bool ok, class ConnectionEvent & event) const;
     void checkResult(qint64 len, class ConnectionEvent & event) const;
     void checkError(class ConnectionEvent & event) const;
+    void close();
+
+private slots:
+    void onReadyRead();
+
+signals:
+    void readyRead();
+
+protected:
+    SerialPortConnection(const QString & name, XmlRecorder* record, XmlReplay* replay);
+    virtual bool open();
+
+public:
+    // See DeviceConnectionManager::openConnection() to create connections.
+    virtual ~SerialPortConnection();
+    
+    bool setBaudRate(qint32 baudRate, QSerialPort::Directions directions = QSerialPort::AllDirections);
+    bool setDataBits(QSerialPort::DataBits dataBits);
+    bool setParity(QSerialPort::Parity parity);
+    bool setStopBits(QSerialPort::StopBits stopBits);
+    bool setFlowControl(QSerialPort::FlowControl flowControl);
+    bool clear(QSerialPort::Directions directions = QSerialPort::AllDirections);
+    qint64 bytesAvailable() const;
+    qint64 read(char *data, qint64 maxSize);
+    qint64 write(const char *data, qint64 maxSize);
+    bool flush();
+
+    // Subclass registration with DeviceConnectionManager
+public:
+    static DeviceConnection* createInstance(const QString & name, XmlRecorder* record, XmlReplay* replay);
+    static const QString TYPE;
+    static const bool registered;
+    virtual const QString & type() const { return TYPE; }
+};
+
+// TODO: temporary class for legacy compatibility
+class SerialPort : public QObject
+{
+    Q_OBJECT
+    
+private:
+    SerialPortConnection* m_conn;
+    QString m_portName;
 
 private slots:
     void onReadyRead();
@@ -75,13 +152,10 @@ signals:
     void readyRead();
 
 public:
-    // TODO: temporary methods for legacy compatibility
-    SerialPortConnection();
-    void setPortName(const QString &name);
+    SerialPort();
+    virtual ~SerialPort();
 
-    SerialPortConnection(const QString &name);
-    virtual ~SerialPortConnection();
-    
+    void setPortName(const QString &name);
     bool open(QIODevice::OpenMode mode);
     bool setBaudRate(qint32 baudRate, QSerialPort::Directions directions = QSerialPort::AllDirections);
     bool setDataBits(QSerialPort::DataBits dataBits);
@@ -94,12 +168,6 @@ public:
     qint64 write(const char *data, qint64 maxSize);
     bool flush();
     void close();
-
-};
-
-// TODO: temporary class for legacy compatibility
-class SerialPort : public SerialPortConnection
-{
 };
 
 // TODO: This class's functionality will eventually be internal to a

oscar/tests/deviceconnectiontests.cpp

@@ -9,6 +9,9 @@
 #include "deviceconnectiontests.h"
 #include "SleepLib/deviceconnection.h"
 
+// TODO: eventually this should move to serialoximeter.h
+#include "SleepLib/loader_plugins/cms50f37_loader.h"
+
 #include <QTemporaryFile>
 
 void DeviceConnectionTests::testSerialPortInfoSerialization()
@@ -88,3 +91,43 @@ void DeviceConnectionTests::testSerialPortScanning()
     devices.replay(nullptr);  // turn off replay
     list3 = SerialPortInfo::availablePorts();
 }
+
+
+void DeviceConnectionTests::testOximeterConnection()
+{
+    CMS50F37Loader::Register();
+
+    // Initialize main event loop to initialize threads and enable signals and slots.
+    int argc = 1;
+    const char* argv = "test";
+    QCoreApplication app(argc, (char**) &argv);
+    
+    QString string;
+    DeviceConnectionManager & devices = DeviceConnectionManager::getInstance();
+    devices.record(string);
+
+    // new API
+    QString portName = "cu.SLAB_USBtoUART";
+    {
+        QScopedPointer<DeviceConnection> conn(devices.openConnection("serial", portName));
+        Q_ASSERT(conn);
+        Q_ASSERT(devices.openConnection("serial", portName) == nullptr);
+    }
+    {
+        QScopedPointer<SerialPortConnection> conn(devices.openSerialPortConnection(portName));
+        Q_ASSERT(conn);
+        Q_ASSERT(devices.openSerialPortConnection(portName) == nullptr);
+    }
+    // legacy API
+    SerialPort port;
+    port.setPortName(portName);
+    if (port.open(QSerialPort::ReadWrite)) {
+        qDebug() << "port opened";
+        port.close();
+    }
+
+    devices.record(nullptr);
+    
+    qDebug().noquote() << string;
+    
+}

oscar/tests/deviceconnectiontests.h

@@ -14,5 +14,6 @@ class DeviceConnectionTests : public QObject
 private slots:
     void testSerialPortInfoSerialization();
     void testSerialPortScanning();
+    void testOximeterConnection();
 };
 DECLARE_TEST(DeviceConnectionTests)