application.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2016 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_CORE_APPLICATION_H
#define SWIFT_CORE_APPLICATION_H
 
#include <atomic>
#include <functional>
 
#include <QByteArray>
#include <QCommandLineOption>
#include <QCommandLineParser>
#include <QList>
#include <QNetworkAccessManager>
#include <QObject>
#include <QReadWriteLock>
#include <QScopedPointer>
#include <QString>
#include <QStringList>
 
#include "core/application/applicationsettings.h"
#include "core/corefacadeconfig.h"
#include "core/data/globalsetup.h"
#include "core/db/databasereaderconfig.h"
#include "core/githubpackagesreader.h"
#include "core/inputmanager.h"
#include "core/swiftcoreexport.h"
#include "core/webreaderflags.h"
#include "misc/applicationinfolist.h"
#include "misc/db/updateinfo.h"
#include "misc/identifiable.h"
#include "misc/network/networkutils.h"
#include "misc/network/url.h"
#include "misc/slot.h"
#include "misc/statusmessagelist.h"
 
class QHttpMultiPart;
class QNetworkReply;
class QNetworkRequest;
 
namespace swift::misc
{
    class CFileLogger;
    class CLogCategoryList;
    namespace shared_state
    {
        class CDataLinkDBus;
    }
} // namespace swift::misc
 
namespace swift::core
{
    class CCoreFacade;
    class CCookieManager;
    class CSetupReader;
    class CWebDataServices;
    class ISimulator;
    namespace context
    {
        class IContextApplication;
        class IContextAudio;
        class CContextAudioBase;
        class IContextNetwork;
        class IContextOwnAircraft;
        class IContextSimulator;
    } // namespace context
 
    class SWIFT_CORE_EXPORT CApplication : public QObject, public swift::misc::CIdentifiable
    {
        Q_OBJECT
 
    public:
        static CApplication *instance();
 
        static const QStringList &getLogCategories();
 
        explicit CApplication(swift::misc::CApplicationInfo::Application application, bool init = true);
 
        explicit CApplication(
            const QString &applicationName = executable(),
            swift::misc::CApplicationInfo::Application application = swift::misc::CApplicationInfo::Unknown,
            bool init = true);
 
        ~CApplication() override;
 
        static swift::misc::CApplicationInfoList getRunningApplications();
 
        static bool isApplicationRunning(swift::misc::CApplicationInfo::Application application);
 
        bool isAlreadyRunning() const;
 
        virtual void gracefulShutdown();
 
        bool isShuttingDown() const;
 
        bool isIncognito() const;
 
        void setIncognito(bool incognito);
 
        void toggleIncognito();
 
        const swift::misc::CApplicationInfo &getApplicationInfo() const { return m_applicationInfo; }
 
        const QString &getApplicationName() const { return m_applicationName; }
 
        const QString &getApplicationNameAndVersion() const;
 
        const QString &getApplicationNameVersionDetailed() const;
 
        data::CGlobalSetup getGlobalSetup() const;
 
        swift::misc::db::CUpdateInfo getUpdateInfo() const;
 
        void reloadUpdateInfo();
 
        swift::misc::db::CDistribution getOwnDistribution() const;
 
        const QString &versionStringDetailed() const;
 
        const QString &swiftVersionString() const;
 
        const char *swiftVersionChar();
 
        bool isDeveloperFlagSet() const { return m_devFlag; }
 
        QString getInfoString(const QString &separator) const;
 
        void restartApplication(const QStringList &newArguments = {}, const QStringList &removeArguments = {});
 
        int exec();
 
        static QString getTemporaryDirectory();
 
        static bool registerAsRunning();
 
        static bool unregisterAsRunning();
 
        static void exit(int retcode = EXIT_SUCCESS);
 
        static void processEventsFor(int milliseconds);
 
        static QStringList clearCaches();
 
        // ----------------------- settings -------------------------------
 
        bool hasUnsavedSettings() const;
 
        void saveSettingsOnShutdown(bool saveSettings);
 
        QStringList getUnsavedSettingsKeys() const;
 
        swift::misc::CStatusMessage saveSettingsByKey(const QStringList &keys);
 
        // ----------------------- cmd line args / parsing ----------------------------------------
 
        QStringList argumentsJoined(const QStringList &newArguments = {},
                                    const QStringList &removeArguments = {}) const;
 
        static QStringList arguments();
 
 
        bool addParserOption(const QCommandLineOption &option);
 
        bool addParserOptions(const QList<QCommandLineOption> &options);
 
        void addDBusAddressOption();
 
        QString getCmdDBusAddressValue() const;
 
        void addNetworkOptions();
 
        void addAudioOptions();
 
        bool skipSingleApplicationCheck() const;
 
        bool isParserOptionSet(const QString &option) const;
 
        bool isParserOptionSet(const QCommandLineOption &option) const;
 
        QString getParserValue(const QString &option) const;
 
        QString getParserValue(const QCommandLineOption &option) const;
 
        bool parseCommandLineArgsAndLoadSetup();
 
        virtual void cmdLineErrorMessage(const QString &text, const QString &informativeText) const;
 
        virtual void cmdLineErrorMessage(const swift::misc::CStatusMessageList &msgs) const;
 
 
        void simulateCrash();
 
        void simulateAssert();
 
        void enableCrashDumpUpload(bool enable);
 
        bool isSupportingCrashpad() const;
 
        // ----------------------- Input ----------------------------------------
 
        CInputManager *getInputManager() const { return m_inputManager; }
 
        // ----------------------- simulator ----------------------------------------
 
        QPointer<ISimulator> getISimulator() const;
 
        bool hasSimulator() const;
 
        // ----------------------- contexts ----------------------------------------
 
        swift::misc::shared_state::CDataLinkDBus *getDataLinkDBus();
 
 
        bool supportsContexts(bool ignoreShutdownTest = false) const;
 
        const CCoreFacadeConfig &getCoreFacadeConfig() const { return m_coreFacadeConfig; }
 
        swift::misc::CStatusMessageList initContextsAndStartCoreFacade(const CCoreFacadeConfig &coreConfig);
 
        swift::misc::CStatusMessageList startCoreFacadeWithoutContexts();
 
        swift::misc::CStatusMessageList
        initAndStartWebDataServices(CWebReaderFlags::WebReader webReader,
                                    const db::CDatabaseReaderConfigList &dbReaderConfig);
 
        CCoreFacade *getCoreFacade() { return m_coreFacade.data(); }
 
        bool isLocalContext() const;
 
        bool isDBusContext() const;
 
        const CCoreFacade *getCoreFacade() const { return m_coreFacade.data(); }
 
 
        const context::IContextNetwork *getIContextNetwork() const;
        const context::IContextAudio *getIContextAudio() const;
        const context::CContextAudioBase *getCContextAudioBase() const;
        const context::IContextApplication *getIContextApplication() const;
        const context::IContextOwnAircraft *getIContextOwnAircraft() const;
        const context::IContextSimulator *getIContextSimulator() const;
        context::IContextNetwork *getIContextNetwork();
        context::IContextAudio *getIContextAudio();
        context::CContextAudioBase *getCContextAudioBase();
        context::IContextApplication *getIContextApplication();
        context::IContextOwnAircraft *getIContextOwnAircraft();
        context::IContextSimulator *getIContextSimulator();
 
        // ----------------------- setup data ---------------------------------
 
        virtual bool hasMinimumMappingVersion() const;
 
        bool hasSetupReader() const;
 
        CSetupReader *getSetupReader() const;
 
        bool isSetupAvailable() const;
 
        swift::misc::network::CUrl getVatsimMetarUrl() const;
 
        swift::misc::network::CUrl getVatsimDataFileUrl() const;
 
        swift::misc::network::CUrl getVatsimServerFileUrl() const;
 
        swift::misc::network::CUrl getVatsimFsdHttpUrl() const;
 
        virtual bool start();
 
        // ------------------------- network -----------------------------------------------
 
 
        static constexpr int NoRedirects = -1; 
        static constexpr int NoLogRequestId = -1; 
        static constexpr int DefaultMaxRedirects = 2; 
 
        using CallbackSlot = swift::misc::CSlot<void(QNetworkReply *)>;
 
        using ProgressSlot = swift::misc::CSlot<void(int, qint64, qint64, const QUrl &)>;
 
        void deleteAllCookies();
 
        const QNetworkAccessManager *getNetworkAccessManager() const { return m_accessManager; }
 
        QNetworkAccessManager *getNetworkAccessManager() { return m_accessManager; }
 
        bool hasWebDataServices() const;
 
        CWebDataServices *getWebDataServices() const;
 
        QNetworkReply *getFromNetwork(const swift::misc::network::CUrl &url, const CallbackSlot &callback,
                                      int maxRedirects = DefaultMaxRedirects);
 
        QNetworkReply *getFromNetwork(const swift::misc::network::CUrl &url, const CallbackSlot &callback,
                                      const ProgressSlot &progress, int maxRedirects = DefaultMaxRedirects);
 
        QNetworkReply *getFromNetwork(const swift::misc::network::CUrl &url, int logId, const CallbackSlot &callback,
                                      const ProgressSlot &progress, int maxRedirects = DefaultMaxRedirects);
 
        QNetworkReply *getFromNetwork(const QNetworkRequest &request, const CallbackSlot &callback,
                                      int maxRedirects = DefaultMaxRedirects);
 
        QNetworkReply *getFromNetwork(const QNetworkRequest &request, const CallbackSlot &callback,
                                      const ProgressSlot &progress, int maxRedirects = DefaultMaxRedirects);
 
        QNetworkReply *getFromNetwork(const QNetworkRequest &request, int logId, const CallbackSlot &callback,
                                      const ProgressSlot &progress, int maxRedirects = DefaultMaxRedirects);
 
        QNetworkReply *deleteResourceFromNetwork(const QNetworkRequest &request, int logId,
                                                 const CallbackSlot &callback, int maxRedirects = DefaultMaxRedirects);
 
        QNetworkReply *postToNetwork(const QNetworkRequest &request, int logId, const QByteArray &data,
                                     const CallbackSlot &callback);
 
        QNetworkReply *postToNetwork(const QNetworkRequest &request, int logId, QHttpMultiPart *multiPart,
                                     const CallbackSlot &callback);
 
        QNetworkReply *headerFromNetwork(const swift::misc::network::CUrl &url, const CallbackSlot &callback,
                                         int maxRedirects = NoRedirects);
 
        QNetworkReply *headerFromNetwork(const QNetworkRequest &request, const CallbackSlot &callback,
                                         int maxRedirects = NoRedirects);
 
        QNetworkReply *
        downloadFromNetwork(const swift::misc::network::CUrl &url, const QString &saveAsFileName,
                            const swift::misc::CSlot<void(const swift::misc::CStatusMessage &)> &callback,
                            int maxRedirects = DefaultMaxRedirects);
 
    signals:
        void updateInfoAvailable(bool success);
 
        void startUpCompleted(bool success);
 
        void coreFacadeStarted();
 
        void webDataServicesStarted(bool success);
 
        void aboutToShutdown();
 
    protected:
        virtual void displaySetupLoadFailure(swift::misc::CStatusMessageList msgs);
 
        virtual void onStartUpCompleted();
 
        void init(bool withMetadata);
 
        static int indexOfCommandLineOption(const QCommandLineOption &option,
                                            const QStringList &args = CApplication::arguments());
 
        static void argumentsWithoutOption(const QCommandLineOption &option, QStringList &args);
 
        virtual bool parsingHookIn() { return true; }
 
        virtual void onCoreFacadeStarted();
 
        virtual swift::misc::CStatusMessageList startHookIn() { return swift::misc::CStatusMessageList(); }
 
        bool isSet(const QCommandLineOption &option) const;
 
        swift::misc::CStatusMessageList startCoreFacade();
 
        swift::misc::CStatusMessageList startWebDataServices(CWebReaderFlags::WebReader webReader,
                                                             const db::CDatabaseReaderConfigList &dbReaderConfig);
 
        static const QString &executable();
 
        static void registerMetadata();
 
        // cmd parsing
        QList<QCommandLineOption> m_allOptions; 
        QCommandLineParser m_parser; 
        QCommandLineOption m_cmdHelp { "help" }; 
        QCommandLineOption m_cmdVersion { "version" }; 
        QCommandLineOption m_cmdDBusAddress { "emptyDBus" }; 
        QCommandLineOption m_cmdDevelopment { "dev" }; 
        QCommandLineOption m_cmdClearCache { "clearcache" }; 
        QCommandLineOption m_cmdTestCrashpad { "testcrashpad" }; 
        QCommandLineOption m_cmdSkipSingleApp { "skipsa" }; 
        bool m_parsed = false; 
        bool m_started = false; 
        bool m_alreadyRunning = false; 
        std::atomic_bool m_shutdown { false }; 
        std::atomic_bool m_incognito { false }; 
        std::atomic_bool m_shutdownInProgress { false }; 
 
    private:
        swift::misc::CStatusMessageList loadSetup();
 
        void cmdLineHelpMessage();
 
        void cmdLineVersionMessage();
 
        void initNetwork();
 
        void initLogging();
 
        void initParser();
 
        bool initIsRunningInDeveloperEnvironment() const;
 
        swift::misc::CStatusMessage initLocalSettings();
 
        using NetworkRequestOrPostFunction =
            std::function<QNetworkReply *(QNetworkAccessManager &, const QNetworkRequest &)>;
 
        QNetworkReply *httpRequestImpl(const QNetworkRequest &request, int logId, const CallbackSlot &callback,
                                       int maxRedirects, NetworkRequestOrPostFunction requestOrPostMethod);
 
        QNetworkReply *httpRequestImpl(const QNetworkRequest &request, int logId, const CallbackSlot &callback,
                                       const ProgressSlot &progress, int maxRedirects,
                                       NetworkRequestOrPostFunction getPostOrDeleteRequest);
 
        void httpRequestImplInQAMThread(const QNetworkRequest &request, int logId, const CallbackSlot &callback,
                                        const ProgressSlot &progress, int maxRedirects,
                                        NetworkRequestOrPostFunction getPostOrDeleteRequest);
 
        void tagApplicationDataDirectory();
 
        bool startupCheck() const;
 
        bool loadSetupAndHandleErrors();
 
        bool parseCommandLineArguments();
 
        CInputManager *m_inputManager = nullptr; 
        QNetworkAccessManager *m_accessManager = nullptr; 
        swift::misc::CApplicationInfo m_applicationInfo; 
        QScopedPointer<CCoreFacade> m_coreFacade; 
        QScopedPointer<CSetupReader> m_setupReader; 
        QScopedPointer<CGitHubPackagesReader> m_gitHubPackagesReader; 
        QScopedPointer<CWebDataServices> m_webDataServices; 
        QScopedPointer<swift::misc::CFileLogger> m_fileLogger; 
        QPointer<CCookieManager> m_cookieManager; 
        const QString m_applicationName; 
        QReadWriteLock m_accessManagerLock; 
        CCoreFacadeConfig m_coreFacadeConfig; 
        bool m_useContexts = false; 
        bool m_devFlag = false; 
        bool m_saveSettingsOnShutdown = true; 
        bool m_localSettingsLoaded = false; 
 
        // -------------- crashpad -----------------
        swift::misc::CSettingReadOnly<application::TCrashDumpUploadEnabled> m_crashDumpUploadEnabled {
            this, &CApplication::onCrashDumpUploadEnabledChanged
        };
 
        void onCrashDumpUploadEnabledChanged();
    };
} // namespace swift::core
 
extern SWIFT_CORE_EXPORT swift::core::CApplication *sApp;
 
#endif // SWIFT_CORE_APPLICATION_H