mirror of
https://gitlab.com/pholy/OSCAR-code.git
synced 2025-04-06 03:00:43 +00:00
09a96b893e
This is significant now because it will allow accurate recording of multiple simultaneous connections. This is important for the future because it establishes the necessary infrastructure for recording downloaded sessions into their own files so that they can be saved as backups.
1560 lines
43 KiB
C++
1560 lines
43 KiB
C++
/* Device Connection Class Implementation
|
|
*
|
|
* Copyright (c) 2020 The OSCAR Team
|
|
*
|
|
* This file is subject to the terms and conditions of the GNU General Public
|
|
* License. See the file COPYING in the main directory of the source code
|
|
* for more details. */
|
|
|
|
#include "deviceconnection.h"
|
|
#include "version.h"
|
|
#include <QtSerialPort/QSerialPortInfo>
|
|
#include <QFile>
|
|
#include <QFileInfo>
|
|
#include <QDir>
|
|
#include <QBuffer>
|
|
#include <QDateTime>
|
|
#include <QDebug>
|
|
|
|
|
|
static QString hex(int i)
|
|
{
|
|
return QString("0x") + QString::number(i, 16).toUpper();
|
|
}
|
|
|
|
|
|
// MARK: -
|
|
// MARK: XML record/playback base classes
|
|
|
|
class XmlRecorder
|
|
{
|
|
public:
|
|
static const QString TAG;
|
|
|
|
XmlRecorder(class QFile * file, const QString & tag = XmlRecorder::TAG);
|
|
XmlRecorder(QString & string, const QString & tag = XmlRecorder::TAG);
|
|
virtual ~XmlRecorder();
|
|
XmlRecorder* close();
|
|
inline QXmlStreamWriter & xml() { return *m_xml; }
|
|
inline void lock() { m_mutex.lock(); }
|
|
inline void unlock() { m_mutex.unlock(); }
|
|
protected:
|
|
XmlRecorder(XmlRecorder* parent, const QString & id, const QString & tag);
|
|
QXmlStreamWriter* addSubstream(XmlRecorder* child, const QString & id);
|
|
const QString m_tag;
|
|
QFile* m_file; // nullptr for non-file recordings
|
|
QXmlStreamWriter* m_xml;
|
|
QMutex m_mutex;
|
|
XmlRecorder* m_parent;
|
|
|
|
virtual void prologue();
|
|
virtual void epilogue();
|
|
};
|
|
const QString XmlRecorder::TAG = "xmlreplay";
|
|
|
|
class XmlReplayEvent;
|
|
|
|
class XmlReplay
|
|
{
|
|
public:
|
|
XmlReplay(class QFile * file, const QString & tag = XmlRecorder::TAG);
|
|
XmlReplay(QXmlStreamReader & xml, const QString & tag = XmlRecorder::TAG);
|
|
virtual ~XmlReplay();
|
|
XmlReplay* close();
|
|
template<class T> inline T* getNextEvent(const QString & id = "");
|
|
|
|
|
|
protected:
|
|
XmlReplay(XmlReplay* parent, const QString & id, const QString & tag = XmlRecorder::TAG);
|
|
QXmlStreamReader* findSubstream(XmlReplay* child, const QString & id);
|
|
|
|
void deserialize(QXmlStreamReader & xml);
|
|
void deserializeEvents(QXmlStreamReader & xml);
|
|
const QString m_tag;
|
|
QFile* m_file;
|
|
|
|
QHash<QString,QHash<QString,QList<XmlReplayEvent*>>> m_eventIndex;
|
|
QHash<QString,QHash<QString,int>> m_indexPosition;
|
|
QList<XmlReplayEvent*> m_events;
|
|
|
|
XmlReplayEvent* getNextEvent(const QString & type, const QString & id = "");
|
|
void seekToTime(const QDateTime & time);
|
|
|
|
XmlReplayEvent* m_pendingSignal;
|
|
QMutex m_lock;
|
|
inline void lock() { m_lock.lock(); }
|
|
inline void unlock() { m_lock.unlock(); }
|
|
void processPendingSignals(const QObject* target);
|
|
friend class XmlReplayLock;
|
|
|
|
XmlReplay* m_parent;
|
|
};
|
|
|
|
class XmlReplayEvent
|
|
{
|
|
public:
|
|
XmlReplayEvent();
|
|
virtual ~XmlReplayEvent() = default;
|
|
virtual const QString & tag() const = 0;
|
|
virtual const QString id() const { static const QString none(""); return none; }
|
|
virtual bool randomAccess() const { return false; }
|
|
|
|
void record(XmlRecorder* xml) const;
|
|
friend QXmlStreamWriter & operator<<(QXmlStreamWriter & xml, const XmlReplayEvent & event);
|
|
friend QXmlStreamReader & operator>>(QXmlStreamReader & xml, XmlReplayEvent & event);
|
|
void writeTag(QXmlStreamWriter & xml) const;
|
|
|
|
typedef XmlReplayEvent* (*FactoryMethod)();
|
|
static bool registerClass(const QString & tag, FactoryMethod factory);
|
|
static XmlReplayEvent* createInstance(const QString & tag);
|
|
|
|
void set(const QString & name, const QString & value)
|
|
{
|
|
if (!m_values.contains(name)) {
|
|
m_keys.append(name);
|
|
}
|
|
m_values[name] = value;
|
|
}
|
|
void set(const QString & name, qint64 value)
|
|
{
|
|
set(name, QString::number(value));
|
|
}
|
|
void setData(const char* data, qint64 length)
|
|
{
|
|
Q_ASSERT(usesData() == true);
|
|
QByteArray bytes = QByteArray::fromRawData(data, length);
|
|
m_data = bytes.toHex(' ').toUpper();
|
|
}
|
|
inline QString get(const QString & name) const
|
|
{
|
|
if (!m_values.contains(name)) {
|
|
qWarning().noquote() << *this << "missing attribute:" << name;
|
|
}
|
|
return m_values[name];
|
|
}
|
|
QByteArray getData() const
|
|
{
|
|
Q_ASSERT(usesData() == true);
|
|
if (m_data.isEmpty()) {
|
|
qWarning().noquote() << "replaying event with missing data" << *this;
|
|
QByteArray empty;
|
|
return empty; // toUtf8() below crashes with an empty string.
|
|
}
|
|
return QByteArray::fromHex(m_data.toUtf8());
|
|
}
|
|
inline bool ok() const { return m_values.contains("error") == false; }
|
|
operator QString() const
|
|
{
|
|
QString out;
|
|
QXmlStreamWriter xml(&out);
|
|
xml << *this;
|
|
return out;
|
|
}
|
|
|
|
void copyIf(const XmlReplayEvent* other)
|
|
{
|
|
// Leave the proposed event alone if there was no replay event.
|
|
if (other == nullptr) {
|
|
return;
|
|
}
|
|
// Do not copy timestamp.
|
|
m_values = other->m_values;
|
|
m_keys = other->m_keys;
|
|
m_data = other->m_data;
|
|
}
|
|
protected:
|
|
void copy(const XmlReplayEvent & other)
|
|
{
|
|
copyIf(&other);
|
|
m_time = other.m_time;
|
|
}
|
|
|
|
protected:
|
|
static QHash<QString,FactoryMethod> s_factories;
|
|
|
|
QDateTime m_time;
|
|
XmlReplayEvent* m_next;
|
|
|
|
const char* m_signal;
|
|
inline bool isSignal() const { return m_signal != nullptr; }
|
|
virtual void signal(QObject* target)
|
|
{
|
|
QMetaObject::invokeMethod(target, m_signal, Qt::QueuedConnection);
|
|
}
|
|
|
|
QHash<QString,QString> m_values;
|
|
QList<QString> m_keys;
|
|
QString m_data;
|
|
|
|
virtual bool usesData() const { return false; }
|
|
virtual void write(QXmlStreamWriter & xml) const
|
|
{
|
|
for (auto key : m_keys) {
|
|
xml.writeAttribute(key, m_values[key]);
|
|
}
|
|
if (!m_data.isEmpty()) {
|
|
Q_ASSERT(usesData() == true);
|
|
xml.writeCharacters(m_data);
|
|
}
|
|
}
|
|
virtual void read(QXmlStreamReader & xml)
|
|
{
|
|
QXmlStreamAttributes attribs = xml.attributes();
|
|
for (auto & attrib : attribs) {
|
|
if (attrib.name() != "time") { // skip outer timestamp
|
|
set(attrib.name().toString(), attrib.value().toString());
|
|
}
|
|
}
|
|
if (usesData()) {
|
|
m_data = xml.readElementText();
|
|
} else {
|
|
xml.skipCurrentElement();
|
|
}
|
|
}
|
|
|
|
friend class XmlReplay;
|
|
};
|
|
QHash<QString,XmlReplayEvent::FactoryMethod> XmlReplayEvent::s_factories;
|
|
|
|
class XmlReplayLock
|
|
{
|
|
public:
|
|
XmlReplayLock(const QObject* obj, XmlReplay* replay)
|
|
: m_target(obj), m_replay(replay)
|
|
{
|
|
if (m_replay) {
|
|
m_replay->lock();
|
|
}
|
|
}
|
|
~XmlReplayLock()
|
|
{
|
|
if (m_replay) {
|
|
m_replay->processPendingSignals(m_target);
|
|
m_replay->unlock();
|
|
}
|
|
}
|
|
|
|
protected:
|
|
const QObject* m_target;
|
|
XmlReplay* m_replay;
|
|
};
|
|
|
|
static QString substreamFilepath(QFile* parent, const QString & id)
|
|
{
|
|
Q_ASSERT(parent);
|
|
QFileInfo info(*parent);
|
|
QString path = info.canonicalPath() + QDir::separator() + info.completeBaseName() + "-" + id + ".xml";
|
|
return path;
|
|
}
|
|
|
|
|
|
XmlRecorder::XmlRecorder(QFile* stream, const QString & tag)
|
|
: m_tag(tag), m_file(stream), m_xml(new QXmlStreamWriter(stream)), m_parent(nullptr)
|
|
{
|
|
prologue();
|
|
}
|
|
|
|
XmlRecorder::XmlRecorder(QString & string, const QString & tag)
|
|
: m_tag(tag), m_file(nullptr), m_xml(new QXmlStreamWriter(&string)), m_parent(nullptr)
|
|
{
|
|
prologue();
|
|
}
|
|
|
|
// Protected constructor for substreams.
|
|
XmlRecorder::XmlRecorder(XmlRecorder* parent, const QString & id, const QString & tag)
|
|
: m_tag(tag), m_file(nullptr), m_xml(nullptr), m_parent(parent)
|
|
{
|
|
Q_ASSERT(m_parent);
|
|
m_xml = m_parent->addSubstream(this, id);
|
|
if (m_xml == nullptr) {
|
|
qWarning() << "Not recording" << id;
|
|
static QString null;
|
|
m_xml = new QXmlStreamWriter(&null);
|
|
}
|
|
|
|
m_xml->setAutoFormatting(true);
|
|
m_xml->setAutoFormattingIndent(2);
|
|
// Substreams handle their own prologue.
|
|
}
|
|
|
|
QXmlStreamWriter* XmlRecorder::addSubstream(XmlRecorder* child, const QString & id)
|
|
{
|
|
Q_ASSERT(child);
|
|
QXmlStreamWriter* xml = nullptr;
|
|
|
|
if (m_file) {
|
|
QString childPath = substreamFilepath(m_file, id);
|
|
child->m_file = new QFile(childPath);
|
|
if (child->m_file->open(QIODevice::WriteOnly | QIODevice::Append)) {
|
|
xml = new QXmlStreamWriter(child->m_file);
|
|
qDebug() << "Recording to" << childPath;
|
|
} else {
|
|
qWarning() << "Unable to open" << childPath << "for writing";
|
|
}
|
|
} else {
|
|
qWarning() << "String-based substreams are not supported";
|
|
// Maybe some day support string-based substreams:
|
|
// - parent passes string to child
|
|
// - on connectionClosed, parent asks recorder to flush string to stream
|
|
}
|
|
|
|
return xml;
|
|
}
|
|
|
|
XmlRecorder::~XmlRecorder()
|
|
{
|
|
epilogue();
|
|
delete m_xml;
|
|
// file substreams manage their own file
|
|
if (m_parent && m_file) {
|
|
delete m_file;
|
|
}
|
|
}
|
|
|
|
XmlRecorder* XmlRecorder::close()
|
|
{
|
|
auto parent = m_parent;
|
|
delete this;
|
|
return parent;
|
|
}
|
|
|
|
void XmlRecorder::prologue()
|
|
{
|
|
Q_ASSERT(m_xml);
|
|
m_xml->setAutoFormatting(true);
|
|
m_xml->setAutoFormattingIndent(2);
|
|
m_xml->writeStartElement(m_tag);
|
|
}
|
|
|
|
void XmlRecorder::epilogue()
|
|
{
|
|
Q_ASSERT(m_xml);
|
|
m_xml->writeEndElement(); // close enclosing tag
|
|
}
|
|
|
|
XmlReplay::XmlReplay(QFile* file, const QString & tag)
|
|
: m_tag(tag), m_file(file), m_pendingSignal(nullptr), m_parent(nullptr)
|
|
{
|
|
Q_ASSERT(file);
|
|
QFileInfo info(*file);
|
|
qDebug() << "Replaying from" << info.canonicalFilePath();
|
|
|
|
QXmlStreamReader xml(file);
|
|
deserialize(xml);
|
|
}
|
|
|
|
XmlReplay::XmlReplay(QXmlStreamReader & xml, const QString & tag)
|
|
: m_tag(tag), m_file(nullptr), m_pendingSignal(nullptr), m_parent(nullptr)
|
|
{
|
|
deserialize(xml);
|
|
}
|
|
|
|
XmlReplay::XmlReplay(XmlReplay* parent, const QString & id, const QString & tag)
|
|
: m_tag(tag), m_file(nullptr), m_pendingSignal(nullptr), m_parent(parent)
|
|
{
|
|
Q_ASSERT(m_parent);
|
|
|
|
auto xml = m_parent->findSubstream(this, id);
|
|
if (xml) {
|
|
deserialize(*xml);
|
|
delete xml;
|
|
} else {
|
|
qWarning() << "Not replaying" << id;
|
|
}
|
|
}
|
|
|
|
QXmlStreamReader* XmlReplay::findSubstream(XmlReplay* child, const QString & id)
|
|
{
|
|
Q_ASSERT(child);
|
|
QXmlStreamReader* xml = nullptr;
|
|
|
|
if (m_file) {
|
|
QString childPath = substreamFilepath(m_file, id);
|
|
child->m_file = new QFile(childPath);
|
|
if (child->m_file->open(QIODevice::ReadOnly)) {
|
|
xml = new QXmlStreamReader(child->m_file);
|
|
qDebug() << "Replaying from" << childPath;
|
|
} else {
|
|
qWarning() << "Unable to open" << childPath << "for reading";
|
|
}
|
|
} else {
|
|
qWarning() << "String-based substreams are not supported";
|
|
// Maybe some day support string-based substreams:
|
|
// - when deserializing, use e.g. ConnectionEvents to cache the substream strings
|
|
// - then return a QXmlStreamReader here using that string
|
|
}
|
|
|
|
return xml;
|
|
}
|
|
|
|
XmlReplay::~XmlReplay()
|
|
{
|
|
for (auto event : m_events) {
|
|
delete event;
|
|
}
|
|
// file substreams manage their own file
|
|
if (m_parent && m_file) {
|
|
delete m_file;
|
|
}
|
|
}
|
|
|
|
XmlReplay* XmlReplay::close()
|
|
{
|
|
auto parent = m_parent;
|
|
delete this;
|
|
return parent;
|
|
}
|
|
|
|
void XmlReplay::deserialize(QXmlStreamReader & xml)
|
|
{
|
|
if (xml.readNextStartElement()) {
|
|
if (xml.name() == m_tag) {
|
|
deserializeEvents(xml);
|
|
} else {
|
|
qWarning() << "unexpected payload in replay XML:" << xml.name();
|
|
xml.skipCurrentElement();
|
|
}
|
|
}
|
|
}
|
|
|
|
void XmlReplay::deserializeEvents(QXmlStreamReader & xml)
|
|
{
|
|
while (xml.readNextStartElement()) {
|
|
QString type = xml.name().toString();
|
|
XmlReplayEvent* event = XmlReplayEvent::createInstance(type);
|
|
if (event) {
|
|
xml >> *event;
|
|
|
|
// Add to list
|
|
if (m_events.isEmpty() == false) {
|
|
m_events.last()->m_next = event;
|
|
}
|
|
m_events.append(event);
|
|
|
|
// Add to index
|
|
const QString & id = event->id();
|
|
auto & events = m_eventIndex[type][id];
|
|
events.append(event);
|
|
} else {
|
|
xml.skipCurrentElement();
|
|
}
|
|
}
|
|
}
|
|
|
|
void XmlReplay::processPendingSignals(const QObject* target)
|
|
{
|
|
if (m_pendingSignal) {
|
|
XmlReplayEvent* pending = m_pendingSignal;
|
|
m_pendingSignal = nullptr;
|
|
|
|
// Dequeue the signal from the index; this may update m_pendingSignal.
|
|
XmlReplayEvent* dequeued = getNextEvent(pending->tag(), pending->id());
|
|
if (dequeued != pending) {
|
|
qWarning() << "triggered signal doesn't match dequeued signal!" << pending << dequeued;
|
|
}
|
|
|
|
// It is safe to re-cast this as non-const because signals are deferred
|
|
// and cannot alter the underlying target until the const method holding
|
|
// the lock releases it at function exit.
|
|
pending->signal(const_cast<QObject*>(target));
|
|
}
|
|
}
|
|
|
|
void XmlReplay::seekToTime(const QDateTime & time)
|
|
{
|
|
for (auto & type : m_eventIndex.keys()) {
|
|
for (auto & key : m_eventIndex[type].keys()) {
|
|
auto & events = m_eventIndex[type][key];
|
|
int pos;
|
|
for (pos = 0; pos < events.size(); pos++) {
|
|
auto & event = events.at(pos);
|
|
// Random-access events should always start searching from position 0.
|
|
if (event->randomAccess() || event->m_time >= time) {
|
|
break;
|
|
}
|
|
}
|
|
// If pos == events.size(), that means there are no more events of this type
|
|
// after the given time.
|
|
m_indexPosition[type][key] = pos;
|
|
}
|
|
}
|
|
}
|
|
|
|
XmlReplayEvent* XmlReplay::getNextEvent(const QString & type, const QString & id)
|
|
{
|
|
XmlReplayEvent* event = nullptr;
|
|
|
|
if (m_lock.tryLock()) {
|
|
qWarning() << "XML replay" << type << "object not locked by event handler!";
|
|
m_lock.unlock();
|
|
}
|
|
|
|
if (m_eventIndex.contains(type)) {
|
|
auto & ids = m_eventIndex[type];
|
|
if (ids.contains(id)) {
|
|
auto & events = ids[id];
|
|
|
|
// Start at the position identified by the previous random-access event.
|
|
int pos = m_indexPosition[type][id];
|
|
if (pos < events.size()) {
|
|
event = events.at(pos);
|
|
// TODO: if we're simulating the original timing, return nullptr if we haven't reached this event's time yet;
|
|
// otherwise:
|
|
events.removeAt(pos);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (event && event->randomAccess()) {
|
|
seekToTime(event->m_time);
|
|
}
|
|
|
|
if (event && event->m_next && event->m_next->isSignal()) {
|
|
Q_ASSERT(m_pendingSignal == nullptr); // if this ever fails, we may need m_pendingSignal to be a list
|
|
m_pendingSignal = event->m_next;
|
|
}
|
|
|
|
return event;
|
|
}
|
|
|
|
template<class T>
|
|
T* XmlReplay::getNextEvent(const QString & id)
|
|
{
|
|
T* event = dynamic_cast<T*>(getNextEvent(T::TAG, id));
|
|
return event;
|
|
}
|
|
|
|
|
|
// MARK: -
|
|
// MARK: XML record/playback event base class
|
|
|
|
XmlReplayEvent::XmlReplayEvent()
|
|
: m_time(QDateTime::currentDateTime()), m_next(nullptr), m_signal(nullptr)
|
|
{
|
|
}
|
|
|
|
void XmlReplayEvent::record(XmlRecorder* writer) const
|
|
{
|
|
// Do nothing if we're not recording.
|
|
if (writer != nullptr) {
|
|
writer->lock();
|
|
writer->xml() << *this;
|
|
writer->unlock();
|
|
}
|
|
}
|
|
|
|
bool XmlReplayEvent::registerClass(const QString & tag, XmlReplayEvent::FactoryMethod factory)
|
|
{
|
|
if (s_factories.contains(tag)) {
|
|
qWarning() << "Event class already registered for tag" << tag;
|
|
return false;
|
|
}
|
|
s_factories[tag] = factory;
|
|
return true;
|
|
}
|
|
|
|
XmlReplayEvent* XmlReplayEvent::createInstance(const QString & tag)
|
|
{
|
|
XmlReplayEvent* event = nullptr;
|
|
XmlReplayEvent::FactoryMethod factory = s_factories.value(tag);
|
|
if (factory == nullptr) {
|
|
qWarning() << "No event class registered for XML tag" << tag;
|
|
} else {
|
|
event = factory();
|
|
}
|
|
return event;
|
|
}
|
|
|
|
void XmlReplayEvent::writeTag(QXmlStreamWriter & xml) const
|
|
{
|
|
QDateTime time = m_time.toOffsetFromUtc(m_time.offsetFromUtc()); // force display of UTC offset
|
|
#if QT_VERSION < QT_VERSION_CHECK(5,9,0)
|
|
// TODO: Can we please deprecate support for Qt older than 5.9?
|
|
QString timestamp = time.toString(Qt::ISODate);
|
|
#else
|
|
QString timestamp = time.toString(Qt::ISODateWithMs);
|
|
#endif
|
|
xml.writeStartElement(tag());
|
|
xml.writeAttribute("time", timestamp);
|
|
|
|
write(xml);
|
|
}
|
|
|
|
QXmlStreamWriter & operator<<(QXmlStreamWriter & xml, const XmlReplayEvent & event)
|
|
{
|
|
event.writeTag(xml);
|
|
xml.writeEndElement();
|
|
return xml;
|
|
}
|
|
|
|
QXmlStreamReader & operator>>(QXmlStreamReader & xml, XmlReplayEvent & event)
|
|
{
|
|
Q_ASSERT(xml.isStartElement() && xml.name() == event.tag());
|
|
|
|
QDateTime time;
|
|
if (xml.attributes().hasAttribute("time")) {
|
|
#if QT_VERSION < QT_VERSION_CHECK(5,9,0)
|
|
// TODO: Can we please deprecate support for Qt older than 5.9?
|
|
time = QDateTime::fromString(xml.attributes().value("time").toString(), Qt::ISODate);
|
|
#else
|
|
time = QDateTime::fromString(xml.attributes().value("time").toString(), Qt::ISODateWithMs);
|
|
#endif
|
|
} else {
|
|
qWarning() << "Missing timestamp in" << xml.name() << "tag, using current time";
|
|
time = QDateTime::currentDateTime();
|
|
}
|
|
event.m_time = time;
|
|
|
|
event.read(xml);
|
|
return xml;
|
|
}
|
|
|
|
template<typename T> QXmlStreamWriter & operator<<(QXmlStreamWriter & xml, const QList<T> & list)
|
|
{
|
|
for (auto & item : list) {
|
|
xml << item;
|
|
}
|
|
return xml;
|
|
}
|
|
|
|
template<typename T> QXmlStreamReader & operator>>(QXmlStreamReader & xml, QList<T> & list)
|
|
{
|
|
list.clear();
|
|
while (xml.readNextStartElement()) {
|
|
T item;
|
|
xml >> item;
|
|
list.append(item);
|
|
}
|
|
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
|
|
{
|
|
public:
|
|
static const QString TAG;
|
|
static const bool registered;
|
|
virtual const QString & tag() const { return TAG; };
|
|
|
|
static XmlReplayEvent* createInstance()
|
|
{
|
|
Derived* instance = new Derived();
|
|
return static_cast<XmlReplayEvent*>(instance);
|
|
}
|
|
};
|
|
|
|
#define REGISTER_XMLREPLAYEVENT(tag, type) \
|
|
template<> const QString XmlReplayBase<type>::TAG = tag; \
|
|
template<> const bool XmlReplayBase<type>::registered = XmlReplayEvent::registerClass(XmlReplayBase<type>::TAG, XmlReplayBase<type>::createInstance);
|
|
|
|
|
|
// MARK: -
|
|
// MARK: Device connection manager
|
|
|
|
class DeviceRecorder : public XmlRecorder
|
|
{
|
|
public:
|
|
static const QString TAG;
|
|
|
|
DeviceRecorder(class QFile * file) : XmlRecorder(file, DeviceRecorder::TAG) { m_xml->writeAttribute("oscar", getVersion().toString()); }
|
|
DeviceRecorder(QString & string) : XmlRecorder(string, DeviceRecorder::TAG) { m_xml->writeAttribute("oscar", getVersion().toString()); }
|
|
};
|
|
const QString DeviceRecorder::TAG = "devicereplay";
|
|
|
|
class DeviceReplay : public XmlReplay
|
|
{
|
|
public:
|
|
DeviceReplay(class QFile * file) : XmlReplay(file, DeviceRecorder::TAG) {}
|
|
DeviceReplay(QXmlStreamReader & xml) : XmlReplay(xml, DeviceRecorder::TAG) {}
|
|
};
|
|
|
|
|
|
inline DeviceConnectionManager & DeviceConnectionManager::getInstance()
|
|
{
|
|
static DeviceConnectionManager instance;
|
|
return instance;
|
|
}
|
|
|
|
DeviceConnectionManager::DeviceConnectionManager()
|
|
: m_record(nullptr), m_replay(nullptr)
|
|
{
|
|
}
|
|
|
|
void DeviceConnectionManager::record(QFile* stream)
|
|
{
|
|
if (m_record) {
|
|
delete m_record;
|
|
}
|
|
if (stream) {
|
|
m_record = new DeviceRecorder(stream);
|
|
} else {
|
|
// nullptr turns off recording
|
|
m_record = nullptr;
|
|
}
|
|
}
|
|
|
|
void DeviceConnectionManager::record(QString & string)
|
|
{
|
|
if (m_record) {
|
|
delete m_record;
|
|
}
|
|
m_record = new DeviceRecorder(string);
|
|
}
|
|
|
|
void DeviceConnectionManager::replay(const QString & string)
|
|
{
|
|
QXmlStreamReader xml(string);
|
|
reset();
|
|
if (m_replay) {
|
|
delete m_replay;
|
|
}
|
|
m_replay = new DeviceReplay(xml);
|
|
}
|
|
|
|
void DeviceConnectionManager::replay(QFile* file)
|
|
{
|
|
reset();
|
|
if (m_replay) {
|
|
delete m_replay;
|
|
}
|
|
if (file) {
|
|
m_replay = new DeviceReplay(file);
|
|
} else {
|
|
// nullptr turns off replay
|
|
m_replay = nullptr;
|
|
}
|
|
}
|
|
|
|
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.contains(name)) {
|
|
qWarning() << "connection to" << name << "already open";
|
|
return nullptr;
|
|
}
|
|
|
|
DeviceConnection* conn = s_factories[type](name, m_record, m_replay);
|
|
if (conn) {
|
|
if (conn->open()) {
|
|
m_connections[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;
|
|
}
|
|
return conn;
|
|
}
|
|
|
|
void DeviceConnectionManager::connectionClosed(DeviceConnection* conn)
|
|
{
|
|
Q_ASSERT(conn);
|
|
const QString & type = conn->type();
|
|
const QString & name = conn->name();
|
|
|
|
if (m_connections.contains(name)) {
|
|
if (m_connections[name] == conn) {
|
|
m_connections.remove(name);
|
|
} else {
|
|
qWarning() << "connection to" << name << "not created by openConnection!";
|
|
}
|
|
} else {
|
|
qWarning() << type << "connection to" << name << "missing";
|
|
}
|
|
}
|
|
|
|
// 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
|
|
|
|
class GetAvailableSerialPortsEvent : public XmlReplayBase<GetAvailableSerialPortsEvent>
|
|
{
|
|
public:
|
|
QList<SerialPortInfo> m_ports;
|
|
|
|
protected:
|
|
virtual void write(QXmlStreamWriter & xml) const
|
|
{
|
|
xml << m_ports;
|
|
}
|
|
virtual void read(QXmlStreamReader & xml)
|
|
{
|
|
xml >> m_ports;
|
|
}
|
|
};
|
|
REGISTER_XMLREPLAYEVENT("getAvailableSerialPorts", GetAvailableSerialPortsEvent);
|
|
|
|
|
|
QList<SerialPortInfo> DeviceConnectionManager::getAvailableSerialPorts()
|
|
{
|
|
XmlReplayLock lock(this, m_replay);
|
|
GetAvailableSerialPortsEvent event;
|
|
|
|
if (!m_replay) {
|
|
for (auto & info : QSerialPortInfo::availablePorts()) {
|
|
event.m_ports.append(SerialPortInfo(info));
|
|
}
|
|
} else {
|
|
auto replayEvent = m_replay->getNextEvent<GetAvailableSerialPortsEvent>();
|
|
if (replayEvent) {
|
|
event.m_ports = replayEvent->m_ports;
|
|
} else {
|
|
// If there are no replay events available, reuse the most recent state.
|
|
event.m_ports = m_serialPorts;
|
|
}
|
|
}
|
|
m_serialPorts = event.m_ports;
|
|
|
|
event.record(m_record);
|
|
return event.m_ports;
|
|
}
|
|
|
|
|
|
// MARK: -
|
|
// MARK: Serial port info
|
|
|
|
SerialPortInfo::SerialPortInfo(const QSerialPortInfo & other)
|
|
{
|
|
if (other.isNull() == false) {
|
|
m_info["portName"] = other.portName();
|
|
m_info["systemLocation"] = other.systemLocation();
|
|
m_info["description"] = other.description();
|
|
m_info["manufacturer"] = other.manufacturer();
|
|
m_info["serialNumber"] = other.serialNumber();
|
|
if (other.hasVendorIdentifier()) {
|
|
m_info["vendorIdentifier"] = other.vendorIdentifier();
|
|
}
|
|
if (other.hasProductIdentifier()) {
|
|
m_info["productIdentifier"] = other.productIdentifier();
|
|
}
|
|
}
|
|
}
|
|
|
|
SerialPortInfo::SerialPortInfo(const SerialPortInfo & other)
|
|
: m_info(other.m_info)
|
|
{
|
|
}
|
|
|
|
SerialPortInfo::SerialPortInfo(const QString & data)
|
|
{
|
|
QXmlStreamReader xml(data);
|
|
xml.readNextStartElement();
|
|
xml >> *this;
|
|
}
|
|
|
|
SerialPortInfo::SerialPortInfo()
|
|
{
|
|
}
|
|
|
|
// TODO: This is a temporary wrapper until we begin refactoring.
|
|
QList<SerialPortInfo> SerialPortInfo::availablePorts()
|
|
{
|
|
return DeviceConnectionManager::getInstance().getAvailableSerialPorts();
|
|
}
|
|
|
|
QXmlStreamWriter & operator<<(QXmlStreamWriter & xml, const SerialPortInfo & info)
|
|
{
|
|
xml.writeStartElement("serial");
|
|
if (info.isNull() == false) {
|
|
xml.writeAttribute("portName", info.portName());
|
|
xml.writeAttribute("systemLocation", info.systemLocation());
|
|
xml.writeAttribute("description", info.description());
|
|
xml.writeAttribute("manufacturer", info.manufacturer());
|
|
xml.writeAttribute("serialNumber", info.serialNumber());
|
|
if (info.hasVendorIdentifier()) {
|
|
xml.writeAttribute("vendorIdentifier", hex(info.vendorIdentifier()));
|
|
}
|
|
if (info.hasProductIdentifier()) {
|
|
xml.writeAttribute("productIdentifier", hex(info.productIdentifier()));
|
|
}
|
|
}
|
|
xml.writeEndElement();
|
|
return xml;
|
|
}
|
|
|
|
QXmlStreamReader & operator>>(QXmlStreamReader & xml, SerialPortInfo & info)
|
|
{
|
|
if (xml.atEnd() == false && xml.isStartElement() && xml.name() == "serial") {
|
|
for (auto & attribute : xml.attributes()) {
|
|
QString name = attribute.name().toString();
|
|
QString value = attribute.value().toString();
|
|
if (name == "vendorIdentifier" || name == "productIdentifier") {
|
|
bool ok;
|
|
quint16 id = value.toUInt(&ok, 0);
|
|
if (ok) {
|
|
info.m_info[name] = id;
|
|
} else {
|
|
qWarning() << "invalid" << name << "value" << value;
|
|
}
|
|
} else {
|
|
info.m_info[name] = value;
|
|
}
|
|
}
|
|
} else {
|
|
qWarning() << "no <serial> tag";
|
|
}
|
|
xml.skipCurrentElement();
|
|
return xml;
|
|
}
|
|
|
|
SerialPortInfo::operator QString() const
|
|
{
|
|
QString out;
|
|
QXmlStreamWriter xml(&out);
|
|
xml << *this;
|
|
return out;
|
|
}
|
|
|
|
bool SerialPortInfo::operator==(const SerialPortInfo & other) const
|
|
{
|
|
return m_info == other.m_info;
|
|
}
|
|
|
|
|
|
// TODO: restrict constructor to OpenConnectionEvent
|
|
class ConnectionEvent : public XmlReplayBase<ConnectionEvent>
|
|
{
|
|
public:
|
|
ConnectionEvent() { Q_ASSERT(false); } // Implement if we ever support string-based substreams
|
|
ConnectionEvent(const XmlReplayEvent & trigger)
|
|
{
|
|
copy(trigger);
|
|
}
|
|
virtual const QString id() const
|
|
{
|
|
QString time = m_time.toString("yyyyMMdd.HHmmss.zzz");
|
|
return m_values["name"] + "-" + time;
|
|
}
|
|
};
|
|
REGISTER_XMLREPLAYEVENT("connection", ConnectionEvent);
|
|
|
|
// MARK: -
|
|
// MARK: Device connection base class
|
|
|
|
class ConnectionRecorder : public XmlRecorder
|
|
{
|
|
public:
|
|
ConnectionRecorder(XmlRecorder* parent, const ConnectionEvent& event) : XmlRecorder(parent, event.id(), event.tag())
|
|
{
|
|
Q_ASSERT(m_xml);
|
|
event.writeTag(*m_xml);
|
|
m_xml->writeAttribute("oscar", getVersion().toString());
|
|
}
|
|
};
|
|
|
|
class ConnectionReplay : public XmlReplay
|
|
{
|
|
public:
|
|
ConnectionReplay(XmlReplay* parent, const ConnectionEvent& event) : XmlReplay(parent, event.id(), event.tag()) {}
|
|
};
|
|
|
|
|
|
DeviceConnection::DeviceConnection(const QString & name, XmlRecorder* record, XmlReplay* replay)
|
|
: m_name(name), m_record(record), m_replay(replay), m_opened(false)
|
|
{
|
|
}
|
|
|
|
DeviceConnection::~DeviceConnection()
|
|
{
|
|
}
|
|
|
|
class SetValueEvent : public XmlReplayBase<SetValueEvent>
|
|
{
|
|
public:
|
|
SetValueEvent() {}
|
|
SetValueEvent(const QString & name, int value)
|
|
{
|
|
set(name, value);
|
|
}
|
|
virtual const QString id() const { return m_keys.first(); }
|
|
};
|
|
REGISTER_XMLREPLAYEVENT("set", SetValueEvent);
|
|
|
|
class GetValueEvent : public XmlReplayBase<GetValueEvent>
|
|
{
|
|
public:
|
|
GetValueEvent() {}
|
|
GetValueEvent(const QString & id)
|
|
{
|
|
set(id, 0);
|
|
}
|
|
virtual const QString id() const { return m_keys.first(); }
|
|
void setValue(qint64 value)
|
|
{
|
|
if (m_keys.isEmpty()) {
|
|
qWarning() << "setValue: get event missing key";
|
|
return;
|
|
}
|
|
set(m_keys.first(), value);
|
|
}
|
|
QString value() const
|
|
{
|
|
if (m_keys.isEmpty()) {
|
|
qWarning() << "getValue: get event missing key";
|
|
return 0;
|
|
}
|
|
return get(m_keys.first());
|
|
}
|
|
};
|
|
REGISTER_XMLREPLAYEVENT("get", GetValueEvent);
|
|
|
|
class OpenConnectionEvent : public XmlReplayBase<OpenConnectionEvent>
|
|
{
|
|
public:
|
|
OpenConnectionEvent() {}
|
|
OpenConnectionEvent(const QString & type, const QString & name)
|
|
{
|
|
set("type", type);
|
|
set("name", name);
|
|
}
|
|
virtual const QString id() const { return m_values["name"]; }
|
|
};
|
|
REGISTER_XMLREPLAYEVENT("openConnection", OpenConnectionEvent);
|
|
|
|
class CloseConnectionEvent : public XmlReplayBase<CloseConnectionEvent>
|
|
{
|
|
public:
|
|
CloseConnectionEvent() {}
|
|
CloseConnectionEvent(const QString & type, const QString & name)
|
|
{
|
|
set("type", type);
|
|
set("name", name);
|
|
}
|
|
virtual const QString id() const { return m_values["name"]; }
|
|
};
|
|
REGISTER_XMLREPLAYEVENT("closeConnection", CloseConnectionEvent);
|
|
|
|
class ClearConnectionEvent : public XmlReplayBase<ClearConnectionEvent>
|
|
{
|
|
};
|
|
REGISTER_XMLREPLAYEVENT("clear", ClearConnectionEvent);
|
|
|
|
class FlushConnectionEvent : public XmlReplayBase<FlushConnectionEvent>
|
|
{
|
|
};
|
|
REGISTER_XMLREPLAYEVENT("flush", FlushConnectionEvent);
|
|
|
|
class ReceiveDataEvent : public XmlReplayBase<ReceiveDataEvent>
|
|
{
|
|
virtual bool usesData() const { return true; }
|
|
};
|
|
REGISTER_XMLREPLAYEVENT("rx", ReceiveDataEvent);
|
|
|
|
class TransmitDataEvent : public XmlReplayBase<TransmitDataEvent>
|
|
{
|
|
virtual bool usesData() const { return true; }
|
|
public:
|
|
virtual const QString id() const { return m_data; }
|
|
virtual bool randomAccess() const { return true; }
|
|
};
|
|
REGISTER_XMLREPLAYEVENT("tx", TransmitDataEvent);
|
|
|
|
class ReadyReadEvent : public XmlReplayBase<ReadyReadEvent>
|
|
{
|
|
public:
|
|
ReadyReadEvent() { m_signal = "onReadyRead"; }
|
|
};
|
|
REGISTER_XMLREPLAYEVENT("readyRead", ReadyReadEvent);
|
|
|
|
|
|
// MARK: -
|
|
// MARK: Serial port connection
|
|
|
|
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()));
|
|
}
|
|
|
|
bool SerialPortConnection::open()
|
|
{
|
|
if (m_opened) {
|
|
qWarning() << "serial connection to" << m_name << "already opened";
|
|
return false;
|
|
}
|
|
XmlReplayLock lock(this, m_replay);
|
|
OpenConnectionEvent* replayEvent = nullptr;
|
|
OpenConnectionEvent event("serial", m_name);
|
|
|
|
if (!m_replay) {
|
|
// TODO: move this into SerialPortConnection::openDevice() and move everything
|
|
// else up to DeviceConnection::open().
|
|
m_port.setPortName(m_name);
|
|
checkResult(m_port.open(QSerialPort::ReadWrite), event);
|
|
} else {
|
|
replayEvent = m_replay->getNextEvent<OpenConnectionEvent>(event.id());
|
|
if (replayEvent) {
|
|
event.copyIf(replayEvent);
|
|
} else {
|
|
event.set("error", QSerialPort::DeviceNotFoundError);
|
|
}
|
|
}
|
|
|
|
event.record(m_record);
|
|
m_opened = event.ok();
|
|
|
|
if (m_opened) {
|
|
// open a connection substream for connection events
|
|
if (m_record) {
|
|
ConnectionEvent connEvent(event);
|
|
m_record = new ConnectionRecorder(m_record, connEvent);
|
|
}
|
|
if (m_replay) {
|
|
Q_ASSERT(replayEvent);
|
|
ConnectionEvent connEvent(*replayEvent); // we need to use the replay's timestamp to find the referenced substream
|
|
m_replay = new ConnectionReplay(m_replay, connEvent);
|
|
}
|
|
}
|
|
|
|
return event.ok();
|
|
}
|
|
|
|
bool SerialPortConnection::setBaudRate(qint32 baudRate, QSerialPort::Directions directions)
|
|
{
|
|
XmlReplayLock lock(this, m_replay);
|
|
SetValueEvent event("baudRate", baudRate);
|
|
event.set("directions", directions);
|
|
|
|
if (!m_replay) {
|
|
checkResult(m_port.setBaudRate(baudRate, directions), event);
|
|
} else {
|
|
auto replayEvent = m_replay->getNextEvent<SetValueEvent>(event.id());
|
|
event.copyIf(replayEvent);
|
|
}
|
|
event.record(m_record);
|
|
|
|
return event.ok();
|
|
}
|
|
|
|
bool SerialPortConnection::setDataBits(QSerialPort::DataBits dataBits)
|
|
{
|
|
XmlReplayLock lock(this, m_replay);
|
|
SetValueEvent event("setDataBits", dataBits);
|
|
|
|
if (!m_replay) {
|
|
checkResult(m_port.setDataBits(dataBits), event);
|
|
} else {
|
|
auto replayEvent = m_replay->getNextEvent<SetValueEvent>(event.id());
|
|
event.copyIf(replayEvent);
|
|
}
|
|
event.record(m_record);
|
|
|
|
return event.ok();
|
|
}
|
|
|
|
bool SerialPortConnection::setParity(QSerialPort::Parity parity)
|
|
{
|
|
XmlReplayLock lock(this, m_replay);
|
|
SetValueEvent event("setParity", parity);
|
|
|
|
if (!m_replay) {
|
|
checkResult(m_port.setParity(parity), event);
|
|
} else {
|
|
auto replayEvent = m_replay->getNextEvent<SetValueEvent>(event.id());
|
|
event.copyIf(replayEvent);
|
|
}
|
|
event.record(m_record);
|
|
|
|
return event.ok();
|
|
}
|
|
|
|
bool SerialPortConnection::setStopBits(QSerialPort::StopBits stopBits)
|
|
{
|
|
XmlReplayLock lock(this, m_replay);
|
|
SetValueEvent event("setStopBits", stopBits);
|
|
|
|
if (!m_replay) {
|
|
checkResult(m_port.setStopBits(stopBits), event);
|
|
} else {
|
|
auto replayEvent = m_replay->getNextEvent<SetValueEvent>(event.id());
|
|
event.copyIf(replayEvent);
|
|
}
|
|
event.record(m_record);
|
|
|
|
return event.ok();
|
|
}
|
|
|
|
bool SerialPortConnection::setFlowControl(QSerialPort::FlowControl flowControl)
|
|
{
|
|
XmlReplayLock lock(this, m_replay);
|
|
SetValueEvent event("setFlowControl", flowControl);
|
|
|
|
if (!m_replay) {
|
|
checkResult(m_port.setFlowControl(flowControl), event);
|
|
} else {
|
|
auto replayEvent = m_replay->getNextEvent<SetValueEvent>(event.id());
|
|
event.copyIf(replayEvent);
|
|
}
|
|
event.record(m_record);
|
|
|
|
return event.ok();
|
|
}
|
|
|
|
bool SerialPortConnection::clear(QSerialPort::Directions directions)
|
|
{
|
|
XmlReplayLock lock(this, m_replay);
|
|
ClearConnectionEvent event;
|
|
event.set("directions", directions);
|
|
|
|
if (!m_replay) {
|
|
checkResult(m_port.clear(directions), event);
|
|
} else {
|
|
auto replayEvent = m_replay->getNextEvent<ClearConnectionEvent>();
|
|
event.copyIf(replayEvent);
|
|
}
|
|
event.record(m_record);
|
|
|
|
return event.ok();
|
|
}
|
|
|
|
qint64 SerialPortConnection::bytesAvailable() const
|
|
{
|
|
XmlReplayLock lock(this, m_replay);
|
|
GetValueEvent event("bytesAvailable");
|
|
qint64 result;
|
|
|
|
if (!m_replay) {
|
|
result = m_port.bytesAvailable();
|
|
event.setValue(result);
|
|
checkResult(result, event);
|
|
} else {
|
|
auto replayEvent = m_replay->getNextEvent<GetValueEvent>(event.id());
|
|
event.copyIf(replayEvent);
|
|
|
|
bool ok;
|
|
result = event.value().toLong(&ok);
|
|
if (!ok) {
|
|
qWarning() << event.tag() << event.id() << "has bad value";
|
|
}
|
|
}
|
|
event.record(m_record);
|
|
|
|
return result;
|
|
}
|
|
|
|
qint64 SerialPortConnection::read(char *data, qint64 maxSize)
|
|
{
|
|
XmlReplayLock lock(this, m_replay);
|
|
qint64 len;
|
|
ReceiveDataEvent event;
|
|
|
|
if (!m_replay) {
|
|
len = m_port.read(data, maxSize);
|
|
if (len > 0) {
|
|
event.setData(data, len);
|
|
}
|
|
event.set("len", len);
|
|
if (len != maxSize) {
|
|
event.set("req", maxSize);
|
|
}
|
|
checkResult(len, event);
|
|
} else {
|
|
auto replayEvent = m_replay->getNextEvent<ReceiveDataEvent>();
|
|
event.copyIf(replayEvent);
|
|
if (!replayEvent) {
|
|
qWarning() << "reading data past replay";
|
|
event.set("len", -1);
|
|
event.set("error", QSerialPort::ReadError);
|
|
}
|
|
|
|
bool ok;
|
|
len = event.get("len").toLong(&ok);
|
|
if (ok) {
|
|
if (event.ok()) {
|
|
if (len != maxSize) {
|
|
qWarning() << "replay of" << len << "bytes but" << maxSize << "requested";
|
|
}
|
|
if (len > maxSize) {
|
|
len = maxSize;
|
|
}
|
|
QByteArray replayData = event.getData();
|
|
memcpy(data, replayData, len);
|
|
}
|
|
} else {
|
|
qWarning() << event << "has bad len";
|
|
len = -1;
|
|
}
|
|
}
|
|
event.record(m_record);
|
|
|
|
return len;
|
|
}
|
|
|
|
qint64 SerialPortConnection::write(const char *data, qint64 maxSize)
|
|
{
|
|
XmlReplayLock lock(this, m_replay);
|
|
qint64 len;
|
|
TransmitDataEvent event;
|
|
event.setData(data, maxSize);
|
|
|
|
if (!m_replay) {
|
|
len = m_port.write(data, maxSize);
|
|
event.set("len", len);
|
|
if (len != maxSize) {
|
|
event.set("req", maxSize);
|
|
}
|
|
checkResult(len, event);
|
|
} else {
|
|
auto replayEvent = m_replay->getNextEvent<TransmitDataEvent>(event.id());
|
|
event.copyIf(replayEvent);
|
|
if (!replayEvent) {
|
|
qWarning() << "writing data past replay";
|
|
event.set("len", -1);
|
|
event.set("error", QSerialPort::ReadError);
|
|
}
|
|
|
|
bool ok;
|
|
len = event.get("len").toLong(&ok);
|
|
if (!ok) {
|
|
qWarning() << event << "has bad len";
|
|
len = -1;
|
|
}
|
|
}
|
|
event.record(m_record);
|
|
|
|
return len;
|
|
}
|
|
|
|
bool SerialPortConnection::flush()
|
|
{
|
|
XmlReplayLock lock(this, m_replay);
|
|
FlushConnectionEvent event;
|
|
|
|
if (!m_replay) {
|
|
checkResult(m_port.flush(), event);
|
|
} else {
|
|
auto replayEvent = m_replay->getNextEvent<FlushConnectionEvent>();
|
|
event.copyIf(replayEvent);
|
|
}
|
|
event.record(m_record);
|
|
|
|
return event.ok();
|
|
}
|
|
|
|
void SerialPortConnection::close()
|
|
{
|
|
if (m_opened) {
|
|
// close event substream first
|
|
if (m_record) {
|
|
m_record = m_record->close();
|
|
}
|
|
if (m_replay) {
|
|
m_replay = m_replay->close();
|
|
}
|
|
}
|
|
|
|
XmlReplayLock lock(this, m_replay);
|
|
CloseConnectionEvent event("serial", m_name);
|
|
|
|
// TODO: We'll also need to include a loader ID and stream version number
|
|
// in the "connection" tag, so that if we ever have to change a loader's download code,
|
|
// the older replays will still work as expected.
|
|
|
|
if (!m_replay) {
|
|
// TODO: move this into SerialPortConnection::closeDevice() and move everything
|
|
// else up to DeviceConnection::close().
|
|
m_port.close();
|
|
checkError(event);
|
|
} else {
|
|
auto replayEvent = m_replay->getNextEvent<CloseConnectionEvent>(event.id());
|
|
if (replayEvent) {
|
|
event.copyIf(replayEvent);
|
|
} else {
|
|
event.set("error", QSerialPort::ResourceError);
|
|
}
|
|
}
|
|
|
|
event.record(m_record);
|
|
}
|
|
|
|
void SerialPortConnection::onReadyRead()
|
|
{
|
|
{
|
|
// Wait until the replay signaler (if any) has released its lock.
|
|
XmlReplayLock lock(this, m_replay);
|
|
|
|
// This needs to be recorded before the signal below, since the slot may trigger more events.
|
|
ReadyReadEvent event;
|
|
event.record(m_record);
|
|
|
|
// Unlocking will queue any subsequent signals.
|
|
}
|
|
|
|
// Because clients typically leave this as Qt::AutoConnection, the below emit may
|
|
// execute immediately in this thread, so we have to release the lock before sending
|
|
// the signal.
|
|
|
|
// Unlike client-called events, We don't need to handle replay differently here,
|
|
// because the replay will signal this slot just like the serial port.
|
|
emit readyRead();
|
|
}
|
|
|
|
void SerialPortConnection::checkResult(bool ok, XmlReplayEvent & event) const
|
|
{
|
|
QSerialPort::SerialPortError error = m_port.error();
|
|
if (ok && error == QSerialPort::NoError) return;
|
|
event.set("error", error);
|
|
if (ok) event.set("ok", ok); // we don't expect to see this, but we should know if it happens
|
|
}
|
|
|
|
void SerialPortConnection::checkResult(qint64 len, XmlReplayEvent & event) const
|
|
{
|
|
QSerialPort::SerialPortError error = m_port.error();
|
|
if (len < 0 || error != QSerialPort::NoError) {
|
|
event.set("error", error);
|
|
}
|
|
}
|
|
|
|
void SerialPortConnection::checkError(XmlReplayEvent & event) const
|
|
{
|
|
QSerialPort::SerialPortError error = m_port.error();
|
|
if (error != QSerialPort::NoError) {
|
|
event.set("error", error);
|
|
}
|
|
}
|
|
|
|
|
|
// MARK: -
|
|
// MARK: SerialPort legacy class
|
|
|
|
SerialPort::SerialPort()
|
|
: m_conn(nullptr)
|
|
{
|
|
}
|
|
|
|
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();
|
|
}
|