Fix: Prevent UI reset when new device inserted during write (#825)

src/app/drivemanager.cpp

@@ -157,6 +157,12 @@ void DriveManager::onDriveConnected(Drive *d)
     endInsertRows();
     emit drivesChanged();
 
+    // Fix for issue #825: Only change selection if the currently selected drive is not busy
+    if (selected() && selected()->isBusy()) {
+        return;
+    }
+
+    // Standard logic: Select the new drive if not busy
     if (m_provider->initialized()) {
         m_selectedIndex = position;
         emit selectedChanged();
@@ -289,6 +295,11 @@ bool Drive::delayedWrite() const
     return m_delayedWrite;
 }
 
+bool Drive::isBusy() const
+{
+    return m_process && m_process->state() != QProcess::NotRunning;
+}
+
 void Drive::setDelayedWrite(const bool &o)
 {
     if (m_delayedWrite != o) {

src/app/drivemanager.h

@@ -22,6 +22,8 @@
 
 #include <QAbstractListModel>
 #include <QDebug>
+#include <QProcess>
+#include <memory>
 
 #include "releasemanager.h"
 
@@ -30,6 +32,34 @@ class DriveProvider;
 class Drive;
 class UdisksDrive;
 
+/**
+ * @brief Custom deleter for QProcess to ensure proper cleanup
+ * 
+ * Handles platform-specific process termination before deletion
+ */
+struct DriveOperationDeleter {
+    void operator()(QProcess *process) {
+        if (!process) {
+            return;
+        }
+
+        if (process->state() != QProcess::NotRunning) {
+#ifdef Q_OS_WIN
+            process->kill();
+            process->waitForFinished();
+#else
+            process->terminate();
+            if (!process->waitForFinished(3000)) {
+                process->kill();
+                process->waitForFinished();
+            }
+#endif
+        }
+
+        delete process;
+    }
+};
+
 /**
  * @brief The DriveManager class
  *
@@ -169,6 +199,7 @@ class Drive : public QObject
     virtual qreal size() const;
     virtual RestoreStatus restoreStatus();
     virtual bool delayedWrite() const;
+    virtual bool isBusy() const;
 
     virtual void setDelayedWrite(const bool &o);
 
@@ -194,6 +225,7 @@ public slots:
     RestoreStatus m_restoreStatus{CLEAN};
     QString m_error{};
     bool m_delayedWrite{false};
+    std::unique_ptr<QProcess, DriveOperationDeleter> m_process;
 };
 
 #endif // DRIVEMANAGER_H

src/app/linuxdrivemanager.cpp

@@ -210,8 +210,8 @@ bool LinuxDrive::write(ReleaseVariant *data)
     if (m_image->status() == ReleaseVariant::READY || m_image->status() == ReleaseVariant::FAILED || m_image->status() == ReleaseVariant::FAILED_VERIFICATION || m_image->status() == ReleaseVariant::FINISHED)
         m_image->setStatus(ReleaseVariant::WRITING);
 
-    if (!m_process)
-        m_process = new QProcess(this);
+    // Create new process using unique_ptr
+    m_process.reset(new QProcess(this));
 
     QStringList args;
     if (QFile::exists(qApp->applicationDirPath() + "/../helper/linux/helper")) {
@@ -235,11 +235,11 @@ bool LinuxDrive::write(ReleaseVariant *data)
     mDebug() << this->metaObject()->className() << "Helper command will be" << args;
     m_process->setArguments(args);
 
-    connect(m_process, &QProcess::readyRead, this, &LinuxDrive::onReadyRead);
-    connect(m_process, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(onFinished(int, QProcess::ExitStatus)));
+    connect(m_process.get(), &QProcess::readyRead, this, &LinuxDrive::onReadyRead);
+    connect(m_process.get(), SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(onFinished(int, QProcess::ExitStatus)));
     // TODO check if this is actually necessary - it should work just fine even without it
-    connect(m_process, &QProcess::errorOccurred, this, &LinuxDrive::onErrorOccurred);
-    connect(qApp, &QCoreApplication::aboutToQuit, m_process, &QProcess::terminate);
+    connect(m_process.get(), &QProcess::errorOccurred, this, &LinuxDrive::onErrorOccurred);
+    connect(qApp, &QCoreApplication::aboutToQuit, m_process.get(), &QProcess::terminate);
 
     m_process->start(QIODevice::ReadOnly);
 
@@ -250,7 +250,7 @@ void LinuxDrive::cancel()
 {
     Drive::cancel();
     static bool beingCancelled = false;
-    if (m_process != nullptr && !beingCancelled) {
+    if (m_process && !beingCancelled) {
         beingCancelled = true;
         if (m_image) {
             if (m_image->status() == ReleaseVariant::WRITE_VERIFYING) {
@@ -260,9 +260,8 @@ void LinuxDrive::cancel()
                 m_image->setStatus(ReleaseVariant::FAILED);
             }
         }
-        m_process->kill();
-        m_process->deleteLater();
-        m_process = nullptr;
+        // Reset the unique_ptr, which automatically invokes DriveOperationDeleter
+        m_process.reset();
         beingCancelled = false;
     }
 }
@@ -271,8 +270,8 @@ void LinuxDrive::restore()
 {
     mDebug() << this->metaObject()->className() << "Will now restore" << this->m_device;
 
-    if (!m_process)
-        m_process = new QProcess(this);
+    // Create new process using unique_ptr
+    m_process.reset(new QProcess(this));
 
     m_restoreStatus = RESTORING;
     emit restoreStatusChanged();
@@ -294,9 +293,9 @@ void LinuxDrive::restore()
     mDebug() << this->metaObject()->className() << "Helper command will be" << args;
     m_process->setArguments(args);
 
-    connect(m_process, &QProcess::readyRead, this, &LinuxDrive::onReadyRead);
-    connect(m_process, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(onRestoreFinished(int, QProcess::ExitStatus)));
-    connect(qApp, &QCoreApplication::aboutToQuit, m_process, &QProcess::terminate);
+    connect(m_process.get(), &QProcess::readyRead, this, &LinuxDrive::onReadyRead);
+    connect(m_process.get(), SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(onRestoreFinished(int, QProcess::ExitStatus)));
+    connect(qApp, &QCoreApplication::aboutToQuit, m_process.get(), &QProcess::terminate);
 
     m_process->start(QIODevice::ReadOnly);
 }
@@ -353,11 +352,8 @@ void LinuxDrive::onFinished(int exitCode, QProcess::ExitStatus status)
         }
     }
 
-    if (m_process) {
-        m_process->deleteLater();
-        m_process = nullptr;
-        m_image = nullptr;
-    }
+    // Process cleanup handled automatically by unique_ptr deleter
+    m_image = nullptr;
 }
 
 void LinuxDrive::onRestoreFinished(int exitCode, QProcess::ExitStatus status)
@@ -373,10 +369,7 @@ void LinuxDrive::onRestoreFinished(int exitCode, QProcess::ExitStatus status)
     } else {
         m_restoreStatus = RESTORED;
     }
-    if (m_process) {
-        m_process->deleteLater();
-        m_process = nullptr;
-    }
+    // Process cleanup handled automatically by unique_ptr deleter
     emit restoreStatusChanged();
 }
 
@@ -389,8 +382,7 @@ void LinuxDrive::onErrorOccurred(QProcess::ProcessError e)
     QString errorMessage = m_process->errorString();
     mWarning() << "Restoring failed:" << errorMessage;
     m_image->setErrorString(errorMessage);
-    m_process->deleteLater();
-    m_process = nullptr;
+    // Process cleanup handled automatically by unique_ptr deleter
     m_image->setStatus(ReleaseVariant::FAILED);
     m_image = nullptr;
 }

src/app/linuxdrivemanager.h

@@ -76,8 +76,6 @@ private slots:
 
 private:
     QString m_device;
-
-    QProcess *m_process{nullptr};
 };
 
 #endif // LINUXDRIVEMANAGER_H

src/app/macdrivemanager.cpp

@@ -87,19 +87,16 @@ bool MacDrive::write(ReleaseVariant *data)
     if (m_image->status() == ReleaseVariant::READY || m_image->status() == ReleaseVariant::FAILED || m_image->status() == ReleaseVariant::FAILED_VERIFICATION || m_image->status() == ReleaseVariant::FINISHED)
         m_image->setStatus(ReleaseVariant::WRITING);
 
-    if (m_child) {
-        // TODO some handling of an already present process
-        m_child->deleteLater();
-    }
-    m_child = new QProcess(this);
-    connect(m_child, static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished), this, &MacDrive::onFinished);
-    connect(m_child, &QProcess::readyRead, this, &MacDrive::onReadyRead);
-    connect(qApp, &QCoreApplication::aboutToQuit, m_child, &QProcess::terminate);
+    // Create new process using unique_ptr
+    m_process.reset(new QProcess(this));
+    connect(m_process.get(), static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished), this, &MacDrive::onFinished);
+    connect(m_process.get(), &QProcess::readyRead, this, &MacDrive::onReadyRead);
+    connect(qApp, &QCoreApplication::aboutToQuit, m_process.get(), &QProcess::terminate);
 
     if (QFile::exists(qApp->applicationDirPath() + "/../../../../helper/mac/helper.app/Contents/MacOS/helper")) {
-        m_child->setProgram(QString("%1/../../../../helper/mac/helper.app/Contents/MacOS/helper").arg(qApp->applicationDirPath()));
+        m_process->setProgram(QString("%1/../../../../helper/mac/helper.app/Contents/MacOS/helper").arg(qApp->applicationDirPath()));
     } else if (QFile::exists(qApp->applicationDirPath() + "/helper")) {
-        m_child->setProgram(QString("%1/helper").arg(qApp->applicationDirPath()));
+        m_process->setProgram(QString("%1/helper").arg(qApp->applicationDirPath()));
     } else {
         data->setErrorString(tr("Could not find the helper binary. Check your installation."));
         setDelayedWrite(false);
@@ -114,39 +111,35 @@ bool MacDrive::write(ReleaseVariant *data)
     }
     args.append(m_bsdDevice);
 
-    mCritical() << "The command is" << m_child->program() << args;
-    m_child->setArguments(args);
+    mCritical() << "The command is" << m_process->program() << args;
+    m_process->setArguments(args);
 
-    m_child->start();
+    m_process->start();
 
     return true;
 }
 
 void MacDrive::cancel()
 {
     Drive::cancel();
-    if (m_child) {
-        m_child->kill();
-        m_child->deleteLater();
-        m_child = nullptr;
-    }
+    // Reset the unique_ptr, which automatically invokes DriveOperationDeleter
+    m_process.reset();
 }
 
 void MacDrive::restore()
 {
     mCritical() << "starting to restore";
-    if (m_child)
-        m_child->deleteLater();
 
-    m_child = new QProcess(this);
+    // Create new process using unique_ptr
+    m_process.reset(new QProcess(this));
 
     m_restoreStatus = RESTORING;
     emit restoreStatusChanged();
 
     if (QFile::exists(qApp->applicationDirPath() + "/../../../../helper/mac/helper.app/Contents/MacOS/helper")) {
-        m_child->setProgram(QString("%1/../../../../helper/mac/helper.app/Contents/MacOS/helper").arg(qApp->applicationDirPath()));
+        m_process->setProgram(QString("%1/../../../../helper/mac/helper.app/Contents/MacOS/helper").arg(qApp->applicationDirPath()));
     } else if (QFile::exists(qApp->applicationDirPath() + "/helper")) {
-        m_child->setProgram(QString("%1/helper").arg(qApp->applicationDirPath()));
+        m_process->setProgram(QString("%1/helper").arg(qApp->applicationDirPath()));
     } else {
         m_restoreStatus = RESTORE_ERROR;
         return;
@@ -155,16 +148,16 @@ void MacDrive::restore()
     QStringList args;
     args.append("restore");
     args.append(m_bsdDevice);
-    m_child->setArguments(args);
+    m_process->setArguments(args);
 
-    m_child->setProcessChannelMode(QProcess::ForwardedChannels);
+    m_process->setProcessChannelMode(QProcess::ForwardedChannels);
 
-    connect(m_child, static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished), this, &MacDrive::onRestoreFinished);
-    connect(qApp, &QCoreApplication::aboutToQuit, m_child, &QProcess::terminate);
+    connect(m_process.get(), static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished), this, &MacDrive::onRestoreFinished);
+    connect(qApp, &QCoreApplication::aboutToQuit, m_process.get(), &QProcess::terminate);
 
-    mCritical() << "The command is" << m_child->program() << args;
+    mCritical() << "The command is" << m_process->program() << args;
 
-    m_child->start();
+    m_process->start();
 }
 
 void MacDrive::onFinished(int exitCode, QProcess::ExitStatus exitStatus)
@@ -173,11 +166,11 @@ void MacDrive::onFinished(int exitCode, QProcess::ExitStatus exitStatus)
 
     setDelayedWrite(false);
 
-    if (!m_child)
+    if (!m_process)
         return;
 
     if (exitCode != 0) {
-        QString output = m_child->readAllStandardError();
+        QString output = m_process->readAllStandardError();
         QRegularExpression re("^.+:.+: ");
         QStringList lines = output.split('\n');
         if (lines.length() > 0) {
@@ -194,25 +187,24 @@ void MacDrive::onFinished(int exitCode, QProcess::ExitStatus exitStatus)
 
 void MacDrive::onRestoreFinished(int exitCode, QProcess::ExitStatus exitStatus)
 {
-    if (!m_child)
+    if (!m_process)
         return;
 
     mCritical() << "Process finished" << exitCode << exitStatus;
-    mCritical() << m_child->readAllStandardError();
+    mCritical() << m_process->readAllStandardError();
 
     if (exitCode == 0)
         m_restoreStatus = RESTORED;
     else
         m_restoreStatus = RESTORE_ERROR;
     emit restoreStatusChanged();
 
-    m_child->deleteLater();
-    m_child = nullptr;
+    // Process cleanup handled automatically by unique_ptr deleter
 }
 
 void MacDrive::onReadyRead()
 {
-    if (!m_child)
+    if (!m_process)
         return;
 
     if (m_image->status() == ReleaseVariant::WRITING) {
@@ -223,9 +215,9 @@ void MacDrive::onReadyRead()
     if (m_image->status() != ReleaseVariant::WRITE_VERIFYING && m_image->status() != ReleaseVariant::WRITING)
         m_image->setStatus(ReleaseVariant::WRITING);
 
-    while (m_child->bytesAvailable() > 0) {
+    while (m_process->bytesAvailable() > 0) {
         bool ok;
-        int64_t bytes = m_child->readLine().trimmed().toULongLong(&ok);
+        int64_t bytes = m_process->readLine().trimmed().toULongLong(&ok);
         if (ok)
             m_progress->setValue(bytes);
     }

src/app/macdrivemanager.h

@@ -60,7 +60,6 @@ private slots:
 
 private:
     QString m_bsdDevice;
-    QProcess *m_child{nullptr};
 };
 
 #endif // MACDRIVEMANAGER_H