Started workin on stuff

Signed-off-by: Trial97 <alexandru.tripon97@gmail.com>

launcher/java/providers/AdoptiumJavaDownloader.cpp

@@ -0,0 +1,119 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2023 Trial97 <alexandru.tripon97@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/>.
+ */
+#include "java/providers/AdoptiumJavaDownloader.h"
+#include <quazip.h>
+#include <memory>
+#include "MMCZip.h"
+
+#include "Application.h"
+#include "net/NetJob.h"
+#include "tasks/Task.h"
+
+void AdoptiumJavaDownloader::executeTask()
+{
+    downloadJava();
+};
+
+QString AdoptiumJavaDownloader::getArch() const
+{
+    if (m_os_arch == "arm64")
+        return "aarch64";
+    if (m_os_arch.isEmpty())
+        return "x86";
+    return m_os_arch;
+}
+
+void AdoptiumJavaDownloader::downloadJava()
+{
+    // JRE found ! download the zip
+    setStatus(tr("Downloading Java from Adoptium"));
+
+    auto javaVersion = m_is_legacy ? QString("8") : QString("17");
+    auto azulOS = m_os_name == "osx" ? "mac" : m_os_name;
+    auto arch = getArch();
+    MetaEntryPtr entry = APPLICATION->metacache()->resolveEntry("java", "adoptiumJRE.zip");
+
+    auto download = makeShared<NetJob>(QString("JRE::DownloadJava"), APPLICATION->network());
+    download->addNetAction(Net::Download::makeCached(
+        QString("https://api.adoptium.net/v3/binary/latest/%1/ga/%2/%3/jre/hotspot/normal/eclipse").arg(javaVersion, azulOS, arch), entry));
+    auto fullPath = entry->getFullPath();
+
+    connect(download.get(), &NetJob::finished, [download, this] { disconnect(this, &Task::aborted, download.get(), &NetJob::abort); });
+    // connect(download.get(), &NetJob::aborted, [path] { APPLICATION->instances()->destroyStagingPath(path); });
+    connect(download.get(), &NetJob::progress, this, &AdoptiumJavaDownloader::progress);
+    connect(download.get(), &NetJob::failed, this, &AdoptiumJavaDownloader::emitFailed);
+    connect(this, &Task::aborted, download.get(), &NetJob::abort);
+    connect(download.get(), &NetJob::succeeded, [this, fullPath] {
+        // This should do all of the extracting and creating folders
+        extractJava(fullPath);
+    });
+    download->start();
+};
+
+void AdoptiumJavaDownloader::extractJava(QString input)
+{
+    setStatus(tr("Extracting java"));
+    auto zip = std::make_shared<QuaZip>(input);
+    auto files = zip->getFileNameList();
+    if (files.isEmpty()) {
+        emitFailed("Empty archive");
+        return;
+    }
+    auto zipTask = makeShared<MMCZip::ExtractZipTask>(input, m_final_path, files[0]);
+
+    auto progressStep = std::make_shared<TaskStepProgress>();
+    connect(zipTask.get(), &Task::finished, this, [this, progressStep] {
+        progressStep->state = TaskStepState::Succeeded;
+        stepProgress(*progressStep);
+    });
+
+    connect(this, &Task::aborted, zipTask.get(), &Task::abort);
+    connect(zipTask.get(), &Task::finished, [zipTask, this] { disconnect(this, &Task::aborted, zipTask.get(), &Task::abort); });
+
+    connect(zipTask.get(), &Task::succeeded, this, &AdoptiumJavaDownloader::emitSucceeded);
+    connect(zipTask.get(), &Task::aborted, this, &AdoptiumJavaDownloader::emitAborted);
+    connect(zipTask.get(), &Task::failed, this, [this, progressStep](QString reason) {
+        progressStep->state = TaskStepState::Failed;
+        stepProgress(*progressStep);
+        emitFailed(reason);
+    });
+    connect(zipTask.get(), &Task::stepProgress, this, &AdoptiumJavaDownloader::propagateStepProgress);
+
+    connect(zipTask.get(), &Task::progress, this, [this, progressStep](qint64 current, qint64 total) {
+        progressStep->update(current, total);
+        stepProgress(*progressStep);
+    });
+    connect(zipTask.get(), &Task::status, this, [this, progressStep](QString status) {
+        progressStep->status = status;
+        stepProgress(*progressStep);
+    });
+    zipTask->start();
+};
+
+static const QStringList supportedOs = {
+    "linux", "windows", "mac", "solaris", "aix", "alpine-linux",
+};
+
+static const QStringList supportedArch = {
+    "x64", "x86", "x32", "ppc64", "ppc64le", "s390x", "aarch64", "arm", "sparcv9", "riscv64",
+};
+
+bool AdoptiumJavaDownloader::isSupported() const
+{
+    return supportedOs.contains(m_os_name == "osx" ? "mac" : m_os_name) && supportedArch.contains(getArch());
+};

launcher/java/providers/AdoptiumJavaDownloader.h

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2023 Trial97 <alexandru.tripon97@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/>.
+ */
+
+#pragma once
+
+#include "java/providers/BasicJavaDownloader.h"
+
+class AdoptiumJavaDownloader : public BasicJavaDownloader {
+    Q_OBJECT
+   public:
+    void executeTask() override;
+
+    virtual QString name() const override { return "Adoptium"; };
+    virtual bool isSupported() const override;
+   private slots:
+    void downloadJava();
+    void extractJava(QString input);
+
+   private:
+    QString getArch() const;
+};

launcher/java/providers/AzulJavaDownloader.cpp

@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2023 Trial97 <alexandru.tripon97@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/>.
+ */
+#include "java/providers/AzulJavaDownloader.h"
+#include <qcontainerfwd.h>
+#include "MMCZip.h"
+
+#include "Application.h"
+#include "Json.h"
+#include "net/NetJob.h"
+#include "tasks/Task.h"
+
+void AzulJavaDownloader::executeTask()
+{
+    downloadJavaList();
+};
+
+void AzulJavaDownloader::downloadJavaList()
+{
+    setStatus(tr("Querying Azul meta"));
+
+    auto javaVersion = m_is_legacy ? QString("8.0") : QString("17.0");
+    auto azulOS = m_os_name == "osx" ? "macos" : m_os_name;
+    auto arch = getArch();
+    auto metaResponse = std::make_shared<QByteArray>();
+    auto downloadJob = makeShared<NetJob>(QString("JRE::QueryAzulMeta"), APPLICATION->network());
+    downloadJob->addNetAction(Net::Download::makeByteArray(QString("https://api.azul.com/metadata/v1/zulu/packages/?"
+                                                                   "java_version=%1"
+                                                                   "&os=%2"
+                                                                   "&arch=%3"
+                                                                   "&archive_type=zip"
+                                                                   "&java_package_type=jre"
+                                                                   "&support_term=lts"
+                                                                   "&latest=true"
+                                                                   "status=ga"
+                                                                   "&availability_types=CA"
+                                                                   "&page=1"
+                                                                   "&page_size=1")
+                                                               .arg(javaVersion, azulOS, arch),
+                                                           metaResponse));
+    connect(downloadJob.get(), &NetJob::finished,
+            [downloadJob, metaResponse, this] { disconnect(this, &Task::aborted, downloadJob.get(), &NetJob::abort); });
+    connect(this, &Task::aborted, downloadJob.get(), &NetJob::abort);
+    connect(downloadJob.get(), &NetJob::failed, this, &AzulJavaDownloader::emitFailed);
+    connect(downloadJob.get(), &NetJob::progress, this, &AzulJavaDownloader::progress);
+    connect(downloadJob.get(), &NetJob::succeeded, [metaResponse, this] {
+        QJsonParseError parse_error{};
+        QJsonDocument doc = QJsonDocument::fromJson(*metaResponse, &parse_error);
+        if (parse_error.error != QJsonParseError::NoError) {
+            qWarning() << "Error while parsing JSON response at " << parse_error.offset << " reason: " << parse_error.errorString();
+            qWarning() << *metaResponse;
+            return;
+        }
+        auto array = Json::ensureArray(doc.array());
+        if (!array.empty()) {
+            downloadJava(array);
+        } else {
+            emitFailed(tr("No suitable JRE found"));
+        }
+    });
+    downloadJob->start();
+};
+
+QString AzulJavaDownloader::getArch() const
+{
+    if (m_os_arch == "arm64")
+        return "aarch64";
+    if (m_os_arch == "arm")
+        return "aarch32";
+    if (m_os_arch.isEmpty())
+        return "x86";
+    return m_os_arch;
+}
+
+void AzulJavaDownloader::downloadJava(const QJsonArray& array)
+{
+    // JRE found ! download the zip
+    setStatus(tr("Downloading Java from Azul"));
+
+    MetaEntryPtr entry = APPLICATION->metacache()->resolveEntry("java", "azulJRE.zip");
+
+    auto downloadURL = QUrl(array[0].toObject()["url"].toString());
+    auto download = makeShared<NetJob>(QString("JRE::DownloadJava"), APPLICATION->network());
+    download->addNetAction(Net::Download::makeCached(downloadURL, entry));
+    auto fullPath = entry->getFullPath();
+
+    connect(download.get(), &NetJob::finished, [download, this] { disconnect(this, &Task::aborted, download.get(), &NetJob::abort); });
+    // connect(download.get(), &NetJob::aborted, [path] { APPLICATION->instances()->destroyStagingPath(path); });
+    connect(download.get(), &NetJob::progress, this, &AzulJavaDownloader::progress);
+    connect(download.get(), &NetJob::failed, this, &AzulJavaDownloader::emitFailed);
+    connect(this, &Task::aborted, download.get(), &NetJob::abort);
+    connect(download.get(), &NetJob::succeeded, [downloadURL, this, fullPath] {
+        // This should do all of the extracting and creating folders
+        extractJava(fullPath, downloadURL.fileName().chopped(4));
+    });
+    download->start();
+};
+
+void AzulJavaDownloader::extractJava(QString input, QString subdirectory)
+{
+    setStatus(tr("Extracting java"));
+    auto zipTask = makeShared<MMCZip::ExtractZipTask>(input, m_final_path, subdirectory);
+
+    auto progressStep = std::make_shared<TaskStepProgress>();
+    connect(zipTask.get(), &Task::finished, this, [this, progressStep] {
+        progressStep->state = TaskStepState::Succeeded;
+        stepProgress(*progressStep);
+    });
+
+    connect(this, &Task::aborted, zipTask.get(), &Task::abort);
+    connect(zipTask.get(), &Task::finished, [zipTask, this] { disconnect(this, &Task::aborted, zipTask.get(), &Task::abort); });
+
+    connect(zipTask.get(), &Task::succeeded, this, &AzulJavaDownloader::emitSucceeded);
+    connect(zipTask.get(), &Task::aborted, this, &AzulJavaDownloader::emitAborted);
+    connect(zipTask.get(), &Task::failed, this, [this, progressStep](QString reason) {
+        progressStep->state = TaskStepState::Failed;
+        stepProgress(*progressStep);
+        emitFailed(reason);
+    });
+    connect(zipTask.get(), &Task::stepProgress, this, &AzulJavaDownloader::propagateStepProgress);
+
+    connect(zipTask.get(), &Task::progress, this, [this, progressStep](qint64 current, qint64 total) {
+        progressStep->update(current, total);
+        stepProgress(*progressStep);
+    });
+    connect(zipTask.get(), &Task::status, this, [this, progressStep](QString status) {
+        progressStep->status = status;
+        stepProgress(*progressStep);
+    });
+    zipTask->start();
+};
+
+static const QStringList supportedOs = {
+    "macos", "linux", "windows", "linux-musl", "linux-glibc", "qnx", "solaris", "aix",
+};
+
+static const QStringList supportedArch = {
+    "x86",   "x64",   "amd64",   "i686",     "arm",   "aarch64", "aarch32", "aarch32sf", "aarch32hf",  "ppc",
+    "ppc64", "ppc32", "ppc32hf", "ppc32spe", "sparc", "sparc64", "sparc32", "sparcv9",   "sparcv9-64", "sparcv9-32",
+};
+
+bool AzulJavaDownloader::isSupported() const
+{
+    return supportedOs.contains(m_os_name == "osx" ? "macos" : m_os_name) && supportedArch.contains(getArch());
+};

launcher/java/providers/AzulJavaDownloader.h

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2023 Trial97 <alexandru.tripon97@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/>.
+ */
+
+#pragma once
+
+#include "java/providers/BasicJavaDownloader.h"
+
+class AzulJavaDownloader : public BasicJavaDownloader {
+    Q_OBJECT
+   public:
+    void executeTask() override;
+
+    virtual QString name() const override { return "Azul"; };
+    virtual bool isSupported() const override;
+   private slots:
+    void downloadJavaList();
+    void downloadJava(const QJsonArray& doc);
+    void extractJava(QString input, QString subdirectory);
+
+   private:
+    QString getArch() const;
+};

launcher/java/providers/BasicJavaDownloader.cpp

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2023 Trial97 <alexandru.tripon97@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/>.
+ */
+#include "java/providers/BasicJavaDownloader.h"
+
+#include "SysInfo.h"
+#include "tasks/Task.h"
+
+BasicJavaDownloader::BasicJavaDownloader(QString final_path, bool m_is_legacy, QObject* parent)
+    : Task(parent)
+    , m_os_name(SysInfo::currentSystem())
+    , m_os_arch(SysInfo::useQTForArch())
+    , m_final_path(final_path)
+    , m_is_legacy(m_is_legacy)
+{}

launcher/java/providers/BasicJavaDownloader.h

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2023 Trial97 <alexandru.tripon97@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/>.
+ */
+
+#pragma once
+
+#include "tasks/Task.h"
+
+class BasicJavaDownloader : public Task {
+    Q_OBJECT
+   public:
+    BasicJavaDownloader(QString final_path, bool m_is_legacy = false, QObject* parent = nullptr);
+    virtual ~BasicJavaDownloader() = default;
+
+    [[nodiscard]] bool canAbort() const override { return true; }
+
+    virtual QString name() const = 0;
+    virtual bool isSupported() const = 0;
+
+   protected:
+    QString m_os_name;
+    QString m_os_arch;
+    QString m_final_path;
+    bool m_is_legacy;
+
+    Task::Ptr m_current_task;
+};

launcher/java/providers/MojangJavaDownloader.cpp

@@ -0,0 +1,185 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2023 Trial97 <alexandru.tripon97@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/>.
+ */
+#include "java/providers/MojanglJavaDownloader.h"
+
+#include "Application.h"
+#include "FileSystem.h"
+#include "Json.h"
+#include "net/ChecksumValidator.h"
+#include "net/NetJob.h"
+
+struct File {
+    QString path;
+    QString url;
+    QByteArray hash;
+    bool isExec;
+};
+
+void MojangJavaDownloader::executeTask()
+{
+    downloadJavaList();
+};
+
+void MojangJavaDownloader::downloadJavaList()
+{
+    auto netJob = makeShared<NetJob>(QString("JRE::QueryVersions"), APPLICATION->network());
+    auto response = std::make_shared<QByteArray>();
+    setStatus(tr("Querying mojang meta"));
+    netJob->addNetAction(Net::Download::makeByteArray(
+        QUrl("https://piston-meta.mojang.com/v1/products/java-runtime/2ec0cc96c44e5a76b9c8b7c39df7210883d12871/all.json"), response));
+
+    connect(netJob.get(), &NetJob::finished, [netJob, this] {
+        // delete so that it's not called on a deleted job
+        // FIXME: is this needed? qt should handle this
+        disconnect(this, &Task::aborted, netJob.get(), &NetJob::abort);
+    });
+    connect(this, &Task::aborted, netJob.get(), &NetJob::abort);
+
+    connect(netJob.get(), &NetJob::progress, this, &MojangJavaDownloader::progress);
+    connect(netJob.get(), &NetJob::failed, this, &MojangJavaDownloader::emitFailed);
+    connect(netJob.get(), &NetJob::succeeded, [response, this, netJob] {
+        QJsonParseError parse_error{};
+        QJsonDocument doc = QJsonDocument::fromJson(*response, &parse_error);
+        if (parse_error.error != QJsonParseError::NoError) {
+            qWarning() << "Error while parsing JSON response at " << parse_error.offset << " reason: " << parse_error.errorString();
+            qWarning() << *response;
+            emitFailed(parse_error.errorString());
+            return;
+        }
+        auto versionArray = Json::ensureArray(Json::ensureObject(doc.object(), getOS()), m_is_legacy ? "jre-legacy" : "java-runtime-gamma");
+        if (!versionArray.empty()) {
+            parseManifest(versionArray);
+
+        } else {
+            // mojang does not have a JRE for us, so fail
+            emitFailed("No suitable JRE found");
+        }
+    });
+
+    netJob->start();
+};
+
+QString MojangJavaDownloader::getOS() const
+{
+    if (m_os_name == "windows") {
+        if (m_os_arch == "x86_64") {
+            return "windows-x64";
+        }
+        if (m_os_arch == "i386") {
+            return "windows-x86";
+        }
+        // Unknown, maybe arm, appending arch for downloader
+        return "windows-" + m_os_arch;
+    }
+    if (m_os_name == "osx") {
+        if (m_os_arch == "arm64") {
+            return "mac-os-arm64";
+        }
+        return "mac-os";
+    }
+    if (m_os_name == "linux") {
+        if (m_os_arch == "x86_64") {
+            return "linux";
+        }
+        // will work for i386, and arm(64)
+        return "linux-" + m_os_arch;
+    }
+    return {};
+}
+void MojangJavaDownloader::parseManifest(const QJsonArray& versionArray)
+{
+    setStatus(tr("Downloading Java from Mojang"));
+    auto url = Json::ensureString(Json::ensureObject(Json::ensureObject(versionArray[0]), "manifest"), "url");
+    auto download = makeShared<NetJob>(QString("JRE::DownloadJava"), APPLICATION->network());
+    auto files = std::make_shared<QByteArray>();
+
+    download->addNetAction(Net::Download::makeByteArray(QUrl(url), files));
+
+    connect(download.get(), &NetJob::finished, [download, this] { disconnect(this, &Task::aborted, download.get(), &NetJob::abort); });
+    connect(download.get(), &NetJob::progress, this, &MojangJavaDownloader::progress);
+    connect(download.get(), &NetJob::failed, this, &MojangJavaDownloader::emitFailed);
+    connect(this, &Task::aborted, download.get(), &NetJob::abort);
+
+    connect(download.get(), &NetJob::succeeded, [files, this] {
+        QJsonParseError parse_error{};
+        QJsonDocument doc = QJsonDocument::fromJson(*files, &parse_error);
+        if (parse_error.error != QJsonParseError::NoError) {
+            qWarning() << "Error while parsing JSON response at " << parse_error.offset << " reason: " << parse_error.errorString();
+            qWarning() << *files;
+            emitFailed(parse_error.errorString());
+            return;
+        }
+        downloadJava(doc);
+    });
+    download->start();
+};
+
+void MojangJavaDownloader::downloadJava(const QJsonDocument& doc)
+{
+    // valid json doc, begin making jre spot
+    FS::ensureFolderPathExists(m_final_path);
+    std::vector<File> toDownload;
+    auto list = Json::ensureObject(Json::ensureObject(doc.object()), "files");
+    for (const auto& paths : list.keys()) {
+        auto file = FS::PathCombine(m_final_path, paths);
+
+        const QJsonObject& meta = Json::ensureObject(list, paths);
+        auto type = Json::ensureString(meta, "type");
+        if (type == "directory") {
+            FS::ensureFolderPathExists(file);
+        } else if (type == "link") {
+            // this is linux only !
+            auto path = Json::ensureString(meta, "target");
+            if (!path.isEmpty()) {
+                auto target = FS::PathCombine(file, "../" + path);
+                QFile(target).link(file);
+            }
+        } else if (type == "file") {
+            // TODO download compressed version if it exists ?
+            auto raw = Json::ensureObject(Json::ensureObject(meta, "downloads"), "raw");
+            auto isExec = Json::ensureBoolean(meta, "executable", false);
+            auto url = Json::ensureString(raw, "url");
+            if (!url.isEmpty() && QUrl(url).isValid()) {
+                auto f = File{ file, url, QByteArray::fromHex(Json::ensureString(raw, "sha1").toLatin1()), isExec };
+                toDownload.push_back(f);
+            }
+        }
+    }
+    auto elementDownload = new NetJob("JRE::FileDownload", APPLICATION->network());
+    for (const auto& file : toDownload) {
+        auto dl = Net::Download::makeFile(file.url, file.path);
+        if (!file.hash.isEmpty()) {
+            dl->addValidator(new Net::ChecksumValidator(QCryptographicHash::Sha1, file.hash));
+        }
+        if (file.isExec) {
+            connect(dl.get(), &Net::Download::succeeded,
+                    [file] { QFile(file.path).setPermissions(QFile(file.path).permissions() | QFileDevice::Permissions(0x1111)); });
+        }
+        elementDownload->addNetAction(dl);
+    }
+    connect(elementDownload, &NetJob::finished, [elementDownload, this] {
+        disconnect(this, &Task::aborted, elementDownload, &NetJob::abort);
+        elementDownload->deleteLater();
+    });
+    connect(elementDownload, &NetJob::progress, this, &MojangJavaDownloader::progress);
+    connect(elementDownload, &NetJob::failed, this, &MojangJavaDownloader::emitFailed);
+
+    connect(this, &Task::aborted, elementDownload, &NetJob::abort);
+    connect(elementDownload, &NetJob::succeeded, [this] { emitSucceeded(); });
+    elementDownload->start();
+};

launcher/java/providers/MojanglJavaDownloader.h

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2023 Trial97 <alexandru.tripon97@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/>.
+ */
+
+#pragma once
+
+#include "java/providers/BasicJavaDownloader.h"
+
+class MojangJavaDownloader : public BasicJavaDownloader {
+    Q_OBJECT
+   public:
+    void executeTask() override;
+
+    virtual QString name() const override { return "Mojang"; };
+    virtual bool isSupported() const override { return !getOS().isEmpty(); };
+   private slots:
+    void downloadJavaList();
+    void parseManifest(const QJsonArray& versionArray);
+    void downloadJava(const QJsonDocument& doc);
+
+   private:
+    QString getOS() const;
+};