diff options
Diffstat (limited to 'archived/projt-launcher/launcher/Application.cpp')
| -rw-r--r-- | archived/projt-launcher/launcher/Application.cpp | 2450 |
1 files changed, 2450 insertions, 0 deletions
diff --git a/archived/projt-launcher/launcher/Application.cpp b/archived/projt-launcher/launcher/Application.cpp new file mode 100644 index 0000000000..cb878e5bc0 --- /dev/null +++ b/archived/projt-launcher/launcher/Application.cpp @@ -0,0 +1,2450 @@ +// SPDX-License-Identifier: GPL-3.0-only AND Apache-2.0 +// SPDX-FileCopyrightText: 2026 Project Tick +// SPDX-FileContributor: Project Tick Team +/* + * ProjT Launcher - Minecraft Launcher + * Copyright (C) 2026 Project Tick + * + * 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, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + === Upstream License Block (Do Not Modify) ============================== + * + * Prism Launcher - Minecraft Launcher + * Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net> + * Copyright (C) 2022 Lenny McLennington <lenny@sneed.church> + * Copyright (C) 2022 Tayou <git@tayou.org> + * Copyright (C) 2023 TheKodeToad <TheKodeToad@proton.me> + * Copyright (C) 2023 Rachel Powers <508861+Ryex@users.noreply.github.com> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * This file incorporates work covered by the following copyright and + * permission notice: + * + * Copyright 2013-2021 MultiMC Contributors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + ======================================================================== */ + +#include "Application.h" +#include "BuildConfig.h" + +#include "DataMigrationTask.h" +#include "java/services/RuntimeCatalog.hpp" +#include "minecraft/BackupManager.h" +#include "net/PasteUpload.h" +#include "tasks/Task.h" +#include "tools/GenericProfiler.h" +#include "ui/InstanceWindow.h" +#include "ui/MainWindow.h" +#include "ui/ViewLogWindow.h" + +#include "ui/dialogs/ProgressDialog.h" +#include "ui/instanceview/AccessibleInstanceView.h" + +#include <QStatusBar> + +#include "ui/pages/BasePageProvider.h" +#include "ui/pages/global/APIPage.h" +#include "ui/pages/global/AccountListPage.h" +#include "ui/pages/global/AppearancePage.h" +#include "ui/pages/global/ExternalToolsPage.h" +#include "ui/pages/global/JavaPage.h" +#include "ui/pages/global/LanguagePage.h" +#include "ui/pages/global/LauncherPage.h" +#include "ui/pages/global/MinecraftPage.h" +#include "ui/pages/global/ProxyPage.h" + +#include "ui/setupwizard/AutoJavaWizardPage.h" +#include "ui/setupwizard/JavaWizardPage.h" +#include "ui/setupwizard/LanguageWizardPage.h" +#include "ui/setupwizard/LoginWizardPage.h" +#include "ui/setupwizard/PasteWizardPage.h" +#include "ui/setupwizard/SearchWizardPage.h" +#include "ui/setupwizard/SetupWizard.h" +#include "ui/setupwizard/ThemeWizardPage.h" + +#include "ui/dialogs/CustomMessageBox.h" + +#include "ui/pagedialog/PageDialog.h" + +#include "ui/themes/ThemeManager.h" + +#include "ApplicationMessage.h" + +#include <iostream> +#include <mutex> + +#include <QAccessible> +#include <QCommandLineParser> +#include <QDebug> +#include <QDir> +#include <QFileInfo> +#include <QFileOpenEvent> +#include <QIcon> +#include <QLibraryInfo> +#include <QList> +#include <QNetworkAccessManager> +#include <QProgressDialog> +#include <QStringList> +#include <QStringLiteral> +#include <QStyleFactory> +#include <QTranslator> +#include <QWindow> + +#include "InstanceList.h" +#include "MTPixmapCache.h" + +#include <minecraft/auth/AccountList.hpp> +#include "icons/IconList.hpp" +#include "net/HttpMetaCache.h" + +#include "java/services/RuntimeCatalog.hpp" + +#include "updater/ExternalUpdater.h" + +#include "tools/JProfiler.h" +#include "tools/JVisualVM.h" +#include "tools/MCEditTool.h" + +#include "settings/INISettingsObject.h" +#include "settings/Setting.h" + +#include "meta/Index.hpp" +#include "translations/TranslationsModel.h" + +#include <DesktopServices.h> +#include <FileSystem.h> +#include <LocalPeer.h> + +#include <stdlib.h> +#include <sys.h> +#include <QStringLiteral> +#include "SysInfo.h" + +#ifdef Q_OS_LINUX +#include <dlfcn.h> +#include "MangoHud.h" +#include "gamemode_client.h" +#endif + +#if defined(Q_OS_LINUX) +#include <sys/statvfs.h> +#endif + +#if defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD) +#include <sys/mount.h> +#include <sys/types.h> +#endif + +#if defined(Q_OS_MAC) +#if defined(SPARKLE_ENABLED) +#include "updater/MacSparkleUpdater.h" +#endif +#else +#include "updater/ProjTExternalUpdater.h" +#endif + +#if defined Q_OS_WIN32 +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#endif +#include <windows.h> +#include <QStyleHints> +#include "console/WindowsConsole.hpp" +#endif + +#include "console/Console.hpp" + +#define STRINGIFY(x) #x +#define TOSTRING(x) STRINGIFY(x) + +static const QLatin1String liveCheckFile("live.check"); + +PixmapCache* PixmapCache::s_instance = nullptr; + +static bool isANSIColorConsole; + +static QString defaultLogFormat = QStringLiteral("%{time process}" + " " + "%{if-debug}Debug:%{endif}" + "%{if-info}Info:%{endif}" + "%{if-warning}Warning:%{endif}" + "%{if-critical}Critical:%{endif}" + "%{if-fatal}Fatal:%{endif}" + " " + "%{if-category}[%{category}] %{endif}" + "%{message}" + " " + "(%{function}:%{line})"); + +#define ansi_reset "\x1b[0m" +#define ansi_bold "\x1b[1m" +#define ansi_reset_bold "\x1b[22m" +#define ansi_faint "\x1b[2m" +#define ansi_italic "\x1b[3m" +#define ansi_red_fg "\x1b[31m" +#define ansi_green_fg "\x1b[32m" +#define ansi_yellow_fg "\x1b[33m" +#define ansi_blue_fg "\x1b[34m" +#define ansi_purple_fg "\x1b[35m" +#define ansi_inverse "\x1b[7m" + +// clang-format off +static QString ansiLogFormat = QStringLiteral( + ansi_faint "%{time process}" ansi_reset + " " + "%{if-debug}" ansi_bold ansi_green_fg "D:" ansi_reset "%{endif}" + "%{if-info}" ansi_bold ansi_blue_fg "I:" ansi_reset "%{endif}" + "%{if-warning}" ansi_bold ansi_yellow_fg "W:" ansi_reset_bold "%{endif}" + "%{if-critical}" ansi_bold ansi_red_fg "C:" ansi_reset_bold "%{endif}" + "%{if-fatal}" ansi_bold ansi_inverse ansi_red_fg "F:" ansi_reset_bold "%{endif}" + " " + "%{if-category}" ansi_bold "[%{category}]" ansi_reset_bold " %{endif}" + "%{message}" + " " + ansi_reset ansi_faint "(%{function}:%{line})" ansi_reset +); +// clang-format on + +#undef ansi_inverse +#undef ansi_purple_fg +#undef ansi_blue_fg +#undef ansi_yellow_fg +#undef ansi_green_fg +#undef ansi_red_fg +#undef ansi_italic +#undef ansi_faint +#undef ansi_bold +#undef ansi_reset_bold +#undef ansi_reset + +/** This is used so that we can output to the log file in addition to the CLI. */ +void appDebugOutput(QtMsgType type, const QMessageLogContext& context, const QString& msg) +{ + static std::mutex loggerMutex; + const std::lock_guard<std::mutex> lock(loggerMutex); // synchronized, QFile logFile is not thread-safe + + if (isANSIColorConsole) + { + // ensure default is set for log file + qSetMessagePattern(defaultLogFormat); + } + + QString out = qFormatLogMessage(type, context, msg); + if (APPLICATION->logModel) + { + APPLICATION->logModel->append(MessageLevel::getLevel(type), out); + } + + out += QChar::LineFeed; + APPLICATION->logFile->write(out.toUtf8()); + APPLICATION->logFile->flush(); + + if (isANSIColorConsole) + { + // format ansi for console; + qSetMessagePattern(ansiLogFormat); + out = qFormatLogMessage(type, context, msg); + out += QChar::LineFeed; + } + + QTextStream(stderr) << out.toLocal8Bit(); + fflush(stderr); +} + +std::tuple<QDateTime, QString, QString, QString, QString> read_lock_File(const QString& path) +{ + auto contents = QString(FS::read(path)); + auto lines = contents.split('\n'); + + QDateTime timestamp; + QString from, to, target, data_path; + for (auto line : lines) + { + auto index = line.indexOf("="); + if (index < 0) + continue; + auto left = line.left(index); + auto right = line.mid(index + 1); + if (left.toLower() == "timestamp") + { + timestamp = QDateTime::fromString(right, Qt::ISODate); + } + else if (left.toLower() == "from") + { + from = right; + } + else if (left.toLower() == "to") + { + to = right; + } + else if (left.toLower() == "target") + { + target = right; + } + else if (left.toLower() == "data_path") + { + data_path = right; + } + } + return std::make_tuple(timestamp, from, to, target, data_path); +} + +Application::Application(int& argc, char** argv) : QApplication(argc, argv) +{ +#if defined Q_OS_WIN32 + // attach the parent console if stdout not already captured + if (projt::console::AttachWindowsConsole()) + { + consoleAttached = true; + if (auto err = projt::console::EnableAnsiSupport(); !err) + { + isANSIColorConsole = true; + } + else + { + std::cout << "Error setting up ansi console" << err.message() << std::endl; + } + } +#else + if (projt::console::isConsole()) + { + isANSIColorConsole = true; + } +#endif + + setOrganizationName(BuildConfig.LAUNCHER_NAME); + setOrganizationDomain(BuildConfig.LAUNCHER_DOMAIN); + setApplicationName(BuildConfig.LAUNCHER_NAME); + setApplicationDisplayName( + QString("%1 %2").arg(BuildConfig.LAUNCHER_DISPLAYNAME, BuildConfig.printableVersionString())); + setApplicationVersion(BuildConfig.printableVersionString() + "\n" + BuildConfig.GIT_COMMIT); + setDesktopFileName(BuildConfig.LAUNCHER_APPID); + m_startTime = QDateTime::currentDateTime(); + + // Don't quit on hiding the last window + this->setQuitOnLastWindowClosed(false); + this->setQuitLockEnabled(false); + + // Commandline parsing + QCommandLineParser parser; + parser.setApplicationDescription(BuildConfig.LAUNCHER_DISPLAYNAME); + + parser.addOptions( + { { { "d", "dir" }, "Use a custom path as application root (use '.' for current directory)", "directory" }, + { { "l", "launch" }, "Launch the specified instance (by instance ID)", "instance" }, + { { "s", "server" }, + "Join the specified server on launch (only valid in combination with --launch)", + "address" }, + { { "w", "world" }, "Join the specified world on launch (only valid in combination with --launch)", "world" }, + { { "a", "profile" }, + "Use the account specified by its profile name (only valid in combination with --launch)", + "profile" }, + { { "o", "offline" }, + "Launch offline, with given player name (only valid in combination with --launch)", + "offline" }, + { "alive", "Write a small '" + liveCheckFile + "' file after the launcher starts" }, + { { "I", "import" }, "Import instance or resource from specified local path or URL", "url" }, + { "show", "Opens the window for the specified instance (by instance ID)", "show" } }); + // Has to be positional for some OS to handle that properly + parser.addPositionalArgument("URL", + "Import the resource(s) at the given URL(s) (same as -I / --import)", + "[URL...]"); + + parser.addHelpOption(); + parser.addVersionOption(); + + parser.process(arguments()); + + m_instanceIdToLaunch = parser.value("launch"); + m_serverToJoin = parser.value("server"); + m_worldToJoin = parser.value("world"); + m_profileToUse = parser.value("profile"); + if (parser.isSet("offline")) + { + m_offline = true; + m_offlineName = parser.value("offline"); + } + m_liveCheck = parser.isSet("alive"); + + m_instanceIdToShowWindowOf = parser.value("show"); + + for (auto url : parser.values("import")) + { + m_urlsToImport.append(normalizeImportUrl(url)); + } + + // treat unspecified positional arguments as import urls + for (auto url : parser.positionalArguments()) + { + m_urlsToImport.append(normalizeImportUrl(url)); + } + + // error if --launch is missing with --server or --profile + if ((!m_serverToJoin.isEmpty() || !m_worldToJoin.isEmpty() || !m_profileToUse.isEmpty() || m_offline) + && m_instanceIdToLaunch.isEmpty()) + { + std::cerr << "--server, --profile and --offline can only be used in combination with --launch!" << std::endl; + m_status = Application::Failed; + return; + } + + QString origcwdPath = QDir::currentPath(); + QString binPath = applicationDirPath(); + + { + // Root path is used for updates and portable data +#if defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD) + QDir foo(FS::PathCombine(binPath, "..")); // typically portable-root or /usr + m_rootPath = foo.absolutePath(); +#elif defined(Q_OS_WIN32) + m_rootPath = binPath; +#elif defined(Q_OS_MAC) + QDir foo(FS::PathCombine(binPath, "../..")); + m_rootPath = foo.absolutePath(); + // on macOS, touch the root to force Finder to reload the .app metadata (and fix any icon change issues) + FS::updateTimestamp(m_rootPath); +#endif + } + + QString adjustedBy; + QString dataPath; + // change folder + QString dataDirEnv; + QString dirParam = parser.value("dir"); + if (!dirParam.isEmpty()) + { + // the dir param. it makes multimc data path point to whatever the user specified + // on command line + adjustedBy = "Command line"; + dataPath = dirParam; + } + else if (dataDirEnv = QProcessEnvironment::systemEnvironment().value( + QString("%1_DATA_DIR").arg(BuildConfig.LAUNCHER_NAME.toUpper())); + !dataDirEnv.isEmpty()) + { + adjustedBy = "System environment"; + dataPath = dataDirEnv; + } + else + { + QDir foo; + if (DesktopServices::isSnap()) + { + foo = QDir(qEnvironmentVariable("SNAP_USER_COMMON")); + } + else + { + foo = QDir(FS::PathCombine(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation), "..")); + } + + dataPath = foo.absolutePath(); + adjustedBy = "Persistent data path"; + +#ifndef Q_OS_MACOS + if (auto portableUserData = FS::PathCombine(m_rootPath, "UserData"); QDir(portableUserData).exists()) + { + dataPath = portableUserData; + adjustedBy = "Portable user data path"; + m_portable = true; + } + else if (QFile::exists(FS::PathCombine(m_rootPath, "portable.txt"))) + { + dataPath = m_rootPath; + adjustedBy = "Portable data path"; + m_portable = true; + } +#endif + } + + if (!FS::ensureFolderPathExists(dataPath)) + { + showFatalErrorMessage("The launcher data folder could not be created.", + QString("The launcher data folder could not be created.\n" + "\n" + "Make sure you have the right permissions to the launcher data folder and any " + "folder needed to access it.\n" + "(%1)\n" + "\n" + "The launcher cannot continue until you fix this problem.") + .arg(dataPath)); + return; + } + if (!QDir::setCurrent(dataPath)) + { + showFatalErrorMessage("The launcher data folder could not be opened.", + QString("The launcher data folder could not be opened.\n" + "\n" + "Make sure you have the right permissions to the launcher data folder.\n" + "(%1)\n" + "\n" + "The launcher cannot continue until you fix this problem.") + .arg(dataPath)); + return; + } + m_dataPath = dataPath; + + /* + * Establish the mechanism for communication with an already running ProjTLauncher that uses the same binary. + * If there is one, tell it what the user actually wanted to do and exit. + * We want to initialize this before logging to avoid messing with the log of a potential already running copy. + * + * Using binary path (applicationDirPath) instead of data path prevents update conflicts + * when multiple instances with different data directories share the same binary. + */ + auto appID = + ApplicationId::fromPathAndVersion(QCoreApplication::applicationDirPath(), BuildConfig.printableVersionString()); + { + m_peerInstance = new LocalPeer(this, appID); + connect(m_peerInstance, &LocalPeer::messageReceived, this, &Application::messageReceived); + if (m_peerInstance->isClient()) + { + bool sentMessage = false; + int timeout = 2000; + + if (m_instanceIdToLaunch.isEmpty()) + { + ApplicationMessage activate; + activate.command = "activate"; + sentMessage = m_peerInstance->sendMessage(activate.serialize(), timeout); + + if (!m_urlsToImport.isEmpty()) + { + for (auto url : m_urlsToImport) + { + ApplicationMessage import; + import.command = "import"; + import.args.insert("url", url.toString()); + sentMessage = m_peerInstance->sendMessage(import.serialize(), timeout); + } + } + } + else + { + ApplicationMessage launch; + launch.command = "launch"; + launch.args["id"] = m_instanceIdToLaunch; + + if (!m_serverToJoin.isEmpty()) + { + launch.args["server"] = m_serverToJoin; + } + else if (!m_worldToJoin.isEmpty()) + { + launch.args["world"] = m_worldToJoin; + } + if (!m_profileToUse.isEmpty()) + { + launch.args["profile"] = m_profileToUse; + } + if (m_offline) + { + launch.args["offline_enabled"] = "true"; + launch.args["offline_name"] = m_offlineName; + } + sentMessage = m_peerInstance->sendMessage(launch.serialize(), timeout); + } + if (sentMessage) + { + m_status = Application::Succeeded; + return; + } + else + { + std::cerr << "Unable to redirect command to already running instance\n"; + // C function not Qt function - event loop not started yet + ::exit(1); + } + } + } + + // init the logger + { + static const QString baseLogFile = BuildConfig.LAUNCHER_NAME + "-%0.log"; + static const QString logBase = FS::PathCombine("logs", baseLogFile); + if (FS::ensureFolderPathExists("logs")) + { // if this did not fail + for (auto i = 0; i <= 4; i++) + if (auto oldName = baseLogFile.arg(i); QFile::exists(oldName)) // do not pointlessly delete new files if + // the old ones are not there + FS::move(oldName, logBase.arg(i)); + } + + for (auto i = 4; i > 0; i--) + { + const QString source = logBase.arg(i - 1); + if (QFile::exists(source)) + { + FS::move(source, logBase.arg(i)); + } + } + + logFile = std::unique_ptr<QFile>(new QFile(logBase.arg(0))); + if (!logFile->open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate)) + { + showFatalErrorMessage("The launcher data folder is not writable!", + QString("The launcher couldn't create a log file - the data folder is not writable.\n" + "\n" + "Make sure you have write permissions to the data folder.\n" + "(%1)\n" + "\n" + "The launcher cannot continue until you fix this problem.") + .arg(dataPath)); + return; + } + qInstallMessageHandler(appDebugOutput); + qSetMessagePattern(defaultLogFormat); + + logModel.reset(new projt::launch::LaunchLogModel(this)); + + bool foundLoggingRules = false; + + auto logRulesFile = QStringLiteral("qtlogging.ini"); + auto logRulesPath = FS::PathCombine(dataPath, logRulesFile); + + qInfo() << "Testing" << logRulesPath << "..."; + foundLoggingRules = QFile::exists(logRulesPath); + + // search the dataPath() + // seach app data standard path + if (!foundLoggingRules && !isPortable() && dirParam.isEmpty() && dataDirEnv.isEmpty()) + { + logRulesPath = QStandardPaths::locate(QStandardPaths::AppDataLocation, FS::PathCombine("..", logRulesFile)); + if (!logRulesPath.isEmpty()) + { + qInfo() << "Found" << logRulesPath << "..."; + foundLoggingRules = true; + } + } + // seach root path + if (!foundLoggingRules) + { +#if defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD) + logRulesPath = FS::PathCombine(m_rootPath, "share", BuildConfig.LAUNCHER_NAME, logRulesFile); +#else + logRulesPath = FS::PathCombine(m_rootPath, logRulesFile); +#endif + qInfo() << "Testing" << logRulesPath << "..."; + foundLoggingRules = QFile::exists(logRulesPath); + } + + if (foundLoggingRules) + { + // load and set logging rules + qInfo() << "Loading logging rules from:" << logRulesPath; + QSettings loggingRules(logRulesPath, QSettings::IniFormat); + loggingRules.beginGroup("Rules"); + QStringList rule_names = loggingRules.childKeys(); + QStringList rules; + qInfo() << "Setting log rules:"; + for (auto rule_name : rule_names) + { + auto rule = QString("%1=%2").arg(rule_name).arg(loggingRules.value(rule_name).toString()); + rules.append(rule); + qInfo() << " " << rule; + } + auto rules_str = rules.join("\n"); + QLoggingCategory::setFilterRules(rules_str); + } + + qInfo() << "<> Log initialized."; + } + + { + bool migrated = false; + + if (!migrated) + migrated = handleDataMigration( + dataPath, + FS::PathCombine(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation), "../../PolyMC"), + "PolyMC", + "polymc.cfg"); + if (!migrated) + migrated = handleDataMigration( + dataPath, + FS::PathCombine(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation), "../../multimc"), + "MultiMC", + "multimc.cfg"); + } + + { + qInfo() << qPrintable(BuildConfig.LAUNCHER_DISPLAYNAME + ", " + + QString(BuildConfig.LAUNCHER_COPYRIGHT).replace("\n", ", ")); + qInfo() << "Version : " << BuildConfig.printableVersionString(); + qInfo() << "Platform : " << BuildConfig.BUILD_PLATFORM; + qInfo() << "Git commit : " << BuildConfig.GIT_COMMIT; + qInfo() << "Git refspec : " << BuildConfig.GIT_REFSPEC; + qInfo() << "Compiled for : " << BuildConfig.systemID(); + qInfo() << "Compiled by : " << BuildConfig.compilerID(); + qInfo() << "Build Artifact : " << BuildConfig.BUILD_ARTIFACT; + qInfo() << "Updates Enabled : " << (updaterEnabled() ? "Yes" : "No"); + if (adjustedBy.size()) + { + qInfo() << "Work dir before adjustment : " << origcwdPath; + qInfo() << "Work dir after adjustment : " << QDir::currentPath(); + qInfo() << "Adjusted by : " << adjustedBy; + } + else + { + qInfo() << "Work dir : " << QDir::currentPath(); + } + qInfo() << "Binary path : " << binPath; + qInfo() << "Application root path : " << m_rootPath; + if (!m_instanceIdToLaunch.isEmpty()) + { + qInfo() << "ID of instance to launch : " << m_instanceIdToLaunch; + } + if (!m_serverToJoin.isEmpty()) + { + qInfo() << "Address of server to join :" << m_serverToJoin; + } + else if (!m_worldToJoin.isEmpty()) + { + qInfo() << "Name of the world to join :" << m_worldToJoin; + } + qInfo() << "<> Paths set."; + } + + if (m_liveCheck) + { + QFile check(liveCheckFile); + if (check.open(QIODevice::WriteOnly | QIODevice::Truncate)) + { + auto payload = appID.toString().toUtf8(); + if (check.write(payload) == payload.size()) + { + check.close(); + } + else + { + qWarning() << "Could not write into" << liveCheckFile << "!"; + check.remove(); // also closes file! + } + } + else + { + qWarning() << "Could not open" << liveCheckFile << "for writing!"; + } + } + + // Initialize application settings + { + // Provide a fallback for migration from PolyMC + m_settings.reset(new INISettingsObject({ BuildConfig.LAUNCHER_CONFIGFILE, "polymc.cfg", "multimc.cfg" }, this)); + + // Theming + m_settings->registerSetting("IconTheme", QString()); + m_settings->registerSetting("ApplicationTheme", QString()); + m_settings->registerSetting("BackgroundCat", QString("kitteh")); + m_settings->registerSetting("HubSearchEngine", QString()); + + // Remembered state + m_settings->registerSetting("LastUsedGroupForNewInstance", QString()); + + m_settings->registerSetting("MenuBarInsteadOfToolBar", false); + + m_settings->registerSetting("NumberOfConcurrentTasks", 10); + m_settings->registerSetting("NumberOfConcurrentDownloads", 6); + m_settings->registerSetting("NumberOfManualRetries", 1); + m_settings->registerSetting("RequestTimeout", 60); + + QString defaultMonospace; + int defaultSize = 11; +#ifdef Q_OS_WIN32 + defaultMonospace = "Courier"; + defaultSize = 10; +#elif defined(Q_OS_MAC) + defaultMonospace = "Menlo"; +#else + defaultMonospace = "Monospace"; +#endif + + // resolve the font so the default actually matches + QFont consoleFont; + consoleFont.setFamily(defaultMonospace); + consoleFont.setStyleHint(QFont::Monospace); + consoleFont.setFixedPitch(true); + QFontInfo consoleFontInfo(consoleFont); + QString resolvedDefaultMonospace = consoleFontInfo.family(); + QFont resolvedFont(resolvedDefaultMonospace); + qDebug() << "Detected default console font:" << resolvedDefaultMonospace + << ", substitutions:" << resolvedFont.substitutions().join(','); + + m_settings->registerSetting("ConsoleFont", resolvedDefaultMonospace); + m_settings->registerSetting("ConsoleFontSize", defaultSize); + m_settings->registerSetting("ConsoleMaxLines", 100000); + m_settings->registerSetting("ConsoleOverflowStop", true); + + logModel->setMaxLines(getConsoleMaxLines(settings())); + logModel->setStopOnOverflow(shouldStopOnConsoleOverflow(settings())); + logModel->setOverflowMessage( + tr("Cannot display this log since the log length surpassed %1 lines.").arg(logModel->getMaxLines())); + + // Folders + m_settings->registerSetting("InstanceDir", "instances"); + m_settings->registerSetting({ "CentralModsDir", "ModsDir" }, "mods"); + m_settings->registerSetting("IconsDir", "icons"); + m_settings->registerSetting("DownloadsDir", QStandardPaths::writableLocation(QStandardPaths::DownloadLocation)); + m_settings->registerSetting("DownloadsDirWatchRecursive", false); + m_settings->registerSetting("MoveModsFromDownloadsDir", false); + m_settings->registerSetting("SkinsDir", "skins"); + m_settings->registerSetting("JavaDir", "java"); + + // Editors + m_settings->registerSetting("JsonEditor", QString()); + + // Language + m_settings->registerSetting("Language", QString()); + m_settings->registerSetting("UseSystemLocale", false); + + // Console + m_settings->registerSetting("ShowConsole", false); + m_settings->registerSetting("AutoCloseConsole", false); + m_settings->registerSetting("ShowConsoleOnError", true); + m_settings->registerSetting("LogPrePostOutput", true); + + // Window Size + m_settings->registerSetting({ "LaunchMaximized", "MCWindowMaximize" }, false); + m_settings->registerSetting({ "MinecraftWinWidth", "MCWindowWidth" }, 854); + m_settings->registerSetting({ "MinecraftWinHeight", "MCWindowHeight" }, 480); + + // Proxy Settings + m_settings->registerSetting("ProxyType", "None"); + m_settings->registerSetting({ "ProxyAddr", "ProxyHostName" }, "127.0.0.1"); + m_settings->registerSetting("ProxyPort", 8080); + m_settings->registerSetting({ "ProxyUser", "ProxyUsername" }, ""); + m_settings->registerSetting({ "ProxyPass", "ProxyPassword" }, ""); + + // Memory + m_settings->registerSetting({ "MinMemAlloc", "MinMemoryAlloc" }, 512); + m_settings->registerSetting({ "MaxMemAlloc", "MaxMemoryAlloc" }, SysInfo::defaultMaxJvmMem()); + m_settings->registerSetting("PermGen", 128); + // Java Settings + m_settings->registerSetting("JavaPath", ""); + m_settings->registerSetting("JavaSignature", ""); + m_settings->registerSetting("JavaArchitecture", ""); + m_settings->registerSetting("JavaRealArchitecture", ""); + m_settings->registerSetting("JavaVersion", ""); + m_settings->registerSetting("JavaVendor", ""); + m_settings->registerSetting("LastHostname", ""); + m_settings->registerSetting("JvmArgs", ""); + m_settings->registerSetting("IgnoreJavaCompatibility", false); + m_settings->registerSetting("IgnoreJavaWizard", false); + auto defaultEnableAutoJava = m_settings->get("JavaPath").toString().isEmpty(); + m_settings->registerSetting("AutomaticJavaSwitch", defaultEnableAutoJava); + m_settings->registerSetting("AutomaticJavaDownload", defaultEnableAutoJava); + m_settings->registerSetting("UserAskedAboutAutomaticJavaDownload", false); + + // Legacy settings + m_settings->registerSetting("OnlineFixes", false); + + // Native library workarounds + m_settings->registerSetting("UseNativeOpenAL", false); + m_settings->registerSetting("CustomOpenALPath", ""); + m_settings->registerSetting("UseNativeGLFW", false); + m_settings->registerSetting("CustomGLFWPath", ""); + + // Performance related options + m_settings->registerSetting("EnableFeralGamemode", false); + m_settings->registerSetting("EnableMangoHud", false); + m_settings->registerSetting("UseDiscreteGpu", false); + m_settings->registerSetting("UseZink", false); + + // Game time + m_settings->registerSetting("ShowGameTime", true); + m_settings->registerSetting("ShowGlobalGameTime", true); + m_settings->registerSetting("RecordGameTime", true); + m_settings->registerSetting("ShowGameTimeWithoutDays", false); + + // Minecraft mods + m_settings->registerSetting("ModMetadataDisabled", false); + m_settings->registerSetting("ModDependenciesDisabled", false); + m_settings->registerSetting("SkipModpackUpdatePrompt", false); + m_settings->registerSetting("ShowModIncompat", false); + + // Minecraft offline player name + m_settings->registerSetting("LastOfflinePlayerName", ""); + + // Backup settings + m_settings->registerSetting("AutoBackupBeforeLaunch", false); + + // Wrapper command for launch + m_settings->registerSetting("WrapperCommand", ""); + + // Custom Commands + m_settings->registerSetting({ "PreLaunchCommand", "PreLaunchCmd" }, ""); + m_settings->registerSetting({ "PostExitCommand", "PostExitCmd" }, ""); + + // The cat + m_settings->registerSetting("TheCat", false); + m_settings->registerSetting("CatOpacity", 100); + m_settings->registerSetting("CatFit", "fit"); + + m_settings->registerSetting("StatusBarVisible", true); + + m_settings->registerSetting("ToolbarsLocked", false); + + // Instance + m_settings->registerSetting("InstSortMode", "Name"); + m_settings->registerSetting("InstRenamingMode", "AskEverytime"); + m_settings->registerSetting("SelectedInstance", QString()); + + // Window state and geometry + m_settings->registerSetting("MainWindowState", ""); + m_settings->registerSetting("MainWindowGeometry", ""); + + m_settings->registerSetting("ConsoleWindowState", ""); + m_settings->registerSetting("ConsoleWindowGeometry", ""); + + m_settings->registerSetting("SettingsGeometry", ""); + + m_settings->registerSetting("PagedGeometry", ""); + + m_settings->registerSetting("NewInstanceGeometry", ""); + + m_settings->registerSetting("UpdateDialogGeometry", ""); + + m_settings->registerSetting("ModDownloadGeometry", ""); + m_settings->registerSetting("RPDownloadGeometry", ""); + m_settings->registerSetting("TPDownloadGeometry", ""); + m_settings->registerSetting("ShaderDownloadGeometry", ""); + m_settings->registerSetting("DataPackDownloadGeometry", ""); + + m_settings->registerSetting("NewsGeometry", ""); + + // data pack window + // in future, more pages may be added - so this name is chosen to avoid needing migration + m_settings->registerSetting("WorldManagementGeometry", ""); + + // Pastebin settings with automatic migration from legacy format + migratePastebinSettings(); + + { + // Meta URL + m_settings->registerSetting("MetaURLOverride", ""); + + QUrl metaUrl(m_settings->get("MetaURLOverride").toString()); + + // get rid of invalid meta urls + if (!metaUrl.isValid() || (metaUrl.scheme() != "http" && metaUrl.scheme() != "https")) + m_settings->reset("MetaURLOverride"); + + // Resource URL + m_settings->registerSetting("ResourceURL", ""); + QString resourceUrlStr = m_settings->get("ResourceURL").toString(); + if (!resourceUrlStr.isEmpty()) + { + QUrl resourceUrl(resourceUrlStr); + if (!resourceUrl.isValid() || (resourceUrl.scheme() != "http" && resourceUrl.scheme() != "https")) + m_settings->reset("ResourceURL"); + } + } + m_settings->registerSetting("CloseAfterLaunch", false); + m_settings->registerSetting("QuitAfterGameStop", false); + + m_settings->registerSetting("Env", "{}"); + + // Custom Microsoft Authentication Client ID + m_settings->registerSetting("MSAClientIDOverride", ""); + + // Custom Flame API Key + { + m_settings->registerSetting("CFKeyOverride", ""); + m_settings->registerSetting("FlameKeyOverride", ""); + + QString flameKey = m_settings->get("CFKeyOverride").toString(); + + if (!flameKey.isEmpty()) + m_settings->set("FlameKeyOverride", flameKey); + m_settings->reset("CFKeyOverride"); + } + m_settings->registerSetting("ModrinthToken", ""); + m_settings->registerSetting("FallbackMRBlockedMods", true); + m_settings->registerSetting("UserAgentOverride", ""); + + // FTBApp instances + m_settings->registerSetting("FTBAppInstancesPath", ""); + + // Custom Technic Client ID + m_settings->registerSetting("TechnicClientID", ""); + + // Init page provider + { + m_globalSettingsProvider = std::make_shared<GenericPageProvider>(tr("Settings")); + m_globalSettingsProvider->addPage<LauncherPage>(); + m_globalSettingsProvider->addPage<LanguagePage>(); + m_globalSettingsProvider->addPage<AppearancePage>(); + m_globalSettingsProvider->addPage<MinecraftPage>(); + m_globalSettingsProvider->addPage<JavaPage>(); + m_globalSettingsProvider->addPage<AccountListPage>(); + m_globalSettingsProvider->addPage<APIPage>(); + m_globalSettingsProvider->addPage<ExternalToolsPage>(); + m_globalSettingsProvider->addPage<ProxyPage>(); + } + + PixmapCache::setInstance(new PixmapCache(this)); + + qInfo() << "<> Settings loaded."; + } + +#ifndef QT_NO_ACCESSIBILITY + QAccessible::installFactory(groupViewAccessibleFactory); +#endif /* !QT_NO_ACCESSIBILITY */ + + // initialize network access and proxy setup + { + m_network.reset(new QNetworkAccessManager()); + QString proxyTypeStr = settings()->get("ProxyType").toString(); + QString addr = settings()->get("ProxyAddr").toString(); + int port = settings()->get("ProxyPort").value<qint16>(); + QString user = settings()->get("ProxyUser").toString(); + QString pass = settings()->get("ProxyPass").toString(); + updateProxySettings(proxyTypeStr, addr, port, user, pass); + qInfo() << "<> Network done."; + } + + // load translations + { + m_translations.reset(new TranslationsModel("translations")); + auto bcp47Name = m_settings->get("Language").toString(); + m_translations->selectLanguage(bcp47Name); + qInfo() << "Your language is" << bcp47Name; + qInfo() << "<> Translations loaded."; + } + + // Instance icons + { + auto setting = APPLICATION->settings()->getSetting("IconsDir"); + QStringList instFolders = { ":/icons/multimc/32x32/instances/", + ":/icons/multimc/50x50/instances/", + ":/icons/multimc/128x128/instances/", + ":/icons/multimc/scalable/instances/" }; + m_icons.reset(new projt::icons::IconList(instFolders, setting->get().toString())); + connect(setting.get(), + &Setting::SettingChanged, + [this](const Setting&, QVariant value) { m_icons->directoryChanged(value.toString()); }); + qInfo() << "<> Instance icons initialized."; + } + + // Themes + m_themeManager = std::make_unique<ThemeManager>(); + + // initialize and load all instances + { + auto InstDirSetting = m_settings->getSetting("InstanceDir"); + // instance path: check for problems with '!' in instance path and warn the user in the log + // and remember that we have to show him a dialog when the gui starts (if it does so) + QString instDir = InstDirSetting->get().toString(); + qInfo() << "Instance path : " << instDir; + if (FS::checkProblemticPathJava(QDir(instDir))) + { + qWarning() << "Your instance path contains \'!\' and this is known to cause java problems!"; + } + m_instances.reset(new InstanceList(m_settings, instDir, this)); + connect(InstDirSetting.get(), &Setting::SettingChanged, m_instances.get(), &InstanceList::on_InstFolderChanged); + qInfo() << "Loading Instances..."; + m_instances->loadList(); + qInfo() << "<> Instances loaded."; + } + + // and accounts + { + m_accounts.reset(new AccountList(this)); + qInfo() << "Loading accounts..."; + m_accounts->setListFilePath("accounts.json", true); + m_accounts->loadList(); + m_accounts->fillQueue(); + qInfo() << "<> Accounts loaded."; + } + + // init the http meta cache + { + m_metacache.reset(new HttpMetaCache("metacache")); + m_metacache->addBase("asset_indexes", QDir("assets/indexes").absolutePath()); + m_metacache->addBase("libraries", QDir("libraries").absolutePath()); + m_metacache->addBase("fmllibs", QDir("mods/minecraftforge/libs").absolutePath()); + m_metacache->addBase("general", QDir("cache").absolutePath()); + m_metacache->addBase("ATLauncherPacks", QDir("cache/ATLauncherPacks").absolutePath()); + m_metacache->addBase("FTBPacks", QDir("cache/FTBPacks").absolutePath()); + m_metacache->addBase("TechnicPacks", QDir("cache/TechnicPacks").absolutePath()); + m_metacache->addBase("FlamePacks", QDir("cache/FlamePacks").absolutePath()); + m_metacache->addBase("FlameMods", QDir("cache/FlameMods").absolutePath()); + m_metacache->addBase("ModrinthPacks", QDir("cache/ModrinthPacks").absolutePath()); + m_metacache->addBase("ModrinthModpacks", QDir("cache/ModrinthModpacks").absolutePath()); + m_metacache->addBase("translations", QDir("translations").absolutePath()); + m_metacache->addBase("meta", QDir("meta").absolutePath()); + m_metacache->addBase("java", QDir("cache/java").absolutePath()); + m_metacache->Load(); + qInfo() << "<> Cache initialized."; + } + + // now we have network, download translation updates + m_translations->downloadIndex(); + + // Register Java profiler integrations + m_profilers.insert("jprofiler", std::shared_ptr<BaseProfilerFactory>(new JProfilerFactory())); + m_profilers.insert("jvisualvm", std::shared_ptr<BaseProfilerFactory>(new JVisualVMFactory())); + m_profilers.insert("generic", std::shared_ptr<BaseProfilerFactory>(new GenericProfilerFactory())); + for (auto profiler : m_profilers.values()) + { + profiler->registerSettings(m_settings); + } + + // Create the MCEdit thing... why is this here? + { + m_mcedit.reset(new MCEditTool(m_settings)); + } + +#ifdef Q_OS_MACOS + connect(this, &Application::clickedOnDock, [this]() { this->showMainWindow(); }); +#endif + + connect(this, + &Application::aboutToQuit, + [this]() + { + if (m_instances) + { + // save any remaining instance state + m_instances->saveNow(); + } + if (logFile) + { + logFile->flush(); + logFile->close(); + } + }); + + updateCapabilities(); + + detectLibraries(); + + // check update locks + { + auto update_log_path = FS::PathCombine(m_dataPath, "logs", "prism_launcher_update.log"); + + auto update_lock = QFileInfo(FS::PathCombine(m_dataPath, ".prism_launcher_update.lock")); + if (update_lock.exists()) + { + auto [timestamp, from, to, target, data_path] = read_lock_File(update_lock.absoluteFilePath()); + auto infoMsg = tr("This installation has a update lock file present at: %1\n" + "\n" + "Timestamp: %2\n" + "Updating from version %3 to %4\n" + "Target install path: %5\n" + "Data Path: %6" + "\n" + "This likely means that a update attempt failed. Please ensure your installation is in " + "working order before " + "proceeding.\n" + "Check the Prism Launcher updater log at: \n" + "%7\n" + "for details on the last update attempt.\n" + "\n" + "To delete this lock and proceed select \"Ignore\" below.") + .arg(update_lock.absoluteFilePath()) + .arg(timestamp.toString(Qt::ISODate), from, to, target, data_path) + .arg(update_log_path); + auto msgBox = QMessageBox(QMessageBox::Warning, + tr("Update In Progress"), + infoMsg, + QMessageBox::Ignore | QMessageBox::Abort); + msgBox.setDefaultButton(QMessageBox::Abort); + msgBox.setModal(true); + msgBox.setDetailedText(FS::read(update_log_path)); + msgBox.setMinimumWidth(460); + msgBox.adjustSize(); + auto res = msgBox.exec(); + switch (res) + { + case QMessageBox::Ignore: + { + FS::deletePath(update_lock.absoluteFilePath()); + break; + } + case QMessageBox::Abort: [[fallthrough]]; + default: + { + qDebug() << "Exiting because update lockfile is present"; + QMetaObject::invokeMethod(this, []() { exit(1); }, Qt::QueuedConnection); + return; + } + } + } + + auto update_fail_marker = QFileInfo(FS::PathCombine(m_dataPath, ".prism_launcher_update.fail")); + if (update_fail_marker.exists()) + { + auto infoMsg = tr("An update attempt failed\n" + "\n" + "Please ensure your installation is in working order before " + "proceeding.\n" + "Check the Prism Launcher updater log at: \n" + "%1\n" + "for details on the last update attempt.") + .arg(update_log_path); + auto msgBox = QMessageBox(QMessageBox::Warning, + tr("Update Failed"), + infoMsg, + QMessageBox::Ignore | QMessageBox::Abort); + msgBox.setDefaultButton(QMessageBox::Abort); + msgBox.setModal(true); + msgBox.setDetailedText(FS::read(update_log_path)); + msgBox.setMinimumWidth(460); + msgBox.adjustSize(); + auto res = msgBox.exec(); + switch (res) + { + case QMessageBox::Ignore: + { + FS::deletePath(update_fail_marker.absoluteFilePath()); + break; + } + case QMessageBox::Abort: [[fallthrough]]; + default: + { + qDebug() << "Exiting because update lockfile is present"; + QMetaObject::invokeMethod(this, []() { exit(1); }, Qt::QueuedConnection); + return; + } + } + } + + auto update_success_marker = QFileInfo(FS::PathCombine(m_dataPath, ".prism_launcher_update.success")); + if (update_success_marker.exists()) + { + auto infoMsg = tr("Update succeeded\n" + "\n" + "You are now running %1 .\n" + "Check the Prism Launcher updater log at: \n" + "%2\n" + "for details.") + .arg(BuildConfig.printableVersionString()) + .arg(update_log_path); + auto msgBox = new QMessageBox(QMessageBox::Information, tr("Update Succeeded"), infoMsg, QMessageBox::Ok); + msgBox->setDefaultButton(QMessageBox::Ok); + msgBox->setDetailedText(FS::read(update_log_path)); + msgBox->setAttribute(Qt::WA_DeleteOnClose); + msgBox->setMinimumWidth(460); + msgBox->adjustSize(); + msgBox->open(); + FS::deletePath(update_success_marker.absoluteFilePath()); + } + } + + // notify user if /tmp is mounted with `noexec` (#1693) + QString jvmArgs = m_settings->get("JvmArgs").toString(); + if (jvmArgs.indexOf("java.io.tmpdir") == -1) + { /* java.io.tmpdir is a valid workaround, so don't annoy */ + bool is_tmp_noexec = false; + +#if defined(Q_OS_LINUX) + + struct statvfs tmp_stat; + statvfs("/tmp", &tmp_stat); + is_tmp_noexec = tmp_stat.f_flag & ST_NOEXEC; + +#elif defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD) + + struct statfs tmp_stat; + statfs("/tmp", &tmp_stat); + is_tmp_noexec = tmp_stat.f_flags & MNT_NOEXEC; + +#endif + + if (is_tmp_noexec) + { + auto infoMsg = tr("Your /tmp directory is currently mounted with the 'noexec' flag enabled.\n" + "Some versions of Minecraft may not launch.\n" + "\n" + "You may solve this issue by remounting /tmp as 'exec' or setting " + "the java.io.tmpdir JVM argument to a writeable directory in a " + "filesystem where the 'exec' flag is set (e.g., /home/user/.local/tmp)\n"); + auto msgBox = new QMessageBox(QMessageBox::Information, + tr("Incompatible system configuration"), + infoMsg, + QMessageBox::Ok); + msgBox->setDefaultButton(QMessageBox::Ok); + msgBox->setAttribute(Qt::WA_DeleteOnClose); + msgBox->setMinimumWidth(460); + msgBox->adjustSize(); + msgBox->open(); + } + } + + if (createSetupWizard()) + { + return; + } + + m_themeManager->applyCurrentlySelectedTheme(true); + performMainStartupAction(); +} + +bool Application::createSetupWizard() +{ + bool javaRequired = [this]() + { + if (BuildConfig.JAVA_DOWNLOADER_ENABLED && settings()->get("AutomaticJavaDownload").toBool()) + { + return false; + } + bool ignoreJavaWizard = settings()->get("IgnoreJavaWizard").toBool(); + if (ignoreJavaWizard) + { + return false; + } + QString currentHostName = QHostInfo::localHostName(); + QString oldHostName = settings()->get("LastHostname").toString(); + if (currentHostName != oldHostName) + { + settings()->set("LastHostname", currentHostName); + return true; + } + QString currentJavaPath = settings()->get("JavaPath").toString(); + QString actualPath = FS::ResolveExecutable(currentJavaPath); + return actualPath.isNull(); + }(); + bool askjava = BuildConfig.JAVA_DOWNLOADER_ENABLED && !javaRequired + && !settings()->get("AutomaticJavaDownload").toBool() + && !settings()->get("AutomaticJavaSwitch").toBool() + && !settings()->get("UserAskedAboutAutomaticJavaDownload").toBool(); + bool languageRequired = settings()->get("Language").toString().isEmpty(); + bool pasteInterventionRequired = settings()->get("PastebinURL") != ""; + bool searchEngineRequired = settings()->get("HubSearchEngine").toString().isEmpty(); + bool validWidgets = m_themeManager->isValidApplicationTheme(settings()->get("ApplicationTheme").toString()); + bool validIcons = m_themeManager->isValidIconTheme(settings()->get("IconTheme").toString()); + bool login = !m_accounts->anyAccountIsValid() && capabilities() & Application::SupportsMSA; + bool themeInterventionRequired = !validWidgets || !validIcons; + bool wizardRequired = + javaRequired || languageRequired || pasteInterventionRequired || searchEngineRequired || themeInterventionRequired + || askjava || login; + if (wizardRequired) + { + // set default theme after going into theme wizard + if (!validIcons) + settings()->set("IconTheme", QString("pe_colored")); + if (!validWidgets) + { +#if defined(Q_OS_WIN32) && QT_VERSION >= QT_VERSION_CHECK(6, 5, 0) + const QString style = QGuiApplication::styleHints()->colorScheme() == Qt::ColorScheme::Dark + ? QStringLiteral("dark") + : QStringLiteral("bright"); +#else + const QString style = QStringLiteral("system"); +#endif + + settings()->set("ApplicationTheme", style); + } + + m_themeManager->applyCurrentlySelectedTheme(true); + + m_setupWizard = new SetupWizard(nullptr); + if (languageRequired) + { + m_setupWizard->addPage(new LanguageWizardPage(m_setupWizard)); + } + + if (javaRequired) + { + m_setupWizard->addPage(new JavaWizardPage(m_setupWizard)); + } + else if (askjava) + { + m_setupWizard->addPage(new AutoJavaWizardPage(m_setupWizard)); + } + + if (pasteInterventionRequired) + { + m_setupWizard->addPage(new PasteWizardPage(m_setupWizard)); + } + + if (searchEngineRequired) + { + m_setupWizard->addPage(new SearchWizardPage(m_setupWizard)); + } + + if (themeInterventionRequired) + { + m_setupWizard->addPage(new ThemeWizardPage(m_setupWizard)); + } + + if (login) + { + m_setupWizard->addPage(new LoginWizardPage(m_setupWizard)); + } + connect(m_setupWizard, &QDialog::finished, this, &Application::setupWizardFinished); + m_setupWizard->show(); + } + + return wizardRequired || login; +} + +bool Application::updaterEnabled() +{ +#if defined(Q_OS_MAC) + return BuildConfig.UPDATER_ENABLED; +#else + return BuildConfig.UPDATER_ENABLED && QFileInfo(FS::PathCombine(m_rootPath, updaterBinaryName())).isFile(); +#endif +} + +QString Application::updaterBinaryName() +{ + auto exe_name = QStringLiteral("%1_updater").arg(BuildConfig.LAUNCHER_APP_BINARY_NAME); +#if defined Q_OS_WIN32 + exe_name.append(".exe"); +#else + exe_name.prepend("bin/"); +#endif + return exe_name; +} + +bool Application::event(QEvent* event) +{ +#ifdef Q_OS_MACOS + if (event->type() == QEvent::ApplicationStateChange) + { + auto ev = static_cast<QApplicationStateChangeEvent*>(event); + + if (m_prevAppState == Qt::ApplicationActive && ev->applicationState() == Qt::ApplicationActive) + { + emit clickedOnDock(); + } + m_prevAppState = ev->applicationState(); + } +#endif + + if (event->type() == QEvent::FileOpen) + { + if (!m_mainWindow) + { + showMainWindow(false); + } + auto ev = static_cast<QFileOpenEvent*>(event); + m_mainWindow->processURLs({ ev->url() }); + } + + return QApplication::event(event); +} + +void Application::setupWizardFinished(int status) +{ + qDebug() << "Wizard result =" << status; + performMainStartupAction(); +} + +void Application::performMainStartupAction() +{ + m_status = Application::Initialized; + if (!m_instanceIdToLaunch.isEmpty()) + { + auto inst = instances()->getInstanceById(m_instanceIdToLaunch); + if (inst) + { + MinecraftTarget::Ptr targetToJoin = nullptr; + MinecraftAccountPtr accountToUse = nullptr; + + qDebug() << "<> Instance" << m_instanceIdToLaunch << "launching"; + if (!m_serverToJoin.isEmpty()) + { + auto parsedTarget = MinecraftTarget::parse(m_serverToJoin, false); + if (!parsedTarget.isValid()) + { + qWarning() << "Invalid server address:" << m_serverToJoin; + } + else + { + targetToJoin.reset(new MinecraftTarget(parsedTarget)); + qDebug() << " Launching with server" << m_serverToJoin; + } + } + else if (!m_worldToJoin.isEmpty()) + { + targetToJoin.reset(new MinecraftTarget(MinecraftTarget::parse(m_worldToJoin, true))); + qDebug() << " Launching with world" << m_worldToJoin; + } + + if (!m_profileToUse.isEmpty()) + { + accountToUse = accounts()->getAccountByProfileName(m_profileToUse); + if (!accountToUse) + { + return; + } + qDebug() << " Launching with account" << m_profileToUse; + } + + launch(inst, m_offline ? LaunchMode::Offline : LaunchMode::Normal, targetToJoin, accountToUse, m_offlineName); + return; + } + } + if (!m_instanceIdToShowWindowOf.isEmpty()) + { + auto inst = instances()->getInstanceById(m_instanceIdToShowWindowOf); + if (inst) + { + qDebug() << "<> Showing window of instance " << m_instanceIdToShowWindowOf; + showInstanceWindow(inst); + return; + } + } + if (!m_mainWindow) + { + // normal main window + showMainWindow(false); + qDebug() << "<> Main window shown."; + } + + // initialize the updater + if (updaterEnabled()) + { + qDebug() << "Initializing updater"; +#ifdef Q_OS_MAC +#if defined(SPARKLE_ENABLED) + m_updater.reset(new MacSparkleUpdater()); +#endif +#else + m_updater.reset(new ProjTExternalUpdater(m_mainWindow, m_rootPath, m_dataPath)); +#endif + qDebug() << "<> Updater started."; + } + + { // delete instances tmp dirctory + auto instDir = m_settings->get("InstanceDir").toString(); + const QString tempRoot = FS::PathCombine(instDir, ".tmp"); + FS::deletePath(tempRoot); + } + + if (!m_urlsToImport.isEmpty()) + { + qDebug() << "<> Importing from url:" << m_urlsToImport; + m_mainWindow->processURLs(m_urlsToImport); + } +} + +void Application::showFatalErrorMessage(const QString& title, const QString& content) +{ + m_status = Application::Failed; + auto dialog = CustomMessageBox::selectable(nullptr, title, content, QMessageBox::Critical); + dialog->exec(); +} + +Application::~Application() +{ + // Shut down logger by setting the logger function to nothing + qInstallMessageHandler(nullptr); + +#if defined Q_OS_WIN32 + // Detach from Windows console + if (consoleAttached) + { + fclose(stdout); + fclose(stdin); + fclose(stderr); + FreeConsole(); + } +#endif +} + +void Application::messageReceived(const QByteArray& message) +{ + ApplicationMessage received; + received.parse(message); + + auto& command = received.command; + + if (status() != Initialized) + { + bool isLoginAtempt = false; + if (command == "import") + { + QString url = received.args["url"]; + isLoginAtempt = !url.isEmpty() && normalizeImportUrl(url).scheme() == BuildConfig.LAUNCHER_APP_BINARY_NAME; + } + if (!isLoginAtempt) + { + qDebug() << "Received message" << message << "while still initializing. It will be ignored."; + return; + } + } + + if (command == "activate") + { + showMainWindow(); + } + else if (command == "import") + { + QString url = received.args["url"]; + if (url.isEmpty()) + { + qWarning() << "Received" << command << "message without a zip path/URL."; + return; + } + if (!m_mainWindow) + { + showMainWindow(false); + } + m_mainWindow->processURLs({ normalizeImportUrl(url) }); + } + else if (command == "launch") + { + QString id = received.args["id"]; + QString server = received.args["server"]; + QString world = received.args["world"]; + QString profile = received.args["profile"]; + bool offline = received.args["offline_enabled"] == "true"; + QString offlineName = received.args["offline_name"]; + + InstancePtr instance; + if (!id.isEmpty()) + { + instance = instances()->getInstanceById(id); + if (!instance) + { + qWarning() << "Launch command requires an valid instance ID. " << id << "resolves to nothing."; + return; + } + } + else + { + qWarning() << "Launch command called without an instance ID..."; + return; + } + + MinecraftTarget::Ptr serverObject = nullptr; + if (!server.isEmpty()) + { + serverObject = std::make_shared<MinecraftTarget>(MinecraftTarget::parse(server, false)); + } + else if (!world.isEmpty()) + { + serverObject = std::make_shared<MinecraftTarget>(MinecraftTarget::parse(world, true)); + } + MinecraftAccountPtr accountObject; + if (!profile.isEmpty()) + { + accountObject = accounts()->getAccountByProfileName(profile); + if (!accountObject) + { + qWarning() << "Launch command requires the specified profile to be valid. " << profile + << "does not resolve to any account."; + return; + } + } + + launch(instance, offline ? LaunchMode::Offline : LaunchMode::Normal, serverObject, accountObject, offlineName); + } + else + { + qWarning() << "Received invalid message" << message; + } +} + +std::shared_ptr<TranslationsModel> Application::translations() +{ + return m_translations; +} + +std::shared_ptr<projt::java::RuntimeCatalog> Application::runtimeCatalog() +{ + if (!m_runtimeCatalog) + { + m_runtimeCatalog.reset(new projt::java::RuntimeCatalog()); + } + return m_runtimeCatalog; +} + +QIcon Application::logo() +{ + return QIcon(":/" + BuildConfig.LAUNCHER_SVGFILENAME); +} + +bool Application::openJsonEditor(const QString& filename) +{ + const QString file = QDir::current().absoluteFilePath(filename); + if (m_settings->get("JsonEditor").toString().isEmpty()) + { + return DesktopServices::openUrl(QUrl::fromLocalFile(file)); + } + else + { + // return DesktopServices::openFile(m_settings->get("JsonEditor").toString(), file); + return DesktopServices::run(m_settings->get("JsonEditor").toString(), { file }); + } +} + +bool Application::launch(InstancePtr instance, + LaunchMode mode, + MinecraftTarget::Ptr targetToJoin, + MinecraftAccountPtr accountToUse, + const QString& offlineName) +{ + if (m_updateRunning) + { + qDebug() << "Cannot launch instances while an update is running. Please try again when updates are completed."; + } + else if (instance->canLaunch()) + { + // Auto-backup before launch if enabled + if (settings()->get("AutoBackupBeforeLaunch").toBool()) + { + qDebug() << "Creating auto-backup before launch..."; + + QProgressDialog* progress = + new QProgressDialog("Creating backup before launch...", QString(), 0, 0, m_mainWindow); + progress->setWindowModality(Qt::WindowModal); + progress->setMinimumDuration(0); + progress->setValue(0); + progress->setCancelButton(nullptr); + progress->show(); + QApplication::processEvents(); + + BackupManager* backupManager = new BackupManager(this); + connect(backupManager, + &BackupManager::backupCreated, + this, + [this, instance, mode, offlineName, progress, backupManager](const QString& instanceId, + const QString& backupName) + { + if (instanceId == instance->id()) + { + qDebug() << "Auto-backup before launch completed."; + progress->close(); + progress->deleteLater(); + backupManager->deleteLater(); + continueLaunchAfterBackup(instanceId, mode, offlineName); + } + }); + connect(backupManager, + &BackupManager::backupFailed, + this, + [progress, backupManager](const QString&, const QString& error) + { + qWarning() << "Auto-backup before launch failed:" << error; + progress->close(); + progress->deleteLater(); + backupManager->deleteLater(); + }); + BackupOptions options; + options.includeSaves = true; + options.includeConfig = true; + options.includeOptions = true; + options.includeMods = false; + backupManager->createBackupAsync(instance, "auto-backup-pre-launch", options); + // launch işlemini backup tamamlanınca başlatıyoruz, burada return ile çıkıyoruz + return true; + } + continueLaunchAfterBackup(instance->id(), mode, offlineName); + return true; + } + return false; +} + +void Application::continueLaunchAfterBackup(QString instanceId, LaunchMode mode, QString offlineName) +{ + InstancePtr instance = instances()->getInstanceById(instanceId); + InstanceWindow* window = nullptr; + + if (instance->settings()->get("ShowConsole").toBool()) + { + window = showInstanceWindow(instance); + } + + // Get window from instance if not already set + if (!window) + { + window = instance->getInstanceWindow(); + } + if (window) + { + if (!window->saveAll()) + { + return; + } + } + + // Create and configure launch controller + auto controller = makeShared<LaunchController>(); + controller->setInstance(instance); + controller->setLaunchMode(mode); + controller->setProfiler(profilers().value(instance->settings()->get("Profiler").toString(), nullptr).get()); + controller->setOfflineName(offlineName); + if (window) + { + controller->setParentWidget(window); + } + else if (m_mainWindow) + { + controller->setParentWidget(m_mainWindow); + } + connect(controller.get(), &LaunchController::succeeded, this, &Application::controllerSucceeded); + connect(controller.get(), &LaunchController::failed, this, &Application::controllerFailed); + connect(controller.get(), &LaunchController::aborted, this, [this] { controllerFailed(tr("Aborted")); }); + + // Store controller in instance + instance->setLaunchController(controller); + controller->executeTask(); +} + +bool Application::kill(InstancePtr instance) +{ + if (!instance->isRunning()) + { + qWarning() << "Attempted to kill instance" << instance->id() << ", which isn't running."; + return false; + } + + // Get controller from instance + auto controller = instance->getLaunchController(); + if (controller) + { + return controller->abort(); + } + return true; +} + +void Application::closeCurrentWindow() +{ + if (focusWindow()) + focusWindow()->close(); +} + +void Application::addRunningInstance() +{ + m_runningInstances++; + if (m_runningInstances == 1) + { + emit updateAllowedChanged(false); + } +} + +void Application::subRunningInstance() +{ + if (m_runningInstances == 0) + { + qCritical() << "Something went really wrong and we now have less than 0 running instances... WTF"; + return; + } + m_runningInstances--; + if (m_runningInstances == 0) + { + emit updateAllowedChanged(true); + } +} + +bool Application::shouldExitNow() const +{ + return m_runningInstances == 0 && m_openWindows == 0; +} + +bool Application::updatesAreAllowed() +{ + return m_runningInstances == 0; +} + +void Application::updateIsRunning(bool running) +{ + m_updateRunning = running; +} + +void Application::controllerSucceeded() +{ + auto controller = qobject_cast<LaunchController*>(sender()); + if (!controller) + return; + auto instance = controller->instance(); + + // on success, do... + if (instance->settings()->get("AutoCloseConsole").toBool()) + { + auto window = instance->getInstanceWindow(); + if (window) + { + QMetaObject::invokeMethod(window, &QWidget::close, Qt::QueuedConnection); + } + } + + // Clear controller from instance + instance->setLaunchController(nullptr); + subRunningInstance(); + + // quit when there are no more windows. + if (shouldExitNow()) + { + m_status = Status::Succeeded; + exit(0); + } +} + +void Application::controllerFailed(const QString& error) +{ + Q_UNUSED(error); + auto controller = qobject_cast<LaunchController*>(sender()); + if (!controller) + return; + auto instance = controller->instance(); + + // on failure, do... nothing + // Clear controller from instance + instance->setLaunchController(nullptr); + subRunningInstance(); + + // quit when there are no more windows. + if (shouldExitNow()) + { + m_status = Status::Failed; + exit(1); + } +} + +void Application::ShowGlobalSettings(class QWidget* parent, QString open_page) +{ + if (!m_globalSettingsProvider) + { + return; + } + emit globalSettingsAboutToOpen(); + { + SettingsObject::Lock lock(APPLICATION->settings()); + PageDialog dlg(m_globalSettingsProvider.get(), open_page, parent); + connect(&dlg, &PageDialog::applied, this, &Application::globalSettingsApplied); + dlg.exec(); + } +} + +MainWindow* Application::showMainWindow(bool minimized) +{ + if (m_mainWindow) + { + m_mainWindow->setWindowState(m_mainWindow->windowState() & ~Qt::WindowMinimized); + m_mainWindow->raise(); + m_mainWindow->activateWindow(); + } + else + { + m_mainWindow = new MainWindow(); + m_mainWindow->restoreState( + QByteArray::fromBase64(APPLICATION->settings()->get("MainWindowState").toString().toUtf8())); + m_mainWindow->restoreGeometry( + QByteArray::fromBase64(APPLICATION->settings()->get("MainWindowGeometry").toString().toUtf8())); + + if (minimized) + { + m_mainWindow->showMinimized(); + } + else + { + m_mainWindow->show(); + } + + m_mainWindow->checkInstancePathForProblems(); + connect(this, &Application::updateAllowedChanged, m_mainWindow, &MainWindow::updatesAllowedChanged); + connect(m_mainWindow, &MainWindow::isClosing, this, &Application::on_windowClose); + m_openWindows++; + } + return m_mainWindow; +} + +ViewLogWindow* Application::showLogWindow() +{ + if (m_viewLogWindow) + { + m_viewLogWindow->setWindowState(m_viewLogWindow->windowState() & ~Qt::WindowMinimized); + m_viewLogWindow->raise(); + m_viewLogWindow->activateWindow(); + } + else + { + m_viewLogWindow = new ViewLogWindow(); + connect(m_viewLogWindow, &ViewLogWindow::isClosing, this, &Application::on_windowClose); + m_openWindows++; + } + return m_viewLogWindow; +} + +InstanceWindow* Application::showInstanceWindow(InstancePtr instance, QString page) +{ + if (!instance) + return nullptr; + + auto window = instance->getInstanceWindow(); + + if (window) + { +// If the window is minimized on macOS or Windows, activate and bring it up +#ifdef Q_OS_MACOS + if (window->isMinimized()) + { + window->setWindowState(window->windowState() & ~Qt::WindowMinimized); + } +#elif defined(Q_OS_WIN) + if (window->isMinimized()) + { + window->showNormal(); + } +#endif + + window->raise(); + window->activateWindow(); + } + else + { + window = new InstanceWindow(instance); + instance->setInstanceWindow(window); + m_openWindows++; + connect(window, &InstanceWindow::isClosing, this, &Application::on_windowClose); + } + + if (!page.isEmpty()) + { + window->selectPage(page); + } + + // Update controller parent if exists + auto controller = instance->getLaunchController(); + if (controller) + { + controller->setParentWidget(window); + } + return window; +} + +void Application::on_windowClose() +{ + m_openWindows--; + auto instWindow = qobject_cast<InstanceWindow*>(sender()); + if (instWindow) + { + // Get instance and clear window reference + auto instance = instances()->getInstanceById(instWindow->instanceId()); + if (instance) + { + instance->setInstanceWindow(nullptr); + + // Update controller parent if exists + auto controller = instance->getLaunchController(); + if (controller) + { + controller->setParentWidget(m_mainWindow); + } + } + } + auto mainWindow = qobject_cast<MainWindow*>(sender()); + if (mainWindow) + { + m_mainWindow = nullptr; + } + auto logWindow = qobject_cast<ViewLogWindow*>(sender()); + if (logWindow) + { + m_viewLogWindow = nullptr; + } + // quit when there are no more windows. + if (shouldExitNow()) + { + exit(0); + } +} + +void Application::updateProxySettings(QString proxyTypeStr, QString addr, int port, QString user, QString password) +{ + // Set the application proxy settings. + if (proxyTypeStr == "SOCKS5") + { + QNetworkProxy::setApplicationProxy(QNetworkProxy(QNetworkProxy::Socks5Proxy, addr, port, user, password)); + } + else if (proxyTypeStr == "HTTP") + { + QNetworkProxy::setApplicationProxy(QNetworkProxy(QNetworkProxy::HttpProxy, addr, port, user, password)); + } + else if (proxyTypeStr == "None") + { + // If we have no proxy set, set no proxy and return. + QNetworkProxy::setApplicationProxy(QNetworkProxy(QNetworkProxy::NoProxy)); + } + else + { + // If we have "Default" selected, set Qt to use the system proxy settings. + QNetworkProxyFactory::setUseSystemConfiguration(true); + } + + qDebug() << "Detecting proxy settings..."; + QNetworkProxy proxy = QNetworkProxy::applicationProxy(); + m_network->setProxy(proxy); + + QString proxyDesc; + if (proxy.type() == QNetworkProxy::NoProxy) + { + qDebug() << "Using no proxy is an option!"; + return; + } + switch (proxy.type()) + { + case QNetworkProxy::DefaultProxy: proxyDesc = "Default proxy: "; break; + case QNetworkProxy::Socks5Proxy: proxyDesc = "Socks5 proxy: "; break; + case QNetworkProxy::HttpProxy: proxyDesc = "HTTP proxy: "; break; + case QNetworkProxy::HttpCachingProxy: proxyDesc = "HTTP caching: "; break; + case QNetworkProxy::FtpCachingProxy: proxyDesc = "FTP caching: "; break; + default: proxyDesc = "DERP proxy: "; break; + } + proxyDesc += QString("%1:%2").arg(proxy.hostName()).arg(proxy.port()); + qDebug() << proxyDesc; +} + +shared_qobject_ptr<HttpMetaCache> Application::metacache() +{ + return m_metacache; +} + +shared_qobject_ptr<QNetworkAccessManager> Application::network() +{ + return m_network; +} + +shared_qobject_ptr<projt::meta::MetaIndex> Application::metadataIndex() +{ + if (!m_metadataIndex) + { + m_metadataIndex.reset(new projt::meta::MetaIndex()); + } + return m_metadataIndex; +} + +void Application::updateCapabilities() +{ + m_capabilities = None; + if (!getMSAClientID().isEmpty()) + m_capabilities |= SupportsMSA; + if (!getFlameAPIKey().isEmpty()) + m_capabilities |= SupportsFlame; + +#ifdef Q_OS_LINUX + if (gamemode_query_status() >= 0) + m_capabilities |= SupportsGameMode; + + if (!MangoHud::getLibraryString().isEmpty()) + m_capabilities |= SupportsMangoHud; +#endif +} + +void Application::detectLibraries() +{ +#ifdef Q_OS_LINUX + m_detectedGLFWPath = MangoHud::findLibrary(BuildConfig.GLFW_LIBRARY_NAME); + m_detectedOpenALPath = MangoHud::findLibrary(BuildConfig.OPENAL_LIBRARY_NAME); + qDebug() << "Detected native libraries:" << m_detectedGLFWPath << m_detectedOpenALPath; +#endif +} + +QString Application::getJarPath(QString jarFile) +{ + QStringList potentialPaths = { +#if defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD) + FS::PathCombine(m_rootPath, "share", BuildConfig.LAUNCHER_NAME), +#endif + FS::PathCombine(m_rootPath, "jars"), + FS::PathCombine(applicationDirPath(), "jars"), + FS::PathCombine(applicationDirPath(), "..", "jars") // from inside build dir, for debuging + }; + for (QString p : potentialPaths) + { + QString jarPath = FS::PathCombine(p, jarFile); + if (QFileInfo(jarPath).isFile()) + return jarPath; + } + return {}; +} + +QString Application::getMSAClientID() +{ + QString clientIDOverride = m_settings->get("MSAClientIDOverride").toString(); + if (!clientIDOverride.isEmpty()) + { + return clientIDOverride; + } + + return BuildConfig.MSA_CLIENT_ID; +} + +QString Application::getFlameAPIKey() +{ + QString keyOverride = m_settings->get("FlameKeyOverride").toString(); + if (!keyOverride.isEmpty()) + { + return keyOverride; + } + + return BuildConfig.FLAME_API_KEY; +} + +QString Application::getModrinthAPIToken() +{ + QString tokenOverride = m_settings->get("ModrinthToken").toString(); + if (!tokenOverride.isEmpty()) + return tokenOverride; + + return QString(); +} + +QString Application::getUserAgent() +{ + QString uaOverride = m_settings->get("UserAgentOverride").toString(); + if (!uaOverride.isEmpty()) + { + return uaOverride.replace("$LAUNCHER_VER", BuildConfig.printableVersionString()); + } + + return BuildConfig.USER_AGENT; +} + +bool Application::handleDataMigration(const QString& currentData, + const QString& oldData, + const QString& name, + const QString& configFile) const +{ + QString nomigratePath = FS::PathCombine(currentData, name + "_nomigrate.txt"); + QStringList configPaths = { FS::PathCombine(oldData, configFile), + FS::PathCombine(oldData, BuildConfig.LAUNCHER_CONFIGFILE) }; + + QLocale locale; + + // Is there a valid config at the old location? + bool configExists = false; + for (QString configPath : configPaths) + { + configExists |= QFileInfo::exists(configPath); + } + + if (!configExists || QFileInfo::exists(nomigratePath)) + { + qDebug() << "<> No migration needed from" << name; + return false; + } + + QString message; + bool currentExists = QFileInfo::exists(FS::PathCombine(currentData, BuildConfig.LAUNCHER_CONFIGFILE)); + + if (currentExists) + { + message = tr("Old data from %1 was found, but you already have existing data for %2. Sadly you will need to " + "migrate yourself. Do " + "you want to be reminded of the pending data migration next time you start %2?") + .arg(name, BuildConfig.LAUNCHER_DISPLAYNAME); + } + else + { + message = tr("It looks like you used %1 before. Do you want to migrate your data to the new location of %2?") + .arg(name, BuildConfig.LAUNCHER_DISPLAYNAME); + + QFileInfo logInfo(FS::PathCombine(oldData, name + "-0.log")); + if (logInfo.exists()) + { + QString lastModified = logInfo.lastModified().toString(locale.dateFormat()); + message = tr("It looks like you used %1 on %2 before. Do you want to migrate your data to the new location " + "of %3?") + .arg(name, lastModified, BuildConfig.LAUNCHER_DISPLAYNAME); + } + } + + QMessageBox::StandardButton askMoveDialogue = QMessageBox::question(nullptr, + BuildConfig.LAUNCHER_DISPLAYNAME, + message, + QMessageBox::Yes | QMessageBox::No, + QMessageBox::Yes); + + auto setDoNotMigrate = [&nomigratePath] + { + QFile file(nomigratePath); + if (!file.open(QIODevice::WriteOnly)) + { + qWarning() << "setDoNotMigrate failed; Failed to open file '" << file.fileName() << "' for writing!"; + } + }; + + // create no-migrate file if user doesn't want to migrate + if (askMoveDialogue != QMessageBox::Yes) + { + qDebug() << "<> Migration declined for" << name; + setDoNotMigrate(); + return currentExists; // cancel further migrations, if we already have a data directory + } + + if (!currentExists) + { + // Migrate! + using namespace Filters; + + QList<Filter> filters; + filters.append(equals(configFile)); + filters.append(equals(BuildConfig.LAUNCHER_CONFIGFILE)); // it's possible that we already used that directory + // before + filters.append(startsWith("logs/")); + filters.append(equals("accounts.json")); + filters.append(startsWith("accounts/")); + filters.append(startsWith("assets/")); + filters.append(startsWith("icons/")); + filters.append(startsWith("instances/")); + filters.append(startsWith("libraries/")); + filters.append(startsWith("mods/")); + filters.append(startsWith("themes/")); + + ProgressDialog diag; + DataMigrationTask task(oldData, currentData, any(std::move(filters))); + if (diag.execWithTask(task)) + { + qDebug() << "<> Migration succeeded"; + setDoNotMigrate(); + } + else + { + QString reason = task.failReason(); + QMessageBox::critical(nullptr, + BuildConfig.LAUNCHER_DISPLAYNAME, + tr("Migration failed! Reason: %1").arg(reason)); + } + } + else + { + qWarning() << "<> Migration was skipped, due to existing data"; + } + return true; +} + +void Application::triggerUpdateCheck() +{ + if (m_updater) + { + qDebug() << "Checking for updates."; + m_updater->setBetaAllowed(false); // There are no other channels than stable + m_updater->checkForUpdates(); + } + else + { + qDebug() << "Updater not available."; + } +} + +QUrl Application::normalizeImportUrl(QString const& url) +{ + auto local_file = QFileInfo(url); + if (local_file.exists()) + { + return QUrl::fromLocalFile(local_file.absoluteFilePath()); + } + else + { + return QUrl::fromUserInput(url); + } +} + +const QString Application::javaPath() +{ + return m_settings->get("JavaDir").toString(); +} + +void Application::addQSavePath(QString path) +{ + QMutexLocker locker(&m_qsaveResourcesMutex); + m_qsaveResources[path] = m_qsaveResources.value(path, 0) + 1; +} + +void Application::removeQSavePath(QString path) +{ + QMutexLocker locker(&m_qsaveResourcesMutex); + auto count = m_qsaveResources.value(path, 0) - 1; + if (count <= 0) + { + m_qsaveResources.remove(path); + } + else + { + m_qsaveResources[path] = count; + } +} + +bool Application::checkQSavePath(QString path) +{ + QMutexLocker locker(&m_qsaveResourcesMutex); + for (auto partialPath : m_qsaveResources.keys()) + { + if (path.startsWith(partialPath) && m_qsaveResources.value(partialPath, 0) > 0) + { + return true; + } + } + return false; +} + +void Application::migratePastebinSettings() +{ + m_settings->registerSetting("PastebinURL", ""); + m_settings->registerSetting("PastebinType", PasteUpload::PasteType::Mclogs); + m_settings->registerSetting("PastebinCustomAPIBase", ""); + m_settings->registerSetting("PastebinMigrationDone", false); + + // Skip if migration already completed + if (m_settings->get("PastebinMigrationDone").toBool()) + { + return; + } + + // Check if legacy URL exists + QString pastebinURL = m_settings->get("PastebinURL").toString(); + if (!pastebinURL.isEmpty()) + { + // Migrate from legacy 0x0.st URL to new format + bool userHadDefaultPastebin = pastebinURL == "https://0x0.st"; + if (!userHadDefaultPastebin) + { + m_settings->set("PastebinType", PasteUpload::PasteType::NullPointer); + m_settings->set("PastebinCustomAPIBase", pastebinURL); + } + m_settings->reset("PastebinURL"); + } + + // Validate PastebinType + bool ok; + int pasteType = m_settings->get("PastebinType").toInt(&ok); + if (!ok || !(PasteUpload::PasteType::First <= pasteType && pasteType <= PasteUpload::PasteType::Last)) + { + m_settings->reset("PastebinType"); + m_settings->reset("PastebinCustomAPIBase"); + } + + // Mark migration as complete + m_settings->set("PastebinMigrationDone", true); +} |