From f997529cd4fb077b06d05da9c6ff0c23b85b4ebb Mon Sep 17 00:00:00 2001
From: Rachel Powers <508861+Ryex@users.noreply.github.com>
Date: Thu, 30 Mar 2023 11:22:55 -0700
Subject: feat: better task tracking

Signed-off-by: Rachel Powers <508861+Ryex@users.noreply.github.com>
---
 launcher/tasks/ConcurrentTask.cpp | 99 +++++++++++++++++++++++++++++----------
 launcher/tasks/ConcurrentTask.h   | 20 ++++----
 launcher/tasks/Task.cpp           | 26 +++++-----
 launcher/tasks/Task.h             | 35 ++++++++++++--
 4 files changed, 132 insertions(+), 48 deletions(-)

(limited to 'launcher/tasks')

diff --git a/launcher/tasks/ConcurrentTask.cpp b/launcher/tasks/ConcurrentTask.cpp
index 3cc37b2a..48e1bc18 100644
--- a/launcher/tasks/ConcurrentTask.cpp
+++ b/launcher/tasks/ConcurrentTask.cpp
@@ -15,14 +15,13 @@ ConcurrentTask::~ConcurrentTask()
     }
 }
 
-auto ConcurrentTask::getStepProgress() const -> qint64
+auto ConcurrentTask::getStepProgress() const -> QList<TaskStepProgress>
 {
-    return m_stepProgress;
-}
-
-auto ConcurrentTask::getStepTotalProgress() const -> qint64
-{
-    return m_stepTotalProgress;
+    QList<TaskStepProgress> task_progress;
+    for (auto progress : task_progress) {
+        task_progress.append(task_progress);
+    }
+    return task_progress;
 }
 
 void ConcurrentTask::addTask(Task::Ptr task)
@@ -33,10 +32,13 @@ void ConcurrentTask::addTask(Task::Ptr task)
 void ConcurrentTask::executeTask()
 {
     // Start the least amount of tasks needed, but at least one
-    int num_starts = qMax(1, qMin(m_total_max_size, m_queue.size()));
-    for (int i = 0; i < num_starts; i++) {
-        QMetaObject::invokeMethod(this, &ConcurrentTask::startNext, Qt::QueuedConnection);
-    }
+    // int num_starts = qMax(1, qMin(m_total_max_size, m_queue.size()));
+    // for (int i = 0; i < num_starts; i++) {
+    //     QMetaObject::invokeMethod(this, &ConcurrentTask::startNext, Qt::QueuedConnection);
+    // }
+    // Start One task, startNext hadles starting the up to the m_total_max_size
+    // while tracking the number currently being done
+    QMetaObject::invokeMethod(this, &ConcurrentTask::startNext, Qt::QueuedConnection);
 }
 
 bool ConcurrentTask::abort()
@@ -97,17 +99,18 @@ void ConcurrentTask::startNext()
 
     Task::Ptr next = m_queue.dequeue();
 
-    connect(next.get(), &Task::succeeded, this, [this, next] { subTaskSucceeded(next); });
+    connect(next.get(), &Task::succeeded, this, [this, next](){ subTaskSucceeded(next); });
     connect(next.get(), &Task::failed, this, [this, next](QString msg) { subTaskFailed(next, msg); });
 
-    connect(next.get(), &Task::status, this, &ConcurrentTask::subTaskStatus);
-    connect(next.get(), &Task::stepStatus, this, &ConcurrentTask::subTaskStatus);
+    connect(next.get(), &Task::status, this, [this, next](QString msg){ subTaskStatus(next, msg); });
+    connect(next.get(), &Task::stepProgress, this, [this, next](QList<TaskStepProgress> tp){ subTaskStepProgress(next, tp); });
 
-    connect(next.get(), &Task::progress, this, &ConcurrentTask::subTaskProgress);
+    connect(next.get(), &Task::progress, this, [this, next](qint64 current, qint64 total){ subTaskProgress(next, current, total); });
 
     m_doing.insert(next.get(), next);
+    m_task_progress.insert(next->getUid(), std::make_shared<TaskStepProgress>(TaskStepProgress({next->getUid()}))); 
+
 
-    setStepStatus(next->isMultiStep() ? next->getStepStatus() : next->getStatus());
     updateState();
 
     QCoreApplication::processEvents();
@@ -123,7 +126,10 @@ void ConcurrentTask::startNext()
 void ConcurrentTask::subTaskSucceeded(Task::Ptr task)
 {
     m_done.insert(task.get(), task);
+    m_succeeded.insert(task.get(), task);
+
     m_doing.remove(task.get());
+    m_task_progress.value(task->getUid())->state = TaskState::Succeeded;
 
     disconnect(task.get(), 0, this, 0);
 
@@ -138,6 +144,7 @@ void ConcurrentTask::subTaskFailed(Task::Ptr task, const QString& msg)
     m_failed.insert(task.get(), task);
 
     m_doing.remove(task.get());
+    m_task_progress.value(task->getUid())->state = TaskState::Failed;
 
     disconnect(task.get(), 0, this, 0);
 
@@ -146,20 +153,64 @@ void ConcurrentTask::subTaskFailed(Task::Ptr task, const QString& msg)
     startNext();
 }
 
-void ConcurrentTask::subTaskStatus(const QString& msg)
+void ConcurrentTask::subTaskStatus(Task::Ptr task, const QString& msg)
+{
+    auto taskProgress = m_task_progress.value(task->getUid());
+    taskProgress->status = msg;
+    updateState();
+}
+
+void ConcurrentTask::subTaskProgress(Task::Ptr task, qint64 current, qint64 total)
 {
-    setStepStatus(msg);
+    auto taskProgress = m_task_progress.value(task->getUid());
+    
+    taskProgress->current = current;
+    taskProgress->total = total;
+
+    taskProgress->details = task->getDetails(); 
+
+    updateStepProgress();
+    updateState();
 }
 
-void ConcurrentTask::subTaskProgress(qint64 current, qint64 total)
+void ConcurrentTask::subTaskStepProgress(Task::Ptr task, QList<TaskStepProgress> task_step_progress)
 {
-    m_stepProgress = current;
-    m_stepTotalProgress = total;
+    for (auto progress : task_step_progress) {
+        if (!m_task_progress.contains(progress.uid))
+            m_task_progress.insert(progress.uid, std::make_shared<TaskStepProgress>(progress));
+
+
+    }
+    
+}
+
+void ConcurrentTask::updateStepProgress()
+{
+   qint64 current = 0, total = 0;
+   for ( auto taskProgress : m_task_progress ) {
+       current += taskProgress->current;
+       total += taskProgress->total;
+   }
+
+   m_stepProgress = current;
+   m_stepTotalProgress = total;
 }
 
 void ConcurrentTask::updateState()
 {
-    setProgress(m_done.count(), totalSize());
-    setStatus(tr("Executing %1 task(s) (%2 out of %3 are done)")
-                  .arg(QString::number(m_doing.count()), QString::number(m_done.count()), QString::number(totalSize())));
+    if (totalSize() > 1) {
+        setProgress(m_done.count(), totalSize());
+        setStatus(tr("Executing %1 task(s) (%2 out of %3 are done)").arg(QString::number(m_doing.count()), QString::number(m_done.count()), QString::number(totalSize())));
+    } else {
+        setProgress(m_stepProgress, m_stepTotalProgress);
+        QString status = tr("Please wait ...");
+        if (m_queue.size() > 0) {
+            status = tr("Waiting for 1 task to start ...");
+        } else if (m_doing.size() > 0) {
+            status = tr("Executing 1 task:");
+        } else if (m_done.size() > 0) {
+            status = tr("Task finished.");
+        }
+        setStatus(status);
+    }
 }
diff --git a/launcher/tasks/ConcurrentTask.h b/launcher/tasks/ConcurrentTask.h
index d074d2e2..93469766 100644
--- a/launcher/tasks/ConcurrentTask.h
+++ b/launcher/tasks/ConcurrentTask.h
@@ -1,7 +1,10 @@
 #pragma once
 
+#include <QUuid>
+#include <QHash>
 #include <QQueue>
 #include <QSet>
+#include <memory>
 
 #include "tasks/Task.h"
 
@@ -16,10 +19,7 @@ public:
     bool canAbort() const override { return true; }
 
     inline auto isMultiStep() const -> bool override { return m_queue.size() > 1; };
-    auto getStepProgress() const -> qint64 override;
-    auto getStepTotalProgress() const -> qint64 override;
-
-    inline auto getStepStatus() const -> QString override { return m_step_status; }
+    auto getStepProgress() const -> QList<TaskStepProgress> override;
 
     void addTask(Task::Ptr task);
 
@@ -39,14 +39,15 @@ slots:
 
     void subTaskSucceeded(Task::Ptr);
     void subTaskFailed(Task::Ptr, const QString &msg);
-    void subTaskStatus(const QString &msg);
-    void subTaskProgress(qint64 current, qint64 total);
+    void subTaskStatus(Task::Ptr task, const QString &msg);
+    void subTaskProgress(Task::Ptr task, qint64 current, qint64 total);
+    void subTaskStepProgress(Task::Ptr task, QList<TaskStepProgress> task_step_progress);
 
 protected:
     // NOTE: This is not thread-safe.
     [[nodiscard]] unsigned int totalSize() const { return m_queue.size() + m_doing.size() + m_done.size(); }
 
-    void setStepStatus(QString status) { m_step_status = status; emit stepStatus(status); };
+    void updateStepProgress();
 
     virtual void updateState();
 
@@ -56,9 +57,12 @@ protected:
 
     QQueue<Task::Ptr> m_queue;
 
-    QHash<Task*, Task::Ptr> m_doing;
+    QHash<Task*, Task::Ptr> m_doing; 
     QHash<Task*, Task::Ptr> m_done;
     QHash<Task*, Task::Ptr> m_failed;
+    QHash<Task*, Task::Ptr> m_succeeded;
+
+    QHash<QUuid, std::shared_ptr<TaskStepProgress>> m_task_progress;
 
     int m_total_max_size;
 
diff --git a/launcher/tasks/Task.cpp b/launcher/tasks/Task.cpp
index 9ea1bb26..452dc2e3 100644
--- a/launcher/tasks/Task.cpp
+++ b/launcher/tasks/Task.cpp
@@ -37,8 +37,11 @@
 
 #include <QDebug>
 
+Q_LOGGING_CATEGORY(TaskLogC, "Task")
+
 Task::Task(QObject *parent, bool show_debug) : QObject(parent), m_show_debug(show_debug)
 {
+    m_uid = QUuid::createUuid();
     setAutoDelete(false);
 }
 
@@ -65,31 +68,31 @@ void Task::start()
         case State::Inactive:
         {
             if (m_show_debug)
-                qDebug() << "Task" << describe() << "starting for the first time";
+                qCDebug(TaskLogC) << "Task" << describe() << "starting for the first time";
             break;
         }
         case State::AbortedByUser:
         {
             if (m_show_debug)
-                qDebug() << "Task" << describe() << "restarting for after being aborted by user";
+                qCDebug(TaskLogC) << "Task" << describe() << "restarting for after being aborted by user";
             break;
         }
         case State::Failed:
         {
             if (m_show_debug)
-                qDebug() << "Task" << describe() << "restarting for after failing at first";
+                qCDebug(TaskLogC) << "Task" << describe() << "restarting for after failing at first";
             break;
         }
         case State::Succeeded:
         {
             if (m_show_debug)
-                qDebug() << "Task" << describe() << "restarting for after succeeding at first";
+                qCDebug(TaskLogC) << "Task" << describe() << "restarting for after succeeding at first";
             break;
         }
         case State::Running:
         {
             if (m_show_debug)
-                qWarning() << "The launcher tried to start task" << describe() << "while it was already running!";
+                qCWarning(TaskLogC) << "The launcher tried to start task" << describe() << "while it was already running!";
             return;
         }
     }
@@ -104,12 +107,12 @@ void Task::emitFailed(QString reason)
     // Don't fail twice.
     if (!isRunning())
     {
-        qCritical() << "Task" << describe() << "failed while not running!!!!: " << reason;
+        qCCritical(TaskLogC) << "Task" << describe() << "failed while not running!!!!: " << reason;
         return;
     }
     m_state = State::Failed;
     m_failReason = reason;
-    qCritical() << "Task" << describe() << "failed: " << reason;
+    qCCritical(TaskLogC) << "Task" << describe() << "failed: " << reason;
     emit failed(reason);
     emit finished();
 }
@@ -119,13 +122,13 @@ void Task::emitAborted()
     // Don't abort twice.
     if (!isRunning())
     {
-        qCritical() << "Task" << describe() << "aborted while not running!!!!";
+        qCCritical(TaskLogC) << "Task" << describe() << "aborted while not running!!!!";
         return;
     }
     m_state = State::AbortedByUser;
     m_failReason = "Aborted.";
     if (m_show_debug)
-        qDebug() << "Task" << describe() << "aborted.";
+        qCDebug(TaskLogC) << "Task" << describe() << "aborted.";
     emit aborted();
     emit finished();
 }
@@ -135,12 +138,12 @@ void Task::emitSucceeded()
     // Don't succeed twice.
     if (!isRunning())
     {
-        qCritical() << "Task" << describe() << "succeeded while not running!!!!";
+        qCCritical(TaskLogC) << "Task" << describe() << "succeeded while not running!!!!";
         return;
     }
     m_state = State::Succeeded;
     if (m_show_debug)
-        qDebug() << "Task" << describe() << "succeeded";
+        qCDebug(TaskLogC) << "Task" << describe() << "succeeded";
     emit succeeded();
     emit finished();
 }
@@ -159,6 +162,7 @@ QString Task::describe()
     {
         out << name;
     }
+    out << " ID: " << m_uid.toString(QUuid::WithoutBraces);
     out << QChar(')');
     out.flush();
     return outStr;
diff --git a/launcher/tasks/Task.h b/launcher/tasks/Task.h
index 3d607dca..a6ab15b8 100644
--- a/launcher/tasks/Task.h
+++ b/launcher/tasks/Task.h
@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-only
 /*
- *  PolyMC - Minecraft Launcher
+ *  PrismLauncher - Minecraft Launcher
  *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
+ *  Copyright (c) 2023 Rachel Powers <508861+Ryex@users.noreply.github.com>
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -36,9 +37,29 @@
 #pragma once
 
 #include <QRunnable>
+#include <QUuid>
+#include <QLoggingCategory>
 
 #include "QObjectPtr.h"
 
+enum class TaskState {
+    Waiting,
+    Running,
+    Failed,
+    Succeeded,
+    Finished
+};
+
+struct TaskStepProgress {
+    QUuid uid; 
+    qint64 current;
+    qint64 total;
+    QString status;
+    QString details;
+    TaskState state = TaskState::Waiting;
+    bool isDone() { return (state == TaskState::Failed) || (state == TaskState::Succeeded) || (state == TaskState::Finished); }
+};
+
 class Task : public QObject, public QRunnable {
     Q_OBJECT
    public:
@@ -73,12 +94,14 @@ class Task : public QObject, public QRunnable {
     auto getState() const -> State { return m_state; }
 
     QString getStatus() { return m_status; }
-    virtual auto getStepStatus() const -> QString { return m_status; }
 
     qint64 getProgress() { return m_progress; }
     qint64 getTotalProgress() { return m_progressTotal; }
-    virtual auto getStepProgress() const -> qint64 { return 0; }
-    virtual auto getStepTotalProgress() const -> qint64 { return 100; }
+    virtual auto getStepProgress() const -> QList<TaskStepProgress> { return {}; }
+
+    virtual auto getDetails() const -> QString { return ""; } 
+
+    QUuid getUid() { return m_uid; }
 
    protected:
     void logWarning(const QString& line);
@@ -94,7 +117,7 @@ class Task : public QObject, public QRunnable {
     void aborted();
     void failed(QString reason);
     void status(QString status);
-    void stepStatus(QString status);
+    void stepProgress(QList<TaskStepProgress> task_progress); // 
 
     /** Emitted when the canAbort() status has changed.
      */
@@ -135,4 +158,6 @@ class Task : public QObject, public QRunnable {
    private:
     // Change using setAbortStatus
     bool m_can_abort = false;
+    QUuid m_uid;
+
 };
-- 
cgit 


From 9d2f0e4dc8fc3995052770c6a7948cb0372fdcbb Mon Sep 17 00:00:00 2001
From: Rachel Powers <508861+Ryex@users.noreply.github.com>
Date: Thu, 30 Mar 2023 23:50:29 -0700
Subject: feat: Propogated subtask progress

Oh boy this is big.

> TaskStepProgress struct is now QMetaObject compatabile and can be sent through signals
> Task now has a method to propogates sub task progress it must be signal bound by each task containing a task wishing to report progress of it's children.
> Downloads report speed
> Tasks now have UUIDS to track them
  - use when reporting
  - use when logging
  - use when storeing them or objects related to them

Signed-off-by: Rachel Powers <508861+Ryex@users.noreply.github.com>
---
 launcher/tasks/ConcurrentTask.cpp | 44 +++++++++++++++++++++++----------------
 launcher/tasks/ConcurrentTask.h   |  6 +++---
 launcher/tasks/Task.cpp           |  5 +++++
 launcher/tasks/Task.h             | 26 +++++++++++++++--------
 4 files changed, 51 insertions(+), 30 deletions(-)

(limited to 'launcher/tasks')

diff --git a/launcher/tasks/ConcurrentTask.cpp b/launcher/tasks/ConcurrentTask.cpp
index 48e1bc18..fde7d0ad 100644
--- a/launcher/tasks/ConcurrentTask.cpp
+++ b/launcher/tasks/ConcurrentTask.cpp
@@ -2,6 +2,7 @@
 
 #include <QDebug>
 #include <QCoreApplication>
+#include "tasks/Task.h"
 
 ConcurrentTask::ConcurrentTask(QObject* parent, QString task_name, int max_concurrent)
     : Task(parent), m_name(task_name), m_total_max_size(max_concurrent)
@@ -15,13 +16,9 @@ ConcurrentTask::~ConcurrentTask()
     }
 }
 
-auto ConcurrentTask::getStepProgress() const -> QList<TaskStepProgress>
+auto ConcurrentTask::getStepProgress() const -> TaskStepProgressList
 {
-    QList<TaskStepProgress> task_progress;
-    for (auto progress : task_progress) {
-        task_progress.append(task_progress);
-    }
-    return task_progress;
+    return m_task_progress.values();
 }
 
 void ConcurrentTask::addTask(Task::Ptr task)
@@ -103,7 +100,7 @@ void ConcurrentTask::startNext()
     connect(next.get(), &Task::failed, this, [this, next](QString msg) { subTaskFailed(next, msg); });
 
     connect(next.get(), &Task::status, this, [this, next](QString msg){ subTaskStatus(next, msg); });
-    connect(next.get(), &Task::stepProgress, this, [this, next](QList<TaskStepProgress> tp){ subTaskStepProgress(next, tp); });
+    connect(next.get(), &Task::stepProgress, this, [this, next](TaskStepProgressList tp){ subTaskStepProgress(next, tp); });
 
     connect(next.get(), &Task::progress, this, [this, next](qint64 current, qint64 total){ subTaskProgress(next, current, total); });
 
@@ -112,6 +109,7 @@ void ConcurrentTask::startNext()
 
 
     updateState();
+    updateStepProgress();
 
     QCoreApplication::processEvents();
 
@@ -129,12 +127,12 @@ void ConcurrentTask::subTaskSucceeded(Task::Ptr task)
     m_succeeded.insert(task.get(), task);
 
     m_doing.remove(task.get());
-    m_task_progress.value(task->getUid())->state = TaskState::Succeeded;
+    m_task_progress.value(task->getUid())->state = TaskStepState::Succeeded;
 
     disconnect(task.get(), 0, this, 0);
 
     updateState();
-
+    updateStepProgress();
     startNext();
 }
 
@@ -144,20 +142,22 @@ void ConcurrentTask::subTaskFailed(Task::Ptr task, const QString& msg)
     m_failed.insert(task.get(), task);
 
     m_doing.remove(task.get());
-    m_task_progress.value(task->getUid())->state = TaskState::Failed;
+    m_task_progress.value(task->getUid())->state = TaskStepState::Failed;
 
     disconnect(task.get(), 0, this, 0);
 
     updateState();
-
+    updateStepProgress();
     startNext();
 }
 
 void ConcurrentTask::subTaskStatus(Task::Ptr task, const QString& msg)
 {
     auto taskProgress = m_task_progress.value(task->getUid());
-    taskProgress->status = msg;
+    taskProgress->status = msg; 
+    taskProgress->state = TaskStepState::Running;
     updateState();
+    updateStepProgress();
 }
 
 void ConcurrentTask::subTaskProgress(Task::Ptr task, qint64 current, qint64 total)
@@ -166,21 +166,28 @@ void ConcurrentTask::subTaskProgress(Task::Ptr task, qint64 current, qint64 tota
     
     taskProgress->current = current;
     taskProgress->total = total;
-
+    taskProgress->state = TaskStepState::Running;
     taskProgress->details = task->getDetails(); 
 
     updateStepProgress();
     updateState();
 }
 
-void ConcurrentTask::subTaskStepProgress(Task::Ptr task, QList<TaskStepProgress> task_step_progress)
+void ConcurrentTask::subTaskStepProgress(Task::Ptr task, TaskStepProgressList task_step_progress)
 {
     for (auto progress : task_step_progress) {
-        if (!m_task_progress.contains(progress.uid))
-            m_task_progress.insert(progress.uid, std::make_shared<TaskStepProgress>(progress));
-
-
+        if (!m_task_progress.contains(progress->uid)) {
+            m_task_progress.insert(progress->uid, progress);
+        } else {
+            auto tp = m_task_progress.value(progress->uid);
+            tp->current = progress->current;
+            tp->total = progress->total;
+            tp->status = progress->status;
+            tp->details = progress->details;
+        }           
     }
+
+    updateStepProgress();
     
 }
 
@@ -194,6 +201,7 @@ void ConcurrentTask::updateStepProgress()
 
    m_stepProgress = current;
    m_stepTotalProgress = total;
+   emit stepProgress(m_task_progress.values());
 }
 
 void ConcurrentTask::updateState()
diff --git a/launcher/tasks/ConcurrentTask.h b/launcher/tasks/ConcurrentTask.h
index 93469766..9d4413c6 100644
--- a/launcher/tasks/ConcurrentTask.h
+++ b/launcher/tasks/ConcurrentTask.h
@@ -18,8 +18,8 @@ public:
 
     bool canAbort() const override { return true; }
 
-    inline auto isMultiStep() const -> bool override { return m_queue.size() > 1; };
-    auto getStepProgress() const -> QList<TaskStepProgress> override;
+    inline auto isMultiStep() const -> bool override { return totalSize() > 1; };
+    auto getStepProgress() const -> TaskStepProgressList override;
 
     void addTask(Task::Ptr task);
 
@@ -41,7 +41,7 @@ slots:
     void subTaskFailed(Task::Ptr, const QString &msg);
     void subTaskStatus(Task::Ptr task, const QString &msg);
     void subTaskProgress(Task::Ptr task, qint64 current, qint64 total);
-    void subTaskStepProgress(Task::Ptr task, QList<TaskStepProgress> task_step_progress);
+    void subTaskStepProgress(Task::Ptr task, TaskStepProgressList task_step_progress);
 
 protected:
     // NOTE: This is not thread-safe.
diff --git a/launcher/tasks/Task.cpp b/launcher/tasks/Task.cpp
index 452dc2e3..5aada876 100644
--- a/launcher/tasks/Task.cpp
+++ b/launcher/tasks/Task.cpp
@@ -148,6 +148,11 @@ void Task::emitSucceeded()
     emit finished();
 }
 
+void Task::propogateStepProgress(TaskStepProgressList task_progress)
+{
+    emit stepProgress(task_progress);
+}
+
 QString Task::describe()
 {
     QString outStr;
diff --git a/launcher/tasks/Task.h b/launcher/tasks/Task.h
index a6ab15b8..863f8a4c 100644
--- a/launcher/tasks/Task.h
+++ b/launcher/tasks/Task.h
@@ -42,7 +42,7 @@
 
 #include "QObjectPtr.h"
 
-enum class TaskState {
+enum class TaskStepState {
     Waiting,
     Running,
     Failed,
@@ -50,16 +50,22 @@ enum class TaskState {
     Finished
 };
 
+Q_DECLARE_METATYPE(TaskStepState)
+
 struct TaskStepProgress {
     QUuid uid; 
-    qint64 current;
-    qint64 total;
-    QString status;
-    QString details;
-    TaskState state = TaskState::Waiting;
-    bool isDone() { return (state == TaskState::Failed) || (state == TaskState::Succeeded) || (state == TaskState::Finished); }
+    qint64 current = 0;
+    qint64 total = -1;
+    QString status = "";
+    QString details = "";
+    TaskStepState state = TaskStepState::Waiting;
+    bool isDone() { return (state == TaskStepState::Failed) || (state == TaskStepState::Succeeded) || (state == TaskStepState::Finished); }
 };
 
+Q_DECLARE_METATYPE(TaskStepProgress)
+
+typedef QList<std::shared_ptr<TaskStepProgress>> TaskStepProgressList;
+
 class Task : public QObject, public QRunnable {
     Q_OBJECT
    public:
@@ -97,7 +103,7 @@ class Task : public QObject, public QRunnable {
 
     qint64 getProgress() { return m_progress; }
     qint64 getTotalProgress() { return m_progressTotal; }
-    virtual auto getStepProgress() const -> QList<TaskStepProgress> { return {}; }
+    virtual auto getStepProgress() const -> TaskStepProgressList { return {}; }
 
     virtual auto getDetails() const -> QString { return ""; } 
 
@@ -117,7 +123,7 @@ class Task : public QObject, public QRunnable {
     void aborted();
     void failed(QString reason);
     void status(QString status);
-    void stepProgress(QList<TaskStepProgress> task_progress); // 
+    void stepProgress(TaskStepProgressList task_progress); // 
 
     /** Emitted when the canAbort() status has changed.
      */
@@ -140,6 +146,8 @@ class Task : public QObject, public QRunnable {
     virtual void emitAborted();
     virtual void emitFailed(QString reason = "");
 
+    virtual void propogateStepProgress(TaskStepProgressList task_progress);
+
    public slots:
     void setStatus(const QString& status);
     void setProgress(qint64 current, qint64 total);
-- 
cgit 


From f1028fa66d556b024765ba4e21ac76d4510a3e3e Mon Sep 17 00:00:00 2001
From: Rachel Powers <508861+Ryex@users.noreply.github.com>
Date: Fri, 31 Mar 2023 12:29:59 -0700
Subject: fix: properly map progress range - doument PCRE used for URL
 compacting

Signed-off-by: Rachel Powers <508861+Ryex@users.noreply.github.com>
---
 launcher/tasks/ConcurrentTask.cpp | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

(limited to 'launcher/tasks')

diff --git a/launcher/tasks/ConcurrentTask.cpp b/launcher/tasks/ConcurrentTask.cpp
index fde7d0ad..41c405db 100644
--- a/launcher/tasks/ConcurrentTask.cpp
+++ b/launcher/tasks/ConcurrentTask.cpp
@@ -28,12 +28,7 @@ void ConcurrentTask::addTask(Task::Ptr task)
 
 void ConcurrentTask::executeTask()
 {
-    // Start the least amount of tasks needed, but at least one
-    // int num_starts = qMax(1, qMin(m_total_max_size, m_queue.size()));
-    // for (int i = 0; i < num_starts; i++) {
-    //     QMetaObject::invokeMethod(this, &ConcurrentTask::startNext, Qt::QueuedConnection);
-    // }
-    // Start One task, startNext hadles starting the up to the m_total_max_size
+    // Start One task, startNext hadels starting the up to the m_total_max_size
     // while tracking the number currently being done
     QMetaObject::invokeMethod(this, &ConcurrentTask::startNext, Qt::QueuedConnection);
 }
-- 
cgit 


From b6452215c16f6b1ee45fea746f9498767e48d049 Mon Sep 17 00:00:00 2001
From: Rachel Powers <508861+Ryex@users.noreply.github.com>
Date: Fri, 31 Mar 2023 19:25:01 -0700
Subject: feat: add `details` signal to `Task` feat: add details to mod pack
 downloading feat: add logging rule sloading form `ligging.ini at data path
 root feat: add `launcher.task` `launcher.task.net` and
 `launcher.task.net.[down|up]load` logging categories fix: add new subtask
 progress to the end of the lay out not the beginning (cuts down on
 flickering)

Signed-off-by: Rachel Powers <508861+Ryex@users.noreply.github.com>
---
 launcher/tasks/ConcurrentTask.cpp | 11 ++++++++--
 launcher/tasks/ConcurrentTask.h   |  1 +
 launcher/tasks/Task.cpp           | 42 +++++++++++++++++++++++++--------------
 launcher/tasks/Task.h             |  8 +++++++-
 4 files changed, 44 insertions(+), 18 deletions(-)

(limited to 'launcher/tasks')

diff --git a/launcher/tasks/ConcurrentTask.cpp b/launcher/tasks/ConcurrentTask.cpp
index 41c405db..8d4f94ed 100644
--- a/launcher/tasks/ConcurrentTask.cpp
+++ b/launcher/tasks/ConcurrentTask.cpp
@@ -95,6 +95,7 @@ void ConcurrentTask::startNext()
     connect(next.get(), &Task::failed, this, [this, next](QString msg) { subTaskFailed(next, msg); });
 
     connect(next.get(), &Task::status, this, [this, next](QString msg){ subTaskStatus(next, msg); });
+    connect(next.get(), &Task::details, this, [this, next](QString msg){ subTaskDetails(next, msg); });
     connect(next.get(), &Task::stepProgress, this, [this, next](TaskStepProgressList tp){ subTaskStepProgress(next, tp); });
 
     connect(next.get(), &Task::progress, this, [this, next](qint64 current, qint64 total){ subTaskProgress(next, current, total); });
@@ -151,7 +152,14 @@ void ConcurrentTask::subTaskStatus(Task::Ptr task, const QString& msg)
     auto taskProgress = m_task_progress.value(task->getUid());
     taskProgress->status = msg; 
     taskProgress->state = TaskStepState::Running;
-    updateState();
+    updateStepProgress();
+}
+
+void ConcurrentTask::subTaskDetails(Task::Ptr task, const QString& msg)
+{
+    auto taskProgress = m_task_progress.value(task->getUid());
+    taskProgress->details = msg; 
+    taskProgress->state = TaskStepState::Running;
     updateStepProgress();
 }
 
@@ -162,7 +170,6 @@ void ConcurrentTask::subTaskProgress(Task::Ptr task, qint64 current, qint64 tota
     taskProgress->current = current;
     taskProgress->total = total;
     taskProgress->state = TaskStepState::Running;
-    taskProgress->details = task->getDetails(); 
 
     updateStepProgress();
     updateState();
diff --git a/launcher/tasks/ConcurrentTask.h b/launcher/tasks/ConcurrentTask.h
index 9d4413c6..43e9f866 100644
--- a/launcher/tasks/ConcurrentTask.h
+++ b/launcher/tasks/ConcurrentTask.h
@@ -40,6 +40,7 @@ slots:
     void subTaskSucceeded(Task::Ptr);
     void subTaskFailed(Task::Ptr, const QString &msg);
     void subTaskStatus(Task::Ptr task, const QString &msg);
+    void subTaskDetails(Task::Ptr task, const QString &msg);
     void subTaskProgress(Task::Ptr task, qint64 current, qint64 total);
     void subTaskStepProgress(Task::Ptr task, TaskStepProgressList task_step_progress);
 
diff --git a/launcher/tasks/Task.cpp b/launcher/tasks/Task.cpp
index 5aada876..ffde4a10 100644
--- a/launcher/tasks/Task.cpp
+++ b/launcher/tasks/Task.cpp
@@ -37,7 +37,7 @@
 
 #include <QDebug>
 
-Q_LOGGING_CATEGORY(TaskLogC, "Task")
+Q_LOGGING_CATEGORY(taskLogC, "launcher.task")
 
 Task::Task(QObject *parent, bool show_debug) : QObject(parent), m_show_debug(show_debug)
 {
@@ -54,11 +54,23 @@ void Task::setStatus(const QString &new_status)
     }
 }
 
+void Task::setDetails(const QString& new_details)
+{
+    if (m_details != new_details)
+    {
+        m_details = new_details;
+        emit details(m_details);
+    }
+}
+
 void Task::setProgress(qint64 current, qint64 total)
 {
-    m_progress = current;
-    m_progressTotal = total;
-    emit progress(m_progress, m_progressTotal);
+    if ((m_progress != current) || (m_progressTotal != total)) {
+        m_progress = current;
+        m_progressTotal = total;
+        
+        emit progress(m_progress, m_progressTotal);
+    } 
 }
 
 void Task::start()
@@ -68,31 +80,31 @@ void Task::start()
         case State::Inactive:
         {
             if (m_show_debug)
-                qCDebug(TaskLogC) << "Task" << describe() << "starting for the first time";
+                qCDebug(taskLogC) << "Task" << describe() << "starting for the first time";
             break;
         }
         case State::AbortedByUser:
         {
             if (m_show_debug)
-                qCDebug(TaskLogC) << "Task" << describe() << "restarting for after being aborted by user";
+                qCDebug(taskLogC) << "Task" << describe() << "restarting for after being aborted by user";
             break;
         }
         case State::Failed:
         {
             if (m_show_debug)
-                qCDebug(TaskLogC) << "Task" << describe() << "restarting for after failing at first";
+                qCDebug(taskLogC) << "Task" << describe() << "restarting for after failing at first";
             break;
         }
         case State::Succeeded:
         {
             if (m_show_debug)
-                qCDebug(TaskLogC) << "Task" << describe() << "restarting for after succeeding at first";
+                qCDebug(taskLogC) << "Task" << describe() << "restarting for after succeeding at first";
             break;
         }
         case State::Running:
         {
             if (m_show_debug)
-                qCWarning(TaskLogC) << "The launcher tried to start task" << describe() << "while it was already running!";
+                qCWarning(taskLogC) << "The launcher tried to start task" << describe() << "while it was already running!";
             return;
         }
     }
@@ -107,12 +119,12 @@ void Task::emitFailed(QString reason)
     // Don't fail twice.
     if (!isRunning())
     {
-        qCCritical(TaskLogC) << "Task" << describe() << "failed while not running!!!!: " << reason;
+        qCCritical(taskLogC) << "Task" << describe() << "failed while not running!!!!: " << reason;
         return;
     }
     m_state = State::Failed;
     m_failReason = reason;
-    qCCritical(TaskLogC) << "Task" << describe() << "failed: " << reason;
+    qCCritical(taskLogC) << "Task" << describe() << "failed: " << reason;
     emit failed(reason);
     emit finished();
 }
@@ -122,13 +134,13 @@ void Task::emitAborted()
     // Don't abort twice.
     if (!isRunning())
     {
-        qCCritical(TaskLogC) << "Task" << describe() << "aborted while not running!!!!";
+        qCCritical(taskLogC) << "Task" << describe() << "aborted while not running!!!!";
         return;
     }
     m_state = State::AbortedByUser;
     m_failReason = "Aborted.";
     if (m_show_debug)
-        qCDebug(TaskLogC) << "Task" << describe() << "aborted.";
+        qCDebug(taskLogC) << "Task" << describe() << "aborted.";
     emit aborted();
     emit finished();
 }
@@ -138,12 +150,12 @@ void Task::emitSucceeded()
     // Don't succeed twice.
     if (!isRunning())
     {
-        qCCritical(TaskLogC) << "Task" << describe() << "succeeded while not running!!!!";
+        qCCritical(taskLogC) << "Task" << describe() << "succeeded while not running!!!!";
         return;
     }
     m_state = State::Succeeded;
     if (m_show_debug)
-        qCDebug(TaskLogC) << "Task" << describe() << "succeeded";
+        qCDebug(taskLogC) << "Task" << describe() << "succeeded";
     emit succeeded();
     emit finished();
 }
diff --git a/launcher/tasks/Task.h b/launcher/tasks/Task.h
index 863f8a4c..96b3b855 100644
--- a/launcher/tasks/Task.h
+++ b/launcher/tasks/Task.h
@@ -42,6 +42,8 @@
 
 #include "QObjectPtr.h"
 
+Q_DECLARE_LOGGING_CATEGORY(taskLogC)
+
 enum class TaskStepState {
     Waiting,
     Running,
@@ -100,12 +102,13 @@ class Task : public QObject, public QRunnable {
     auto getState() const -> State { return m_state; }
 
     QString getStatus() { return m_status; }
+    QString getDetails() { return m_details; }
 
     qint64 getProgress() { return m_progress; }
     qint64 getTotalProgress() { return m_progressTotal; }
     virtual auto getStepProgress() const -> TaskStepProgressList { return {}; }
 
-    virtual auto getDetails() const -> QString { return ""; } 
+     
 
     QUuid getUid() { return m_uid; }
 
@@ -123,6 +126,7 @@ class Task : public QObject, public QRunnable {
     void aborted();
     void failed(QString reason);
     void status(QString status);
+    void details(QString details);
     void stepProgress(TaskStepProgressList task_progress); // 
 
     /** Emitted when the canAbort() status has changed.
@@ -150,6 +154,7 @@ class Task : public QObject, public QRunnable {
 
    public slots:
     void setStatus(const QString& status);
+    void setDetails(const QString& details);
     void setProgress(qint64 current, qint64 total);
 
    protected:
@@ -157,6 +162,7 @@ class Task : public QObject, public QRunnable {
     QStringList m_Warnings;
     QString m_failReason = "";
     QString m_status;
+    QString m_details;
     int m_progress = 0;
     int m_progressTotal = 100;
 
-- 
cgit 


From 6b28af6cc5cc935bff47fcf8f4534827c958dbc3 Mon Sep 17 00:00:00 2001
From: Rachel Powers <508861+Ryex@users.noreply.github.com>
Date: Sun, 2 Apr 2023 19:40:32 -0700
Subject: fix: clean up license headers for Tasks

Signed-off-by: Rachel Powers <508861+Ryex@users.noreply.github.com>
---
 launcher/tasks/ConcurrentTask.cpp      | 35 ++++++++++++++++++++++++++++++++++
 launcher/tasks/ConcurrentTask.h        | 35 ++++++++++++++++++++++++++++++++++
 launcher/tasks/MultipleOptionsTask.cpp | 34 +++++++++++++++++++++++++++++++++
 launcher/tasks/MultipleOptionsTask.h   | 34 +++++++++++++++++++++++++++++++++
 launcher/tasks/SequentialTask.cpp      | 35 ++++++++++++++++++++++++++++++++++
 launcher/tasks/SequentialTask.h        | 35 ++++++++++++++++++++++++++++++++++
 launcher/tasks/Task.cpp                |  1 +
 7 files changed, 209 insertions(+)

(limited to 'launcher/tasks')

diff --git a/launcher/tasks/ConcurrentTask.cpp b/launcher/tasks/ConcurrentTask.cpp
index 8d4f94ed..3c62cf4d 100644
--- a/launcher/tasks/ConcurrentTask.cpp
+++ b/launcher/tasks/ConcurrentTask.cpp
@@ -1,3 +1,38 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
+ *  Copyright (c) 2023 Rachel Powers <508861+Ryex@users.noreply.github.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This file incorporates work covered by the following copyright and
+ * permission notice:
+ *
+ *      Copyright 2013-2021 MultiMC Contributors
+ *
+ *      Licensed under the Apache License, Version 2.0 (the "License");
+ *      you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *      Unless required by applicable law or agreed to in writing, software
+ *      distributed under the License is distributed on an "AS IS" BASIS,
+ *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *      See the License for the specific language governing permissions and
+ *      limitations under the License.
+ */
 #include "ConcurrentTask.h"
 
 #include <QDebug>
diff --git a/launcher/tasks/ConcurrentTask.h b/launcher/tasks/ConcurrentTask.h
index 43e9f866..1cf1520e 100644
--- a/launcher/tasks/ConcurrentTask.h
+++ b/launcher/tasks/ConcurrentTask.h
@@ -1,3 +1,38 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
+ *  Copyright (c) 2023 Rachel Powers <508861+Ryex@users.noreply.github.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This file incorporates work covered by the following copyright and
+ * permission notice:
+ *
+ *      Copyright 2013-2021 MultiMC Contributors
+ *
+ *      Licensed under the Apache License, Version 2.0 (the "License");
+ *      you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *      Unless required by applicable law or agreed to in writing, software
+ *      distributed under the License is distributed on an "AS IS" BASIS,
+ *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *      See the License for the specific language governing permissions and
+ *      limitations under the License.
+ */
 #pragma once
 
 #include <QUuid>
diff --git a/launcher/tasks/MultipleOptionsTask.cpp b/launcher/tasks/MultipleOptionsTask.cpp
index 034499df..89187a26 100644
--- a/launcher/tasks/MultipleOptionsTask.cpp
+++ b/launcher/tasks/MultipleOptionsTask.cpp
@@ -1,3 +1,37 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This file incorporates work covered by the following copyright and
+ * permission notice:
+ *
+ *      Copyright 2013-2021 MultiMC Contributors
+ *
+ *      Licensed under the Apache License, Version 2.0 (the "License");
+ *      you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *      Unless required by applicable law or agreed to in writing, software
+ *      distributed under the License is distributed on an "AS IS" BASIS,
+ *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *      See the License for the specific language governing permissions and
+ *      limitations under the License.
+ */
 #include "MultipleOptionsTask.h"
 
 #include <QDebug>
diff --git a/launcher/tasks/MultipleOptionsTask.h b/launcher/tasks/MultipleOptionsTask.h
index db7d4d9a..a344343e 100644
--- a/launcher/tasks/MultipleOptionsTask.h
+++ b/launcher/tasks/MultipleOptionsTask.h
@@ -1,3 +1,37 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This file incorporates work covered by the following copyright and
+ * permission notice:
+ *
+ *      Copyright 2013-2021 MultiMC Contributors
+ *
+ *      Licensed under the Apache License, Version 2.0 (the "License");
+ *      you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *      Unless required by applicable law or agreed to in writing, software
+ *      distributed under the License is distributed on an "AS IS" BASIS,
+ *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *      See the License for the specific language governing permissions and
+ *      limitations under the License.
+ */
 #pragma once
 
 #include "SequentialTask.h"
diff --git a/launcher/tasks/SequentialTask.cpp b/launcher/tasks/SequentialTask.cpp
index b2f86328..abf7536b 100644
--- a/launcher/tasks/SequentialTask.cpp
+++ b/launcher/tasks/SequentialTask.cpp
@@ -1,3 +1,38 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
+ *  Copyright (c) 2023 Rachel Powers <508861+Ryex@users.noreply.github.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This file incorporates work covered by the following copyright and
+ * permission notice:
+ *
+ *      Copyright 2013-2021 MultiMC Contributors
+ *
+ *      Licensed under the Apache License, Version 2.0 (the "License");
+ *      you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *      Unless required by applicable law or agreed to in writing, software
+ *      distributed under the License is distributed on an "AS IS" BASIS,
+ *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *      See the License for the specific language governing permissions and
+ *      limitations under the License.
+ */
 #include "SequentialTask.h"
 
 #include <QDebug>
diff --git a/launcher/tasks/SequentialTask.h b/launcher/tasks/SequentialTask.h
index 5eace96e..cec3b2be 100644
--- a/launcher/tasks/SequentialTask.h
+++ b/launcher/tasks/SequentialTask.h
@@ -1,3 +1,38 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
+ *  Copyright (c) 2023 Rachel Powers <508861+Ryex@users.noreply.github.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This file incorporates work covered by the following copyright and
+ * permission notice:
+ *
+ *      Copyright 2013-2021 MultiMC Contributors
+ *
+ *      Licensed under the Apache License, Version 2.0 (the "License");
+ *      you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *      Unless required by applicable law or agreed to in writing, software
+ *      distributed under the License is distributed on an "AS IS" BASIS,
+ *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *      See the License for the specific language governing permissions and
+ *      limitations under the License.
+ */
 #pragma once
 
 #include "ConcurrentTask.h"
diff --git a/launcher/tasks/Task.cpp b/launcher/tasks/Task.cpp
index ffde4a10..e5f61919 100644
--- a/launcher/tasks/Task.cpp
+++ b/launcher/tasks/Task.cpp
@@ -2,6 +2,7 @@
 /*
  *  PolyMC - Minecraft Launcher
  *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
+ *  Copyright (c) 2023 Rachel Powers <508861+Ryex@users.noreply.github.com>
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
-- 
cgit 


From 0fb6a2836be2fe51e27a47595950923dca329006 Mon Sep 17 00:00:00 2001
From: Rachel Powers <508861+Ryex@users.noreply.github.com>
Date: Sun, 2 Apr 2023 21:51:07 -0700
Subject: refactor: propogate only only one StepProgress at a time

Signed-off-by: Rachel Powers <508861+Ryex@users.noreply.github.com>
---
 launcher/tasks/ConcurrentTask.cpp | 99 +++++++++++++++++++++------------------
 launcher/tasks/ConcurrentTask.h   |  2 +-
 launcher/tasks/Task.cpp           |  2 +-
 launcher/tasks/Task.h             |  9 ++--
 4 files changed, 60 insertions(+), 52 deletions(-)

(limited to 'launcher/tasks')

diff --git a/launcher/tasks/ConcurrentTask.cpp b/launcher/tasks/ConcurrentTask.cpp
index 3c62cf4d..8434ecdc 100644
--- a/launcher/tasks/ConcurrentTask.cpp
+++ b/launcher/tasks/ConcurrentTask.cpp
@@ -35,13 +35,15 @@
  */
 #include "ConcurrentTask.h"
 
-#include <QDebug>
 #include <QCoreApplication>
+#include <QDebug>
 #include "tasks/Task.h"
 
 ConcurrentTask::ConcurrentTask(QObject* parent, QString task_name, int max_concurrent)
     : Task(parent), m_name(task_name), m_total_max_size(max_concurrent)
-{ setObjectName(task_name); }
+{
+    setObjectName(task_name);
+}
 
 ConcurrentTask::~ConcurrentTask()
 {
@@ -126,18 +128,17 @@ void ConcurrentTask::startNext()
 
     Task::Ptr next = m_queue.dequeue();
 
-    connect(next.get(), &Task::succeeded, this, [this, next](){ subTaskSucceeded(next); });
+    connect(next.get(), &Task::succeeded, this, [this, next]() { subTaskSucceeded(next); });
     connect(next.get(), &Task::failed, this, [this, next](QString msg) { subTaskFailed(next, msg); });
 
-    connect(next.get(), &Task::status, this, [this, next](QString msg){ subTaskStatus(next, msg); });
-    connect(next.get(), &Task::details, this, [this, next](QString msg){ subTaskDetails(next, msg); });
-    connect(next.get(), &Task::stepProgress, this, [this, next](TaskStepProgressList tp){ subTaskStepProgress(next, tp); });
+    connect(next.get(), &Task::status, this, [this, next](QString msg) { subTaskStatus(next, msg); });
+    connect(next.get(), &Task::details, this, [this, next](QString msg) { subTaskDetails(next, msg); });
+    connect(next.get(), &Task::stepProgress, this, [this, next](TaskStepProgress tp) { subTaskStepProgress(next, tp); });
 
-    connect(next.get(), &Task::progress, this, [this, next](qint64 current, qint64 total){ subTaskProgress(next, current, total); });
+    connect(next.get(), &Task::progress, this, [this, next](qint64 current, qint64 total) { subTaskProgress(next, current, total); });
 
     m_doing.insert(next.get(), next);
-    m_task_progress.insert(next->getUid(), std::make_shared<TaskStepProgress>(TaskStepProgress({next->getUid()}))); 
-
+    m_task_progress.insert(next->getUid(), std::make_shared<TaskStepProgress>(TaskStepProgress({ next->getUid() })));
 
     updateState();
     updateStepProgress();
@@ -158,10 +159,12 @@ void ConcurrentTask::subTaskSucceeded(Task::Ptr task)
     m_succeeded.insert(task.get(), task);
 
     m_doing.remove(task.get());
-    m_task_progress.value(task->getUid())->state = TaskStepState::Succeeded;
+    auto task_progress = m_task_progress.value(task->getUid());
+    task_progress->state = TaskStepState::Succeeded;
 
     disconnect(task.get(), 0, this, 0);
 
+    emit stepProgress(*task_progress.get());
     updateState();
     updateStepProgress();
     startNext();
@@ -173,10 +176,13 @@ void ConcurrentTask::subTaskFailed(Task::Ptr task, const QString& msg)
     m_failed.insert(task.get(), task);
 
     m_doing.remove(task.get());
-    m_task_progress.value(task->getUid())->state = TaskStepState::Failed;
+
+    auto task_progress = m_task_progress.value(task->getUid());
+    task_progress->state = TaskStepState::Failed;
 
     disconnect(task.get(), 0, this, 0);
 
+    emit stepProgress(*task_progress.get());
     updateState();
     updateStepProgress();
     startNext();
@@ -184,68 +190,71 @@ void ConcurrentTask::subTaskFailed(Task::Ptr task, const QString& msg)
 
 void ConcurrentTask::subTaskStatus(Task::Ptr task, const QString& msg)
 {
-    auto taskProgress = m_task_progress.value(task->getUid());
-    taskProgress->status = msg; 
-    taskProgress->state = TaskStepState::Running;
+    auto task_progress = m_task_progress.value(task->getUid());
+    task_progress->status = msg;
+    task_progress->state = TaskStepState::Running;
+    
+    emit stepProgress(*task_progress.get());
     updateStepProgress();
 }
 
 void ConcurrentTask::subTaskDetails(Task::Ptr task, const QString& msg)
 {
-    auto taskProgress = m_task_progress.value(task->getUid());
-    taskProgress->details = msg; 
-    taskProgress->state = TaskStepState::Running;
+    auto task_progress = m_task_progress.value(task->getUid());
+    task_progress->details = msg;
+    task_progress->state = TaskStepState::Running;
+    
+    emit stepProgress(*task_progress.get());
     updateStepProgress();
 }
 
 void ConcurrentTask::subTaskProgress(Task::Ptr task, qint64 current, qint64 total)
 {
-    auto taskProgress = m_task_progress.value(task->getUid());
-    
-    taskProgress->current = current;
-    taskProgress->total = total;
-    taskProgress->state = TaskStepState::Running;
+    auto task_progress = m_task_progress.value(task->getUid());
 
+    task_progress->current = current;
+    task_progress->total = total;
+    task_progress->state = TaskStepState::Running;
+    
+    emit stepProgress(*task_progress.get());
     updateStepProgress();
     updateState();
 }
 
-void ConcurrentTask::subTaskStepProgress(Task::Ptr task, TaskStepProgressList task_step_progress)
+void ConcurrentTask::subTaskStepProgress(Task::Ptr task, TaskStepProgress task_progress)
 {
-    for (auto progress : task_step_progress) {
-        if (!m_task_progress.contains(progress->uid)) {
-            m_task_progress.insert(progress->uid, progress);
-        } else {
-            auto tp = m_task_progress.value(progress->uid);
-            tp->current = progress->current;
-            tp->total = progress->total;
-            tp->status = progress->status;
-            tp->details = progress->details;
-        }           
+    if (!m_task_progress.contains(task_progress.uid)) {
+        m_task_progress.insert(task_progress.uid, std::make_shared<TaskStepProgress>(task_progress));
+    } else {
+        auto tp = m_task_progress.value(task_progress.uid);
+        tp->current = task_progress.current;
+        tp->total = task_progress.total;
+        tp->status = task_progress.status;
+        tp->details = task_progress.details;
     }
-
-    updateStepProgress();
     
+    emit stepProgress(task_progress);
+    updateStepProgress();
 }
 
 void ConcurrentTask::updateStepProgress()
 {
-   qint64 current = 0, total = 0;
-   for ( auto taskProgress : m_task_progress ) {
-       current += taskProgress->current;
-       total += taskProgress->total;
-   }
-
-   m_stepProgress = current;
-   m_stepTotalProgress = total;
-   emit stepProgress(m_task_progress.values());
+    qint64 current = 0, total = 0;
+    for (auto taskProgress : m_task_progress) {
+        current += taskProgress->current;
+        total += taskProgress->total;
+    }
+
+    m_stepProgress = current;
+    m_stepTotalProgress = total;
 }
 
 void ConcurrentTask::updateState()
 {
     if (totalSize() > 1) {
         setProgress(m_done.count(), totalSize());
-        setStatus(tr("Executing %1 task(s) (%2 out of %3 are done)").arg(QString::number(m_doing.count()), QString::number(m_done.count()), QString::number(totalSize())));
+        setStatus(tr("Executing %1 task(s) (%2 out of %3 are done)")
+                      .arg(QString::number(m_doing.count()), QString::number(m_done.count()), QString::number(totalSize())));
     } else {
         setProgress(m_stepProgress, m_stepTotalProgress);
         QString status = tr("Please wait ...");
diff --git a/launcher/tasks/ConcurrentTask.h b/launcher/tasks/ConcurrentTask.h
index 1cf1520e..974e8d4d 100644
--- a/launcher/tasks/ConcurrentTask.h
+++ b/launcher/tasks/ConcurrentTask.h
@@ -77,7 +77,7 @@ slots:
     void subTaskStatus(Task::Ptr task, const QString &msg);
     void subTaskDetails(Task::Ptr task, const QString &msg);
     void subTaskProgress(Task::Ptr task, qint64 current, qint64 total);
-    void subTaskStepProgress(Task::Ptr task, TaskStepProgressList task_step_progress);
+    void subTaskStepProgress(Task::Ptr task, TaskStepProgress task_step_progress);
 
 protected:
     // NOTE: This is not thread-safe.
diff --git a/launcher/tasks/Task.cpp b/launcher/tasks/Task.cpp
index e5f61919..fd1b8898 100644
--- a/launcher/tasks/Task.cpp
+++ b/launcher/tasks/Task.cpp
@@ -161,7 +161,7 @@ void Task::emitSucceeded()
     emit finished();
 }
 
-void Task::propogateStepProgress(TaskStepProgressList task_progress)
+void Task::propogateStepProgress(TaskStepProgress task_progress)
 {
     emit stepProgress(task_progress);
 }
diff --git a/launcher/tasks/Task.h b/launcher/tasks/Task.h
index 96b3b855..9ae70270 100644
--- a/launcher/tasks/Task.h
+++ b/launcher/tasks/Task.h
@@ -48,8 +48,7 @@ enum class TaskStepState {
     Waiting,
     Running,
     Failed,
-    Succeeded,
-    Finished
+    Succeeded
 };
 
 Q_DECLARE_METATYPE(TaskStepState)
@@ -61,7 +60,7 @@ struct TaskStepProgress {
     QString status = "";
     QString details = "";
     TaskStepState state = TaskStepState::Waiting;
-    bool isDone() { return (state == TaskStepState::Failed) || (state == TaskStepState::Succeeded) || (state == TaskStepState::Finished); }
+    bool isDone() { return (state == TaskStepState::Failed) || (state == TaskStepState::Succeeded); }
 };
 
 Q_DECLARE_METATYPE(TaskStepProgress)
@@ -127,7 +126,7 @@ class Task : public QObject, public QRunnable {
     void failed(QString reason);
     void status(QString status);
     void details(QString details);
-    void stepProgress(TaskStepProgressList task_progress); // 
+    void stepProgress(TaskStepProgress task_progress); // 
 
     /** Emitted when the canAbort() status has changed.
      */
@@ -150,7 +149,7 @@ class Task : public QObject, public QRunnable {
     virtual void emitAborted();
     virtual void emitFailed(QString reason = "");
 
-    virtual void propogateStepProgress(TaskStepProgressList task_progress);
+    virtual void propogateStepProgress(TaskStepProgress task_progress);
 
    public slots:
     void setStatus(const QString& status);
-- 
cgit 


From d7032d975cb71bbf69d1dcd6a916db85ceb7619c Mon Sep 17 00:00:00 2001
From: Rachel Powers <508861+Ryex@users.noreply.github.com>
Date: Fri, 7 Apr 2023 13:01:45 -0700
Subject: fix: no need to loop all sub tasks

pathc by flowin

Signed-off-by: Rachel Powers <508861+Ryex@users.noreply.github.com>
Signed-off-by: flow <flowlnlnln@gmail.com>
---
 launcher/tasks/ConcurrentTask.cpp | 54 +++++++++++++++++++++++++++------------
 launcher/tasks/ConcurrentTask.h   |  3 ++-
 launcher/tasks/Task.h             |  4 +++
 3 files changed, 44 insertions(+), 17 deletions(-)

(limited to 'launcher/tasks')

diff --git a/launcher/tasks/ConcurrentTask.cpp b/launcher/tasks/ConcurrentTask.cpp
index 8434ecdc..439879e6 100644
--- a/launcher/tasks/ConcurrentTask.cpp
+++ b/launcher/tasks/ConcurrentTask.cpp
@@ -138,10 +138,12 @@ void ConcurrentTask::startNext()
     connect(next.get(), &Task::progress, this, [this, next](qint64 current, qint64 total) { subTaskProgress(next, current, total); });
 
     m_doing.insert(next.get(), next);
-    m_task_progress.insert(next->getUid(), std::make_shared<TaskStepProgress>(TaskStepProgress({ next->getUid() })));
+    auto task_progress = std::make_shared<TaskStepProgress>(TaskStepProgress({ next->getUid() }));
+    m_task_progress.insert(next->getUid(), task_progress);
 
     updateState();
-    updateStepProgress();
+    updateStepProgress(*task_progress.get(), Operation::ADDED);
+    
 
     QCoreApplication::processEvents();
 
@@ -166,7 +168,7 @@ void ConcurrentTask::subTaskSucceeded(Task::Ptr task)
 
     emit stepProgress(*task_progress.get());
     updateState();
-    updateStepProgress();
+    updateStepProgress(*task_progress.get(), Operation::REMOVED);
     startNext();
 }
 
@@ -184,7 +186,7 @@ void ConcurrentTask::subTaskFailed(Task::Ptr task, const QString& msg)
 
     emit stepProgress(*task_progress.get());
     updateState();
-    updateStepProgress();
+    updateStepProgress(*task_progress.get(), Operation::REMOVED);
     startNext();
 }
 
@@ -195,7 +197,6 @@ void ConcurrentTask::subTaskStatus(Task::Ptr task, const QString& msg)
     task_progress->state = TaskStepState::Running;
     
     emit stepProgress(*task_progress.get());
-    updateStepProgress();
 }
 
 void ConcurrentTask::subTaskDetails(Task::Ptr task, const QString& msg)
@@ -205,48 +206,69 @@ void ConcurrentTask::subTaskDetails(Task::Ptr task, const QString& msg)
     task_progress->state = TaskStepState::Running;
     
     emit stepProgress(*task_progress.get());
-    updateStepProgress();
 }
 
 void ConcurrentTask::subTaskProgress(Task::Ptr task, qint64 current, qint64 total)
 {
     auto task_progress = m_task_progress.value(task->getUid());
 
+    task_progress->old_current = task_progress->current;
+    task_progress->old_total = task_progress->old_total;
+
     task_progress->current = current;
     task_progress->total = total;
     task_progress->state = TaskStepState::Running;
     
     emit stepProgress(*task_progress.get());
-    updateStepProgress();
+    updateStepProgress(*task_progress.get(), Operation::CHANGED);
     updateState();
 }
 
 void ConcurrentTask::subTaskStepProgress(Task::Ptr task, TaskStepProgress task_progress)
 {
+    Operation op = Operation::ADDED;
+    
     if (!m_task_progress.contains(task_progress.uid)) {
         m_task_progress.insert(task_progress.uid, std::make_shared<TaskStepProgress>(task_progress));
+        op = Operation::ADDED;
     } else {
         auto tp = m_task_progress.value(task_progress.uid);
+
+        tp->old_current = tp->current;
+        tp->old_total = tp->total;
+
         tp->current = task_progress.current;
         tp->total = task_progress.total;
         tp->status = task_progress.status;
         tp->details = task_progress.details;
+
+        op = Operation::CHANGED;
     }
-    
+
     emit stepProgress(task_progress);
-    updateStepProgress();
+    updateStepProgress(task_progress, op);
 }
 
-void ConcurrentTask::updateStepProgress()
+void ConcurrentTask::updateStepProgress(TaskStepProgress const& changed_progress, Operation op)
 {
-    qint64 current = 0, total = 0;
-    for (auto taskProgress : m_task_progress) {
-        current += taskProgress->current;
-        total += taskProgress->total;
+
+    switch (op) {
+        case Operation::ADDED:
+            m_stepProgress += changed_progress.current;
+            m_stepTotalProgress += changed_progress.total;
+            break;
+        case Operation::REMOVED:
+            m_stepProgress -= changed_progress.current;
+            m_stepTotalProgress -= changed_progress.total;
+            break;
+        case Operation::CHANGED:
+            m_stepProgress -= changed_progress.old_current;
+            m_stepTotalProgress -= changed_progress.old_total;
+            m_stepProgress += changed_progress.current;
+            m_stepTotalProgress += changed_progress.total;
+            break;    
     }
 
-    m_stepProgress = current;
-    m_stepTotalProgress = total;
 }
 
 void ConcurrentTask::updateState()
diff --git a/launcher/tasks/ConcurrentTask.h b/launcher/tasks/ConcurrentTask.h
index 974e8d4d..284fa345 100644
--- a/launcher/tasks/ConcurrentTask.h
+++ b/launcher/tasks/ConcurrentTask.h
@@ -83,7 +83,8 @@ protected:
     // NOTE: This is not thread-safe.
     [[nodiscard]] unsigned int totalSize() const { return m_queue.size() + m_doing.size() + m_done.size(); }
 
-    void updateStepProgress();
+    enum class Operation { ADDED, REMOVED, CHANGED };
+    void updateStepProgress(TaskStepProgress const& changed_progress, Operation);
 
     virtual void updateState();
 
diff --git a/launcher/tasks/Task.h b/launcher/tasks/Task.h
index 9ae70270..d71eaf6b 100644
--- a/launcher/tasks/Task.h
+++ b/launcher/tasks/Task.h
@@ -57,6 +57,10 @@ struct TaskStepProgress {
     QUuid uid; 
     qint64 current = 0;
     qint64 total = -1;
+
+    qint64 old_current = 0;
+    qint64 old_total = -1;
+
     QString status = "";
     QString details = "";
     TaskStepState state = TaskStepState::Waiting;
-- 
cgit 


From 236764adf6cb985dfc6d00b9cbcba8eb176510ed Mon Sep 17 00:00:00 2001
From: Rachel Powers <508861+Ryex@users.noreply.github.com>
Date: Fri, 7 Apr 2023 19:44:57 -0700
Subject: refactor: Qt can handle const& in signals and slots

While most Qt types cna use implicit data sharing
pasing our own structs means copies. const& ensure
it's only copied as needed by Qt.

Signed-off-by: Rachel Powers <508861+Ryex@users.noreply.github.com>
---
 launcher/tasks/ConcurrentTask.cpp | 10 ++++++----
 launcher/tasks/ConcurrentTask.h   |  2 +-
 launcher/tasks/Task.cpp           |  2 +-
 launcher/tasks/Task.h             |  6 +++---
 4 files changed, 11 insertions(+), 9 deletions(-)

(limited to 'launcher/tasks')

diff --git a/launcher/tasks/ConcurrentTask.cpp b/launcher/tasks/ConcurrentTask.cpp
index 439879e6..37435739 100644
--- a/launcher/tasks/ConcurrentTask.cpp
+++ b/launcher/tasks/ConcurrentTask.cpp
@@ -133,7 +133,7 @@ void ConcurrentTask::startNext()
 
     connect(next.get(), &Task::status, this, [this, next](QString msg) { subTaskStatus(next, msg); });
     connect(next.get(), &Task::details, this, [this, next](QString msg) { subTaskDetails(next, msg); });
-    connect(next.get(), &Task::stepProgress, this, [this, next](TaskStepProgress tp) { subTaskStepProgress(next, tp); });
+    connect(next.get(), &Task::stepProgress, this, [this, next](TaskStepProgress const& tp) { subTaskStepProgress(next, tp); });
 
     connect(next.get(), &Task::progress, this, [this, next](qint64 current, qint64 total) { subTaskProgress(next, current, total); });
 
@@ -224,13 +224,15 @@ void ConcurrentTask::subTaskProgress(Task::Ptr task, qint64 current, qint64 tota
     updateState();
 }
 
-void ConcurrentTask::subTaskStepProgress(Task::Ptr task, TaskStepProgress task_progress)
+void Concur