4 files changed, 525 insertions, 0 deletions
diff --git a/logic/liteloader/LiteLoaderInstaller.cpp b/logic/liteloader/LiteLoaderInstaller.cpp
new file mode 100644
index 00000000..ea1a4396
--- /dev/null
+++ b/logic/liteloader/LiteLoaderInstaller.cpp
@@ -0,0 +1,150 @@
+/* Copyright 2013 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 <QJsonArray>
+#include <QJsonDocument>
+
+#include "logger/QsLog.h"
+
+#include "logic/minecraft/InstanceVersion.h"
+#include "logic/minecraft/OneSixLibrary.h"
+#include "logic/OneSixInstance.h"
+#include "MultiMC.h"
+#include "logic/liteloader/LiteLoaderVersionList.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 libStr : m_version->libraries)
+	{
+		OneSixLibrary lib(libStr);
+		lib.finalize();
+		QJsonObject libObj = lib.toJson();
+		libObj.insert("insert", QString("prepend"));
+		libraries.append(libObj);
+	}
+
+	// liteloader
+	{
+		OneSixLibrary 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));
+		liteloaderLib.finalize();
+		QJsonObject llLibObj = liteloaderLib.toJson();
+		llLibObj.insert("insert", QString("prepend"));
+		llLibObj.insert("MMC-depend", QString("hard"));
+		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))
+	{
+		QLOG_ERROR() << "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<LiteLoaderVersion>(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->reloadVersion();
+				emitSucceeded();
+			}
+			catch (MMCError &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;
+};
+
+ProgressProvider *LiteLoaderInstaller::createInstallTask(OneSixInstance *instance,
+														 BaseVersionPtr version,
+														 QObject *parent)
+{
+	return new LiteLoaderInstallTask(this, instance, version, parent);
+}
+
+#include "LiteLoaderInstaller.moc"
diff --git a/logic/liteloader/LiteLoaderInstaller.h b/logic/liteloader/LiteLoaderInstaller.h
new file mode 100644
index 00000000..43ad6b83
--- /dev/null
+++ b/logic/liteloader/LiteLoaderInstaller.h
@@ -0,0 +1,40 @@
+/* Copyright 2013 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 <QString>
+#include <QMap>
+
+#include "logic/BaseInstaller.h"
+#include "logic/liteloader/LiteLoaderVersionList.h"
+
+class LiteLoaderInstaller : public BaseInstaller
+{
+public:
+	LiteLoaderInstaller();
+
+	void prepare(LiteLoaderVersionPtr version);
+	bool add(OneSixInstance *to) override;
+
+	ProgressProvider *createInstallTask(OneSixInstance *instance, BaseVersionPtr version, QObject *parent) override;
+
+private:
+	virtual QString id() const override
+	{
+		return "com.mumfrey.liteloader";
+	}
+	LiteLoaderVersionPtr m_version;
+};
diff --git a/logic/liteloader/LiteLoaderVersionList.cpp b/logic/liteloader/LiteLoaderVersionList.cpp
new file mode 100644
index 00000000..ef95eefd
--- /dev/null
+++ b/logic/liteloader/LiteLoaderVersionList.cpp
@@ -0,0 +1,223 @@
+/* Copyright 2013 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 "MultiMC.h"
+#include "logic/net/URLConstants.h"
+
+#include <QtXml>
+
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonArray>
+#include <QJsonValue>
+#include <QJsonParseError>
+
+#include <QtAlgorithms>
+
+#include <QtNetwork>
+
+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<LiteLoaderVersion>(first);
+	auto right = std::dynamic_pointer_cast<LiteLoaderVersion>(second);
+	return left->timestamp > right->timestamp;
+}
+
+void LiteLoaderVersionList::sort()
+{
+	beginResetModel();
+	qSort(m_vlist.begin(), m_vlist.end(), cmpVersions);
+	endResetModel();
+}
+
+BaseVersionPtr LiteLoaderVersionList::getLatestStable() const
+{
+	for (int i = 0; i < m_vlist.length(); i++)
+	{
+		auto ver = std::dynamic_pointer_cast<LiteLoaderVersion>(m_vlist.at(i));
+		if (ver->isLatest)
+		{
+			return m_vlist.at(i);
+		}
+	}
+	return BaseVersionPtr();
+}
+
+void LiteLoaderVersionList::updateListData(QList<BaseVersionPtr> versions)
+{
+	beginResetModel();
+	m_vlist = versions;
+	m_loaded = true;
+	qSort(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 = MMC->metacache()->resolveEntry("liteloader", "versions.json");
+
+	// verify by poking the server.
+	liteloaderEntry->stale = 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<CacheDownload>(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<BaseVersionPtr> 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<BaseVersionPtr> 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").toDouble();
+			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)
+			{
+				version->libraries.append((*lIt).toObject().value("name").toString());
+			}
+			perMcVersionList.append(version);
+		}
+		for (auto version : perMcVersionList)
+		{
+			auto v = std::dynamic_pointer_cast<LiteLoaderVersion>(version);
+			v->isLatest = v->version == latest;
+		}
+		tempList.append(perMcVersionList);
+	}
+	m_list->updateListData(tempList);
+
+	emitSucceeded();
+}
diff --git a/logic/liteloader/LiteLoaderVersionList.h b/logic/liteloader/LiteLoaderVersionList.h
new file mode 100644
index 00000000..0aecc3e1
--- /dev/null
+++ b/logic/liteloader/LiteLoaderVersionList.h
@@ -0,0 +1,112 @@
+/* Copyright 2013 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 <QObject>
+
+#include <QString>
+#include <QStringList>
+#include "logic/BaseVersion.h"
+#include "logic/BaseVersionList.h"
+#include "logic/tasks/Task.h"
+#include "logic/net/NetJob.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;
+	QStringList libraries;
+
+	// meta
+	QString defaultUrl;
+	QString description;
+	QString authors;
+};
+typedef std::shared_ptr<LiteLoaderVersion> LiteLoaderVersionPtr;
+
+class 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 sort();
+
+	virtual BaseVersionPtr getLatestStable() const;
+
+protected:
+	QList<BaseVersionPtr> m_vlist;
+
+	bool m_loaded = false;
+
+protected
+slots:
+	virtual void updateListData(QList<BaseVersionPtr> 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;
+};