Merge symbianutils from qtcreator e82219b344ee471dbb5d8e7f1351404ff9616d6c

6 files changed, 384 insertions, 77 deletions

diff --git a/tools/runonphone/symbianutils/launcher.cpp b/tools/runonphone/symbianutils/launcher.cpp
index 408829b8e9..92b494ac0c 100644
--- a/tools/runonphone/symbianutils/launcher.cpp
+++ b/tools/runonphone/symbianutils/launcher.cpp
@@ -44,6 +44,7 @@
 #include "trkutils_p.h"
 #include "trkdevice.h"
 #include "bluetoothlistener.h"
+#include "symbiandevicemanager.h"
 
 #include <QtCore/QTimer>
 #include <QtCore/QDateTime>
@@ -100,12 +101,15 @@ Launcher::Launcher(Actions startupActions,
     d(new LauncherPrivate(dev))
 {
     d->m_startupActions = startupActions;
-    connect(d->m_device.data(), SIGNAL(messageReceived(trk::TrkResult)), this, SLOT(handleResult(trk::TrkResult)));    
-    connect(this, SIGNAL(finished()), d->m_device.data(), SLOT(close()));
+    connect(d->m_device.data(), SIGNAL(messageReceived(trk::TrkResult)), this, SLOT(handleResult(trk::TrkResult)));
 }
 
 Launcher::~Launcher()
 {
+    // Destroyed before protocol was through: Close
+    if (d->m_closeDevice && d->m_device->isOpen())
+        d->m_device->close();
+    emit destroyed(d->m_device->port());
     logMessage("Shutting down.\n");
     delete d;
 }
@@ -214,11 +218,6 @@ bool Launcher::startServer(QString *errorMessage)
     }
     if (!d->m_device->isOpen() && !d->m_device->open(errorMessage))
         return false;
-    if (d->m_closeDevice) {
-        connect(this, SIGNAL(finished()), d->m_device.data(), SLOT(close()));
-    } else {
-        disconnect(this, SIGNAL(finished()), d->m_device.data(), 0);
-    }
     setState(Connecting);
     // Set up the temporary 'waiting' state if we do not get immediate connection
     QTimer::singleShot(1000, this, SLOT(slotWaitingForTrk()));
@@ -266,6 +265,13 @@ void Launcher::logMessage(const QString &msg)
         qDebug() << "LAUNCHER: " << qPrintable(msg);
 }
 
+void Launcher::handleFinished()
+{
+    if (d->m_closeDevice)
+        d->m_device->close();
+    emit finished();
+}
+
 void Launcher::terminate()
 {
     switch (state()) {
@@ -287,7 +293,7 @@ void Launcher::terminate()
     case Connecting:
     case WaitingForTrk:
         setState(Disconnected);
-        emit finished();
+        handleFinished();
         break;
     }
 }
@@ -446,7 +452,7 @@ void Launcher::handleTrkVersion(const TrkResult &result)
     if (result.errorCode() || result.data.size() < 5) {
         if (d->m_startupActions == ActionPingOnly) {
             setState(Disconnected);
-            emit finished();
+            handleFinished();
         }
         return;
     }
@@ -455,11 +461,13 @@ void Launcher::handleTrkVersion(const TrkResult &result)
     d->m_session.trkAppVersion.protocolMajor = result.data.at(3);
     d->m_session.trkAppVersion.protocolMinor = result.data.at(4);
     setState(DeviceDescriptionReceived);
+    const QString msg = deviceDescription();
+    emit deviceDescriptionReceived(trkServerName(), msg);
     // Ping mode: Log & Terminate
     if (d->m_startupActions == ActionPingOnly) {
-        qWarning("%s", qPrintable(deviceDescription()));
+        qWarning("%s", qPrintable(msg));
         setState(Disconnected);
-        emit finished();
+        handleFinished();
     }
 }
 
@@ -586,7 +594,7 @@ void Launcher::handleWaitForFinished(const TrkResult &result)
 {
     logMessage("   FINISHED: " + stringFromArray(result.data));
     setState(Disconnected);
-    emit finished();
+    handleFinished();
 }
 
 void Launcher::handleSupportMask(const TrkResult &result)
@@ -704,18 +712,14 @@ QByteArray Launcher::startProcessMessage(const QString &executable,
 {
     // It's not started yet
     QByteArray ba;
-    appendShort(&ba, 0, TargetByteOrder); // create new process
+    appendShort(&ba, 0, TargetByteOrder); // create new process (kDSOSProcessItem)
     ba.append(char(0)); // options - currently unused
-    if(arguments.isEmpty()) {
-        appendString(&ba, executable.toLocal8Bit(), TargetByteOrder);
-        return ba;
-    }
-    // Append full command line as one string (leading length information).
-    QByteArray commandLineBa;
-    commandLineBa.append(executable.toLocal8Bit());
-    commandLineBa.append('\0');
-    commandLineBa.append(arguments.join(QString(QLatin1Char(' '))).toLocal8Bit());
-    appendString(&ba, commandLineBa, TargetByteOrder);
+    // One string consisting of binary terminated by '\0' and arguments terminated by '\0'
+    QByteArray commandLineBa = executable.toLocal8Bit();
+    commandLineBa.append(char(0));
+    if (!arguments.isEmpty())
+        commandLineBa.append(arguments.join(QString(QLatin1Char(' '))).toLocal8Bit());
+    appendString(&ba, commandLineBa, TargetByteOrder, true);
     return ba;
 }
 
@@ -737,4 +741,37 @@ void Launcher::resumeProcess(uint pid, uint tid)
     appendInt(&ba, tid, BigEndian);
     d->m_device->sendTrkMessage(TrkContinue, TrkCallback(), ba, "CONTINUE");
 }
+
+// Acquire a device from SymbianDeviceManager, return 0 if not available.
+Launcher *Launcher::acquireFromDeviceManager(const QString &serverName,
+                                             QObject *parent,
+                                             QString *errorMessage)
+{
+    SymbianUtils::SymbianDeviceManager *sdm = SymbianUtils::SymbianDeviceManager::instance();
+    const QSharedPointer<trk::TrkDevice> device = sdm->acquireDevice(serverName);
+    if (device.isNull()) {
+        *errorMessage = tr("Unable to acquire a device for port '%1'. It appears to be in use.").arg(serverName);
+        return 0;
+    }
+    // Wire release signal.
+    Launcher *rc = new Launcher(trk::Launcher::ActionPingOnly, device, parent);
+    connect(rc, SIGNAL(deviceDescriptionReceived(QString,QString)),
+            sdm, SLOT(setAdditionalInformation(QString,QString)));
+    connect(rc, SIGNAL(destroyed(QString)), sdm, SLOT(releaseDevice(QString)));
+    return rc;
+}
+
+// Preliminary release of device, disconnecting the signal.
+void Launcher::releaseToDeviceManager(Launcher *launcher)
+{
+    SymbianUtils::SymbianDeviceManager *sdm = SymbianUtils::SymbianDeviceManager::instance();
+    // Disentangle launcher and its device, remove connection from destroyed
+    launcher->setCloseDevice(false);
+    TrkDevice *device = launcher->trkDevice().data();
+    launcher->disconnect(device);
+    device->disconnect(launcher);
+    launcher->disconnect(sdm);
+    sdm->releaseDevice(launcher->trkServerName());
+}
+
 } // namespace trk
diff --git a/tools/runonphone/symbianutils/launcher.h b/tools/runonphone/symbianutils/launcher.h
index 2b23fd87b9..c47285c1b3 100644
--- a/tools/runonphone/symbianutils/launcher.h
+++ b/tools/runonphone/symbianutils/launcher.h
@@ -97,7 +97,7 @@ public:
     void setInstallFileName(const QString &name);
     void setCommandLineArgs(const QStringList &args);
     bool startServer(QString *errorMessage);
-    void setVerbose(int v);    
+    void setVerbose(int v);
     void setSerialFrame(bool b);
     bool serialFrame() const;
     // Close device or leave it open
@@ -109,6 +109,15 @@ public:
     // becomes valid after successful execution of ActionPingOnly
     QString deviceDescription(unsigned verbose = 0u) const;
 
+    // Acquire a device from SymbianDeviceManager, return 0 if not available.
+    // The device will be released on destruction.
+    static Launcher *acquireFromDeviceManager(const QString &serverName,
+                                              QObject *parent,
+                                              QString *errorMessage);
+    // Preliminary release of device, disconnecting the signal.
+    static void releaseToDeviceManager(Launcher *l);
+
+    // Create Trk message to start a process.
     static QByteArray startProcessMessage(const QString &executable,
                                           const QStringList &arguments);
     // Parse a TrkNotifyStopped message
@@ -119,6 +128,7 @@ public:
     static QString msgStopped(uint pid, uint tid, uint address, const QString &why);
 
 signals:
+    void deviceDescriptionReceived(const QString &port, const QString &description);
     void copyingStarted();
     void canNotConnect(const QString &errorMessage);
     void canNotCreateFile(const QString &filename, const QString &errorMessage);
@@ -135,6 +145,8 @@ signals:
     void copyProgress(int percent);
     void stateChanged(int);
     void processStopped(uint pc, uint pid, uint tid, const QString& reason);
+    // Emitted by the destructor, for releasing devices of SymbianDeviceManager by name
+    void destroyed(const QString &serverName);
 
 public slots:
     void terminate();
@@ -167,6 +179,7 @@ private:
     void copyFileToRemote();
     void installRemotePackageSilently();
     void startInferiorIfNeeded();
+    void handleFinished();
 
     void logMessage(const QString &msg);
     void setState(State s);
diff --git a/tools/runonphone/symbianutils/symbiandevicemanager.cpp b/tools/runonphone/symbianutils/symbiandevicemanager.cpp
index f663816a46..8877ea15cb 100644
--- a/tools/runonphone/symbianutils/symbiandevicemanager.cpp
+++ b/tools/runonphone/symbianutils/symbiandevicemanager.cpp
@@ -40,6 +40,7 @@
 ****************************************************************************/
 
 #include "symbiandevicemanager.h"
+#include "trkdevice.h"
 
 #include <QtCore/QSettings>
 #include <QtCore/QStringList>
@@ -48,6 +49,7 @@
 #include <QtCore/QTextStream>
 #include <QtCore/QSharedData>
 #include <QtCore/QScopedPointer>
+#include <QtCore/QSignalMapper>
 
 namespace SymbianUtils {
 
@@ -61,19 +63,51 @@ const char *SymbianDeviceManager::linuxBlueToothDeviceRootC = "/dev/rfcomm";
 // ------------- SymbianDevice
 class SymbianDeviceData : public QSharedData {
 public:
-    SymbianDeviceData() : type(SerialPortCommunication) {}
+    SymbianDeviceData();
+    ~SymbianDeviceData();
+
+    inline bool isOpen() const { return !device.isNull() && device->isOpen(); }
+    void forcedClose();
 
     QString portName;
     QString friendlyName;
     QString deviceDesc;
     QString manufacturer;
+    QString additionalInformation;
+
     DeviceCommunicationType type;
+    QSharedPointer<trk::TrkDevice> device;
+    bool deviceAcquired;
 };
 
+SymbianDeviceData::SymbianDeviceData() :
+        type(SerialPortCommunication),
+        deviceAcquired(false)
+{
+}
+
+SymbianDeviceData::~SymbianDeviceData()
+{
+    forcedClose();
+}
+
+void SymbianDeviceData::forcedClose()
+{
+    // Close the device when unplugging. Should devices be in 'acquired' state,
+    // their owners should hit on write failures.
+    // Apart from the <shared item> destructor, also called by the devicemanager
+    // to ensure it also happens if other shared instances are still around.
+    if (isOpen()) {
+        if (deviceAcquired)
+            qWarning("Device on '%s' unplugged while an operation is in progress.",
+                     qPrintable(portName));
+        device->close();
+    }
+}
+
 SymbianDevice::SymbianDevice(SymbianDeviceData *data) :
     m_data(data)
 {
-
 }
 
 SymbianDevice::SymbianDevice() :
@@ -96,6 +130,11 @@ SymbianDevice::~SymbianDevice()
 {
 }
 
+void SymbianDevice::forcedClose()
+{
+    m_data->forcedClose();
+}
+
 QString SymbianDevice::portName() const
 {
     return m_data->portName;
@@ -106,6 +145,51 @@ QString SymbianDevice::friendlyName() const
     return m_data->friendlyName;
 }
 
+QString SymbianDevice::additionalInformation() const
+{
+    return m_data->additionalInformation;
+}
+
+void SymbianDevice::setAdditionalInformation(const QString &a)
+{
+    m_data->additionalInformation = a;
+}
+
+SymbianDevice::TrkDevicePtr SymbianDevice::acquireDevice()
+{
+    if (debug)
+        qDebug() << "SymbianDevice::acquireDevice" << m_data->portName
+                << "acquired: " << m_data->deviceAcquired << " open: " << isOpen();
+    if (isNull() || m_data->deviceAcquired)
+        return TrkDevicePtr();
+    if (m_data->device.isNull()) {
+        m_data->device = TrkDevicePtr(new trk::TrkDevice);
+        m_data->device->setPort(m_data->portName);
+        m_data->device->setSerialFrame(m_data->type == SerialPortCommunication);
+    }
+    m_data->deviceAcquired = true;
+    return m_data->device;
+}
+
+void SymbianDevice::releaseDevice(TrkDevicePtr *ptr /* = 0 */)
+{
+    if (debug)
+        qDebug() << "SymbianDevice::releaseDevice" << m_data->portName
+                << " open: " << isOpen();
+    if (m_data->deviceAcquired) {
+        if (m_data->device->isOpen())
+            m_data->device->clearWriteQueue();
+        // Release if a valid pointer was passed in.
+        if (ptr && !ptr->isNull()) {
+            ptr->data()->disconnect();
+            *ptr = TrkDevicePtr();
+        }
+        m_data->deviceAcquired = false;
+    } else {
+        qWarning("Internal error: Attempt to release device that is not acquired.");
+    }
+}
+
 QString SymbianDevice::deviceDesc() const
 {
     return m_data->deviceDesc;
@@ -123,7 +207,12 @@ DeviceCommunicationType SymbianDevice::type() const
 
 bool SymbianDevice::isNull() const
 {
-    return !m_data->portName.isEmpty();
+    return m_data->portName.isEmpty();
+}
+
+bool SymbianDevice::isOpen() const
+{
+    return m_data->isOpen();
 }
 
 QString SymbianDevice::toString() const
@@ -158,7 +247,7 @@ int SymbianDevice::compare(const SymbianDevice &rhs) const
     return 0;
 }
 
-QDebug operator<<(QDebug d, const SymbianDevice &cd)
+SYMBIANUTILS_EXPORT QDebug operator<<(QDebug d, const SymbianDevice &cd)
 {
     d.nospace() << cd.toString();
     return d;
@@ -166,10 +255,11 @@ QDebug operator<<(QDebug d, const SymbianDevice &cd)
 
 // ------------- SymbianDeviceManagerPrivate
 struct SymbianDeviceManagerPrivate {
-    SymbianDeviceManagerPrivate() : m_initialized(false) {}
+    SymbianDeviceManagerPrivate() : m_initialized(false), m_destroyReleaseMapper(0) {}
 
     bool m_initialized;
     SymbianDeviceManager::SymbianDeviceList m_devices;
+    QSignalMapper *m_destroyReleaseMapper;
 };
 
 SymbianDeviceManager::SymbianDeviceManager(QObject *parent) :
@@ -185,8 +275,7 @@ SymbianDeviceManager::~SymbianDeviceManager()
 
 SymbianDeviceManager::SymbianDeviceList SymbianDeviceManager::devices() const
 {
-    if (!d->m_initialized)
-        const_cast<SymbianDeviceManager*>(this)->update(false);
+    ensureInitialized();
     return d->m_devices;
 }
 
@@ -194,6 +283,7 @@ QString SymbianDeviceManager::toString() const
 {
     QString rc;
     QTextStream str(&rc);
+    str << d->m_devices.size() << " devices:\n";
     const int count = d->m_devices.size();
     for (int i = 0; i < count; i++) {
         str << '#' << i << ' ';
@@ -203,13 +293,37 @@ QString SymbianDeviceManager::toString() const
     return rc;
 }
 
+int SymbianDeviceManager::findByPortName(const QString &p) const
+{
+    ensureInitialized();
+    const int count = d->m_devices.size();
+    for (int i = 0; i < count; i++)
+        if (d->m_devices.at(i).portName() == p)
+            return i;
+    return -1;
+}
+
 QString SymbianDeviceManager::friendlyNameForPort(const QString &port) const
 {
-    foreach (const SymbianDevice &device, d->m_devices) {
-        if (device.portName() == port)
-            return device.friendlyName();
-    }
-    return QString();
+    const int idx = findByPortName(port);
+    return idx == -1 ? QString() : d->m_devices.at(idx).friendlyName();
+}
+
+SymbianDeviceManager::TrkDevicePtr
+        SymbianDeviceManager::acquireDevice(const QString &port)
+{
+    ensureInitialized();
+    const int idx = findByPortName(port);
+    if (idx == -1) {
+        qWarning("Attempt to acquire device '%s' that does not exist.", qPrintable(port));
+        if (debug)
+            qDebug() << *this;
+        return TrkDevicePtr();
+      }
+    const TrkDevicePtr rc = d->m_devices[idx].acquireDevice();
+    if (debug)
+        qDebug() << "SymbianDeviceManager::acquireDevice" << port << " returns " << !rc.isNull();
+    return rc;
 }
 
 void SymbianDeviceManager::update()
@@ -217,12 +331,38 @@ void SymbianDeviceManager::update()
     update(true);
 }
 
+void SymbianDeviceManager::releaseDevice(const QString &port)
+{
+    const int idx = findByPortName(port);
+    if (debug)
+        qDebug() << "SymbianDeviceManager::releaseDevice" << port << idx << sender();
+    if (idx != -1) {
+        d->m_devices[idx].releaseDevice();
+    } else {
+        qWarning("Attempt to release non-existing device %s.", qPrintable(port));
+    }
+}
+
+void SymbianDeviceManager::setAdditionalInformation(const QString &port, const QString &ai)
+{
+    const int idx = findByPortName(port);
+    if (idx != -1)
+        d->m_devices[idx].setAdditionalInformation(ai);
+}
+
+void SymbianDeviceManager::ensureInitialized() const
+{
+    if (!d->m_initialized) // Flag is set in update()
+        const_cast<SymbianDeviceManager*>(this)->update(false);
+}
+
 void SymbianDeviceManager::update(bool emitSignals)
 {
+    static int n = 0;
     typedef SymbianDeviceList::iterator SymbianDeviceListIterator;
 
     if (debug)
-        qDebug(">SerialDeviceLister::update(%d)\n%s", int(emitSignals),
+        qDebug(">SerialDeviceLister::update(#%d, signals=%d)\n%s", n++, int(emitSignals),
                qPrintable(toString()));
 
     d->m_initialized = true;
@@ -230,8 +370,11 @@ void SymbianDeviceManager::update(bool emitSignals)
     SymbianDeviceList newDevices = serialPorts() + blueToothDevices();
     if (newDevices.size() > 1)
         qStableSort(newDevices.begin(), newDevices.end());
-    if (d->m_devices == newDevices) // Happy, nothing changed.
+    if (d->m_devices == newDevices) { // Happy, nothing changed.
+        if (debug)
+            qDebug("<SerialDeviceLister::update: unchanged\n");
         return;
+    }
     // Merge the lists and emit the respective added/removed signals, assuming
     // no one can plug a different device on the same port at the speed of lightning
     if (!d->m_devices.isEmpty()) {
@@ -240,7 +383,8 @@ void SymbianDeviceManager::update(bool emitSignals)
             if (newDevices.contains(*oldIt)) {
                 ++oldIt;
             } else {
-                const SymbianDevice toBeDeleted = *oldIt;
+                SymbianDevice toBeDeleted = *oldIt;
+                toBeDeleted.forcedClose();
                 oldIt = d->m_devices.erase(oldIt);
                 if (emitSignals)
                     emit deviceRemoved(toBeDeleted);
@@ -301,16 +445,30 @@ SymbianDeviceManager::SymbianDeviceList SymbianDeviceManager::blueToothDevices()
     // Bluetooth devices are created on connection. List the existing ones
     // or at least the first one.
     const QString prefix = QLatin1String(linuxBlueToothDeviceRootC);
-    const QString friendlyFormat = QLatin1String("Bluetooth device (%1)");
+    const QString blueToothfriendlyFormat = QLatin1String("Bluetooth device (%1)");
     for (int d = 0; d < 4; d++) {
         QScopedPointer<SymbianDeviceData> device(new SymbianDeviceData);
         device->type = BlueToothCommunication;
         device->portName = prefix + QString::number(d);
         if (d == 0 || QFileInfo(device->portName).exists()) {
-            device->friendlyName = friendlyFormat.arg(device->portName);
+            device->friendlyName = blueToothfriendlyFormat.arg(device->portName);
             rc.push_back(SymbianDevice(device.take()));
         }
     }
+    // New kernel versions support /dev/ttyUSB0, /dev/ttyUSB1. Trk responds
+    // on the latter (usually), try first.
+    static const char *usbTtyDevices[] = { "/dev/ttyUSB1", "/dev/ttyUSB0" };
+    const int usbTtyCount = sizeof(usbTtyDevices)/sizeof(const char *);
+    for (int d = 0; d < usbTtyCount; d++) {
+        const QString ttyUSBDevice = QLatin1String(usbTtyDevices[d]);
+        if (QFileInfo(ttyUSBDevice).exists()) {
+            SymbianDeviceData *device = new SymbianDeviceData;
+            device->type = SerialPortCommunication;
+            device->portName = ttyUSBDevice;
+            device->friendlyName = QString::fromLatin1("USB/Serial device (%1)").arg(device->portName);
+            rc.push_back(SymbianDevice(device));
+        }
+    }
 #endif
     return rc;
 }
@@ -322,7 +480,7 @@ SymbianDeviceManager *SymbianDeviceManager::instance()
     return symbianDeviceManager();
 }
 
-QDebug operator<<(QDebug d, const SymbianDeviceManager &sdm)
+SYMBIANUTILS_EXPORT QDebug operator<<(QDebug d, const SymbianDeviceManager &sdm)
 {
     d.nospace() << sdm.toString();
     return d;
diff --git a/tools/runonphone/symbianutils/symbiandevicemanager.h b/tools/runonphone/symbianutils/symbiandevicemanager.h
index dcf131a801..180173d9b2 100644
--- a/tools/runonphone/symbianutils/symbiandevicemanager.h
+++ b/tools/runonphone/symbianutils/symbiandevicemanager.h
@@ -46,12 +46,17 @@
 
 #include <QtCore/QObject>
 #include <QtCore/QExplicitlySharedDataPointer>
+#include <QtCore/QSharedPointer>
 
 QT_BEGIN_NAMESPACE
 class QDebug;
 class QTextStream;
 QT_END_NAMESPACE
 
+namespace trk {
+    class TrkDevice;
+}
+
 namespace SymbianUtils {
 
 struct SymbianDeviceManagerPrivate;
@@ -62,11 +67,16 @@ enum DeviceCommunicationType {
     BlueToothCommunication = 1
 };
 
-// SymbianDevice, explicitly shared.
+// SymbianDevice: Explicitly shared device data and a TrkDevice
+// instance that can be acquired (exclusively) for use.
+// A device removal from the manager will result in the
+// device being closed.
 class SYMBIANUTILS_EXPORT SymbianDevice {
     explicit SymbianDevice(SymbianDeviceData *data);
     friend class SymbianDeviceManager;
 public:
+    typedef QSharedPointer<trk::TrkDevice> TrkDevicePtr;
+
     SymbianDevice();
     SymbianDevice(const SymbianDevice &rhs);
     SymbianDevice &operator=(const SymbianDevice &rhs);
@@ -77,6 +87,17 @@ public:
     bool isNull() const;
     QString portName() const;
     QString friendlyName() const;
+    QString additionalInformation() const;
+    void setAdditionalInformation(const QString &);
+
+    // Acquire: Mark the device as 'out' and return a shared pointer
+    // unless it is already in use by another owner. The result should not
+    // be passed on further.
+    TrkDevicePtr acquireDevice();
+    // Give back a device and mark it as 'free'.
+    void releaseDevice(TrkDevicePtr *ptr = 0);
+
+    bool isOpen() const;
 
     // Windows only.
     QString deviceDesc() const;
@@ -86,10 +107,12 @@ public:
     QString toString() const;
 
 private:
+    void forcedClose();
+
     QExplicitlySharedDataPointer<SymbianDeviceData> m_data;
 };
 
-QDebug operator<<(QDebug d, const SymbianDevice &);
+SYMBIANUTILS_EXPORT QDebug operator<<(QDebug d, const SymbianDevice &);
 
 inline bool operator==(const SymbianDevice &d1, const SymbianDevice &d2)
     { return d1.compare(d2) == 0; }
@@ -100,13 +123,15 @@ inline bool operator<(const SymbianDevice &d1, const SymbianDevice &d2)
 
 /* SymbianDeviceManager: Singleton that maintains a list of Symbian devices.
  * and emits change signals.
- * On Windows, the update slot must be connected to a signal
- * emitted from an event handler listening for WM_DEVICECHANGE. */
+ * On Windows, the update slot must be connected to a [delayed] signal
+ * emitted from an event handler listening for WM_DEVICECHANGE.
+ * Device removal will result in the device being closed. */
 class SYMBIANUTILS_EXPORT SymbianDeviceManager : public QObject
 {
     Q_OBJECT
 public:
     typedef QList<SymbianDevice> SymbianDeviceList;
+    typedef QSharedPointer<trk::TrkDevice> TrkDevicePtr;
 
     static const char *linuxBlueToothDeviceRootC;
 
@@ -120,17 +145,25 @@ public:
     SymbianDeviceList devices() const;
     QString toString() const;
 
+    // Acquire a device for use. See releaseDevice().
+    TrkDevicePtr acquireDevice(const QString &port);
+
+    int findByPortName(const QString &p) const;
     QString friendlyNameForPort(const QString &port) const;
 
 public slots:
     void update();
+    // Relase a device, make it available for further use.
+    void releaseDevice(const QString &port);
+    void setAdditionalInformation(const QString &port, const QString &ai);
 
 signals:
-    void deviceRemoved(const SymbianDevice &d);
-    void deviceAdded(const SymbianDevice &d);
+    void deviceRemoved(const SymbianUtils::SymbianDevice &d);
+    void deviceAdded(const SymbianUtils::SymbianDevice &d);
     void updated();
 
 private:
+    void ensureInitialized() const;
     void update(bool emitSignals);
     SymbianDeviceList serialPorts() const;
     SymbianDeviceList blueToothDevices() const;
@@ -138,7 +171,7 @@ private:
     SymbianDeviceManagerPrivate *d;
 };
 
-QDebug operator<<(QDebug d, const SymbianDeviceManager &);
+SYMBIANUTILS_EXPORT QDebug operator<<(QDebug d, const SymbianDeviceManager &);
 
 } // namespace SymbianUtils
 
diff --git a/tools/runonphone/symbianutils/trkdevice.cpp b/tools/runonphone/symbianutils/trkdevice.cpp
index b327ab3384..bd24300b33 100644
--- a/tools/runonphone/symbianutils/trkdevice.cpp
+++ b/tools/runonphone/symbianutils/trkdevice.cpp
@@ -52,6 +52,7 @@
 #include <QtCore/QMutex>
 #include <QtCore/QWaitCondition>
 #include <QtCore/QSharedPointer>
+#include <QtCore/QScopedPointer>
 #include <QtCore/QMetaType>
 
 #ifdef Q_OS_WIN
@@ -102,6 +103,11 @@ QString winErrorMessage(unsigned long error)
 
 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 {
 
 ///////////////////////////////////////////////////////////////////////
@@ -155,10 +161,11 @@ namespace trk {
 ///////////////////////////////////////////////////////////////////////
 
 class TrkWriteQueue
-{    
+{
     Q_DISABLE_COPY(TrkWriteQueue)
 public:
     explicit TrkWriteQueue();
+    void clear();
 
     // Enqueue messages.
     void queueTrkMessage(byte code, TrkCallback callback,
@@ -208,13 +215,24 @@ TrkWriteQueue::TrkWriteQueue() :
 {
 }
 
+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;
 }
 
@@ -349,7 +367,7 @@ class WriterThread : public QThread
 {
     Q_OBJECT
     Q_DISABLE_COPY(WriterThread)
-public:            
+public:
     explicit WriterThread(const QSharedPointer<DeviceContext> &context);
 
     // Enqueue messages.
@@ -357,6 +375,8 @@ public:
                         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);
 
@@ -374,7 +394,7 @@ public slots:
 private slots:
     void invokeNoopMessage(const trk::TrkMessage &);
 
-private:    
+private:
     bool write(const QByteArray &data, QString *errorMessage);
     inline int writePendingMessage();
 
@@ -462,6 +482,7 @@ void WriterThread::terminate()
     m_waitCondition.wakeAll();
     wait();
     m_terminate = false;
+    m_queue.clear();
 }
 
 #ifdef Q_OS_WIN
@@ -561,6 +582,13 @@ void WriterThread::queueTrkMessage(byte code, TrkCallback callback,
     tryWrite();
 }
 
+void WriterThread::clearWriteQueue()
+{
+    m_dataMutex.lock();
+    m_queue.clear();
+    m_dataMutex.unlock();
+}
+
 void WriterThread::queueTrkInitialPing()
 {
     m_dataMutex.lock();
@@ -592,6 +620,8 @@ class ReaderThreadBase : public QThread
     Q_DISABLE_COPY(ReaderThreadBase)
 public:
 
+    int bytesPending() const { return m_trkReadBuffer.size(); }
+
 signals:
     void messageReceived(const trk::TrkResult &result, const QByteArray &rawData);
 
@@ -692,7 +722,7 @@ int WinReaderThread::tryRead()
     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;
@@ -708,7 +738,7 @@ int WinReaderThread::tryRead()
     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) {
@@ -783,7 +813,7 @@ private:
     int m_terminatePipeFileDescriptors[2];
 };
 
-UnixReaderThread::UnixReaderThread(const QSharedPointer<DeviceContext> &context) : 
+UnixReaderThread::UnixReaderThread(const QSharedPointer<DeviceContext> &context) :
     ReaderThreadBase(context)
 {
     m_terminatePipeFileDescriptors[0] = m_terminatePipeFileDescriptors[1] = -1;
@@ -877,8 +907,8 @@ struct TrkDevicePrivate
     TrkDevicePrivate();
 
     QSharedPointer<DeviceContext> deviceContext;
-    QSharedPointer<WriterThread> writerThread;
-    QSharedPointer<ReaderThread> readerThread;
+    QScopedPointer<WriterThread> writerThread;
+    QScopedPointer<ReaderThread> readerThread;
 
     QByteArray trkReadBuffer;
     int verbose;
@@ -917,14 +947,14 @@ TrkDevice::~TrkDevice()
 
 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()),
@@ -975,7 +1005,7 @@ bool TrkDevice::open(QString *errorMessage)
         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)),
@@ -983,18 +1013,22 @@ bool TrkDevice::open(QString *errorMessage)
             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();    
+            Qt::QueuedConnection);
+    d->writerThread->start();
 
-    if (d->verbose)
-        qDebug() << "Opened" << d->port;
+    if (d->verbose || verboseTrk)
+        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)
@@ -1010,6 +1044,7 @@ void TrkDevice::close()
 #else
     d->deviceContext->file.close();
 #endif
+
     if (d->verbose)
         emitLogMessage("Close");
 }
@@ -1030,6 +1065,8 @@ QString TrkDevice::port() const
 
 void TrkDevice::setPort(const QString &p)
 {
+    if (verboseTrk)
+        qDebug() << "setPort" << p;
     d->port = p;
 }
 
@@ -1045,6 +1082,8 @@ bool TrkDevice::serialFrame() const
 
 void TrkDevice::setSerialFrame(bool f)
 {
+    if (verboseTrk)
+        qDebug() << "setSerialFrame" << f;
     d->deviceContext->serialFrame = f;
 }
 
@@ -1060,12 +1099,14 @@ void TrkDevice::setVerbose(int b)
 
 void TrkDevice::slotMessageReceived(const trk::TrkResult &result, const QByteArray &rawData)
 {
-    d->writerThread->slotHandleResult(result);
-    if (d->verbose > 1)
-        qDebug() << "Received: " << result.toString();
-    emit messageReceived(result);    
-    if (!rawData.isEmpty())
-        emit rawDataReceived(rawData);
+    if (isOpen()) { // Might receive bytes after closing due to queued connections.
+        d->writerThread->slotHandleResult(result);
+        if (d->verbose > 1)
+            qDebug() << "Received: " << result.toString();
+        emit messageReceived(result);
+        if (!rawData.isEmpty())
+            emit rawDataReceived(rawData);
+    }
 }
 
 void TrkDevice::emitError(const QString &s)
@@ -1075,15 +1116,27 @@ void TrkDevice::emitError(const QString &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);
@@ -1092,12 +1145,20 @@ void TrkDevice::sendTrkMessage(byte code, TrkCallback callback,
 
 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!
diff --git a/tools/runonphone/symbianutils/trkdevice.h b/tools/runonphone/symbianutils/trkdevice.h
index 78012fde4f..1021a7df27 100644
--- a/tools/runonphone/symbianutils/trkdevice.h
+++ b/tools/runonphone/symbianutils/trkdevice.h
@@ -64,12 +64,14 @@ struct TrkDevicePrivate;
  * Trk communications. Provides synchronous write and asynchronous
  * read operation.
  * The serialFrames property specifies whether packets are encapsulated in
- * "0x90 <length>" frames, which is currently the case for serial ports. 
+ * "0x90 <length>" frames, which is currently the case for serial ports.
  * Contains a write message queue allowing
  * for queueing messages with a notification callback. If the message receives
  * an ACK, the callback is invoked.
- * The special message TRK_WRITE_QUEUE_NOOP_CODE code can be used for synchronisation.
- * The respective  message will not be sent, the callback is just invoked. */
+ * The special message TRK_WRITE_QUEUE_NOOP_CODE code can be used for synchronization.
+ * The respective  message will not be sent, the callback is just invoked.
+ * Note that calling open/close in quick succession can cause crashes
+ * due to the use of queused signals. */
 
 enum { TRK_WRITE_QUEUE_NOOP_CODE = 0x7f };
 
@@ -111,6 +113,9 @@ public:
     // Send an Ack synchronously, bypassing the queue
     bool sendTrkAck(unsigned char token);
 
+public slots:
+    void clearWriteQueue();
+
 signals:
     void messageReceived(const trk::TrkResult &result);
     // Emitted with the contents of messages enclosed in 07e, not for log output