Added handling of route points passing

map/routing_manager.cpp

@@ -101,12 +101,25 @@ RoutingManager::RoutingManager(Callbacks && callbacks, Delegate & delegate)
     guard.m_controller.CreateUserMark(pt);
 #endif
   });
+
   m_routingSession.SetReadyCallbacks(
       [this](Route const & route, IRouter::ResultCode code) { OnBuildRouteReady(route, code); },
       [this](Route const & route, IRouter::ResultCode code) { OnRebuildRouteReady(route, code); });
 
-  m_routingSession.SetCheckpointCallback(
-      [this](size_t passedCheckpointIdx) { /* TODO insert reaction here */ });
+  m_routingSession.SetCheckpointCallback([this](size_t passedCheckpointIdx)
+  {
+    GetPlatform().RunOnGuiThread([this, passedCheckpointIdx]()
+    {
+      size_t const pointsCount = GetRoutePointsCount();
+      ASSERT_LESS(passedCheckpointIdx, pointsCount, ());
+      if (passedCheckpointIdx == 0)
+        OnRoutePointPassed(RouteMarkType::Start, 0);
+      else if (passedCheckpointIdx + 1 == pointsCount)
+        OnRoutePointPassed(RouteMarkType::Finish, 0);
+      else
+        OnRoutePointPassed(RouteMarkType::Intermediate, static_cast<int8_t>(passedCheckpointIdx - 1));
+    });
+  });
 }
 
 void RoutingManager::SetBookmarkManager(BookmarkManager * bmManager)
@@ -163,6 +176,20 @@ void RoutingManager::OnRebuildRouteReady(Route const & route, IRouter::ResultCod
   CallRouteBuilded(code, storage::TCountriesVec());
 }
 
+void RoutingManager::OnRoutePointPassed(RouteMarkType type, int8_t intermediateIndex)
+{
+  // Remove route point.
+  {
+    ASSERT(m_bmManager != nullptr, ());
+    UserMarkControllerGuard guard(*m_bmManager, UserMarkType::ROUTING_MARK);
+    RoutePointsLayout routePoints(guard.m_controller);
+    routePoints.PassRoutePoint(type, intermediateIndex);
+  }
+
+  if (type == RouteMarkType::Finish)
+    RemoveRoute(false /* deactivateFollowing */);
+}
+
 RouterType RoutingManager::GetBestRouter(m2::PointD const & startPoint,
                                          m2::PointD const & finalPoint) const
 {
@@ -245,8 +272,17 @@ void RoutingManager::RemoveRoute(bool deactivateFollowing)
   if (m_drapeEngine == nullptr)
     return;
 
-  for (auto const & subrouteId : m_drapeSubroutes)
-    m_drapeEngine->RemoveSubroute(subrouteId, deactivateFollowing);
+  std::lock_guard<std::mutex> lock(m_drapeSubroutesMutex);
+  if (deactivateFollowing)
+  {
+    // Remove all subroutes.
+    m_drapeEngine->RemoveSubroute(dp::DrapeID(), true /* deactivateFollowing */);
+  }
+  else
+  {
+    for (auto const & subrouteId : m_drapeSubroutes)
+      m_drapeEngine->RemoveSubroute(subrouteId, false /* deactivateFollowing */);
+  }
   m_drapeSubroutes.clear();
 }
 
@@ -258,6 +294,7 @@ void RoutingManager::InsertRoute(routing::Route const & route)
   // TODO: Now we always update whole route, so we need to remove previous one.
   RemoveRoute(false /* deactivateFollowing */);
 
+  std::lock_guard<std::mutex> lock(m_drapeSubroutesMutex);
   std::vector<RouteSegment> segments;
   std::vector<m2::PointD> points;
   double distance = 0.0;
@@ -341,9 +378,7 @@ void RoutingManager::CloseRouting(bool removeRoutePoints)
     m_drapeEngine->RemoveAllRoutePreviewSegments();
   
   if (m_routingSession.IsBuilt())
-  {
     m_routingSession.EmitCloseRoutingEvent();
-  }
   m_routingSession.Reset();
   RemoveRoute(true /* deactivateFollowing */);
 
@@ -389,6 +424,13 @@ std::vector<RouteMarkData> RoutingManager::GetRoutePoints() const
   return result;
 }
 
+size_t RoutingManager::GetRoutePointsCount() const
+{
+  UserMarkControllerGuard guard(*m_bmManager, UserMarkType::ROUTING_MARK);
+  RoutePointsLayout routePoints(guard.m_controller);
+  return routePoints.GetRoutePointsCount();
+}
+
 bool RoutingManager::CouldAddIntermediatePoint() const
 {
   if (!IsRoutingActive())

map/routing_manager.hpp

@@ -16,6 +16,7 @@
 
 #include <functional>
 #include <memory>
+#include <mutex>
 #include <string>
 #include <utility>
 #include <vector>
@@ -165,6 +166,7 @@ public:
 
   void AddRoutePoint(RouteMarkData && markData);
   std::vector<RouteMarkData> GetRoutePoints() const;
+  size_t GetRoutePointsCount() const;
   void RemoveRoutePoint(RouteMarkType type, int8_t intermediateIndex = 0);
   void RemoveIntermediateRoutePoints();
   void MoveRoutePoint(RouteMarkType currentType, int8_t currentIntermediateIndex,
@@ -181,6 +183,7 @@ public:
                         storage::TCountriesVec const & absentCountries);
   void OnBuildRouteReady(routing::Route const & route, routing::IRouter::ResultCode code);
   void OnRebuildRouteReady(routing::Route const & route, routing::IRouter::ResultCode code);
+  void OnRoutePointPassed(RouteMarkType type, int8_t intermediateIndex);
   void OnLocationUpdate(location::GpsInfo & info);
   void SetAllowSendingPoints(bool isAllowed)
   {
@@ -228,6 +231,7 @@ private:
   BookmarkManager * m_bmManager = nullptr;
 
   std::vector<dp::DrapeID> m_drapeSubroutes;
+  std::mutex m_drapeSubroutesMutex;
 
   DECLARE_THREAD_CHECKER(m_threadChecker);
 };

map/routing_mark.cpp

@@ -172,6 +172,15 @@ bool RoutePointsLayout::MoveRoutePoint(RouteMarkType currentType, int8_t current
   return true;
 }
 
+void RoutePointsLayout::PassRoutePoint(RouteMarkType type, int8_t intermediateIndex)
+{
+  RouteMarkPoint * point = GetRoutePoint(type, intermediateIndex);
+  if (point == nullptr)
+    return;
+  point->SetPassed(true);
+  point->SetIsVisible(false);
+}
+
 RouteMarkPoint * RoutePointsLayout::GetRoutePoint(RouteMarkType type, int8_t intermediateIndex)
 {
   for (size_t i = 0, sz = m_routeMarks.GetUserMarkCount(); i < sz; ++i)
@@ -221,6 +230,11 @@ std::vector<RouteMarkPoint *> RoutePointsLayout::GetRoutePoints()
   return points;
 }
 
+size_t RoutePointsLayout::GetRoutePointsCount() const
+{
+  return m_routeMarks.GetUserMarkCount();
+}
+
 void RoutePointsLayout::ForEachIntermediatePoint(TRoutePointCallback const & fn)
 {
   for (size_t i = 0, sz = m_routeMarks.GetUserMarkCount(); i < sz; ++i)

map/routing_mark.hpp

@@ -42,9 +42,12 @@ public:
   void SetIntermediateIndex(int8_t index) { m_markData.m_intermediateIndex = index; }
   int8_t GetIntermediateIndex() const { return m_markData.m_intermediateIndex; }
 
-  void SetIsMyPosition(bool isMyPosition) { m_markData.m_isMyPosition = isMyPosition;}
+  void SetIsMyPosition(bool isMyPosition) { m_markData.m_isMyPosition = isMyPosition; }
   bool IsMyPosition() const { return m_markData.m_isMyPosition; }
 
+  void SetPassed(bool isPassed) { m_markData.m_isPassed = isPassed; }
+  bool IsPassed() const { return m_markData.m_isPassed; }
+
   RouteMarkData const & GetMarkData() const { return m_markData; }
   void SetMarkData(RouteMarkData && data) { m_markData = std::move(data); }
 
@@ -70,10 +73,12 @@ public:
   RouteMarkPoint * AddRoutePoint(RouteMarkData && data);
   RouteMarkPoint * GetRoutePoint(RouteMarkType type, int8_t intermediateIndex = 0);
   std::vector<RouteMarkPoint *> GetRoutePoints();
+  size_t GetRoutePointsCount() const;
   bool RemoveRoutePoint(RouteMarkType type, int8_t intermediateIndex = 0);
   void RemoveIntermediateRoutePoints();
   bool MoveRoutePoint(RouteMarkType currentType, int8_t currentIntermediateIndex,
                       RouteMarkType destType, int8_t destIntermediateIndex);
+  void PassRoutePoint(RouteMarkType type, int8_t intermediateIndex = 0);
 
 private:
   using TRoutePointCallback = function<void (RouteMarkPoint * mark)>;

qt/draw_widget.cpp

@@ -112,6 +112,15 @@ void DrawWidget::RetryToDownloadCountry(storage::TCountryId const & countryId)
 
 void DrawWidget::PrepareShutdown()
 {
+  auto & routingManager = m_framework.GetRoutingManager();
+  if (routingManager.IsRoutingActive() && routingManager.IsRoutingFollowing())
+  {
+    auto style = m_framework.GetMapStyle();
+    if (style == MapStyle::MapStyleVehicleClear)
+      m_framework.MarkMapStyle(MapStyle::MapStyleClear);
+    else if (style == MapStyle::MapStyleVehicleDark)
+      m_framework.MarkMapStyle(MapStyle::MapStyleDark);
+  }
 }
 
 void DrawWidget::UpdateAfterSettingsChanged()