FCL/sf/mw/qt: comparison tools/runonphone/symbianutils/trkdevice.cpp

equal deleted inserted replaced

-:b72c6db6890b
+:5dc02b23752f
 #include <QtCore/QMap>
 #include <QtCore/QThread>
 #include <QtCore/QMutex>
 #include <QtCore/QWaitCondition>
 #include <QtCore/QSharedPointer>
+#include <QtCore/QScopedPointer>
 #include <QtCore/QMetaType>
 #ifdef Q_OS_WIN
 #  include <windows.h>
 #else
 #endif
 enum { verboseTrk = 0 };
+static inline QString msgAccessingClosedDevice(const QString &msg)
+{
+return QString::fromLatin1("Error: Attempt to access device '%1', which is closed.").arg(msg);
+}
 namespace trk {
 ///////////////////////////////////////////////////////////////////////
 //
 // TrkMessage
 // can use the helper invokeNoopMessage() to trigger its callback.
 //
 ///////////////////////////////////////////////////////////////////////
 class TrkWriteQueue
 {
 Q_DISABLE_COPY(TrkWriteQueue)
 public:
 explicit TrkWriteQueue();
+void clear();
 // Enqueue messages.
 void queueTrkMessage(byte code, TrkCallback callback,
 const QByteArray &data, const QVariant &cookie);
 void queueTrkInitialPing();
 m_trkWriteToken(0),
 m_trkWriteBusy(false)
 {
 }
+void TrkWriteQueue::clear()
+{
+m_trkWriteToken = 0;
+m_trkWriteBusy = false;
+m_trkWriteQueue.clear();
+const int discarded = m_writtenTrkMessages.size();
+m_writtenTrkMessages.clear();
+if (verboseTrk)
+qDebug() << "TrkWriteQueue::clear: discarded " << discarded;
+}
 byte TrkWriteQueue::nextTrkWriteToken()
 {
 ++m_trkWriteToken;
 if (m_trkWriteToken == 0)
 ++m_trkWriteToken;
 if (verboseTrk)
-qDebug() << "Write token: " << m_trkWriteToken;
+qDebug() << "nextTrkWriteToken:" << m_trkWriteToken;
 return m_trkWriteToken;
 }
 void TrkWriteQueue::queueTrkMessage(byte code, TrkCallback callback,
 const QByteArray &data, const QVariant &cookie)
 class WriterThread : public QThread
 {
 Q_OBJECT
 Q_DISABLE_COPY(WriterThread)
 public:
 explicit WriterThread(const QSharedPointer<DeviceContext> &context);
 // Enqueue messages.
 void queueTrkMessage(byte code, TrkCallback callback,
 const QByteArray &data, const QVariant &cookie);
 void queueTrkInitialPing();
+void clearWriteQueue();
 // Call this from the device read notification with the results.
 void slotHandleResult(const TrkResult &result);
 virtual void run();
 void tryWrite();
 private slots:
 void invokeNoopMessage(const trk::TrkMessage &);
 private:
 bool write(const QByteArray &data, QString *errorMessage);
 inline int writePendingMessage();
 const QSharedPointer<DeviceContext> m_context;
 QMutex m_dataMutex;
 {
 m_terminate = true;
 m_waitCondition.wakeAll();
 wait();
 m_terminate = false;
+m_queue.clear();
 }
 #ifdef Q_OS_WIN
 static inline QString msgTerminated(int size)
 m_queue.queueTrkMessage(code, callback, data, cookie);
 m_dataMutex.unlock();
 tryWrite();
 }
+void WriterThread::clearWriteQueue()
+{
+m_dataMutex.lock();
+m_queue.clear();
+m_dataMutex.unlock();
+}
 void WriterThread::queueTrkInitialPing()
 {
 m_dataMutex.lock();
 m_queue.queueTrkInitialPing();
 m_dataMutex.unlock();
 class ReaderThreadBase : public QThread
 {
 Q_OBJECT
 Q_DISABLE_COPY(ReaderThreadBase)
 public:
+int bytesPending() const { return m_trkReadBuffer.size(); }
 signals:
 void messageReceived(const trk::TrkResult &result, const QByteArray &rawData);
 protected:
 // Check if there are already bytes waiting. If not, wait for first byte
 COMSTAT comStat;
 if (!ClearCommError(m_context->device, NULL, &comStat)){
 emit error(QString::fromLatin1("ClearCommError failed: %1").arg(winErrorMessage(GetLastError())));
 return -7;
 }
 const DWORD bytesToRead = qMax(DWORD(1), qMin(comStat.cbInQue, DWORD(BufSize)));
 // Trigger read
 DWORD bytesRead = 0;
 if (ReadFile(m_context->device, &buffer, bytesToRead, &bytesRead, &m_context->readOverlapped)) {
 if (bytesRead == 1) {
 }
 const DWORD readError = GetLastError();
 if (readError != ERROR_IO_PENDING) {
 emit error(QString::fromLatin1("Read error: %1").arg(winErrorMessage(readError)));
 return -1;
 }
 // Wait for either termination or data
 const DWORD wr = WaitForMultipleObjects(HandleCount, m_handles, false, INFINITE);
 if (wr == WAIT_FAILED) {
 emit error(QString::fromLatin1("Wait failed: %1").arg(winErrorMessage(GetLastError())));
 return -2;
 inline int tryRead();
 int m_terminatePipeFileDescriptors[2];
 };
 UnixReaderThread::UnixReaderThread(const QSharedPointer<DeviceContext> &context) :
 ReaderThreadBase(context)
 {
 m_terminatePipeFileDescriptors[0] = m_terminatePipeFileDescriptors[1] = -1;
 // Set up pipes for termination. Should not fail
 if (pipe(m_terminatePipeFileDescriptors) < 0)
 struct TrkDevicePrivate
 {
 TrkDevicePrivate();
 QSharedPointer<DeviceContext> deviceContext;
-QSharedPointer<WriterThread> writerThread;
+QScopedPointer<WriterThread> writerThread;
-QSharedPointer<ReaderThread> readerThread;
+QScopedPointer<ReaderThread> readerThread;
 QByteArray trkReadBuffer;
 int verbose;
 QString errorString;
 QString port;
 delete d;
 }
 bool TrkDevice::open(QString *errorMessage)
 {
-if (d->verbose)
+if (d->verbose || verboseTrk)
 qDebug() << "Opening" << port() << "is open: " << isOpen() << " serialFrame=" << serialFrame();
+if (isOpen())
+return true;
 if (d->port.isEmpty()) {
 *errorMessage = QLatin1String("Internal error: No port set on TrkDevice");
 return false;
 }
-close();
 #ifdef Q_OS_WIN
 const QString fullPort = QLatin1String("\\\\.\\") + d->port;
 d->deviceContext->device = CreateFile(reinterpret_cast<const WCHAR*>(fullPort.utf16()),
 GENERIC_READ | GENERIC_WRITE,
 0,
 if (tcsetattr(d->deviceContext->file.handle(), TCSAFLUSH, &termInfo) < 0) {
 *errorMessage = QString::fromLatin1("Unable to apply terminal settings: %1 %2").arg(errno).arg(QString::fromAscii(strerror(errno)));
 return false;
 }
 #endif
-d->readerThread = QSharedPointer<ReaderThread>(new ReaderThread(d->deviceContext));
+d->readerThread.reset(new ReaderThread(d->deviceContext));
 connect(d->readerThread.data(), SIGNAL(error(QString)), this, SLOT(emitError(QString)),
 Qt::QueuedConnection);
 connect(d->readerThread.data(), SIGNAL(messageReceived(trk::TrkResult,QByteArray)),
 this, SLOT(slotMessageReceived(trk::TrkResult,QByteArray)),
 Qt::QueuedConnection);
 d->readerThread->start();
-d->writerThread = QSharedPointer<WriterThread>(new WriterThread(d->deviceContext));
+d->writerThread.reset(new WriterThread(d->deviceContext));
 connect(d->writerThread.data(), SIGNAL(error(QString)), this, SLOT(emitError(QString)),
 Qt::QueuedConnection);
 d->writerThread->start();
-if (d->verbose)
+if (d->verbose || verboseTrk)
-qDebug() << "Opened" << d->port;
+qDebug() << "Opened" << d->port << d->readerThread.data() << d->writerThread.data();
 return true;
 }
 void TrkDevice::close()
 {
+if (verboseTrk)
+qDebug() << "close" << d->port << " is open: " << isOpen()
+<< " read pending " << (d->readerThread.isNull() ? 0 : d->readerThread->bytesPending())
+<< sender();
 if (!isOpen())
 return;
 if (d->readerThread)
 d->readerThread->terminate();
 if (d->writerThread)
 CloseHandle(d->deviceContext->writeOverlapped.hEvent);
 d->deviceContext->readOverlapped.hEvent = d->deviceContext->writeOverlapped.hEvent = NULL;
 #else
 d->deviceContext->file.close();
 #endif
 if (d->verbose)
 emitLogMessage("Close");
 }
 bool TrkDevice::isOpen() const
 return d->port;
 }
 void TrkDevice::setPort(const QString &p)
 {
+if (verboseTrk)
+qDebug() << "setPort" << p;
 d->port = p;
 }
 QString TrkDevice::errorString() const
 {
 return d->deviceContext->serialFrame;
 }
 void TrkDevice::setSerialFrame(bool f)
 {
+if (verboseTrk)
+qDebug() << "setSerialFrame" << f;
 d->deviceContext->serialFrame = f;
 }
 int TrkDevice::verbose() const
 {
 d->verbose = b;
 }
 void TrkDevice::slotMessageReceived(const trk::TrkResult &result, const QByteArray &rawData)
 {
-d->writerThread->slotHandleResult(result);
+if (isOpen()) { // Might receive bytes after closing due to queued connections.
-if (d->verbose > 1)
+d->writerThread->slotHandleResult(result);
-qDebug() << "Received: " << result.toString();
+if (d->verbose > 1)
-emit messageReceived(result);
+qDebug() << "Received: " << result.toString();
-if (!rawData.isEmpty())
+emit messageReceived(result);
-emit rawDataReceived(rawData);
+if (!rawData.isEmpty())
+emit rawDataReceived(rawData);
+}
 }
 void TrkDevice::emitError(const QString &s)
 {
 d->errorString = s;
 qWarning("%s\n", qPrintable(s));
 emit error(s);
 }
+void TrkDevice::clearWriteQueue()
+{
+if (isOpen())
+d->writerThread->clearWriteQueue();
+}
 void TrkDevice::sendTrkMessage(byte code, TrkCallback callback,
 const QByteArray &data, const QVariant &cookie)
 {
+if (!isOpen()) {
+emitError(msgAccessingClosedDevice(d->port));
+return;
+}
 if (!d->writerThread.isNull()) {
 if (d->verbose > 1) {
-QByteArray msg = "Sending:  ";
+QByteArray msg = "Sending:  0x";
 msg += QByteArray::number(code, 16);
 msg += ": ";
 msg += stringFromArray(data).toLatin1();
+if (cookie.isValid())
+msg += " Cookie: " + cookie.toString().toLatin1();
 qDebug("%s", msg.data());
 }
 d->writerThread->queueTrkMessage(code, callback, data, cookie);
 }
 }
 void TrkDevice::sendTrkInitialPing()
 {
+if (!isOpen()) {
+emitError(msgAccessingClosedDevice(d->port));
+return;
+}
 if (!d->writerThread.isNull())
 d->writerThread->queueTrkInitialPing();
 }
 bool TrkDevice::sendTrkAck(byte token)
 {
+if (!isOpen()) {
+emitError(msgAccessingClosedDevice(d->port));
+return false;
+}
 if (d->writerThread.isNull())
 return false;
 // The acknowledgement must not be queued!
 TrkMessage msg(0x80, token);
 msg.token = token;

changeset 30	5dc02b23752f
parent 18	2f34d5167611
child 33	3e2da88830cd