PlanMasterController.h

Go to the documentation of this file.

#pragma once
 
#include <QtCore/QFileInfo>
#include <QtCore/QObject>
#include <QtCore/QLoggingCategory>
#include <QtQmlIntegration/QtQmlIntegration>
 
#include "MissionController.h"
#include "GeoFenceController.h"
#include "RallyPointController.h"
 
Q_DECLARE_LOGGING_CATEGORY(PlanMasterControllerLog)
 
class QGCCompressionJob;
class QmlObjectListModel;
class MultiVehicleManager;
class Vehicle;
#ifdef QGC_UNITTEST_BUILD
class PlanMasterControllerTest;
#endif
 
class PlanMasterController : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    Q_MOC_INCLUDE("QmlObjectListModel.h")
    Q_MOC_INCLUDE("Vehicle.h")
 
#ifdef QGC_UNITTEST_BUILD
    friend class PlanMasterControllerTest;
#endif
 
public:
    PlanMasterController(QObject* parent = nullptr);
#ifdef QT_DEBUG
    // Used by test code to create master controller with specific firmware/vehicle type
    PlanMasterController(MAV_AUTOPILOT firmwareType, MAV_TYPE vehicleType, QObject* parent = nullptr);
#endif
 
    ~PlanMasterController();
 
    Q_PROPERTY(bool                     flyView                 MEMBER _flyView)
    Q_PROPERTY(Vehicle*                 controllerVehicle       READ controllerVehicle                      CONSTANT)                       
    Q_PROPERTY(Vehicle*                 managerVehicle          READ managerVehicle                         NOTIFY managerVehicleChanged)   
    Q_PROPERTY(MissionController*       missionController       READ missionController                      CONSTANT)
    Q_PROPERTY(GeoFenceController*      geoFenceController      READ geoFenceController                     CONSTANT)
    Q_PROPERTY(RallyPointController*    rallyPointController    READ rallyPointController                   CONSTANT)
    Q_PROPERTY(bool                     offline                 READ offline                                NOTIFY offlineChanged)          
    Q_PROPERTY(bool                     containsItems           READ containsItems                          NOTIFY containsItemsChanged)    
    Q_PROPERTY(bool                     syncInProgress          READ syncInProgress                         NOTIFY syncInProgressChanged)   
    Q_PROPERTY(bool                     dirtyForSave            READ dirtyForSave                           NOTIFY dirtyForSaveChanged)     
    Q_PROPERTY(bool                     dirtyForUpload          READ dirtyForUpload                         NOTIFY dirtyForUploadChanged)   
    Q_PROPERTY(QString                  fileExtension           READ fileExtension                          CONSTANT)                       
    Q_PROPERTY(QString                  kmlFileExtension        READ kmlFileExtension                       CONSTANT)
    Q_PROPERTY(QString                  currentPlanFile         READ currentPlanFile                        NOTIFY currentPlanFileChanged)  
    Q_PROPERTY(QString                  currentPlanFileName     READ currentPlanFileName WRITE setCurrentPlanFileName NOTIFY currentPlanFileNameChanged)  
    Q_PROPERTY(QString                  originalPlanFileName    READ originalPlanFileName                   NOTIFY originalPlanFileNameChanged) 
    Q_PROPERTY(bool                     planFileRenamed         READ planFileRenamed                        NOTIFY planFileRenamedChanged)   
    Q_PROPERTY(QStringList              loadNameFilters         READ loadNameFilters                        CONSTANT)                       
    Q_PROPERTY(QStringList              saveNameFilters         READ saveNameFilters                        CONSTANT)                       
    Q_PROPERTY(QmlObjectListModel*      planCreators            MEMBER _planCreators                        NOTIFY planCreatorsChanged)
    Q_PROPERTY(bool                     manualCreation          READ manualCreation WRITE setManualCreation NOTIFY manualCreationChanged)   
 
    
    Q_INVOKABLE void start(void);
 
    Q_INVOKABLE void startStaticActiveVehicle(Vehicle* vehicle, bool deleteWhenSendCompleted = false);
 
    Q_INVOKABLE int readyForSaveState(void) const { return _missionController.readyForSaveState(); }
 
    Q_INVOKABLE void showPlanFromManagerVehicle(void);
 
    static void sendPlanToVehicle(Vehicle* vehicle, const QString& filename);
 
    Q_INVOKABLE void loadFromVehicle(void);
    Q_INVOKABLE void sendToVehicle(void);
    Q_INVOKABLE void loadFromFile(const QString& filename);
 
    Q_INVOKABLE void loadFromArchive(const QString& archivePath);
 
    Q_INVOKABLE bool saveToCurrent();
    Q_INVOKABLE bool saveToFile(const QString& filename);
    Q_INVOKABLE void saveToKml(const QString& filename);
 
    Q_INVOKABLE bool saveWithCurrentName();                 
    Q_INVOKABLE bool resolvedPlanFileExists() const;        
    Q_INVOKABLE void removeAll(void);                       
    Q_INVOKABLE void removeAllFromVehicle(void);            
 
    MissionController*      missionController(void)     { return &_missionController; }
    GeoFenceController*     geoFenceController(void)    { return &_geoFenceController; }
    RallyPointController*   rallyPointController(void)  { return &_rallyPointController; }
 
    bool        offline         (void) const { return _offline; }
    bool        containsItems   (void) const;
    bool        syncInProgress  (void) const;
    bool        dirtyForSave    (void) const { return _dirtyForSave; }
    bool        dirtyForUpload  (void) const { return _dirtyForUpload; }
    QString     fileExtension   (void) const;
    QString     kmlFileExtension(void) const;
    QString     currentPlanFile     (void) const { return _currentPlanFile; }
    QString     currentPlanFileName (void) const { return _currentPlanFileName; }
    void        setCurrentPlanFileName(const QString& name);
    QString     originalPlanFileName(void) const { return _originalPlanFileName; }
    bool        planFileRenamed(void) const;
    QStringList loadNameFilters (void) const;
    QStringList saveNameFilters (void) const;
    bool        isEmpty         (void) const;
    bool        manualCreation  (void) const { return _manualCreation; }
 
    void        setFlyView(bool flyView) { _flyView = flyView; }
    void        setManualCreation(bool manualCreation);
 
    QJsonDocument saveToJson    ();
 
    Vehicle* controllerVehicle(void) { return _controllerVehicle; }
    Vehicle* managerVehicle(void) { return _managerVehicle; }
 
    static constexpr int   kPlanFileVersion =            1;
    static constexpr const char* kPlanFileType =               "Plan";
    static constexpr const char* kJsonMissionObjectKey =       "mission";
    static constexpr const char* kJsonGeoFenceObjectKey =      "geoFence";
    static constexpr const char* kJsonRallyPointsObjectKey =   "rallyPoints";
 
signals:
    void containsItemsChanged               ();
    void syncInProgressChanged              (void);
    void dirtyForSaveChanged                (bool dirtyForSave);
    void dirtyForUploadChanged              (bool dirtyForUpload);
    void offlineChanged                     (bool offlineEditing);
    void currentPlanFileChanged             (void);
    void currentPlanFileNameChanged         (void);
    void originalPlanFileNameChanged        (void);
    void planFileRenamedChanged              (void);
    void planCreatorsChanged                (QmlObjectListModel* planCreators);
    void managerVehicleChanged              (Vehicle* managerVehicle);
    void promptForPlanUsageOnVehicleChange  (void);
    void manualCreationChanged              ();
 
private slots:
    void _activeVehicleChanged      (Vehicle* activeVehicle);
    void _loadMissionComplete       (void);
    void _loadGeoFenceComplete      (void);
    void _loadRallyPointsComplete   (void);
    void _sendMissionComplete       (void);
    void _sendGeoFenceComplete      (void);
    void _sendRallyPointsComplete   (void);
    void _updateOverallDirty        (void);
    void _updatePlanCreatorsList    (void);
    void _handleExtractionFinished  (bool success);
 
private:
    void _commonInit                (void);
    void _showPlanFromManagerVehicle(void);
    void _setDirtyForSave(bool dirtyForSave);
    void _setDirtyForUpload(bool dirtyForUpload);
    void _setDirtyStates(bool dirtyForSave, bool dirtyForUpload);
    QString _resolvedPlanFilePath() const;
    void    _clearFileNames();
 
#ifdef QGC_UNITTEST_BUILD
    // Used by unit tests to set dirty flags for initial state
    void _setDirtyForSaveUnitTest(bool dirtyForSave) { _dirtyForSave = dirtyForSave; }
    void _setDirtyForUploadUnitTest(bool dirtyForUpload) { _dirtyForUpload = dirtyForUpload; }
#endif
 
    MultiVehicleManager*    _multiVehicleMgr =          nullptr;
    Vehicle*                _controllerVehicle =        nullptr;    
    Vehicle*                _managerVehicle =           nullptr;    
    bool                    _flyView =                  true;
    bool                    _offline =                  true;
    MissionController       _missionController;
    GeoFenceController      _geoFenceController;
    RallyPointController    _rallyPointController;
    bool                    _loadGeoFence =             false;
    bool                    _loadRallyPoints =          false;
    bool                    _sendGeoFence =             false;
    bool                    _sendRallyPoints =          false;
    QString                 _currentPlanFile;
    // NOTE: _currentPlanFileName and _originalPlanFileName must be kept in sync
    // with _currentPlanFile across all code paths that modify any of them:
    // loadFromFile, saveToFile, removeAll, removeAllFromVehicle, _clearFileNames.
    QString                 _currentPlanFileName;
    QString                 _originalPlanFileName;
    bool                    _deleteWhenSendCompleted =  false;
    bool                    _dirtyForSave =             false;
    bool                    _dirtyForUpload =           false;
    bool                    _suppressOverallDirtyUpdate = false;
    QmlObjectListModel*     _planCreators =             nullptr;
    bool                    _manualCreation =           false;
    QGCCompressionJob*      _extractionJob =            nullptr;
    QString                 _extractionOutputDir;
};