Updating airmapd with its fixes for flight plan updates.

libs/airmapd/include/airmap/flight_plan.h

@@ -53,6 +53,8 @@ struct FlightPlan {
   Geometry geometry;                  ///< The geometry describing the flight.
   DateTime start_time;                ///< Point in time when the flight will start/was started.
   DateTime end_time;                  ///< Point in time when the fligth will end.
+  std::vector<RuleSet::Id> rulesets;  ///< RuleSets that apply to this flight plan.
+  std::unordered_map<std::string, RuleSet::Feature::Value> features;  ///< Additional properties of the planned flight.
 };
 
 }  // namespace airmap

src/Airmap/AirMapFlightPlanManager.cc

@@ -17,11 +17,11 @@
 #include "PlanMasterController.h"
 #include "QGCMAVLink.h"
 
-#include "airmap/pilots.h"
-#include "airmap/flights.h"
 #include "airmap/date_time.h"
 #include "airmap/flight_plans.h"
+#include "airmap/flights.h"
 #include "airmap/geometry.h"
+#include "airmap/pilots.h"
 
 using namespace airmap;
 
@@ -413,39 +413,16 @@ AirMapFlightPlanManager::_createFlightPlan()
 
 //-----------------------------------------------------------------------------
 void
-AirMapFlightPlanManager::_uploadFlightPlan()
+AirMapFlightPlanManager::_updateRulesAndFeatures(std::vector<RuleSet::Id>& rulesets, std::unordered_map<std::string, RuleSet::Feature::Value>& features)
 {
-    qCDebug(AirMapManagerLog) << "Uploading flight plan. State:" << (int)_state;
-    if(_state != State::Idle) {
-        QTimer::singleShot(100, this, &AirMapFlightPlanManager::_uploadFlightPlan);
-        return;
-    }
-    _state = State::FlightUpload;
-    std::weak_ptr<LifetimeChecker> isAlive(_instance);
-    _shared.doRequestWithLogin([this, isAlive](const QString& login_token) {
-        if (!isAlive.lock()) return;
-        if (_state != State::FlightUpload) return;
-        FlightPlans::Create::Parameters params;
-        params.max_altitude = _flight.maxAltitude;
-        params.min_altitude = 0.0;
-        params.buffer       = 2.f;
-        params.latitude     = _flight.takeoffCoord.latitude();
-        params.longitude    = _flight.takeoffCoord.longitude();
-        params.pilot.id     = _pilotID.toStdString();
-        quint64 start       = QDateTime::currentDateTimeUtc().toMSecsSinceEpoch();
-        quint64 end         = start + 60 * 30 * 1000;
-        params.start_time   = airmap::from_milliseconds_since_epoch(airmap::Milliseconds{(long long)start});
-        params.end_time     = airmap::from_milliseconds_since_epoch(airmap::Milliseconds{(long long)end});
-        //-- Rules
     AirMapRulesetsManager* pRulesMgr = dynamic_cast<AirMapRulesetsManager*>(qgcApp()->toolbox()->airspaceManager()->ruleSets());
     if(pRulesMgr) {
         for(int rs = 0; rs < pRulesMgr->ruleSets()->count(); rs++) {
             AirMapRuleSet* ruleSet = qobject_cast<AirMapRuleSet*>(pRulesMgr->ruleSets()->get(rs));
             //-- If this ruleset is selected
             if(ruleSet && ruleSet->selected()) {
-                    params.rulesets.push_back(ruleSet->id().toStdString());
+                rulesets.push_back(ruleSet->id().toStdString());
                 //-- Features within each rule
-                    /*
                 for(int r = 0; r < ruleSet->rules()->count(); r++) {
                     AirMapRule* rule = qobject_cast<AirMapRule*>(ruleSet->rules()->get(r));
                     if(rule) {
@@ -454,18 +431,18 @@ AirMapFlightPlanManager::_uploadFlightPlan()
                             if(feature && feature->value().isValid()) {
                                 switch(feature->type()) {
                                 case AirspaceRuleFeature::Boolean:
-                                        params.features[feature->name().toStdString()] = RuleSet::Feature::Value(feature->value().toBool());
+                                    features[feature->name().toStdString()] = RuleSet::Feature::Value(feature->value().toBool());
                                     break;
                                 case AirspaceRuleFeature::Float:
                                     //-- Sanity check for floats
                                     if(isfinite(feature->value().toFloat())) {
-                                            params.features[feature->name().toStdString()] = RuleSet::Feature::Value(feature->value().toFloat());
+                                        features[feature->name().toStdString()] = RuleSet::Feature::Value(feature->value().toFloat());
                                     }
                                     break;
                                 case AirspaceRuleFeature::String:
                                     //-- Skip empty responses
                                     if(!feature->value().toString().isEmpty()) {
-                                            params.features[feature->name().toStdString()] = RuleSet::Feature::Value(feature->value().toString().toStdString());
+                                        features[feature->name().toStdString()] = RuleSet::Feature::Value(feature->value().toString().toStdString());
                                     }
                                     break;
                                 default:
@@ -475,10 +452,38 @@ AirMapFlightPlanManager::_uploadFlightPlan()
                         }
                     }
                 }
-                    */
             }
         }
     }
+}
+
+//-----------------------------------------------------------------------------
+void
+AirMapFlightPlanManager::_uploadFlightPlan()
+{
+    qCDebug(AirMapManagerLog) << "Uploading flight plan. State:" << (int)_state;
+    if(_state != State::Idle) {
+        QTimer::singleShot(100, this, &AirMapFlightPlanManager::_uploadFlightPlan);
+        return;
+    }
+    _state = State::FlightUpload;
+    std::weak_ptr<LifetimeChecker> isAlive(_instance);
+    _shared.doRequestWithLogin([this, isAlive](const QString& login_token) {
+        if (!isAlive.lock()) return;
+        if (_state != State::FlightUpload) return;
+        FlightPlans::Create::Parameters params;
+        params.max_altitude = _flight.maxAltitude;
+        params.min_altitude = 0.0;
+        params.buffer       = 2.f;
+        params.latitude     = _flight.takeoffCoord.latitude();
+        params.longitude    = _flight.takeoffCoord.longitude();
+        params.pilot.id     = _pilotID.toStdString();
+        quint64 start       = QDateTime::currentDateTimeUtc().toMSecsSinceEpoch();
+        quint64 end         = start + 60 * 30 * 1000;
+        params.start_time   = airmap::from_milliseconds_since_epoch(airmap::Milliseconds{(long long)start});
+        params.end_time     = airmap::from_milliseconds_since_epoch(airmap::Milliseconds{(long long)end});
+        //-- Rules & Features
+        _updateRulesAndFeatures(params.rulesets, params.features);
         //-- Geometry: polygon
         Geometry::Polygon polygon;
         for (const auto& qcoord : _flight.coords) {
@@ -535,6 +540,10 @@ AirMapFlightPlanManager::_updateFlightPlan()
     _flightPlan.buffer            = 2.f;
     _flightPlan.takeoff.latitude  = _flight.takeoffCoord.latitude();
     _flightPlan.takeoff.longitude = _flight.takeoffCoord.longitude();
+    //-- Rules & Features
+    _flightPlan.rulesets.clear();
+    _flightPlan.features.clear();
+    _updateRulesAndFeatures(_flightPlan.rulesets, _flightPlan.features);
     //-- Geometry: polygon
     Geometry::Polygon polygon;
     for (const auto& qcoord : _flight.coords) {
@@ -544,17 +553,6 @@ AirMapFlightPlanManager::_updateFlightPlan()
         polygon.outer_ring.coordinates.push_back(coord);
     }
     _flightPlan.geometry = Geometry(polygon);
-
-    //-- Rules
-    /*
-    AirMapRulesetsManager* pRulesMgr = dynamic_cast<AirMapRulesetsManager*>(qgcApp()->toolbox()->airspaceManager()->ruleSets());
-    if(pRulesMgr) {
-        foreach(QString ruleset, pRulesMgr->rulesetsIDs()) {
-            params.flight_plan.rulesets.push_back(ruleset.toStdString());
-        }
-    }
-    */
-
     _state = State::FlightUpdate;
     std::weak_ptr<LifetimeChecker> isAlive(_instance);
     _shared.doRequestWithLogin([this, isAlive](const QString& login_token) {

src/Airmap/AirMapFlightPlanManager.h

@@ -20,6 +20,7 @@
 
 #include "airmap/flight.h"
 #include "airmap/flight_plan.h"
+#include "airmap/ruleset.h"
 
 class PlanMasterController;
 
@@ -112,6 +113,7 @@ private slots:
 private:
     void _createFlightPlan                  ();
     bool _collectFlightDtata                ();
+    void _updateRulesAndFeatures            (std::vector<airmap::RuleSet::Id>& rulesets, std::unordered_map<std::string, airmap::RuleSet::Feature::Value>& features);
 
 private:
     enum class State {

src/Airmap/AirMapManager.cc

@@ -37,8 +37,8 @@ AirMapManager::AirMapManager(QGCApplication* app, QGCToolbox* toolbox)
 {
     _logger = std::make_shared<qt::Logger>();
     qt::register_types(); // TODO: still needed?
-    _logger->logging_category().setEnabled(QtDebugMsg,   false);
-    _logger->logging_category().setEnabled(QtInfoMsg,    false);
+    _logger->logging_category().setEnabled(QtDebugMsg,   true);
+    _logger->logging_category().setEnabled(QtInfoMsg,    true);
     _logger->logging_category().setEnabled(QtWarningMsg, false);
     _dispatchingLogger = std::make_shared<qt::DispatchingLogger>(_logger);
     connect(&_shared, &AirMapSharedState::error, this, &AirMapManager::_error);