QDS-14287 Support interruptable operations

This MR brings the following changes;

• add: async project receiving support
• add: push progress information from device
• add: send project starting notification
• fix: google play store version was not increased properly

src/backend/dsconnector/ds.cpp

@@ -7,15 +7,48 @@
 #include <QJsonObject>
 #include <QScreen>
 
-DesignStudio::DesignStudio(QWebSocket *socket, const QString &m_deviceUuid, QObject *parent)
+namespace PackageFromDesignStudio {
+using namespace Qt::Literals;
+constexpr auto designStudioReady = "designStudioReady"_L1;
+constexpr auto projectData = "projectData"_L1;
+constexpr auto stopRunningProject = "stopRunningProject"_L1;
+}; // namespace PackageFromDesignStudio
+
+namespace PackageToDesignStudio {
+using namespace Qt::Literals;
+constexpr auto deviceInfo = "deviceInfo"_L1;
+constexpr auto projectReceivingProgress = "projectReceivingProgress"_L1;
+constexpr auto projectStarting = "projectStarting"_L1;
+constexpr auto projectRunning = "projectRunning"_L1;
+constexpr auto projectStopped = "projectStopped"_L1;
+constexpr auto projectLogs = "projectLogs"_L1;
+}; // namespace PackageToDesignStudio
+
+DesignStudio::DesignStudio(QWebSocket *socket, const QString &deviceID, QObject *parent)
     : QObject(parent)
-    , m_deviceUuid(m_deviceUuid)
+    , m_deviceID(deviceID)
     , m_socket(socket)
 {
     initPingPong();
     initSocket();
+    startPingPong();
+    m_projectStallTimer.setInterval(5000);
+    m_projectStallTimer.setSingleShot(true);
+    connect(&m_projectStallTimer, &QTimer::timeout, this, [this]() {
+        qDebug() << "Project is stalled. Closing the connection.";
+        m_socket->close();
+        m_socket->abort();
+        emit disconnected(m_designStudioID);
+    });
 
-    m_pingTimer.start();
+    m_speedCalculator.setInterval(1000);
+    m_speedCalculator.setSingleShot(false);
+    connect(&m_speedCalculator, &QTimer::timeout, this, [this]() {
+        quint64 elapsedTime = m_projectNotificationTime.msecsTo(QTime::currentTime()) / 1000;
+        int receiveSpeed = elapsedTime > 0 ? m_projectData.size() / elapsedTime / 1024 : 0;
+        qDebug() << "Receive speed" << receiveSpeed << "KB/s (" << receiveSpeed / 1024 << "MB/s )"
+                 << "percentage" << m_lastPercentage << "%";
+    });
 }
 
 void DesignStudio::initPingPong()
@@ -27,7 +60,7 @@ void DesignStudio::initPingPong()
 
     connect(&m_pingTimer, &QTimer::timeout, this, [this]() {
         m_socket->ping();
-        m_pongTimer.start();
+        startPingPong();
     });
 
     connect(m_socket.data(),
@@ -39,20 +72,32 @@ void DesignStudio::initPingPong()
             });
 
     connect(&m_pongTimer, &QTimer::timeout, this, [this]() {
-        qDebug() << "Design Studio" << m_id << "is not responding. Closing the connection.";
+        qDebug() << "Design Studio" << m_designStudioID
+                 << "is not responding. Closing the connection.";
         m_socket->close();
         m_socket->abort();
-        emit disconnected(m_id);
+        emit disconnected(m_designStudioID);
     });
 }
 
+void DesignStudio::stopPingPong()
+{
+    m_pingTimer.stop();
+    m_pongTimer.stop();
+}
+
+void DesignStudio::startPingPong()
+{
+    m_pingTimer.start();
+}
+
 void DesignStudio::initSocket()
 {
     connect(m_socket.data(), &QWebSocket::disconnected, this, [this]() {
-        qDebug() << "Design Studio" << m_id << "disconnected";
+        qDebug() << "Design Studio" << m_designStudioID << "disconnected";
         m_pingTimer.stop();
         m_pongTimer.stop();
-        emit disconnected(m_id);
+        emit disconnected(m_designStudioID);
     });
 
     connect(m_socket.data(),
@@ -61,20 +106,9 @@ void DesignStudio::initSocket()
             &DesignStudio::processTextMessage);
 
     connect(m_socket.data(),
-            &QWebSocket::binaryFrameReceived,
+            &QWebSocket::binaryMessageReceived,
             this,
-            [this](const QByteArray &frame, bool isLastFrame) {
-                m_projectData.append(frame);
-                int percentage = m_projectData.size() * 100 / m_incomingProjectSize;
-                qDebug() << "frame size:" << frame.size() << "current size:" << m_projectData.size()
-                         << "total size:" << m_incomingProjectSize << "percentage:" << percentage
-                         << "isLastFrame:" << isLastFrame;
-                emit projectIncomingProgress(m_id,
-                                             m_projectData.size() * 100 / m_incomingProjectSize);
-                if (isLastFrame) {
-                    emit projectReceived(m_id, m_projectData);
-                }
-            });
+            &DesignStudio::processBinaryMessage);
 }
 
 QString DesignStudio::ipv4Addr() const
@@ -84,7 +118,7 @@ QString DesignStudio::ipv4Addr() const
 
 QString DesignStudio::id() const
 {
-    return m_id;
+    return m_designStudioID;
 }
 
 void DesignStudio::sendDeviceInfo()
@@ -97,7 +131,7 @@ void DesignStudio::sendDeviceInfo()
     deviceInfo["os"] = QSysInfo::prettyProductName();
     deviceInfo["osVersion"] = QSysInfo::productVersion();
     deviceInfo["architecture"] = QSysInfo::currentCpuArchitecture();
-    deviceInfo["deviceId"] = m_deviceUuid;
+    deviceInfo["deviceId"] = m_deviceID;
     deviceInfo["appVersion"] = QString(CMAKE_VAR_GIT_VERSION);
 
     qDebug() << "Sending device info to Design Studio" << deviceInfo;
@@ -131,31 +165,73 @@ void DesignStudio::processTextMessage(const QString &message)
     }
 
     const QString dataType = jsonObj.value("dataType").toString();
+    const QJsonObject data = jsonObj.value("data").toObject();
 
     if (dataType == PackageFromDesignStudio::designStudioReady) {
-        const QString newDesignStudioId = jsonObj.value("data").toString();
-        qDebug() << "Design Studio ready with ID" << newDesignStudioId;
-        m_id = newDesignStudioId;
+        const QString newDesignStudioId = data["designStudioID"].toString();
+        const int commVersion = data["commVersion"].toInt();
+        qDebug() << "Design Studio ready with ID" << newDesignStudioId << "and comm version"
+                 << commVersion;
+        m_designStudioID = newDesignStudioId;
         sendDeviceInfo();
         emit idReceived(newDesignStudioId, ipv4Addr());
     } else if (dataType == PackageFromDesignStudio::projectData) {
-        m_incomingProjectSize = jsonObj.value("data").toInt();
-        qDebug() << "Project is expected with size" << m_incomingProjectSize;
+        m_incomingProjectSize = data["projectSize"].toInt();
+        const QString qtVersion = data["qtVersion"].toString();
+
+        auto qcompare = QString::compare(qtVersion, QT_VERSION_STR, Qt::CaseInsensitive);
+        if (qcompare != 0) {
+            qDebug() << "Qt version mismatch. Expected" << QT_VERSION_STR " or lower, but got"
+                     << qtVersion << ". Project may not work correctly.";
+            emit projectVersionMismatch(QT_VERSION_STR, qtVersion);
+        }
+
+        qDebug() << "Project is expected with size" << m_incomingProjectSize << "and Qt version"
+                 << qtVersion;
         m_projectData.clear();
-        emit projectIncoming(m_incomingProjectSize);
+        m_projectNotificationTime = QTime::currentTime();
+        m_speedCalculator.start();
+        m_projectStallTimer.start();
+
+        stopPingPong();
+        emit projectIncoming(m_designStudioID, m_incomingProjectSize);
     } else if (dataType == PackageFromDesignStudio::stopRunningProject) {
         qDebug() << "Stop running project requested";
-        emit projectStopRequested(m_id);
+        m_projectData.clear();
+        m_speedCalculator.stop();
+        m_projectStallTimer.stop();
+        emit projectStopRequested(m_designStudioID);
     } else {
-        qDebug() << "Unkown JSON message";
+        qDebug() << "Unkown JSON message type:" << dataType;
     }
 }
 
-// this function should only be triggered when the device is receiving a qmlrc project
 void DesignStudio::processBinaryMessage(const QByteArray &data)
 {
-    qDebug() << "Binary message received (most probably a project)";
-    emit projectReceived(m_id, data);
+    m_projectStallTimer.start();
+    m_projectData.append(data);
+    const bool isProjectComplete = m_projectData.size() == m_incomingProjectSize;
+
+    int percentage = m_projectData.size() * 100 / m_incomingProjectSize;
+
+    if (m_lastPercentage != percentage) {
+        emit projectIncomingProgress(m_designStudioID, percentage);
+        m_lastPercentage = percentage;
+        sendData(PackageToDesignStudio::projectReceivingProgress, percentage);
+    }
+
+    if (isProjectComplete) {
+        startPingPong();
+        sendProjectStarting();
+        emit projectReceived(m_designStudioID, m_projectData);
+        m_speedCalculator.stop();
+        m_projectStallTimer.stop();
+    }
+}
+
+void DesignStudio::sendProjectStarting()
+{
+    sendData(PackageToDesignStudio::projectStarting);
 }
 
 void DesignStudio::sendProjectRunning()