QGCApplication.h 12.4 KB
Newer Older
1 2
/****************************************************************************
 *
Gus Grubba's avatar
Gus Grubba committed
3
 * (c) 2009-2020 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
4 5 6 7 8
 *
 * QGroundControl is licensed according to the terms in the file
 * COPYING.md in the root of the source code directory.
 *
 ****************************************************************************/
dogmaphobic's avatar
dogmaphobic committed
9

10
#pragma once
pixhawk's avatar
pixhawk committed
11 12

#include <QApplication>
13
#include <QTimer>
14
#include <QElapsedTimer>
15 16 17 18
#include <QMap>
#include <QSet>
#include <QMetaMethod>
#include <QMetaObject>
Don Gagne's avatar
Don Gagne committed
19 20

// These private headers are require to implement the signal compress support below
21 22
#include <private/qthread_p.h>
#include <private/qobject_p.h>
pixhawk's avatar
pixhawk committed
23

Don Gagne's avatar
Don Gagne committed
24
#include "LinkConfiguration.h"
25 26 27 28 29
#include "MAVLinkProtocol.h"
#include "FlightMapSettings.h"
#include "FirmwarePluginManager.h"
#include "MultiVehicleManager.h"
#include "JoystickManager.h"
30
#include "AudioOutput.h"
31 32
#include "UASMessageHandler.h"
#include "FactSystem.h"
33
#include "GPSRTKFactGroup.h"
Don Gagne's avatar
Don Gagne committed
34

35
#ifdef QGC_RTLAB_ENABLED
36 37
#include "OpalLink.h"
#endif
38

39
// Work around circular header includes
40
class QQmlApplicationEngine;
41
class QGCSingleton;
42
class QGCToolbox;
Don Gagne's avatar
Don Gagne committed
43

44 45 46 47 48 49 50 51 52 53 54 55
/**
 * @brief The main application and management class.
 *
 * This class is started by the main method and provides
 * the central management unit of the groundstation application.
 *
 * Needs QApplication base to support QtCharts module. This way
 * we avoid application crashing on 5.12 when using the module.
 *
 * Note: `lastWindowClosed` will be sent by MessageBox popups and other
 * dialogs, that are spawned in QML, when they are closed
**/
56
class QGCApplication : public QApplication
pixhawk's avatar
pixhawk committed
57
{
58
    Q_OBJECT
pixhawk's avatar
pixhawk committed
59
public:
DonLakeFlyer's avatar
DonLakeFlyer committed
60
    QGCApplication(int &argc, char* argv[], bool unitTesting);
Don Gagne's avatar
Don Gagne committed
61
    ~QGCApplication();
dogmaphobic's avatar
dogmaphobic committed
62

Don Gagne's avatar
Don Gagne committed
63 64
    /// @brief Sets the persistent flag to delete all settings the next time QGroundControl is started.
    void deleteAllSettingsNextBoot(void);
dogmaphobic's avatar
dogmaphobic committed
65

Don Gagne's avatar
Don Gagne committed
66 67
    /// @brief Clears the persistent flag to delete all settings the next time QGroundControl is started.
    void clearDeleteAllSettingsNextBoot(void);
dogmaphobic's avatar
dogmaphobic committed
68

69
    /// @brief Returns true if unit tests are being run
Don Gagne's avatar
Don Gagne committed
70
    bool runningUnitTests(void) { return _runningUnitTests; }
dogmaphobic's avatar
dogmaphobic committed
71

72 73 74
    /// @brief Returns true if Qt debug output should be logged to a file
    bool logOutput(void) { return _logOutput; }

Don Gagne's avatar
Don Gagne committed
75
    /// Used to report a missing Parameter. Warning will be displayed to user. Method may be called
76
    /// multiple times.
Don Gagne's avatar
Don Gagne committed
77
    void reportMissingParameter(int componentId, const QString& name);
78

79
    /// Show non-modal vehicle message to the user
80
    Q_SLOT void showCriticalVehicleMessage(const QString& message);
81 82 83

    /// Show modal application message to the user
    Q_SLOT void showAppMessage(const QString& message, const QString& title = QString());
84

dogmaphobic's avatar
dogmaphobic committed
85
    /// @return true: Fake ui into showing mobile interface
86
    bool fakeMobile(void) const { return _fakeMobile; }
dogmaphobic's avatar
dogmaphobic committed
87

88 89
    // Still working on getting rid of this and using dependency injection instead for everything
    QGCToolbox* toolbox(void) { return _toolbox; }
dogmaphobic's avatar
dogmaphobic committed
90 91 92 93

    /// Do we have Bluetooth Support?
    bool isBluetoothAvailable() { return _bluetoothAvailable; }

94 95 96
    /// Is Internet available?
    bool isInternetAvailable();

97 98
    FactGroup* gpsRtkFactGroup(void)  { return _gpsRtkFactGroup; }

99
    QTranslator& qgcJSONTranslator(void) { return _qgcTranslatorJSON; }
100

101 102 103
    static QString cachedParameterMetaDataFile(void);
    static QString cachedAirframeMetaDataFile(void);

104
    void            setLanguage();
105
    QQuickItem*     mainRootWindow();
106

107 108
    uint64_t        msecsSinceBoot(void) { return _msecsElapsedTime.elapsed(); }

109 110 111
public slots:
    /// You can connect to this slot to show an information message box from a different thread.
    void informationMessageBoxOnMainThread(const QString& title, const QString& msg);
dogmaphobic's avatar
dogmaphobic committed
112

113 114
    /// You can connect to this slot to show a warning message box from a different thread.
    void warningMessageBoxOnMainThread(const QString& title, const QString& msg);
dogmaphobic's avatar
dogmaphobic committed
115

116 117
    /// You can connect to this slot to show a critical message box from a different thread.
    void criticalMessageBoxOnMainThread(const QString& title, const QString& msg);
dogmaphobic's avatar
dogmaphobic committed
118

119
    void showSetupView();
Don Gagne's avatar
Don Gagne committed
120

121
    void qmlAttemptWindowClose();
Don Gagne's avatar
Don Gagne committed
122

123 124 125 126
    /// Save the specified telemetry Log
    void saveTelemetryLogOnMainThread(QString tempLogfile);

    /// Check that the telemetry save path is set correctly
127
    void checkTelemetrySavePathOnMainThread();
128

129 130 131
    /// Get current language
    const QLocale getCurrentLanguage() { return _locale; }

132 133 134
signals:
    /// This is connected to MAVLinkProtocol::checkForLostLogFiles. We signal this to ourselves to call the slot
    /// on the MAVLinkProtocol thread;
135 136 137
    void checkForLostLogFiles   ();

    void languageChanged        (const QLocale locale);
dogmaphobic's avatar
dogmaphobic committed
138

139
public:
140
    // Although public, these methods are internal and should only be called by UnitTest code
dogmaphobic's avatar
dogmaphobic committed
141

142 143
    /// @brief Perform initialize which is common to both normal application running and unit tests.
    ///         Although public should only be called by main.
144
    void _initCommon();
145

Patrick José Pereira's avatar
Patrick José Pereira committed
146
    /// @brief Initialize the application for normal application boot. Or in other words we are not going to run
147
    ///         unit tests. Although public should only be called by main.
148
    bool _initForNormalAppBoot();
dogmaphobic's avatar
dogmaphobic committed
149

Patrick José Pereira's avatar
Patrick José Pereira committed
150
    /// @brief Initialize the application for normal application boot. Or in other words we are not going to run
151
    ///         unit tests. Although public should only be called by main.
152
    bool _initForUnitTests();
Don Gagne's avatar
Don Gagne committed
153

154
    static QGCApplication*  _app;   ///< Our own singleton. Should be reference directly by qgcApp
dogmaphobic's avatar
dogmaphobic committed
155

156 157
    bool    isErrorState()  { return _error; }

Don Gagne's avatar
Don Gagne committed
158 159 160 161
public:
    // Although public, these methods are internal and should only be called by UnitTest code

    /// Shutdown the application object
162
    void _shutdown();
Don Gagne's avatar
Don Gagne committed
163

164 165
    bool _checkTelemetrySavePath(bool useMessageBox);

Don Gagne's avatar
Don Gagne committed
166
private slots:
167 168 169 170 171 172 173 174
    void _missingParamsDisplay                      (void);
    void _qgcCurrentStableVersionDownloadComplete   (QString remoteFile, QString localFile, QString errorMsg);
    bool _parseVersionText                          (const QString& versionString, int& majorVersion, int& minorVersion, int& buildVersion);
    void _onGPSConnect                              (void);
    void _onGPSDisconnect                           (void);
    void _gpsSurveyInStatus                         (float duration, float accuracyMM,  double latitude, double longitude, float altitude, bool valid, bool active);
    void _gpsNumSatellites                          (int numSatellites);
    void _showDelayedAppMessages                    (void);
dogmaphobic's avatar
dogmaphobic committed
175

pixhawk's avatar
pixhawk committed
176
private:
177 178
    QObject*    _rootQmlObject          ();
    void        _checkForNewVersion     ();
179
    void        _exitWithError          (QString errorMessage);
Don Gagne's avatar
Don Gagne committed
180

dogmaphobic's avatar
dogmaphobic committed
181

182 183 184 185
    bool                        _runningUnitTests;                                  ///< true: running unit tests, false: normal app
    static const int            _missingParamsDelayedDisplayTimerTimeout = 1000;    ///< Timeout to wait for next missing fact to come in before display
    QTimer                      _missingParamsDelayedDisplayTimer;                  ///< Timer use to delay missing fact display
    QList<QPair<int,QString>>   _missingParams;                                     ///< List of missing parameter component id:name
186

187
    QQmlApplicationEngine* _qmlAppEngine        = nullptr;
188 189 190
    bool                _logOutput              = false;    ///< true: Log Qt debug output to file
    bool				_fakeMobile             = false;    ///< true: Fake ui into displaying mobile interface
    bool                _settingsUpgraded       = false;    ///< true: Settings format has been upgrade to new version
191 192 193 194 195
    int                 _majorVersion           = 0;
    int                 _minorVersion           = 0;
    int                 _buildVersion           = 0;
    GPSRTKFactGroup*    _gpsRtkFactGroup        = nullptr;
    QGCToolbox*         _toolbox                = nullptr;
196
    QQuickItem*         _mainRootWindow         = nullptr;
197
    bool                _bluetoothAvailable     = false;
198 199 200
    QTranslator         _qgcTranslatorSourceCode;           ///< translations for source code C++/Qml
    QTranslator         _qgcTranslatorJSON;                 ///< translations for json files
    QTranslator         _qgcTranslatorQtLibs;               ///< tranlsations for Qt libraries
201
    QLocale             _locale;
202
    bool                _error                  = false;
203
    QElapsedTimer       _msecsElapsedTime;
dogmaphobic's avatar
dogmaphobic committed
204

205 206
    QList<QPair<QString /* title */, QString /* message */>> _delayedAppMessages;

Don Gagne's avatar
Don Gagne committed
207 208 209
    static const char* _settingsVersionKey;             ///< Settings key which hold settings version
    static const char* _deleteAllSettingsKey;           ///< If this settings key is set on boot, all settings will be deleted

Don Gagne's avatar
Don Gagne committed
210 211
    /// Unit Test have access to creating and destroying singletons
    friend class UnitTest;
Gus Grubba's avatar
Gus Grubba committed
212

213 214 215 216 217 218 219 220 221 222 223 224
private:
    /*! Keeps a list of singal indices for one or more meatobject classes.
     * The indices are signal indices as given by QMetaCallEvent.signalId.
     * On Qt 5, those do *not* match QMetaObject::methodIndex since they
     * exclude non-signal methods. */
    class SignalList {
        Q_DISABLE_COPY(SignalList)
        typedef QMap<const QMetaObject *, QSet<int> > T;
        T m_data;
        /*! Returns a signal index that is can be compared to QMetaCallEvent.signalId. */
        static int signalIndex(const QMetaMethod & method) {
            Q_ASSERT(method.methodType() == QMetaMethod::Signal);
225

226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
            int index = -1;
            const QMetaObject * mobj = method.enclosingMetaObject();
            for (int i = 0; i <= method.methodIndex(); ++i) {
                if (mobj->method(i).methodType() != QMetaMethod::Signal) continue;
                ++ index;
            }
            return index;
        }
    public:
        SignalList() {}
        void add(const QMetaMethod & method) {
            m_data[method.enclosingMetaObject()].insert(signalIndex(method));
        }
        void remove(const QMetaMethod & method) {
            T::iterator it = m_data.find(method.enclosingMetaObject());
            if (it != m_data.end()) {
                it->remove(signalIndex(method));
                if (it->empty()) m_data.erase(it);
            }
        }
        bool contains(const QMetaObject * metaObject, int signalId) {
            T::const_iterator it = m_data.find(metaObject);
            return it != m_data.end() && it.value().contains(signalId);
        }
    };

    SignalList m_compressedSignals;

public:
    void addCompressedSignal(const QMetaMethod & method) { m_compressedSignals.add(method); }
    void removeCompressedSignal(const QMetaMethod & method) { m_compressedSignals.remove(method); }

private:
    struct EventHelper : private QEvent {
        static void clearPostedFlag(QEvent * ev) {
            (&static_cast<EventHelper*>(ev)->t)[1] &= ~0x8001; // Hack to clear QEvent::posted
        }
    };

    bool compressEvent(QEvent *event, QObject *receiver, QPostEventList *postedEvents) {
        if (event->type() != QEvent::MetaCall)
            return QApplication::compressEvent(event, receiver, postedEvents);

        QMetaCallEvent *mce = static_cast<QMetaCallEvent*>(event);

        if (mce->sender() && !m_compressedSignals.contains(mce->sender()->metaObject(), mce->signalId())) {
            return false;
        }

        for (QPostEventList::iterator it = postedEvents->begin(); it != postedEvents->end(); ++it) {
            QPostEvent &cur = *it;
            if (cur.receiver != receiver || cur.event == 0 || cur.event->type() != event->type())
                continue;
            QMetaCallEvent *cur_mce = static_cast<QMetaCallEvent*>(cur.event);
            if (cur_mce->sender() != mce->sender() || cur_mce->signalId() != mce->signalId() ||
                    cur_mce->id() != mce->id())
                continue;
            if (true) {
              /* Keep The Newest Call */
              // We can't merely qSwap the existing posted event with the new one, since QEvent
              // keeps track of whether it has been posted. Deletion of a formerly posted event
              // takes the posted event list mutex and does a useless search of the posted event
              // list upon deletion. We thus clear the QEvent::posted flag before deletion.
              EventHelper::clearPostedFlag(cur.event);
              delete cur.event;
              cur.event = event;
            } else {
              /* Keep the Oldest Call */
              delete event;
            }
            return true;
        }
        return false;
    }



pixhawk's avatar
pixhawk committed
303 304
};

Don Gagne's avatar
Don Gagne committed
305 306
/// @brief Returns the QGCApplication object singleton.
QGCApplication* qgcApp(void);