An rather unfruitful attempt at consolidating Advisories and Airspaces (they...

An rather unfruitful attempt at consolidating Advisories and Airspaces (they are both arrays of Airspaces). No such luck as they vary wildly. In the end, I'm now exposing the restrictions (Polygons) directly (and inherently) instead of copying them.
Tweaked polygon overlay colors and borders.

src/Airmap/AirMapAdvisoryManager.cc

@@ -8,8 +8,13 @@
  ****************************************************************************/
 
 #include "AirMapAdvisoryManager.h"
+#include "AirspaceRestriction.h"
 #include "AirMapManager.h"
 
+#include <QTimer>
+
+#include "airmap/airspaces.h"
+
 #define ADVISORY_UPDATE_DISTANCE    500     //-- 500m threshold for updates
 
 using namespace airmap;
@@ -25,6 +30,7 @@ AirMapAdvisory::AirMapAdvisory(QObject* parent)
 AirMapAdvisoryManager::AirMapAdvisoryManager(AirMapSharedState& shared, QObject *parent)
     : AirspaceAdvisoryProvider(parent)
     , _valid(false)
+    , _lastRadius(0.0)
     , _shared(shared)
 {
 }
@@ -34,9 +40,10 @@ void
 AirMapAdvisoryManager::setROI(const QGeoCoordinate& center, double radiusMeters)
 {
     //-- If first time or we've moved more than ADVISORY_UPDATE_DISTANCE, ask for updates.
-    if(!_lastRoiCenter.isValid() || _lastRoiCenter.distanceTo(center) > ADVISORY_UPDATE_DISTANCE) {
+    if(!_lastRoiCenter.isValid() || _lastRoiCenter.distanceTo(center) > ADVISORY_UPDATE_DISTANCE || _lastRadius != radiusMeters) {
+        _lastRadius    = radiusMeters;
         _lastRoiCenter = center;
-        _requestAdvisories(center, radiusMeters);
+        _requestAdvisories();
     }
 }
 
@@ -52,7 +59,7 @@ adv_sort(QObject* a, QObject* b)
 
 //-----------------------------------------------------------------------------
 void
-AirMapAdvisoryManager::_requestAdvisories(const QGeoCoordinate& coordinate, double radiusMeters)
+AirMapAdvisoryManager::_requestAdvisories()
 {
     qCDebug(AirMapManagerLog) << "Advisories Request";
     if (!_shared.client()) {
@@ -64,11 +71,14 @@ AirMapAdvisoryManager::_requestAdvisories(const QGeoCoordinate& coordinate, doub
     _valid = false;
     _airspaces.clearAndDeleteContents();
     Status::GetStatus::Parameters params;
-    params.longitude = coordinate.longitude();
-    params.latitude  = coordinate.latitude();
+    params.longitude = _lastRoiCenter.longitude();
+    params.latitude  = _lastRoiCenter.latitude();
+    params.types     = Airspace::Type::all;
     params.weather   = false;
-    params.buffer    = radiusMeters;
-    _shared.client()->status().get_status_by_point(params, [this, coordinate](const Status::GetStatus::Result& result) {
+    params.buffer    = _lastRadius;
+    std::weak_ptr<LifetimeChecker> isAlive(_instance);
+    _shared.client()->status().get_status_by_point(params, [this, isAlive](const Status::GetStatus::Result& result) {
+        if (!isAlive.lock()) return;
         if (result) {
             qCDebug(AirMapManagerLog) << "Successful advisory search. Items:" << result.value().advisories.size();
             _airspaceColor = (AirspaceAdvisoryProvider::AdvisoryColor)(int)result.value().advisory_color;
@@ -79,10 +89,6 @@ AirMapAdvisoryManager::_requestAdvisories(const QGeoCoordinate& coordinate, doub
                 pAdvisory->_name        = QString::fromStdString(advisory.airspace.name());
                 pAdvisory->_type        = (AirspaceAdvisory::AdvisoryType)(int)advisory.airspace.type();
                 pAdvisory->_color       = (AirspaceAdvisoryProvider::AdvisoryColor)(int)advisory.color;
-                //-- TODO: Add airspace center coordinates and radius (easy to get from Json but
-                //   I have no idea how to get it from airmap::Airspace.)
-                // pAdvisory->_coordinates = QGeoCoordinate( something );
-                // pAdvisory->_radius = something ;
                 _airspaces.append(pAdvisory);
                 qCDebug(AirMapManagerLog) << "Adding advisory" << pAdvisory->name();
             }

src/Airmap/AirMapAdvisoryManager.h

@@ -60,9 +60,10 @@ public:
 signals:
     void                error           (const QString& what, const QString& airmapdMessage, const QString& airmapdDetails);
 private:
-    void            _requestAdvisories  (const QGeoCoordinate& coordinate, double radiusMeters);
+    void              _requestAdvisories();
 private:
     bool                _valid;
+    double              _lastRadius;
     AirMapSharedState&  _shared;
     QGeoCoordinate      _lastRoiCenter;
     QmlObjectListModel  _airspaces;

src/Airmap/AirMapManager.cc

@@ -10,10 +10,10 @@
 #include "AirMapManager.h"
 #include "AirMapAdvisoryManager.h"
 #include "AirMapWeatherInfoManager.h"
-#include "AirMapRestrictionManager.h"
 #include "AirMapRulesetsManager.h"
 #include "AirMapSettings.h"
 #include "AirMapTelemetry.h"
+#include "AirMapRestrictionManager.h"
 #include "AirMapTrafficMonitor.h"
 #include "AirMapVehicleManager.h"
 
@@ -112,14 +112,6 @@ AirMapManager::instantiateVehicle(const Vehicle& vehicle)
     return manager;
 }
 
-AirspaceRestrictionProvider*
-AirMapManager::instantiateRestrictionProvider()
-{
-    AirMapRestrictionManager* restrictionManager = new AirMapRestrictionManager(_shared);
-    connect(restrictionManager, &AirMapRestrictionManager::error, this, &AirMapManager::_error);
-    return restrictionManager;
-}
-
 AirspaceRulesetsProvider*
 AirMapManager::instantiateRulesetsProvider()
 {
@@ -143,3 +135,11 @@ AirMapManager::instatiateAirspaceAdvisoryProvider()
     connect(advisories, &AirMapAdvisoryManager::error, this, &AirMapManager::_error);
     return advisories;
 }
+
+AirspaceRestrictionProvider*
+AirMapManager::instantiateAirspaceRestrictionProvider()
+{
+    AirMapRestrictionManager* airspaces = new AirMapRestrictionManager(_shared);
+    connect(airspaces, &AirMapRestrictionManager::error, this, &AirMapManager::_error);
+    return airspaces;
+}

src/Airmap/AirMapManager.h

@@ -20,10 +20,10 @@
 
 class QGCToolbox;
 class AirspaceVehicleManager;
-class AirspaceRestrictionProvider;
 class AirspaceRulesetsProvider;
 class AirspaceWeatherInfoProvider;
 class AirspaceAdvisoryProvider;
+class AirspaceRestrictionProvider;
 
 Q_DECLARE_LOGGING_CATEGORY(AirMapManagerLog)
 
@@ -44,10 +44,10 @@ public:
     void setToolbox (QGCToolbox* toolbox) override;
 
     AirspaceVehicleManager*         instantiateVehicle                      (const Vehicle& vehicle) override;
-    AirspaceRestrictionProvider*    instantiateRestrictionProvider          () override;
     AirspaceRulesetsProvider*       instantiateRulesetsProvider             () override;
     AirspaceWeatherInfoProvider*    instatiateAirspaceWeatherInfoProvider   () override;
     AirspaceAdvisoryProvider*       instatiateAirspaceAdvisoryProvider      () override;
+    AirspaceRestrictionProvider*    instantiateAirspaceRestrictionProvider  () override;
 
     QString name            () const override { return "AirMap"; }
 

src/Airmap/AirMapRestrictionManager.cc

@@ -13,15 +13,32 @@
 
 #include "airmap/airspaces.h"
 
+#define RESTRICTION_UPDATE_DISTANCE    500     //-- 500m threshold for updates
+
 using namespace airmap;
 
+//-----------------------------------------------------------------------------
 AirMapRestrictionManager::AirMapRestrictionManager(AirMapSharedState& shared)
     : _shared(shared)
+    , _lastRadius(0.0)
 {
 }
 
+//-----------------------------------------------------------------------------
 void
 AirMapRestrictionManager::setROI(const QGeoCoordinate& center, double radiusMeters)
+{
+    //-- If first time or we've moved more than ADVISORY_UPDATE_DISTANCE, ask for updates.
+    if(!_lastRoiCenter.isValid() || _lastRoiCenter.distanceTo(center) > RESTRICTION_UPDATE_DISTANCE || _lastRadius != radiusMeters) {
+        _lastRadius    = radiusMeters;
+        _lastRoiCenter = center;
+        _requestRestrictions(center, radiusMeters);
+    }
+}
+
+//-----------------------------------------------------------------------------
+void
+AirMapRestrictionManager::_requestRestrictions(const QGeoCoordinate& center, double radiusMeters)
 {
     if (!_shared.client()) {
         qCDebug(AirMapManagerLog) << "No AirMap client instance. Not updating Airspace";
@@ -32,8 +49,8 @@ AirMapRestrictionManager::setROI(const QGeoCoordinate& center, double radiusMete
         return;
     }
     qCDebug(AirMapManagerLog) << "setting ROI";
-    _polygonList.clear();
-    _circleList.clear();
+    _polygons.clear();
+    _circles.clear();
     _state = State::RetrieveItems;
     Airspaces::Search::Parameters params;
     params.geometry = Geometry::point(center.latitude(), center.longitude());
@@ -52,19 +69,19 @@ AirMapRestrictionManager::setROI(const QGeoCoordinate& center, double radiusMete
                 switch(geometry.type()) {
                     case Geometry::Type::polygon: {
                         const Geometry::Polygon& polygon = geometry.details_for_polygon();
-                        _addPolygonToList(polygon, _polygonList);
+                        _addPolygonToList(polygon);
                     }
                         break;
                     case Geometry::Type::multi_polygon: {
                         const Geometry::MultiPolygon& multiPolygon = geometry.details_for_multi_polygon();
                         for (const auto& polygon : multiPolygon) {
-                            _addPolygonToList(polygon, _polygonList);
+                            _addPolygonToList(polygon);
                         }
                     }
                         break;
                     case Geometry::Type::point: {
                         const Geometry::Point& point = geometry.details_for_point();
-                        _circleList.append(new AirspaceCircularRestriction(QGeoCoordinate(point.latitude, point.longitude), 0.));
+                        _circles.append(new AirspaceCircularRestriction(QGeoCoordinate(point.latitude, point.longitude), 0.));
                         // TODO: radius???
                     }
                         break;
@@ -78,13 +95,13 @@ AirMapRestrictionManager::setROI(const QGeoCoordinate& center, double radiusMete
             emit error("Failed to retrieve Geofences",
                     QString::fromStdString(result.error().message()), description);
         }
-        emit requestDone(true);
         _state = State::Idle;
     });
 }
 
+//-----------------------------------------------------------------------------
 void
-AirMapRestrictionManager::_addPolygonToList(const airmap::Geometry::Polygon& polygon, QList<AirspacePolygonRestriction*>& list)
+AirMapRestrictionManager::_addPolygonToList(const airmap::Geometry::Polygon& polygon)
 {
     QVariantList polygonArray;
     for (const auto& vertex : polygon.outer_ring.coordinates) {
@@ -96,7 +113,7 @@ AirMapRestrictionManager::_addPolygonToList(const airmap::Geometry::Polygon& pol
         }
         polygonArray.append(QVariant::fromValue(coord));
     }
-    list.append(new AirspacePolygonRestriction(polygonArray));
+    _polygons.append(new AirspacePolygonRestriction(polygonArray));
     if (polygon.inner_rings.size() > 0) {
         // no need to support those (they are rare, and in most cases, there's a more restrictive polygon filling the hole)
         qCDebug(AirMapManagerLog) << "Polygon with holes. Size: "<<polygon.inner_rings.size();

src/Airmap/AirMapRestrictionManager.h

@@ -27,19 +27,28 @@ class AirMapRestrictionManager : public AirspaceRestrictionProvider, public Life
 {
     Q_OBJECT
 public:
-    AirMapRestrictionManager        (AirMapSharedState& shared);
-    void setROI                     (const QGeoCoordinate& center, double radiusMeters) override;
+    AirMapRestrictionManager            (AirMapSharedState& shared);
+    QmlObjectListModel* polygons        () override { return &_polygons; }
+    QmlObjectListModel* circles         () override { return &_circles; }
+    void                setROI          (const QGeoCoordinate& center, double radiusMeters) override;
 
 signals:
-    void error                      (const QString& what, const QString& airmapdMessage, const QString& airmapdDetails);
+    void error                          (const QString& what, const QString& airmapdMessage, const QString& airmapdDetails);
 
 private:
-    static void _addPolygonToList   (const airmap::Geometry::Polygon& polygon, QList<AirspacePolygonRestriction*>& list);
+    void            _requestRestrictions(const QGeoCoordinate& center, double radiusMeters);
+    void            _addPolygonToList   (const airmap::Geometry::Polygon& polygon);
+
     enum class State {
         Idle,
         RetrieveItems,
     };
-    State                   _state = State::Idle;
-    AirMapSharedState&      _shared;
+
+    AirMapSharedState&  _shared;
+    double              _lastRadius;
+    QGeoCoordinate      _lastRoiCenter;
+    State               _state = State::Idle;
+    QmlObjectListModel  _polygons;
+    QmlObjectListModel  _circles;
 };
 

src/Airmap/AirMapRulesetsManager.cc

@@ -35,7 +35,7 @@ void AirMapRulesetsManager::setROI(const QGeoCoordinate& center)
         return;
     }
     if (_state != State::Idle) {
-        qCWarning(AirMapManagerLog) << "AirMapRestrictionManager::updateROI: state not idle";
+        qCWarning(AirMapManagerLog) << "AirMapRulesetsManager::updateROI: state not idle";
         return;
     }
     qCDebug(AirMapManagerLog) << "Setting ROI for Rulesets";

src/Airmap/README.md

 ## To be deleted when development is complete
 
+*    "Required" rules must be pre-selectd and cannot be unselected by the user
+
 *    AirMapRestrictionManager seems to be incomplete (if not redundant). Shouldn't we use the array of AirSpace items returned by AirMapAdvisoryManager instead? In addition to the AirSpace object, it gives you a color to use in order of importance.
 
 *    Traffic monitor timeout is now set to 2 minutes following instructions from Thomas Voß.

src/AirspaceManagement/AirspaceController.cc

@@ -29,18 +29,6 @@ AirspaceController::setROI(QGeoCoordinate center, double radius)
     _manager->setROI(center, radius);
 }
 
-QmlObjectListModel*
-AirspaceController::polygons()
-{
-    return _manager->polygonRestrictions();
-}
-
-QmlObjectListModel*
-AirspaceController::circles()
-{
-    return _manager->circularRestrictions();
-}
-
 QString
 AirspaceController::providerName()
 {
@@ -64,3 +52,9 @@ AirspaceController::rulesets()
 {
     return _manager->rulesets();
 }
+
+AirspaceRestrictionProvider*
+AirspaceController::airspaces()
+{
+    return _manager->airspaces();
+}

src/AirspaceManagement/AirspaceController.h

@@ -17,6 +17,7 @@ class QmlObjectListModel;
 class AirspaceWeatherInfoProvider;
 class AirspaceAdvisoryProvider;
 class AirspaceRulesetsProvider;
+class AirspaceRestrictionProvider;
 
 class AirspaceController : public QObject
 {
@@ -25,22 +26,20 @@ public:
     AirspaceController(QObject* parent = NULL);
     ~AirspaceController() = default;
 
-    Q_PROPERTY(QmlObjectListModel*          polygons            READ polygons           CONSTANT)   ///< List of AirspacePolygonRestriction objects
-    Q_PROPERTY(QmlObjectListModel*          circles             READ circles            CONSTANT)   ///< List of AirspaceCircularRestriction objects
     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)
     Q_PROPERTY(bool                         airspaceVisible     READ airspaceVisible    WRITE setairspaceVisible    NOTIFY airspaceVisibleChanged)
 
     Q_INVOKABLE void setROI                             (QGeoCoordinate center, double radius);
 
-    QmlObjectListModel*             polygons            ();
-    QmlObjectListModel*             circles             ();
     QString                         providerName        ();
     AirspaceWeatherInfoProvider*    weatherInfo         ();
     AirspaceAdvisoryProvider*       advisories          ();
     AirspaceRulesetsProvider*       rulesets            ();
+    AirspaceRestrictionProvider*    airspaces           ();
     bool                            airspaceVisible     () { return _airspaceVisible; }
 
     void                            setairspaceVisible  (bool set) { _airspaceVisible = set; emit airspaceVisibleChanged(); }

src/AirspaceManagement/AirspaceManager.cc

@@ -12,8 +12,8 @@
 #include "AirspaceWeatherInfoProvider.h"
 #include "AirspaceAdvisoryProvider.h"
 #include "AirspaceRestriction.h"
-#include "AirspaceRestrictionProvider.h"
 #include "AirspaceRulesetsProvider.h"
+#include "AirspaceRestrictionProvider.h"
 #include "AirspaceVehicleManager.h"
 #include "AirspaceController.h"
 
@@ -28,12 +28,13 @@ AirspaceManager::AirspaceManager(QGCApplication* app, QGCToolbox* toolbox)
     _roiUpdateTimer.setInterval(2000);
     _roiUpdateTimer.setSingleShot(true);
     connect(&_roiUpdateTimer, &QTimer::timeout, this, &AirspaceManager::_updateToROI);
-    qmlRegisterUncreatableType<AirspaceAuthorization>       ("QGroundControl",              1, 0, "AirspaceAuthorization",      "Reference only");
-    qmlRegisterUncreatableType<AirspaceController>          ("QGroundControl.Vehicle",      1, 0, "AirspaceController",         "Reference only");
-    qmlRegisterUncreatableType<AirspaceWeatherInfoProvider> ("QGroundControl.Vehicle",      1, 0, "AirspaceWeatherInfoProvider","Reference only");
-    qmlRegisterUncreatableType<AirspaceAdvisoryProvider>    ("QGroundControl.Vehicle",      1, 0, "AirspaceAdvisoryProvider",   "Reference only");
-    qmlRegisterUncreatableType<AirspaceRule>                ("QGroundControl.Vehicle",      1, 0, "AirspaceRule",               "Reference only");
-    qmlRegisterUncreatableType<AirspaceRulesetsProvider>    ("QGroundControl.Vehicle",      1, 0, "AirspaceRulesetsProvider",   "Reference only");
+    qmlRegisterUncreatableType<AirspaceAuthorization>       ("QGroundControl",              1, 0, "AirspaceAuthorization",          "Reference only");
+    qmlRegisterUncreatableType<AirspaceController>          ("QGroundControl.Vehicle",      1, 0, "AirspaceController",             "Reference only");
+    qmlRegisterUncreatableType<AirspaceWeatherInfoProvider> ("QGroundControl.Vehicle",      1, 0, "AirspaceWeatherInfoProvider",    "Reference only");
+    qmlRegisterUncreatableType<AirspaceAdvisoryProvider>    ("QGroundControl.Vehicle",      1, 0, "AirspaceAdvisoryProvider",       "Reference only");
+    qmlRegisterUncreatableType<AirspaceRule>                ("QGroundControl.Vehicle",      1, 0, "AirspaceRule",                   "Reference only");
+    qmlRegisterUncreatableType<AirspaceRulesetsProvider>    ("QGroundControl.Vehicle",      1, 0, "AirspaceRulesetsProvider",       "Reference only");
+    qmlRegisterUncreatableType<AirspaceRestrictionProvider> ("QGroundControl.Vehicle",      1, 0, "AirspaceRestrictionProvider",    "Reference only");
 }
 
 AirspaceManager::~AirspaceManager()
@@ -47,24 +48,19 @@ AirspaceManager::~AirspaceManager()
     if(_rulesetsProvider) {
         delete _rulesetsProvider;
     }
-    if (_restrictionsProvider) {
-        delete _restrictionsProvider;
+    if(_airspaces) {
+        delete _airspaces;
     }
-    _polygonRestrictions.clearAndDeleteContents();
-    _circleRestrictions.clearAndDeleteContents();
 }
 
 void AirspaceManager::setToolbox(QGCToolbox* toolbox)
 {
     QGCTool::setToolbox(toolbox);
     // We should not call virtual methods in the constructor, so we instantiate the restriction provider here
-    _restrictionsProvider = instantiateRestrictionProvider();
-    if (_restrictionsProvider) {
-        connect(_restrictionsProvider, &AirspaceRestrictionProvider::requestDone, this,   &AirspaceManager::_restrictionsUpdated);
-    }
     _rulesetsProvider   = instantiateRulesetsProvider();
     _weatherProvider    = instatiateAirspaceWeatherInfoProvider();
     _advisories         = instatiateAirspaceAdvisoryProvider();
+    _airspaces          = instantiateAirspaceRestrictionProvider();
 }
 
 void AirspaceManager::setROI(const QGeoCoordinate& center, double radiusMeters)
@@ -76,8 +72,8 @@ void AirspaceManager::setROI(const QGeoCoordinate& center, double radiusMeters)
 
 void AirspaceManager::_updateToROI()
 {
-    if (_restrictionsProvider) {
-        _restrictionsProvider->setROI(_roiCenter, _roiRadius);
+    if(_airspaces) {
+        _airspaces->setROI(_roiCenter, _roiRadius);
     }
     if(_rulesetsProvider) {
         _rulesetsProvider->setROI(_roiCenter);
@@ -89,24 +85,3 @@ void AirspaceManager::_updateToROI()
         _advisories->setROI(_roiCenter, _roiRadius);
     }
 }
-
-void AirspaceManager::_restrictionsUpdated(bool success)
-{
-    _polygonRestrictions.clearAndDeleteContents();
-    _circleRestrictions.clearAndDeleteContents();
-    if (success) {
-        for (const auto& circle : _restrictionsProvider->circles()) {
-            _circleRestrictions.append(circle);
-        }
-        for (const auto& polygon : _restrictionsProvider->polygons()) {
-            _polygonRestrictions.append(polygon);
-        }
-    } else {
-        // TODO: show error?
-    }
-}
-
-void AirspaceManager::_rulessetsUpdated(bool)
-{
-
-}

src/AirspaceManagement/AirspaceManager.h

@@ -18,8 +18,8 @@
  *   classes.
  * - AirspaceVehicleManager
  *   this provides the multi-vehicle support - each vehicle has an instance
- * - AirspaceRestrictionProvider
- *   provides airspace restrictions. Currently only used by AirspaceManager, but
+ * - AirspaceAdvisoriesProvider
+ *   Provides airspace advisories and restrictions. Currently only used by AirspaceManager, but
  *   each vehicle could have its own restrictions.
  */
 
@@ -36,10 +36,10 @@
 class Vehicle;
 class QGCApplication;
 class AirspaceWeatherInfoProvider;
-class AirspaceRestrictionProvider;
 class AirspaceRulesetsProvider;
 class AirspaceVehicleManager;
 class AirspaceAdvisoryProvider;
+class AirspaceRestrictionProvider;
 
 Q_DECLARE_LOGGING_CATEGORY(AirspaceManagementLog)
 
@@ -59,11 +59,6 @@ public:
      */
     virtual AirspaceVehicleManager*         instantiateVehicle                      (const Vehicle& vehicle) = 0;
 
-    /**
-     * Factory method to create an AirspaceRestrictionProvider object
-     */
-    virtual AirspaceRestrictionProvider*    instantiateRestrictionProvider          () = 0;
-
     /**
      * Factory method to create an AirspaceRulesetsProvider object
      */
@@ -79,6 +74,11 @@ public:
      */
     virtual AirspaceAdvisoryProvider*       instatiateAirspaceAdvisoryProvider      () = 0;
 
+    /**
+     * Factory method to create an AirspaceRestrictionProvider object
+     */
+    virtual AirspaceRestrictionProvider*    instantiateAirspaceRestrictionProvider  () = 0;
+
     /**
      * Set the ROI for airspace information (restrictions shown in UI)
      * @param center Center coordinate for ROI
@@ -86,11 +86,10 @@ public:
      */
     void setROI                                 (const QGeoCoordinate& center, double radiusMeters);
 
-    QmlObjectListModel* polygonRestrictions     () { return &_polygonRestrictions; }
-    QmlObjectListModel* circularRestrictions    () { return &_circleRestrictions;  }
     AirspaceWeatherInfoProvider* weatherInfo    () { return _weatherProvider; }
     AirspaceAdvisoryProvider*    advisories     () { return _advisories; }
     AirspaceRulesetsProvider*    rulesets       () { return _rulesetsProvider; }
+    AirspaceRestrictionProvider* airspaces      () { return _airspaces; }
 
     void setToolbox(QGCToolbox* toolbox) override;
 
@@ -99,22 +98,13 @@ public:
      */
     virtual QString name            () const = 0;
 
-protected slots:
-    virtual void _rulessetsUpdated  (bool success);
-
-private slots:
-    void _restrictionsUpdated       (bool success);
-
 private:
     void _updateToROI   ();
 
-    AirspaceRestrictionProvider*    _restrictionsProvider   = nullptr; ///< Restrictions that are shown in the UI
-    AirspaceRulesetsProvider*       _rulesetsProvider       = nullptr; ///< Restrictions that are shown in the UI
+    AirspaceRulesetsProvider*       _rulesetsProvider       = nullptr; ///< Rulesets that are shown in the UI
     AirspaceWeatherInfoProvider*    _weatherProvider        = nullptr; ///< Weather info that is shown in the UI
     AirspaceAdvisoryProvider*       _advisories             = nullptr; ///< Advisory info that is shown in the UI
-
-    QmlObjectListModel _polygonRestrictions;    ///< current polygon restrictions
-    QmlObjectListModel _circleRestrictions;     ///< current circle restrictions
+    AirspaceRestrictionProvider*    _airspaces              = nullptr; ///< Airspace info that is shown in the UI
 
     QTimer                          _roiUpdateTimer;
     QGeoCoordinate                  _roiCenter;

src/AirspaceManagement/AirspaceRestrictionProvider.h

@@ -14,6 +14,8 @@
  * Base class that queries for airspace restrictions
  */
 
+#include "QmlObjectListModel.h"
+
 #include <QObject>
 #include <QList>
 #include <QGeoCoordinate>
@@ -27,6 +29,9 @@ public:
     AirspaceRestrictionProvider     (QObject* parent = NULL);
     ~AirspaceRestrictionProvider    () = default;
 
+    Q_PROPERTY(QmlObjectListModel*  polygons        READ polygons       CONSTANT)
+    Q_PROPERTY(QmlObjectListModel*  circles         READ circles        CONSTANT)
+
     /**
      * Set region of interest that should be queried. When finished, the requestDone() signal will be emmited.
      * @param center Center coordinate for ROI
@@ -34,13 +39,6 @@ public:
      */
     virtual void setROI (const QGeoCoordinate& center, double radiusMeters) = 0;
 
-    const QList<AirspacePolygonRestriction*>&   polygons() const { return _polygonList; }
-    const QList<AirspaceCircularRestriction*>&  circles () const { return _circleList;  }
-
-signals:
-    void requestDone    (bool success);
-
-protected:
-    QList<AirspacePolygonRestriction*>  _polygonList;
-    QList<AirspaceCircularRestriction*> _circleList;
+    virtual QmlObjectListModel* polygons        () = 0;     ///< List of AirspacePolygonRestriction objects
+    virtual QmlObjectListModel* circles         () = 0;     ///< List of AirspaceCircularRestriction objects
 };

src/FlightDisplay/FlightDisplayViewMap.qml

@@ -331,21 +331,21 @@ FlightMap {
 
     // Airspace overlap support
     MapItemView {
-        model:              _airspaceManagement && _activeVehicle.airspaceController.airspaceVisible ? _activeVehicle.airspaceController.circles : []
+        model:              _airspaceManagement && _activeVehicle.airspaceController.airspaceVisible ? _activeVehicle.airspaceController.airspaces.circles : []
         delegate: MapCircle {
             center:         object.center
             radius:         object.radius
+            color:          Qt.rgba(0.94, 0.87, 0, 0.15)
             border.color:   Qt.rgba(1,1,1,0.85)
-            color:          Qt.rgba(0.94,0.87,0,0.25)
         }
     }
 
     MapItemView {
-        model:              _airspaceManagement && _activeVehicle.airspaceController.airspaceVisible ? _activeVehicle.airspaceController.polygons : []
+        model:              _airspaceManagement && _activeVehicle.airspaceController.airspaceVisible ? _activeVehicle.airspaceController.airspaces.polygons : []
         delegate: MapPolygon {
-            border.color:   Qt.rgba(1,1,1,0.85)
-            color:          Qt.rgba(0.94,0.87,0,0.25)
             path:           object.polygon
+            color:          Qt.rgba(0.94, 0.87, 0, 0.15)
+            border.color:   Qt.rgba(1,1,1,0.85)
         }
     }
 }