mc-in-work/PrismLauncher
1
0
Fork 0
mirror of https://github.com/PrismLauncher/PrismLauncher.git synced 2026-06-29 01:54:20 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Use an owning QByteArray in ByteArraySink

Browse source 
Signed-off-by: TheKodeToad <TheKodeToad@proton.me>
This commit is contained in:
TheKodeToad 2026-02-17 22:01:59 +00:00
parent 2b84053011
commit 316121ba8f
No known key found for this signature in database
GPG key ID: 5E39D70B4C93C38E
70 changed files with 397 additions and 390 deletions
Download patch file Download diff file Expand all files Collapse all files

19
launcher/modplatform/EnsureMetadataTask.cpp
View file

@ -215,8 +215,7 @@ Task::Ptr EnsureMetadataTask::modrinthVersionsTask()
{
auto hash_type = ModPlatform::ProviderCapabilities::hashType(ModPlatform::ResourceProvider::MODRINTH).first();
auto response = std::make_shared<QByteArray>();
auto ver_task = modrinth_api.currentVersions(m_resources.keys(), hash_type, response.get());
auto [ver_task, response] = modrinth_api.currentVersions(m_resources.keys(), hash_type);
// Prevents unfortunate timings when aborting the task
if (!ver_task)
@ -267,15 +266,15 @@ Task::Ptr EnsureMetadataTask::modrinthProjectsTask()
for (auto const& data : m_tempVersions)
addonIds.insert(data.addonId.toString(), data.hash);
auto response = std::make_shared<QByteArray>();
Task::Ptr proj_task;
QByteArray* response;
if (addonIds.isEmpty()) {
qWarning() << "No addonId found!";
} else if (addonIds.size() == 1) {
proj_task = modrinth_api.getProject(*addonIds.keyBegin(), response.get());
std::tie(proj_task, response) = modrinth_api.getProject(*addonIds.keyBegin());
} else {
proj_task = modrinth_api.getProjects(addonIds.keys(), response.get());
std::tie(proj_task, response) = modrinth_api.getProjects(addonIds.keys());
}
// Prevents unfortunate timings when aborting the task
@ -341,14 +340,12 @@ Task::Ptr EnsureMetadataTask::modrinthProjectsTask()
// Flame
Task::Ptr EnsureMetadataTask::flameVersionsTask()
{
auto response = std::make_shared<QByteArray>();
QList<uint> fingerprints;
for (auto& murmur : m_resources.keys()) {
fingerprints.push_back(murmur.toUInt());
}
auto ver_task = flame_api.matchFingerprints(fingerprints, response.get());
auto [ver_task, response] = flame_api.matchFingerprints(fingerprints);
connect(ver_task.get(), &Task::succeeded, this, [this, response] {
QJsonParseError parse_error{};
@ -417,15 +414,15 @@ Task::Ptr EnsureMetadataTask::flameProjectsTask()
}
}
auto response = std::make_shared<QByteArray>();
Task::Ptr proj_task;
QByteArray* response;
if (addonIds.isEmpty()) {
qWarning() << "No addonId found!";
} else if (addonIds.size() == 1) {
proj_task = flame_api.getProject(*addonIds.keyBegin(), response.get());
std::tie(proj_task, response) = flame_api.getProject(*addonIds.keyBegin());
} else {
proj_task = flame_api.getProjects(addonIds.keys(), response.get());
std::tie(proj_task, response) = flame_api.getProjects(addonIds.keys());
}
// Prevents unfortunate timings when aborting the task

25
launcher/modplatform/ResourceAPI.cpp
View file

@ -18,10 +18,10 @@ Task::Ptr ResourceAPI::searchProjects(SearchArgs&& args, Callback<QList<ModPlatf
auto search_url = search_url_optional.value();
auto response = std::make_shared<QByteArray>();
auto netJob = makeShared<NetJob>(QString("%1::Search").arg(debugName()), APPLICATION->network());
netJob->addNetAction(Net::ApiDownload::makeByteArray(QUrl(search_url), response.get()));
auto [action, response] = Net::ApiDownload::makeByteArray(QUrl(search_url));
netJob->addNetAction(action);
QObject::connect(netJob.get(), &NetJob::succeeded, [this, response, callbacks] {
QJsonParseError parse_error{};
@ -84,9 +84,9 @@ Task::Ptr ResourceAPI::getProjectVersions(VersionSearchArgs&& args, Callback<QVe
auto versions_url = versions_url_optional.value();
auto netJob = makeShared<NetJob>(QString("%1::Versions").arg(args.pack->name), APPLICATION->network());
auto response = std::make_shared<QByteArray>();
netJob->addNetAction(Net::ApiDownload::makeByteArray(versions_url, response.get()));
auto [action, response] = Net::ApiDownload::makeByteArray(versions_url);
netJob->addNetAction(action);
QObject::connect(netJob.get(), &NetJob::succeeded, [this, response, callbacks, args] {
QJsonParseError parse_error{};
@ -148,8 +148,7 @@ Task::Ptr ResourceAPI::getProjectVersions(VersionSearchArgs&& args, Callback<QVe
Task::Ptr ResourceAPI::getProjectInfo(ProjectInfoArgs&& args, Callback<ModPlatform::IndexedPack::Ptr>&& callbacks) const
{
auto response = std::make_shared<QByteArray>();
auto job = getProject(args.pack->addonId.toString(), response.get());
auto [job, response] = getProject(args.pack->addonId.toString());
QObject::connect(job.get(), &NetJob::succeeded, [this, response, callbacks, args] {
auto pack = args.pack;
@ -204,9 +203,8 @@ Task::Ptr ResourceAPI::getDependencyVersion(DependencySearchArgs&& args, Callbac
auto versions_url = versions_url_optional.value();
auto netJob = makeShared<NetJob>(QString("%1::Dependency").arg(args.dependency.addonId.toString()), APPLICATION->network());
auto response = std::make_shared<QByteArray>();
netJob->addNetAction(Net::ApiDownload::makeByteArray(versions_url, response.get()));
auto [action, response] = Net::ApiDownload::makeByteArray(versions_url);
netJob->addNetAction(action);
QObject::connect(netJob.get(), &NetJob::succeeded, [this, response, callbacks, args] {
QJsonParseError parse_error{};
@ -284,17 +282,18 @@ QString ResourceAPI::mapMCVersionToModrinth(Version v) const
return verStr;
}
Task::Ptr ResourceAPI::getProject(QString addonId, QByteArray* response) const
std::pair<Task::Ptr, QByteArray*> ResourceAPI::getProject(QString addonId) const
{
auto project_url_optional = getInfoURL(addonId);
if (!project_url_optional.has_value())
return nullptr;
return { nullptr, nullptr };
auto project_url = project_url_optional.value();
auto netJob = makeShared<NetJob>(QString("%1::GetProject").arg(addonId), APPLICATION->network());
netJob->addNetAction(Net::ApiDownload::makeByteArray(QUrl(project_url), response));
auto [action, response] = Net::ApiDownload::makeByteArray(QUrl(project_url));
netJob->addNetAction(action);
return netJob;
return { netJob, response };
}

5
launcher/modplatform/ResourceAPI.h
View file

@ -44,6 +44,7 @@
#include <list>
#include <optional>
#include <utility>
#include "../Version.h"
@ -112,8 +113,8 @@ class ResourceAPI {
public slots:
virtual Task::Ptr searchProjects(SearchArgs&&, Callback<QList<ModPlatform::IndexedPack::Ptr>>&&) const;
virtual Task::Ptr getProject(QString addonId, QByteArray* response) const;
virtual Task::Ptr getProjects(QStringList addonIds, QByteArray* response) const = 0;
virtual std::pair<Task::Ptr, QByteArray*> getProject(QString addonId) const;
virtual std::pair<Task::Ptr, QByteArray*> getProjects(QStringList addonIds) const = 0;
virtual Task::Ptr getProjectInfo(ProjectInfoArgs&&, Callback<ModPlatform::IndexedPack::Ptr>&&) const;
Task::Ptr getProjectVersions(VersionSearchArgs&& args, Callback<QVector<ModPlatform::IndexedVersion>>&& callbacks) const;

15
launcher/modplatform/atlauncher/ATLPackInstallTask.cpp
View file

@ -87,9 +87,11 @@ void PackInstallTask::executeTask()
NetJob::Ptr netJob{ new NetJob("ATLauncher::VersionFetch", APPLICATION->network()) };
auto searchUrl =
QString(BuildConfig.ATL_DOWNLOAD_SERVER_URL + "packs/%1/versions/%2/Configs.json").arg(m_pack_safe_name).arg(m_version_name);
netJob->addNetAction(Net::ApiDownload::makeByteArray(QUrl(searchUrl), response.get()));
connect(netJob.get(), &NetJob::succeeded, this, &PackInstallTask::onDownloadSucceeded);
auto [action, response] = Net::ApiDownload::makeByteArray(QUrl(searchUrl));
netJob->addNetAction(action);
connect(netJob.get(), &NetJob::succeeded, this, [this, response] { onDownloadSucceeded(response); });
connect(netJob.get(), &NetJob::failed, this, &PackInstallTask::onDownloadFailed);
connect(netJob.get(), &NetJob::aborted, this, &PackInstallTask::onDownloadAborted);
@ -97,17 +99,20 @@ void PackInstallTask::executeTask()
jobPtr->start();
}
void PackInstallTask::onDownloadSucceeded()
void PackInstallTask::onDownloadSucceeded(QByteArray* responsePtr)
{
qDebug() << "PackInstallTask::onDownloadSucceeded:" << QThread::currentThreadId();
// NOTE(TheKodeToad): moving the response out to avoid it from being destroyed by jobPtr.reset()
QByteArray response = std::move(*responsePtr);
jobPtr.reset();
QJsonParseError parse_error{};
QJsonDocument doc = QJsonDocument::fromJson(*response, &parse_error);
QJsonDocument doc = QJsonDocument::fromJson(response, &parse_error);
if (parse_error.error != QJsonParseError::NoError) {
qWarning() << "Error while parsing JSON response from ATLauncher at" << parse_error.offset
<< "reason:" << parse_error.errorString();
qWarning() << *response.get();
qWarning() << response;
return;
}
auto obj = doc.object();

3
launcher/modplatform/atlauncher/ATLPackInstallTask.h
View file

@ -95,7 +95,7 @@ class PackInstallTask : public InstanceTask {
virtual void executeTask() override;
private slots:
void onDownloadSucceeded();
void onDownloadSucceeded(QByteArray* responsePtr);
void onDownloadFailed(QString reason);
void onDownloadAborted();
@ -125,7 +125,6 @@ class PackInstallTask : public InstanceTask {
bool abortable = false;
NetJob::Ptr jobPtr;
std::unique_ptr<QByteArray> response = std::make_unique<QByteArray>();
InstallMode m_install_mode;
QString m_pack_name;

32
launcher/modplatform/flame/FileResolvingTask.cpp
View file

@ -51,19 +51,19 @@ void Flame::FileResolvingTask::executeTask()
}
setStatus(tr("Resolving mod IDs..."));
setProgress(0, 3);
m_result.reset(new QByteArray());
QStringList fileIds;
for (auto file : m_manifest.files) {
fileIds.push_back(QString::number(file.fileId));
}
m_task = flameAPI.getFiles(fileIds, m_result.get());
auto [task, response] = flameAPI.getFiles(fileIds);
m_task = task;
auto step_progress = std::make_shared<TaskStepProgress>();
connect(m_task.get(), &Task::succeeded, this, [this, step_progress]() {
connect(m_task.get(), &Task::succeeded, this, [this, response, step_progress]() {
step_progress->state = TaskStepState::Succeeded;
stepProgress(*step_progress);
netJobFinished();
netJobFinished(response);
});
connect(m_task.get(), &Task::failed, this, [this, step_progress](QString reason) {
step_progress->state = TaskStepState::Failed;
@ -108,7 +108,7 @@ ModPlatform::ResourceType getResourceType(int classId)
}
}
void Flame::FileResolvingTask::netJobFinished()
void Flame::FileResolvingTask::netJobFinished(QByteArray* response)
{
setProgress(1, 3);
// job to check modrinth for blocked projects
@ -116,7 +116,7 @@ void Flame::FileResolvingTask::netJobFinished()
QJsonArray array;
try {
doc = Json::requireDocument(*m_result);
doc = Json::requireDocument(*response);
array = Json::requireArray(doc.object()["data"]);
} catch (Json::JsonException& e) {
qCritical() << "Non-JSON data returned from the CF API";
@ -153,19 +153,19 @@ void Flame::FileResolvingTask::netJobFinished()
getFlameProjects();
return;
}
m_result.reset(new QByteArray());
m_task = modrinthAPI.currentVersions(hashes, "sha1", m_result.get());
auto [modrinthTask, modrinthResponse] = modrinthAPI.currentVersions(hashes, "sha1");
m_task = modrinthTask;
(dynamic_cast<NetJob*>(m_task.get()))->setAskRetry(false);
auto step_progress = std::make_shared<TaskStepProgress>();
connect(m_task.get(), &Task::succeeded, this, [this, step_progress]() {
connect(m_task.get(), &Task::succeeded, this, [this, modrinthResponse, step_progress]() {
step_progress->state = TaskStepState::Succeeded;
stepProgress(*step_progress);
QJsonParseError parse_error{};
QJsonDocument doc = QJsonDocument::fromJson(*m_result, &parse_error);
QJsonDocument doc = QJsonDocument::fromJson(*modrinthResponse, &parse_error);
if (parse_error.error != QJsonParseError::NoError) {
qWarning() << "Error while parsing JSON response from Modrinth::CurrentVersions at" << parse_error.offset
<< "reason:" << parse_error.errorString();
qWarning() << *m_result;
qWarning() << *modrinthResponse;
getFlameProjects();
return;
@ -222,22 +222,22 @@ void Flame::FileResolvingTask::netJobFinished()
void Flame::FileResolvingTask::getFlameProjects()
{
setProgress(2, 3);
m_result.reset(new QByteArray());
QStringList addonIds;
for (auto file : m_manifest.files) {
addonIds.push_back(QString::number(file.projectId));
}
m_task = flameAPI.getProjects(addonIds, m_result.get());
auto [task, response] = flameAPI.getProjects(addonIds);
m_task = task;
auto step_progress = std::make_shared<TaskStepProgress>();
connect(m_task.get(), &Task::succeeded, this, [this, step_progress] {
connect(m_task.get(), &Task::succeeded, this, [this, response, step_progress] {
QJsonParseError parse_error{};
auto doc = QJsonDocument::fromJson(*m_result, &parse_error);
auto doc = QJsonDocument::fromJson(*response, &parse_error);
if (parse_error.error != QJsonParseError::NoError) {
qWarning() << "Error while parsing JSON response from Modrinth projects task at" << parse_error.offset
<< "reason:" << parse_error.errorString();
qWarning() << *m_result;
qWarning() << *response;
return;
}

3
launcher/modplatform/flame/FileResolvingTask.h
View file

@ -36,14 +36,13 @@ class FileResolvingTask : public Task {
virtual void executeTask() override;
protected slots:
void netJobFinished();
void netJobFinished(QByteArray* response);
private:
void getFlameProjects();
private: /* data */
Flame::Manifest m_manifest;
std::unique_ptr<QByteArray> m_result;
Task::Ptr m_task;
};
} // namespace Flame

62
launcher/modplatform/flame/FlameAPI.cpp
View file

@ -15,7 +15,7 @@
#include "net/ApiUpload.h"
#include "net/NetJob.h"
Task::Ptr FlameAPI::matchFingerprints(const QList<uint>& fingerprints, QByteArray* response)
std::pair<Task::Ptr, QByteArray*> FlameAPI::matchFingerprints(const QList<uint>& fingerprints)
{
auto netJob = makeShared<NetJob>(QString("Flame::MatchFingerprints"), APPLICATION->network());
@ -29,10 +29,10 @@ Task::Ptr FlameAPI::matchFingerprints(const QList<uint>& fingerprints, QByteArra
QJsonDocument body(body_obj);
auto body_raw = body.toJson();
auto [action, response] = Net::ApiUpload::makeByteArray(QString(BuildConfig.FLAME_BASE_URL + "/fingerprints"), body_raw);
netJob->addNetAction(action);
netJob->addNetAction(Net::ApiUpload::makeByteArray(QString(BuildConfig.FLAME_BASE_URL + "/fingerprints"), response, body_raw));
return netJob;
return { netJob, response };
}
QString FlameAPI::getModFileChangelog(int modId, int fileId)
@ -41,11 +41,10 @@ QString FlameAPI::getModFileChangelog(int modId, int fileId)
QString changelog;
auto netJob = makeShared<NetJob>(QString("Flame::FileChangelog"), APPLICATION->network());
auto response = std::make_shared<QByteArray>();
netJob->addNetAction(Net::ApiDownload::makeByteArray(
auto [action, response] = Net::ApiDownload::makeByteArray(
QString(BuildConfig.FLAME_BASE_URL + "/mods/%1/files/%2/changelog")
.arg(QString::fromStdString(std::to_string(modId)), QString::fromStdString(std::to_string(fileId))),
response.get()));
.arg(QString::fromStdString(std::to_string(modId)), QString::fromStdString(std::to_string(fileId))));
netJob->addNetAction(action);
QObject::connect(netJob.get(), &NetJob::succeeded, [&netJob, response, &changelog] {
QJsonParseError parse_error{};
@ -76,9 +75,9 @@ QString FlameAPI::getModDescription(int modId)
QString description;
auto netJob = makeShared<NetJob>(QString("Flame::ModDescription"), APPLICATION->network());
auto response = std::make_shared<QByteArray>();
netJob->addNetAction(Net::ApiDownload::makeByteArray(
QString(BuildConfig.FLAME_BASE_URL + "/mods/%1/description").arg(QString::number(modId)), response.get()));
auto [action, response] =
Net::ApiDownload::makeByteArray(QString(BuildConfig.FLAME_BASE_URL + "/mods/%1/description").arg(QString::number(modId)));
netJob->addNetAction(action);
QObject::connect(netJob.get(), &NetJob::succeeded, [&netJob, response, &description] {
QJsonParseError parse_error{};
@ -103,7 +102,7 @@ QString FlameAPI::getModDescription(int modId)
return description;
}
Task::Ptr FlameAPI::getProjects(QStringList addonIds, QByteArray* response) const
std::pair<Task::Ptr, QByteArray*> FlameAPI::getProjects(QStringList addonIds) const
{
auto netJob = makeShared<NetJob>(QString("Flame::GetProjects"), APPLICATION->network());
@ -117,15 +116,15 @@ Task::Ptr FlameAPI::getProjects(QStringList addonIds, QByteArray* response) cons
QJsonDocument body(body_obj);
auto body_raw = body.toJson();
netJob->addNetAction(Net::ApiUpload::makeByteArray(QString(BuildConfig.FLAME_BASE_URL + "/mods"), response, body_raw));
auto [action, response] = Net::ApiUpload::makeByteArray(QString(BuildConfig.FLAME_BASE_URL + "/mods"), body_raw);
netJob->addNetAction(action);
QObject::connect(netJob.get(), &NetJob::failed, [body_raw] { qDebug() << body_raw; });
return netJob;
return { netJob, response };
}
Task::Ptr FlameAPI::getFiles(const QStringList& fileIds, QByteArray* response) const
std::pair<Task::Ptr, QByteArray*> FlameAPI::getFiles(const QStringList& fileIds) const
{
auto netJob = makeShared<NetJob>(QString("Flame::GetFiles"), APPLICATION->network());
@ -140,22 +139,24 @@ Task::Ptr FlameAPI::getFiles(const QStringList& fileIds, QByteArray* response) c
QJsonDocument body(body_obj);
auto body_raw = body.toJson();
netJob->addNetAction(Net::ApiUpload::makeByteArray(QString(BuildConfig.FLAME_BASE_URL + "/mods/files"), response, body_raw));
auto [action, response] = Net::ApiUpload::makeByteArray(QString(BuildConfig.FLAME_BASE_URL + "/mods/files"), body_raw);
netJob->addNetAction(action);
QObject::connect(netJob.get(), &NetJob::failed, [body_raw] { qDebug() << body_raw; });
return netJob;
return { netJob, response };
}
Task::Ptr FlameAPI::getFile(const QString& addonId, const QString& fileId, QByteArray* response) const
std::pair<Task::Ptr, QByteArray*> FlameAPI::getFile(const QString& addonId, const QString& fileId) const
{
auto netJob = makeShared<NetJob>(QString("Flame::GetFile"), APPLICATION->network());
netJob->addNetAction(
Net::ApiDownload::makeByteArray(QUrl(QString(BuildConfig.FLAME_BASE_URL + "/mods/%1/files/%2").arg(addonId, fileId)), response));
auto [action, response] =
Net::ApiDownload::makeByteArray(QUrl(QString(BuildConfig.FLAME_BASE_URL + "/mods/%1/files/%2").arg(addonId, fileId)));
netJob->addNetAction(action);
QObject::connect(netJob.get(), &NetJob::failed, [addonId, fileId] { qDebug() << "Flame API file failure" << addonId << fileId; });
return netJob;
return { netJob, response };
}
QList<ResourceAPI::SortingMethod> FlameAPI::getSortingMethods() const
@ -171,25 +172,26 @@ QList<ResourceAPI::SortingMethod> FlameAPI::getSortingMethods() const
{ 8, "GameVersion", QObject::tr("Sort by Game Version") } };
}
Task::Ptr FlameAPI::getCategories(QByteArray* response, ModPlatform::ResourceType type)
std::pair<Task::Ptr, QByteArray*> FlameAPI::getCategories(ModPlatform::ResourceType type)
{
auto netJob = makeShared<NetJob>(QString("Flame::GetCategories"), APPLICATION->network());
netJob->addNetAction(Net::ApiDownload::makeByteArray(
QUrl(QString(BuildConfig.FLAME_BASE_URL + "/categories?gameId=432&classId=%1").arg(getClassId(type))), response));
auto [action, response] = Net::ApiDownload::makeByteArray(
QUrl(QString(BuildConfig.FLAME_BASE_URL + "/categories?gameId=432&classId=%1").arg(getClassId(type))));
netJob->addNetAction(action);
QObject::connect(netJob.get(), &Task::failed, [](QString msg) { qDebug() << "Flame failed to get categories:" << msg; });
return netJob;
return { netJob, response };
}
Task::Ptr FlameAPI::getModCategories(QByteArray* response)
std::pair<Task::Ptr, QByteArray*> FlameAPI::getModCategories()
{
return getCategories(response, ModPlatform::ResourceType::Mod);
return getCategories(ModPlatform::ResourceType::Mod);
}
QList<ModPlatform::Category> FlameAPI::loadModCategories(QByteArray* response)
QList<ModPlatform::Category> FlameAPI::loadModCategories(const QByteArray& response)
{
QList<ModPlatform::Category> categories;
QJsonParseError parse_error{};
QJsonDocument doc = QJsonDocument::fromJson(*response, &parse_error);
QJsonDocument doc = QJsonDocument::fromJson(response, &parse_error);
if (parse_error.error != QJsonParseError::NoError) {
qWarning() << "Error while parsing JSON response from categories at" << parse_error.offset
<< "reason:" << parse_error.errorString();

15
launcher/modplatform/flame/FlameAPI.h
View file

@ -5,7 +5,6 @@
#pragma once
#include <QList>
#include <memory>
#include "BuildConfig.h"
#include "Json.h"
#include "Version.h"
@ -23,14 +22,14 @@ class FlameAPI : public ResourceAPI {
ModPlatform::ModLoaderTypes fallback,
bool checkLoaders);
Task::Ptr getProjects(QStringList addonIds, QByteArray* response) const override;
Task::Ptr matchFingerprints(const QList<uint>& fingerprints, QByteArray* response);
Task::Ptr getFiles(const QStringList& fileIds, QByteArray* response) const;
Task::Ptr getFile(const QString& addonId, const QString& fileId, QByteArray* response) const;
std::pair<Task::Ptr, QByteArray*> getProjects(QStringList addonIds) const override;
std::pair<Task::Ptr, QByteArray*> matchFingerprints(const QList<uint>& fingerprints);
std::pair<Task::Ptr, QByteArray*> getFiles(const QStringList& fileIds) const;
std::pair<Task::Ptr, QByteArray*> getFile(const QString& addonId, const QString& fileId) const;
static Task::Ptr getCategories(QByteArray* response, ModPlatform::ResourceType type);
static Task::Ptr getModCategories(QByteArray* response);
static QList<ModPlatform::Category> loadModCategories(QByteArray* response);
static std::pair<Task::Ptr, QByteArray*> getCategories(ModPlatform::ResourceType type);
static std::pair<Task::Ptr, QByteArray*> getModCategories();
static QList<ModPlatform::Category> loadModCategories(const QByteArray& response);
QList<ResourceAPI::SortingMethod> getSortingMethods() const override;

11
launcher/modplatform/flame/FlameCheckUpdate.cpp
View file

@ -52,10 +52,9 @@ void FlameCheckUpdate::executeTask()
if (!versionsUrlOptional.has_value())
continue;
auto response = std::make_shared<QByteArray>();
auto task = Net::ApiDownload::makeByteArray(versionsUrlOptional.value(), response.get());
auto [task, response] = Net::ApiDownload::makeByteArray(versionsUrlOptional.value());
connect(task.get(), &Task::succeeded, this, [this, resource, response] { getLatestVersionCallback(resource, response.get()); });
connect(task.get(), &Task::succeeded, this, [this, resource, response] { getLatestVersionCallback(resource, response); });
netJob->addNetAction(task);
}
m_task.reset(netJob);
@ -139,16 +138,16 @@ void FlameCheckUpdate::collectBlockedMods()
quickSearch[addonId] = resource;
}
auto response = std::make_shared<QByteArray>();
Task::Ptr projTask;
QByteArray* response;
if (addonIds.isEmpty()) {
emitSucceeded();
return;
} else if (addonIds.size() == 1) {
projTask = api.getProject(*addonIds.begin(), response.get());
std::tie(projTask, response) = api.getProject(*addonIds.begin());
} else {
projTask = api.getProjects(addonIds, response.get());
std::tie(projTask, response) = api.getProjects(addonIds);
}
connect(projTask.get(), &Task::succeeded, this, [this, response, addonIds, quickSearch] {

3
launcher/modplatform/flame/FlameInstanceCreationTask.cpp
View file

@ -184,8 +184,7 @@ bool FlameCreationTask::updateInstance()
fileIds.append(QString::number(file.fileId));
}
auto raw_response = std::make_shared<QByteArray>();
auto job = api.getFiles(fileIds, raw_response.get());
auto [job, raw_response] = api.getFiles(fileIds);
QEventLoop loop;

10
launcher/modplatform/flame/FlamePackExportTask.cpp
View file

@ -167,14 +167,14 @@ void FlamePackExportTask::makeApiRequest()
setStatus(tr("Finding versions for hashes..."));
setProgress(2, 5);
auto response = std::make_shared<QByteArray>();
QList<uint> fingerprints;
for (auto& murmur : pendingHashes.keys()) {
fingerprints.push_back(murmur.toUInt());
}
task.reset(api.matchFingerprints(fingerprints, response.get()));
auto [matchTask, response] = api.matchFingerprints(fingerprints);
task = matchTask;
connect(task.get(), &Task::succeeded, this, [this, response] {
QJsonParseError parseError{};
@ -245,16 +245,16 @@ void FlamePackExportTask::getProjectsInfo()
}
}
auto response = std::make_shared<QByteArray>();
Task::Ptr projTask;
QByteArray* response;
if (addonIds.isEmpty()) {
buildZip();
return;
} else if (addonIds.size() == 1) {
projTask = api.getProject(*addonIds.begin(), response.get());
std::tie(projTask, response) = api.getProject(*addonIds.begin());
} else {
projTask = api.getProjects(addonIds, response.get());
std::tie(projTask, response) = api.getProjects(addonIds);
}
connect(projTask.get(), &Task::succeeded, this, [this, response, addonIds] {

15
launcher/modplatform/ftb/FTBPackInstallTask.cpp
View file

@ -91,10 +91,11 @@ void PackInstallTask::executeTask()
auto netJob = makeShared<NetJob>("FTB::VersionFetch", APPLICATION->network());
auto searchUrl = QString(BuildConfig.FTB_API_BASE_URL + "/modpack/%1/%2").arg(m_pack.id).arg(version.id);
m_response.reset(new QByteArray());
netJob->addNetAction(Net::Download::makeByteArray(QUrl(searchUrl), m_response.get()));
QObject::connect(netJob.get(), &NetJob::succeeded, this, &PackInstallTask::onManifestDownloadSucceeded);
auto [action, response] = Net::Download::makeByteArray(QUrl(searchUrl));
netJob->addNetAction(action);
QObject::connect(netJob.get(), &NetJob::succeeded, this, [this, response] { onManifestDownloadSucceeded(response); });
QObject::connect(netJob.get(), &NetJob::failed, this, &PackInstallTask::onManifestDownloadFailed);
QObject::connect(netJob.get(), &NetJob::aborted, this, &PackInstallTask::abort);
QObject::connect(netJob.get(), &NetJob::progress, this, &PackInstallTask::setProgress);
@ -105,15 +106,17 @@ void PackInstallTask::executeTask()
netJob->start();
}
void PackInstallTask::onManifestDownloadSucceeded()
void PackInstallTask::onManifestDownloadSucceeded(QByteArray* responsePtr)
{
// NOTE(TheKodeToad): moving the response out to avoid it from being destroyed by m_net_job.reset()
QByteArray response = std::move(*responsePtr);
m_net_job.reset();
QJsonParseError parse_error{};
QJsonDocument doc = QJsonDocument::fromJson(*m_response, &parse_error);
QJsonDocument doc = QJsonDocument::fromJson(response, &parse_error);
if (parse_error.error != QJsonParseError::NoError) {
qWarning() << "Error while parsing JSON response from FTB at " << parse_error.offset << " reason: " << parse_error.errorString();
qWarning() << *m_response;
qWarning() << response;
return;
}

4
launcher/modplatform/ftb/FTBPackInstallTask.h
View file

@ -62,7 +62,7 @@ class PackInstallTask final : public InstanceTask {
void executeTask() override;
private slots:
void onManifestDownloadSucceeded();
void onManifestDownloadSucceeded(QByteArray* responsePtr);
void onResolveModsSucceeded();
void onCreateInstanceSucceeded();
void onModDownloadSucceeded();
@ -84,8 +84,6 @@ class PackInstallTask final : public InstanceTask {
QList<int> m_fileIds;
std::unique_ptr<QByteArray> m_response;
Modpack m_pack;
QString m_versionName;
Version m_version;

37
launcher/modplatform/legacy_ftb/PackFetchTask.cpp
View file

@ -53,13 +53,18 @@ void PackFetchTask::fetch()
QUrl publicPacksUrl = QUrl(BuildConfig.LEGACY_FTB_CDN_BASE_URL + "static/modpacks.xml");
qDebug() << "Downloading public version info from" << publicPacksUrl.toString();
jobPtr->addNetAction(Net::ApiDownload::makeByteArray(publicPacksUrl, publicModpacksXmlFileData.get()));
auto [publicAction, publicResponse] = Net::ApiDownload::makeByteArray(publicPacksUrl);
jobPtr->addNetAction(publicAction);
QUrl thirdPartyUrl = QUrl(BuildConfig.LEGACY_FTB_CDN_BASE_URL + "static/thirdparty.xml");
qDebug() << "Downloading thirdparty version info from" << thirdPartyUrl.toString();
jobPtr->addNetAction(Net::Download::makeByteArray(thirdPartyUrl, thirdPartyModpacksXmlFileData.get()));
connect(jobPtr.get(), &NetJob::succeeded, this, &PackFetchTask::fileDownloadFinished);
auto [thirdPartyAction, thirdPartyResponse] = Net::Download::makeByteArray(thirdPartyUrl);
jobPtr->addNetAction(thirdPartyAction);
connect(jobPtr.get(), &NetJob::succeeded, this,
[this, publicResponse, thirdPartyResponse] { fileDownloadFinished(publicResponse, thirdPartyResponse); });
connect(jobPtr.get(), &NetJob::failed, this, &PackFetchTask::fileDownloadFailed);
connect(jobPtr.get(), &NetJob::aborted, this, &PackFetchTask::fileDownloadAborted);
@ -71,9 +76,10 @@ void PackFetchTask::fetchPrivate(const QStringList& toFetch)
QString privatePackBaseUrl = BuildConfig.LEGACY_FTB_CDN_BASE_URL + "static/%1.xml";
for (auto& packCode : toFetch) {
auto data = std::make_shared<QByteArray>();
NetJob* job = new NetJob("Fetching private pack", m_network);
job->addNetAction(Net::ApiDownload::makeByteArray(privatePackBaseUrl.arg(packCode), data.get()));
auto [action, data] = Net::ApiDownload::makeByteArray(privatePackBaseUrl.arg(packCode));
job->addNetAction(action);
job->setAskRetry(false);
connect(job, &NetJob::succeeded, this, [this, job, data, packCode] {
@ -85,20 +91,15 @@ void PackFetchTask::fetchPrivate(const QStringList& toFetch)
}
job->deleteLater();
data->clear();
});
connect(job, &NetJob::failed, this, [this, job, packCode, data](QString reason) {
connect(job, &NetJob::failed, this, [this, job, packCode](QString reason) {
emit privateFileDownloadFailed(reason, packCode);
job->deleteLater();
data->clear();
});
connect(job, &NetJob::aborted, this, [this, job, data] {
connect(job, &NetJob::aborted, this, [this, job] {
job->deleteLater();
data->clear();
emit aborted();
});
@ -107,20 +108,21 @@ void PackFetchTask::fetchPrivate(const QStringList& toFetch)
}
}
void PackFetchTask::fileDownloadFinished()
void PackFetchTask::fileDownloadFinished(QByteArray* publicPtr, QByteArray* thirdPartyPtr)
{
jobPtr.reset();
QStringList failedLists;
if (!parseAndAddPacks(*publicModpacksXmlFileData, PackType::Public, publicPacks)) {
if (!parseAndAddPacks(*publicPtr, PackType::Public, publicPacks)) {
failedLists.append(tr("Public Packs"));
}
if (!parseAndAddPacks(*thirdPartyModpacksXmlFileData, PackType::ThirdParty, thirdPartyPacks)) {
if (!parseAndAddPacks(*thirdPartyPtr, PackType::ThirdParty, thirdPartyPacks)) {
failedLists.append(tr("Third Party Packs"));
}
// NOTE(TheKodeToad): we don't want to reset the jobPtr earlier as it may invalidate the responses!
jobPtr.reset();
if (failedLists.size() > 0) {
emit failed(tr("Failed to download some pack lists: %1").arg(failedLists.join("\n- ")));
} else {
@ -139,7 +141,6 @@ bool PackFetchTask::parseAndAddPacks(QByteArray& data, PackType packType, Modpac
if (!doc.setContent(data, false, &errorMsg, &errorLine, &errorCol)) {
auto fullErrMsg = QString("Failed to fetch modpack data: %1 %2:%3!").arg(errorMsg).arg(errorLine).arg(errorCol);
qWarning() << fullErrMsg;
data.clear();
return false;
}

6
launcher/modplatform/legacy_ftb/PackFetchTask.h
View file

@ -3,7 +3,6 @@
#include <QByteArray>
#include <QObject>
#include <QTemporaryDir>
#include <memory>
#include "PackHelpers.h"
#include "net/NetJob.h"
@ -23,15 +22,12 @@ class PackFetchTask : public QObject {
QNetworkAccessManager* m_network;
NetJob::Ptr jobPtr;
std::unique_ptr<QByteArray> publicModpacksXmlFileData = std::make_unique<QByteArray>();
std::unique_ptr<QByteArray> thirdPartyModpacksXmlFileData = std::make_unique<QByteArray>();
bool parseAndAddPacks(QByteArray& data, PackType packType, ModpackList& list);
ModpackList publicPacks;
ModpackList thirdPartyPacks;
protected slots:
void fileDownloadFinished();
void fileDownloadFinished(QByteArray* publicResponse, QByteArray* thirdPartyResponse);
void fileDownloadFailed(QString reason);
void fileDownloadAborted();

69
launcher/modplatform/modrinth/ModrinthAPI.cpp
View file

@ -11,17 +11,18 @@
#include "net/NetJob.h"
#include "net/Upload.h"
Task::Ptr ModrinthAPI::currentVersion(QString hash, QString hash_format, QByteArray* response)
std::pair<Task::Ptr, QByteArray*> ModrinthAPI::currentVersion(QString hash, QString hash_format)
{
auto netJob = makeShared<NetJob>(QString("Modrinth::GetCurrentVersion"), APPLICATION->network());
netJob->addNetAction(Net::ApiDownload::makeByteArray(
QString(BuildConfig.MODRINTH_PROD_URL + "/version_file/%1?algorithm=%2").arg(hash, hash_format), response));
auto [action, response] =
Net::ApiDownload::makeByteArray(QString(BuildConfig.MODRINTH_PROD_URL + "/version_file/%1?algorithm=%2").arg(hash, hash_format));
netJob->addNetAction(action);
return netJob;
return { netJob, response };
}
Task::Ptr ModrinthAPI::currentVersions(const QStringList& hashes, QString hash_format, QByteArray* response)
std::pair<Task::Ptr, QByteArray*> ModrinthAPI::currentVersions(const QStringList& hashes, QString hash_format)
{
auto netJob = makeShared<NetJob>(QString("Modrinth::GetCurrentVersions"), APPLICATION->network());
@ -33,16 +34,16 @@ Task::Ptr ModrinthAPI::currentVersions(const QStringList& hashes, QString hash_f
QJsonDocument body(body_obj);
auto body_raw = body.toJson();
netJob->addNetAction(Net::ApiUpload::makeByteArray(QString(BuildConfig.MODRINTH_PROD_URL + "/version_files"), response, body_raw));
auto [action, response] = Net::ApiUpload::makeByteArray(QString(BuildConfig.MODRINTH_PROD_URL + "/version_files"), body_raw);
netJob->addNetAction(action);
netJob->setAskRetry(false);
return netJob;
return { netJob, response };
}
Task::Ptr ModrinthAPI::latestVersion(QString hash,
QString hash_format,
std::optional<std::vector<Version>> mcVersions,
std::optional<ModPlatform::ModLoaderTypes> loaders,
QByteArray* response)
std::pair<Task::Ptr, QByteArray*> ModrinthAPI::latestVersion(QString hash,
QString hash_format,
std::optional<std::vector<Version>> mcVersions,
std::optional<ModPlatform::ModLoaderTypes> loaders)
{
auto netJob = makeShared<NetJob>(QString("Modrinth::GetLatestVersion"), APPLICATION->network());
@ -62,17 +63,17 @@ Task::Ptr ModrinthAPI::latestVersion(QString hash,
QJsonDocument body(body_obj);
auto body_raw = body.toJson();
netJob->addNetAction(Net::ApiUpload::makeByteArray(
QString(BuildConfig.MODRINTH_PROD_URL + "/version_file/%1/update?algorithm=%2").arg(hash, hash_format), response, body_raw));
auto [action, response] = Net::ApiUpload::makeByteArray(
QString(BuildConfig.MODRINTH_PROD_URL + "/version_file/%1/update?algorithm=%2").arg(hash, hash_format), body_raw);
netJob->addNetAction(action);
return netJob;
return { netJob, response };
}
Task::Ptr ModrinthAPI::latestVersions(const QStringList& hashes,
QString hash_format,
std::optional<std::vector<Version>> mcVersions,
std::optional<ModPlatform::ModLoaderTypes> loaders,
QByteArray* response)
std::pair<Task::Ptr, QByteArray*> ModrinthAPI::latestVersions(const QStringList& hashes,
QString hash_format,
std::optional<std::vector<Version>> mcVersions,
std::optional<ModPlatform::ModLoaderTypes> loaders)
{
auto netJob = makeShared<NetJob>(QString("Modrinth::GetLatestVersions"), APPLICATION->network());
@ -94,21 +95,21 @@ Task::Ptr ModrinthAPI::latestVersions(const QStringList& hashes,
QJsonDocument body(body_obj);
auto body_raw = body.toJson();
auto [action, response] = Net::ApiUpload::makeByteArray(QString(BuildConfig.MODRINTH_PROD_URL + "/version_files/update"), body_raw);
netJob->addNetAction(action);
netJob->addNetAction(
Net::ApiUpload::makeByteArray(QString(BuildConfig.MODRINTH_PROD_URL + "/version_files/update"), response, body_raw));
return netJob;
return { netJob, response };
}
Task::Ptr ModrinthAPI::getProjects(QStringList addonIds, QByteArray* response) const
std::pair<Task::Ptr, QByteArray*> ModrinthAPI::getProjects(QStringList addonIds) const
{
auto netJob = makeShared<NetJob>(QString("Modrinth::GetProjects"), APPLICATION->network());
auto searchUrl = getMultipleModInfoURL(addonIds);
netJob->addNetAction(Net::ApiDownload::makeByteArray(QUrl(searchUrl), response));
auto [action, response] = Net::ApiDownload::makeByteArray(QUrl(searchUrl));
netJob->addNetAction(action);
return netJob;
return { netJob, response };
}
QList<ResourceAPI::SortingMethod> ModrinthAPI::getSortingMethods() const
@ -121,19 +122,21 @@ QList<ResourceAPI::SortingMethod> ModrinthAPI::getSortingMethods() const
{ 5, "updated", QObject::tr("Sort by Last Updated") } };
}
Task::Ptr ModrinthAPI::getModCategories(QByteArray* response)
std::pair<Task::Ptr, QByteArray*> ModrinthAPI::getModCategories()
{
auto netJob = makeShared<NetJob>(QString("Modrinth::GetCategories"), APPLICATION->network());
netJob->addNetAction(Net::ApiDownload::makeByteArray(QUrl(BuildConfig.MODRINTH_PROD_URL + "/tag/category"), response));
auto [action, response] = Net::ApiDownload::makeByteArray(QUrl(BuildConfig.MODRINTH_PROD_URL + "/tag/category"));
netJob->addNetAction(action);
QObject::connect(netJob.get(), &Task::failed, [](QString msg) { qDebug() << "Modrinth failed to get categories:" << msg; });
return netJob;
return { netJob, response };
}
QList<ModPlatform::Category> ModrinthAPI::loadCategories(QByteArray* response, QString projectType)
QList<ModPlatform::Category> ModrinthAPI::loadCategories(const QByteArray& response, QString projectType)
{
QList<ModPlatform::Category> categories;
QJsonParseError parse_error{};
QJsonDocument doc = QJsonDocument::fromJson(*response, &parse_error);
QJsonDocument doc = QJsonDocument::fromJson(response, &parse_error);
if (parse_error.error != QJsonParseError::NoError) {
qWarning() << "Error while parsing JSON response from categories at" << parse_error.offset
<< "reason:" << parse_error.errorString();
@ -159,7 +162,7 @@ QList<ModPlatform::Category> ModrinthAPI::loadCategories(QByteArray* response, Q
return categories;
}
QList<ModPlatform::Category> ModrinthAPI::loadModCategories(QByteArray* response)
QList<ModPlatform::Category> ModrinthAPI::loadModCategories(const QByteArray& response)
{
return loadCategories(response, "mod");
};

31
launcher/modplatform/modrinth/ModrinthAPI.h
View file

@ -11,30 +11,29 @@
#include "modplatform/modrinth/ModrinthPackIndex.h"
#include <QDebug>
#include <utility>
class ModrinthAPI : public ResourceAPI {
public:
Task::Ptr currentVersion(QString hash, QString hash_format, QByteArray* response);
std::pair<Task::Ptr, QByteArray*> currentVersion(QString hash, QString hash_format);
Task::Ptr currentVersions(const QStringList& hashes, QString hash_format, QByteArray* response);
std::pair<Task::Ptr, QByteArray*> currentVersions(const QStringList& hashes, QString hash_format);
Task::Ptr latestVersion(QString hash,
QString hash_format,
std::optional<std::vector<Version>> mcVersions,
std::optional<ModPlatform::ModLoaderTypes> loaders,
QByteArray* response);
std::pair<Task::Ptr, QByteArray*> latestVersion(QString hash,
QString hash_format,
std::optional<std::vector<Version>> mcVersions,
std::optional<ModPlatform::ModLoaderTypes> loaders);
Task::Ptr latestVersions(const QStringList& hashes,
QString hash_format,
std::optional<std::vector<Version>> mcVersions,
std::optional<ModPlatform::ModLoaderTypes> loaders,
QByteArray* response);
std::pair<Task::Ptr, QByteArray*> latestVersions(const QStringList& hashes,
QString hash_format,
std::optional<std::vector<Version>> mcVersions,
std::optional<ModPlatform::ModLoaderTypes> loaders);
Task::Ptr getProjects(QStringList addonIds, QByteArray* response) const override;
std::pair<Task::Ptr, QByteArray*> getProjects(QStringList addonIds) const override;
static Task::Ptr getModCategories(QByteArray* response);
static QList<ModPlatform::Category> loadCategories(QByteArray* response, QString projectType);
static QList<ModPlatform::Category> loadModCategories(QByteArray* response);
static std::pair<Task::Ptr, QByteArray*> getModCategories();
static QList<ModPlatform::Category> loadCategories(const QByteArray& response, QString projectType);
static QList<ModPlatform::Category> loadModCategories(const QByteArray& response);
public:
auto getSortingMethods() const -> QList<ResourceAPI::SortingMethod> override;

5
launcher/modplatform/modrinth/ModrinthCheckUpdate.cpp
View file

@ -88,7 +88,6 @@ void ModrinthCheckUpdate::getUpdateModsForLoader(std::optional<ModPlatform::ModL
setStatus(tr("Waiting for the API response from Modrinth..."));
setProgress(m_progress + 1, m_progressTotal);
auto response = std::make_shared<QByteArray>();
QStringList hashes;
if (forceModLoaderCheck && loader.has_value()) {
for (auto hash : m_mappings.keys()) {
@ -105,9 +104,9 @@ void ModrinthCheckUpdate::getUpdateModsForLoader(std::optional<ModPlatform::ModL
return;
}
auto job = api.latestVersions(hashes, m_hashType, m_gameVersions, loader, response.get());
auto [job, response] = api.latestVersions(hashes, m_hashType, m_gameVersions, loader);
connect(job.get(), &Task::succeeded, this, [this, response, loader] { checkVersionsResponse(response.get(), loader); });
connect(job.get(), &Task::succeeded, this, [this, response, loader] { checkVersionsResponse(response, loader); });
connect(job.get(), &Task::failed, this, &ModrinthCheckUpdate::checkNextLoader);

6
launcher/modplatform/modrinth/ModrinthPackExportTask.cpp
View file

@ -155,9 +155,9 @@ void ModrinthPackExportTask::makeApiRequest()
buildZip();
else {
setStatus(tr("Finding versions for hashes..."));
auto response = std::make_shared<QByteArray>();
task = api.currentVersions(pendingHashes.values(), "sha512", response.get());
connect(task.get(), &Task::succeeded, [this, response]() { parseApiResponse(response.get()); });
auto [versionsTask, response] = api.currentVersions(pendingHashes.values(), "sha512");
task = versionsTask;
connect(task.get(), &Task::succeeded, [this, response]() { parseApiResponse(response); });
connect(task.get(), &Task::failed, this, &ModrinthPackExportTask::emitFailed);
connect(task.get(), &Task::aborted, this, &ModrinthPackExportTask::emitAborted);
task->start();

11
launcher/modplatform/technic/SolderPackInstallTask.cpp
View file

@ -72,24 +72,25 @@ void Technic::SolderPackInstallTask::executeTask()
m_filesNetJob.reset(new NetJob(tr("Resolving modpack files"), m_network));
auto sourceUrl = QString("%1/modpack/%2/%3").arg(m_solderUrl.toString(), m_pack, m_version);
m_filesNetJob->addNetAction(Net::ApiDownload::makeByteArray(sourceUrl, m_response.get()));
auto [action, response] = Net::ApiDownload::makeByteArray(sourceUrl);
m_filesNetJob->addNetAction(action);
auto job = m_filesNetJob.get();
connect(job, &NetJob::succeeded, this, &Technic::SolderPackInstallTask::fileListSucceeded);
connect(job, &NetJob::succeeded, this, [this, response] { fileListSucceeded(response); });
connect(job, &NetJob::failed, this, &Technic::SolderPackInstallTask::downloadFailed);
connect(job, &NetJob::aborted, this, &Technic::SolderPackInstallTask::downloadAborted);
m_filesNetJob->start();
}
void Technic::SolderPackInstallTask::fileListSucceeded()
void Technic::SolderPackInstallTask::fileListSucceeded(QByteArray* response)
{
setStatus(tr("Downloading modpack"));
QJsonParseError parse_error{};
QJsonDocument doc = QJsonDocument::fromJson(*m_response, &parse_error);
QJsonDocument doc = QJsonDocument::fromJson(*response, &parse_error);
if (parse_error.error != QJsonParseError::NoError) {
qWarning() << "Error while parsing JSON response from Solder at" << parse_error.offset << "reason:" << parse_error.errorString();
qWarning() << *m_response;
qWarning() << *response;
return;
}
auto obj = doc.object();

4
launcher/modplatform/technic/SolderPackInstallTask.h
View file

@ -40,7 +40,6 @@
#include <tasks/Task.h>
#include <QUrl>
#include <memory>
namespace Technic {
class SolderPackInstallTask : public InstanceTask {
@ -60,7 +59,7 @@ class SolderPackInstallTask : public InstanceTask {
virtual void executeTask() override;
private slots:
void fileListSucceeded();
void fileListSucceeded(QByteArray* response);
void downloadSucceeded();
void downloadFailed(QString reason);
void downloadProgressChanged(qint64 current, qint64 total);
@ -78,7 +77,6 @@ class SolderPackInstallTask : public InstanceTask {
QString m_pack;
QString m_version;
QString m_minecraftVersion;
std::unique_ptr<QByteArray> m_response = std::make_unique<QByteArray>();
QTemporaryDir m_outputDir;
int m_modCount;
QFuture<bool> m_extractFuture;