AirspaceManager.h 6.43 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12
/****************************************************************************
 *
 *   (c) 2017 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
 *
 * QGroundControl is licensed according to the terms in the file
 * COPYING.md in the root of the source code directory.
 *
 ****************************************************************************/

#pragma once

/**
Gus Grubba's avatar
Gus Grubba committed
13
 * @file AirspaceManager.h
14 15 16 17 18 19 20
 * This file contains the interface definitions used by an airspace management implementation (AirMap).
 * There are 3 base classes that must be subclassed:
 * - AirspaceManager
 *   main manager that contains the restrictions for display. It acts as a factory to create instances of the other
 *   classes.
 * - AirspaceVehicleManager
 *   this provides the multi-vehicle support - each vehicle has an instance
21 22
 * - AirspaceAdvisoriesProvider
 *   Provides airspace advisories and restrictions. Currently only used by AirspaceManager, but
23 24 25 26
 *   each vehicle could have its own restrictions.
 */

#include "QGCToolbox.h"
27
#include "QGCLoggingCategory.h"
Gus Grubba's avatar
Gus Grubba committed
28
#include "QmlObjectListModel.h"
29
#include "QGCGeoBoundingCube.h"
30

31
#include <QGeoCoordinate>
32 33 34
#include <QObject>
#include <QString>
#include <QList>
35
#include <QTimer>
36

Gus Grubba's avatar
Gus Grubba committed
37
class AirspaceAdvisoryProvider;
Gus Grubba's avatar
Gus Grubba committed
38
class AirspaceFlightPlanProvider;
39
class AirspaceRestrictionProvider;
Gus Grubba's avatar
Gus Grubba committed
40 41 42
class AirspaceRulesetsProvider;
class AirspaceVehicleManager;
class AirspaceWeatherInfoProvider;
43
class PlanMasterController;
Gus Grubba's avatar
Gus Grubba committed
44 45
class QGCApplication;
class Vehicle;
46 47 48 49 50 51 52 53 54 55 56 57

Q_DECLARE_LOGGING_CATEGORY(AirspaceManagementLog)

//-----------------------------------------------------------------------------
/**
 * @class AirspaceManager
 * Base class for airspace management. There is one (global) instantiation of this
 */
class AirspaceManager : public QGCTool {
    Q_OBJECT
public:
    AirspaceManager(QGCApplication* app, QGCToolbox* toolbox);
58
    virtual ~AirspaceManager() override;
59

60 61 62
    enum AuthStatus {
        Unknown,
        Anonymous,
63
        Authenticated,
64 65 66 67 68
        Error
    };

    Q_ENUM(AuthStatus)

69 70 71 72 73
    Q_PROPERTY(QString                      providerName        READ providerName       CONSTANT)
    Q_PROPERTY(AirspaceWeatherInfoProvider* weatherInfo         READ weatherInfo        CONSTANT)
    Q_PROPERTY(AirspaceAdvisoryProvider*    advisories          READ advisories         CONSTANT)
    Q_PROPERTY(AirspaceRulesetsProvider*    ruleSets            READ ruleSets           CONSTANT)
    Q_PROPERTY(AirspaceRestrictionProvider* airspaces           READ airspaces          CONSTANT)
Gus Grubba's avatar
Gus Grubba committed
74
    Q_PROPERTY(AirspaceFlightPlanProvider*  flightPlan          READ flightPlan         CONSTANT)
Gus Grubba's avatar
Gus Grubba committed
75 76
    Q_PROPERTY(bool                         connected           READ connected          NOTIFY connectedChanged)
    Q_PROPERTY(QString                      connectStatus       READ connectStatus      NOTIFY connectStatusChanged)
77
    Q_PROPERTY(AirspaceManager::AuthStatus  authStatus          READ authStatus         NOTIFY authStatusChanged)
78
    Q_PROPERTY(bool                         airspaceVisible     READ airspaceVisible    WRITE  setAirspaceVisible    NOTIFY airspaceVisibleChanged)
79

80
    Q_INVOKABLE void setROI                     (const QGeoCoordinate& pointNW, const QGeoCoordinate& pointSE, bool planView, bool reset = false);
81 82 83 84 85

    AirspaceWeatherInfoProvider* weatherInfo    () { return _weatherProvider; }
    AirspaceAdvisoryProvider*    advisories     () { return _advisories; }
    AirspaceRulesetsProvider*    ruleSets       () { return _ruleSetsProvider; }
    AirspaceRestrictionProvider* airspaces      () { return _airspaces; }
Gus Grubba's avatar
Gus Grubba committed
86
    AirspaceFlightPlanProvider*  flightPlan     () { return _flightPlan; }
87 88 89 90 91 92 93

    void setToolbox(QGCToolbox* toolbox) override;

    virtual QString             providerName    () const = 0;   ///< Name of the airspace management provider (used in the UI)

    virtual bool                airspaceVisible () { return _airspaceVisible; }
    virtual void             setAirspaceVisible (bool set) { _airspaceVisible = set; emit airspaceVisibleChanged(); }
Gus Grubba's avatar
Gus Grubba committed
94 95
    virtual bool                connected       () const = 0;
    virtual QString             connectStatus   () const { return QString(); }
96
    virtual double             maxAreaOfInterest() const { return _maxAreaOfInterest; }
97

98 99
    virtual AirspaceManager::AuthStatus authStatus () const { return Anonymous; }

100 101 102
    /**
     * Factory method to create an AirspaceVehicleManager object
     */
Gus Grubba's avatar
Gus Grubba committed
103
    virtual AirspaceVehicleManager*         instantiateVehicle                      (const Vehicle& vehicle) = 0;
104

105
signals:
Gus Grubba's avatar
Gus Grubba committed
106
    void                airspaceVisibleChanged  ();
Gus Grubba's avatar
Gus Grubba committed
107 108
    void                connectedChanged        ();
    void                connectStatusChanged    ();
109
    void                authStatusChanged       ();
110

111
protected:
112
    /**
113 114 115
     * Set the ROI for airspace information (restrictions shown in UI)
     * @param center Center coordinate for ROI
     * @param radiusMeters Radius in meters around center which is of interest
116
     */
117
    virtual void                            _setROI                                 (const QGCGeoBoundingCube& roi);
Gus Grubba's avatar
Gus Grubba committed
118 119

    /**
Gus Grubba's avatar
Gus Grubba committed
120
     * Factory methods
Gus Grubba's avatar
Gus Grubba committed
121
     */
122 123 124 125
    virtual AirspaceRulesetsProvider*       _instantiateRulesetsProvider            () = 0;
    virtual AirspaceWeatherInfoProvider*    _instatiateAirspaceWeatherInfoProvider  () = 0;
    virtual AirspaceAdvisoryProvider*       _instatiateAirspaceAdvisoryProvider     () = 0;
    virtual AirspaceRestrictionProvider*    _instantiateAirspaceRestrictionProvider () = 0;
Gus Grubba's avatar
Gus Grubba committed
126
    virtual AirspaceFlightPlanProvider*     _instantiateAirspaceFlightPlanProvider  () = 0;
127

128
protected:
129 130 131 132 133 134 135
    bool                            _airspaceVisible        = false;
    AirspaceRulesetsProvider*       _ruleSetsProvider       = nullptr;  ///< Rulesets
    AirspaceWeatherInfoProvider*    _weatherProvider        = nullptr;  ///< Weather info
    AirspaceAdvisoryProvider*       _advisories             = nullptr;  ///< Advisory info
    AirspaceRestrictionProvider*    _airspaces              = nullptr;  ///< Airspace info
    AirspaceFlightPlanProvider*     _flightPlan             = nullptr;  ///< Flight plan management
    double                          _maxAreaOfInterest      = 500.0;    ///< Ignore area larger than 500km^2
Gus Grubba's avatar
Gus Grubba committed
136
    QTimer                          _ruleUpdateTimer;
137
    QTimer                          _updateTimer;
138
    QGCGeoBoundingCube              _roi;
139

140
private slots:
Gus Grubba's avatar
Gus Grubba committed
141
    void _updateRulesTimeout        ();
142
    void _updateTimeout             ();
Gus Grubba's avatar
Gus Grubba committed
143
    void _rulesChanged              ();
144

145
private:
146
    void _updateToROI               (bool reset = false);
147

148
};