From b6d455a02bd338e9dc0faa09d4d8177ecd8d569a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Petr=20Mr=C3=A1zek?= Date: Sun, 10 Apr 2016 15:53:05 +0200 Subject: NOISSUE reorganize and document libraries --- .../minecraft/liteloader/LiteLoaderInstaller.cpp | 142 +++++++++++ .../minecraft/liteloader/LiteLoaderInstaller.h | 39 +++ .../minecraft/liteloader/LiteLoaderVersionList.cpp | 276 +++++++++++++++++++++ .../minecraft/liteloader/LiteLoaderVersionList.h | 119 +++++++++ 4 files changed, 576 insertions(+) create mode 100644 api/logic/minecraft/liteloader/LiteLoaderInstaller.cpp create mode 100644 api/logic/minecraft/liteloader/LiteLoaderInstaller.h create mode 100644 api/logic/minecraft/liteloader/LiteLoaderVersionList.cpp create mode 100644 api/logic/minecraft/liteloader/LiteLoaderVersionList.h (limited to 'api/logic/minecraft/liteloader') diff --git a/api/logic/minecraft/liteloader/LiteLoaderInstaller.cpp b/api/logic/minecraft/liteloader/LiteLoaderInstaller.cpp new file mode 100644 index 00000000..25297fa4 --- /dev/null +++ b/api/logic/minecraft/liteloader/LiteLoaderInstaller.cpp @@ -0,0 +1,142 @@ +/* Copyright 2013-2015 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 "LiteLoaderInstaller.h" + +#include +#include + +#include + +#include "minecraft/MinecraftProfile.h" +#include "minecraft/Library.h" +#include "minecraft/onesix/OneSixInstance.h" +#include +#include "minecraft/liteloader/LiteLoaderVersionList.h" +#include "Exception.h" + +LiteLoaderInstaller::LiteLoaderInstaller() : BaseInstaller() +{ +} + +void LiteLoaderInstaller::prepare(LiteLoaderVersionPtr version) +{ + m_version = version; +} +bool LiteLoaderInstaller::add(OneSixInstance *to) +{ + if (!BaseInstaller::add(to)) + { + return false; + } + + QJsonObject obj; + + obj.insert("mainClass", QString("net.minecraft.launchwrapper.Launch")); + obj.insert("+tweakers", QJsonArray::fromStringList(QStringList() << m_version->tweakClass)); + obj.insert("order", 10); + + QJsonArray libraries; + + for (auto Library : m_version->libraries) + { + libraries.append(OneSixVersionFormat::libraryToJson(Library.get())); + } + + // liteloader + { + Library liteloaderLib("com.mumfrey:liteloader:" + m_version->version); + liteloaderLib.setAbsoluteUrl(QString("http://dl.liteloader.com/versions/com/mumfrey/liteloader/%1/%2").arg(m_version->mcVersion, m_version->file)); + QJsonObject llLibObj = OneSixVersionFormat::libraryToJson(&liteloaderLib); + libraries.append(llLibObj); + } + + obj.insert("+libraries", libraries); + obj.insert("name", QString("LiteLoader")); + obj.insert("fileId", id()); + obj.insert("version", m_version->version); + obj.insert("mcVersion", to->intendedVersionId()); + + QFile file(filename(to->instanceRoot())); + if (!file.open(QFile::WriteOnly)) + { + qCritical() << "Error opening" << file.fileName() + << "for reading:" << file.errorString(); + return false; + } + file.write(QJsonDocument(obj).toJson()); + file.close(); + + return true; +} + +class LiteLoaderInstallTask : public Task +{ + Q_OBJECT +public: + LiteLoaderInstallTask(LiteLoaderInstaller *installer, OneSixInstance *instance, + BaseVersionPtr version, QObject *parent) + : Task(parent), m_installer(installer), m_instance(instance), m_version(version) + { + } + +protected: + void executeTask() override + { + LiteLoaderVersionPtr liteloaderVersion = + std::dynamic_pointer_cast(m_version); + if (!liteloaderVersion) + { + return; + } + m_installer->prepare(liteloaderVersion); + if (!m_installer->add(m_instance)) + { + emitFailed(tr("For reasons unknown, the LiteLoader installation failed. Check your " + "MultiMC log files for details.")); + } + else + { + try + { + m_instance->reloadProfile(); + emitSucceeded(); + } + catch (Exception &e) + { + emitFailed(e.cause()); + } + catch (...) + { + emitFailed( + tr("Failed to load the version description file for reasons unknown.")); + } + } + } + +private: + LiteLoaderInstaller *m_installer; + OneSixInstance *m_instance; + BaseVersionPtr m_version; +}; + +Task *LiteLoaderInstaller::createInstallTask(OneSixInstance *instance, + BaseVersionPtr version, + QObject *parent) +{ + return new LiteLoaderInstallTask(this, instance, version, parent); +} + +#include "LiteLoaderInstaller.moc" diff --git a/api/logic/minecraft/liteloader/LiteLoaderInstaller.h b/api/logic/minecraft/liteloader/LiteLoaderInstaller.h new file mode 100644 index 00000000..fe0aee3d --- /dev/null +++ b/api/logic/minecraft/liteloader/LiteLoaderInstaller.h @@ -0,0 +1,39 @@ +/* Copyright 2013-2015 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 +#include + +#include "BaseInstaller.h" +#include "LiteLoaderVersionList.h" + +#include "multimc_logic_export.h" + +class MULTIMC_LOGIC_EXPORT LiteLoaderInstaller : public BaseInstaller +{ +public: + LiteLoaderInstaller(); + + void prepare(LiteLoaderVersionPtr version); + bool add(OneSixInstance *to) override; + virtual QString id() const override { return "com.mumfrey.liteloader"; } + + Task *createInstallTask(OneSixInstance *instance, BaseVersionPtr version, QObject *parent) override; + +private: + LiteLoaderVersionPtr m_version; +}; diff --git a/api/logic/minecraft/liteloader/LiteLoaderVersionList.cpp b/api/logic/minecraft/liteloader/LiteLoaderVersionList.cpp new file mode 100644 index 00000000..b0c9736a --- /dev/null +++ b/api/logic/minecraft/liteloader/LiteLoaderVersionList.cpp @@ -0,0 +1,276 @@ +/* Copyright 2013-2015 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 "LiteLoaderVersionList.h" +#include +#include "Env.h" +#include "net/URLConstants.h" +#include "Exception.h" + +#include + +#include +#include +#include +#include +#include + +#include + +#include + +LiteLoaderVersionList::LiteLoaderVersionList(QObject *parent) : BaseVersionList(parent) +{ +} + +Task *LiteLoaderVersionList::getLoadTask() +{ + return new LLListLoadTask(this); +} + +bool LiteLoaderVersionList::isLoaded() +{ + return m_loaded; +} + +const BaseVersionPtr LiteLoaderVersionList::at(int i) const +{ + return m_vlist.at(i); +} + +int LiteLoaderVersionList::count() const +{ + return m_vlist.count(); +} + +static bool cmpVersions(BaseVersionPtr first, BaseVersionPtr second) +{ + auto left = std::dynamic_pointer_cast(first); + auto right = std::dynamic_pointer_cast(second); + return left->timestamp > right->timestamp; +} + +void LiteLoaderVersionList::sortVersions() +{ + beginResetModel(); + std::sort(m_vlist.begin(), m_vlist.end(), cmpVersions); + endResetModel(); +} + +QVariant LiteLoaderVersionList::data(const QModelIndex &index, int role) const +{ + if (!index.isValid()) + return QVariant(); + + if (index.row() > count()) + return QVariant(); + + auto version = std::dynamic_pointer_cast(m_vlist[index.row()]); + switch (role) + { + case VersionPointerRole: + return qVariantFromValue(m_vlist[index.row()]); + + case VersionRole: + return version->name(); + + case VersionIdRole: + return version->descriptor(); + + case ParentGameVersionRole: + return version->mcVersion; + + case RecommendedRole: + return version->isLatest; + + default: + return QVariant(); + } +} + +QList LiteLoaderVersionList::providesRoles() +{ + return {VersionPointerRole, VersionRole, VersionIdRole, ParentGameVersionRole, RecommendedRole}; +} + +BaseVersionPtr LiteLoaderVersionList::getLatestStable() const +{ + for (int i = 0; i < m_vlist.length(); i++) + { + auto ver = std::dynamic_pointer_cast(m_vlist.at(i)); + if (ver->isLatest) + { + return m_vlist.at(i); + } + } + return BaseVersionPtr(); +} + +void LiteLoaderVersionList::updateListData(QList versions) +{ + beginResetModel(); + m_vlist = versions; + m_loaded = true; + std::sort(m_vlist.begin(), m_vlist.end(), cmpVersions); + endResetModel(); +} + +LLListLoadTask::LLListLoadTask(LiteLoaderVersionList *vlist) +{ + m_list = vlist; +} + +LLListLoadTask::~LLListLoadTask() +{ +} + +void LLListLoadTask::executeTask() +{ + setStatus(tr("Loading LiteLoader version list...")); + auto job = new NetJob("Version index"); + // we do not care if the version is stale or not. + auto liteloaderEntry = ENV.metacache()->resolveEntry("liteloader", "versions.json"); + + // verify by poking the server. + liteloaderEntry->setStale(true); + + job->addNetAction(listDownload = CacheDownload::make(QUrl(URLConstants::LITELOADER_URL), + liteloaderEntry)); + + connect(listDownload.get(), SIGNAL(failed(int)), SLOT(listFailed())); + + listJob.reset(job); + connect(listJob.get(), SIGNAL(succeeded()), SLOT(listDownloaded())); + connect(listJob.get(), SIGNAL(progress(qint64, qint64)), SIGNAL(progress(qint64, qint64))); + listJob->start(); +} + +void LLListLoadTask::listFailed() +{ + emitFailed("Failed to load LiteLoader version list."); + return; +} + +void LLListLoadTask::listDownloaded() +{ + QByteArray data; + { + auto dlJob = listDownload; + auto filename = std::dynamic_pointer_cast(dlJob)->getTargetFilepath(); + QFile listFile(filename); + if (!listFile.open(QIODevice::ReadOnly)) + { + emitFailed("Failed to open the LiteLoader version list."); + return; + } + data = listFile.readAll(); + listFile.close(); + dlJob.reset(); + } + + QJsonParseError jsonError; + QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &jsonError); + + if (jsonError.error != QJsonParseError::NoError) + { + emitFailed("Error parsing version list JSON:" + jsonError.errorString()); + return; + } + + if (!jsonDoc.isObject()) + { + emitFailed("Error parsing version list JSON: jsonDoc is not an object"); + return; + } + + const QJsonObject root = jsonDoc.object(); + + // Now, get the array of versions. + if (!root.value("versions").isObject()) + { + emitFailed("Error parsing version list JSON: missing 'versions' object"); + return; + } + + auto meta = root.value("meta").toObject(); + QString description = meta.value("description").toString(tr("This is a lightweight loader for mods that don't change game mechanics.")); + QString defaultUrl = meta.value("url").toString("http://dl.liteloader.com"); + QString authors = meta.value("authors").toString("Mumfrey"); + auto versions = root.value("versions").toObject(); + + QList tempList; + for (auto vIt = versions.begin(); vIt != versions.end(); ++vIt) + { + const QString mcVersion = vIt.key(); + QString latest; + const QJsonObject artefacts = vIt.value() + .toObject() + .value("artefacts") + .toObject() + .value("com.mumfrey:liteloader") + .toObject(); + QList perMcVersionList; + for (auto aIt = artefacts.begin(); aIt != artefacts.end(); ++aIt) + { + const QString identifier = aIt.key(); + const QJsonObject artefact = aIt.value().toObject(); + if (identifier == "latest") + { + latest = artefact.value("version").toString(); + continue; + } + LiteLoaderVersionPtr version(new LiteLoaderVersion()); + version->version = artefact.value("version").toString(); + version->file = artefact.value("file").toString(); + version->mcVersion = mcVersion; + version->md5 = artefact.value("md5").toString(); + version->timestamp = artefact.value("timestamp").toString().toInt(); + version->tweakClass = artefact.value("tweakClass").toString(); + version->authors = authors; + version->description = description; + version->defaultUrl = defaultUrl; + const QJsonArray libs = artefact.value("libraries").toArray(); + for (auto lIt = libs.begin(); lIt != libs.end(); ++lIt) + { + auto libobject = (*lIt).toObject(); + try + { + auto lib = OneSixVersionFormat::libraryFromJson(libobject, "versions.json"); + // hack to make liteloader 1.7.10_00 work + if(lib->rawName() == GradleSpecifier("org.ow2.asm:asm-all:5.0.3")) + { + lib->setRepositoryURL("http://repo.maven.apache.org/maven2/"); + } + version->libraries.append(lib); + } + catch (Exception &e) + { + qCritical() << "Couldn't read JSON object:"; + continue; + } + } + perMcVersionList.append(version); + } + for (auto version : perMcVersionList) + { + auto v = std::dynamic_pointer_cast(version); + v->isLatest = v->version == latest; + } + tempList.append(perMcVersionList); + } + m_list->updateListData(tempList); + + emitSucceeded(); +} diff --git a/api/logic/minecraft/liteloader/LiteLoaderVersionList.h b/api/logic/minecraft/liteloader/LiteLoaderVersionList.h new file mode 100644 index 00000000..1dba4b6a --- /dev/null +++ b/api/logic/minecraft/liteloader/LiteLoaderVersionList.h @@ -0,0 +1,119 @@ +/* Copyright 2013-2015 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 + +#include +#include +#include "BaseVersion.h" +#include "BaseVersionList.h" +#include "tasks/Task.h" +#include "net/NetJob.h" +#include + +#include "multimc_logic_export.h" + +class LLListLoadTask; +class QNetworkReply; + +class LiteLoaderVersion : public BaseVersion +{ +public: + QString descriptor() override + { + if (isLatest) + { + return QObject::tr("Latest"); + } + return QString(); + } + QString typeString() const override + { + return mcVersion; + } + QString name() override + { + return version; + } + + // important info + QString version; + QString file; + QString mcVersion; + QString md5; + int timestamp; + bool isLatest; + QString tweakClass; + QList libraries; + + // meta + QString defaultUrl; + QString description; + QString authors; +}; +typedef std::shared_ptr LiteLoaderVersionPtr; + +class MULTIMC_LOGIC_EXPORT LiteLoaderVersionList : public BaseVersionList +{ + Q_OBJECT +public: + friend class LLListLoadTask; + + explicit LiteLoaderVersionList(QObject *parent = 0); + + virtual Task *getLoadTask(); + virtual bool isLoaded(); + virtual const BaseVersionPtr at(int i) const; + virtual int count() const; + virtual void sortVersions(); + virtual QVariant data ( const QModelIndex & index, int role = Qt::DisplayRole ) const; + virtual QList< ModelRoles > providesRoles(); + + virtual BaseVersionPtr getLatestStable() const; + +protected: + QList m_vlist; + + bool m_loaded = false; + +protected +slots: + virtual void updateListData(QList versions); +}; + +class LLListLoadTask : public Task +{ + Q_OBJECT + +public: + explicit LLListLoadTask(LiteLoaderVersionList *vlist); + ~LLListLoadTask(); + + virtual void executeTask(); + +protected +slots: + void listDownloaded(); + void listFailed(); + +protected: + NetJobPtr listJob; + CacheDownloadPtr listDownload; + LiteLoaderVersionList *m_list; +}; + +Q_DECLARE_METATYPE(LiteLoaderVersionPtr) -- cgit v1.2.3