Added routing manager

map/routing_manager.cpp

@@ -0,0 +1,422 @@
+#include "routing_manager.hpp"
+
+#include "map/chart_generator.hpp"
+#include "map/mwm_tree.hpp"
+
+#include "tracking/reporter.hpp"
+
+#include "routing/car_router.hpp"
+#include "routing/index_router.hpp"
+#include "routing/num_mwm_id.hpp"
+#include "routing/online_absent_fetcher.hpp"
+#include "routing/road_graph_router.hpp"
+#include "routing/route.hpp"
+#include "routing/routing_algorithm.hpp"
+#include "routing/routing_helpers.hpp"
+
+#include "drape_frontend/drape_engine.hpp"
+
+#include "indexer/map_style_reader.hpp"
+#include "indexer/scales.hpp"
+
+#include "storage/country_info_getter.hpp"
+#include "storage/storage.hpp"
+
+#include "platform/country_file.hpp"
+#include "platform/mwm_traits.hpp"
+#include "platform/platform.hpp"
+
+#include "3party/Alohalytics/src/alohalytics.h"
+
+namespace
+{
+char const kRouterTypeKey[] = "router";
+}  // namespace
+
+namespace marketing
+{
+char const * const kRoutingCalculatingRoute = "Routing_CalculatingRoute";
+}  // namespace marketing
+
+using namespace routing;
+
+RoutingManager::RoutingManager(Callbacks && callbacks, Delegate & delegate)
+  : m_callbacks(std::move(callbacks)), m_delegate(delegate)
+{
+  auto const routingStatisticsFn = [](map<string, string> const & statistics) {
+    alohalytics::LogEvent("Routing_CalculatingRoute", statistics);
+    GetPlatform().GetMarketingService().SendMarketingEvent(marketing::kRoutingCalculatingRoute, {});
+  };
+
+  m_routingSession.Init(routingStatisticsFn, m_callbacks.m_visualizer);
+  m_routingSession.SetReadyCallbacks(
+      [&](Route const & route, IRouter::ResultCode code) { OnBuildRouteReady(route, code); },
+      [&](Route const & route, IRouter::ResultCode code) { OnRebuildRouteReady(route, code); });
+}
+
+void RoutingManager::OnBuildRouteReady(Route const & route, IRouter::ResultCode code)
+{
+  storage::TCountriesVec absentCountries;
+  if (code == IRouter::NoError)
+  {
+    double const kRouteScaleMultiplier = 1.5;
+
+    InsertRoute(route);
+    m_drapeEngine->StopLocationFollow();
+
+    // Validate route (in case of bicycle routing it can be invalid).
+    ASSERT(route.IsValid(), ());
+    if (route.IsValid())
+    {
+      m2::RectD routeRect = route.GetPoly().GetLimitRect();
+      routeRect.Scale(kRouteScaleMultiplier);
+      m_drapeEngine->SetModelViewRect(routeRect, true /* applyRotation */, -1 /* zoom */,
+                                      true /* isAnim */);
+    }
+  }
+  else
+  {
+    absentCountries.assign(route.GetAbsentCountries().begin(), route.GetAbsentCountries().end());
+
+    if (code != IRouter::NeedMoreMaps)
+      RemoveRoute(true /* deactivateFollowing */);
+  }
+  CallRouteBuilded(code, absentCountries);
+}
+
+void RoutingManager::OnRebuildRouteReady(Route const & route, IRouter::ResultCode code)
+{
+  if (code != IRouter::NoError)
+    return;
+
+  RemoveRoute(false /* deactivateFollowing */);
+  InsertRoute(route);
+  CallRouteBuilded(code, storage::TCountriesVec());
+}
+
+RouterType RoutingManager::GetBestRouter(m2::PointD const & startPoint,
+                                         m2::PointD const & finalPoint) const
+{
+  // todo Implement something more sophisticated here (or delete the method).
+  return GetLastUsedRouter();
+}
+
+RouterType RoutingManager::GetLastUsedRouter() const
+{
+  string routerTypeStr;
+  if (!settings::Get(kRouterTypeKey, routerTypeStr))
+    return RouterType::Vehicle;
+
+  auto const routerType = routing::FromString(routerTypeStr);
+
+  switch (routerType)
+  {
+  case RouterType::Pedestrian:
+  case RouterType::Bicycle: return routerType;
+  default: return RouterType::Vehicle;
+  }
+}
+
+void RoutingManager::SetRouterImpl(routing::RouterType type)
+{
+  auto const indexGetterFn = m_callbacks.m_featureIndexGetter;
+  ASSERT(indexGetterFn, ());
+  unique_ptr<IRouter> router;
+  unique_ptr<OnlineAbsentCountriesFetcher> fetcher;
+
+  auto const countryFileGetter = [this](m2::PointD const & p) -> string {
+    // TODO (@gorshenin): fix CountryInfoGetter to return CountryFile
+    // instances instead of plain strings.
+    return m_callbacks.m_countryInfoGetter().GetRegionCountryId(p);
+  };
+
+  if (type == RouterType::Pedestrian)
+  {
+    router = CreatePedestrianAStarBidirectionalRouter(indexGetterFn(), countryFileGetter);
+    m_routingSession.SetRoutingSettings(routing::GetPedestrianRoutingSettings());
+  }
+  else if (type == RouterType::Bicycle)
+  {
+    router = CreateBicycleAStarBidirectionalRouter(indexGetterFn(), countryFileGetter);
+    m_routingSession.SetRoutingSettings(routing::GetBicycleRoutingSettings());
+  }
+  else
+  {
+    auto & index = m_callbacks.m_featureIndexGetter();
+
+    auto localFileChecker = [this](string const & countryFile) -> bool {
+      MwmSet::MwmId const mwmId = m_callbacks.m_featureIndexGetter().GetMwmIdByCountryFile(
+          platform::CountryFile(countryFile));
+      if (!mwmId.IsAlive())
+        return false;
+
+      return version::MwmTraits(mwmId.GetInfo()->m_version).HasRoutingIndex();
+    };
+
+    auto numMwmIds = make_shared<routing::NumMwmIds>();
+
+    m_delegate.RegisterCountryFiles(numMwmIds);
+
+    auto const getMwmRectByName = [this](string const & countryId) -> m2::RectD {
+      return m_callbacks.m_countryInfoGetter().GetLimitRectForLeaf(countryId);
+    };
+
+    router.reset(new CarRouter(
+        index, countryFileGetter,
+        IndexRouter::CreateCarRouter(countryFileGetter, getMwmRectByName, numMwmIds,
+                                     MakeNumMwmTree(*numMwmIds, m_callbacks.m_countryInfoGetter()),
+                                     m_routingSession, index)));
+    fetcher.reset(new OnlineAbsentCountriesFetcher(countryFileGetter, localFileChecker));
+    m_routingSession.SetRoutingSettings(routing::GetCarRoutingSettings());
+  }
+
+  m_routingSession.SetRouter(move(router), move(fetcher));
+  m_currentRouterType = type;
+}
+
+void RoutingManager::RemoveRoute(bool deactivateFollowing)
+{
+  if (m_drapeEngine != nullptr)
+    m_drapeEngine->RemoveRoute(deactivateFollowing);
+}
+
+void RoutingManager::InsertRoute(routing::Route const & route)
+{
+  if (m_drapeEngine == nullptr)
+    return;
+
+  if (route.GetPoly().GetSize() < 2)
+  {
+    LOG(LWARNING, ("Invalid track - only", route.GetPoly().GetSize(), "point(s)."));
+    return;
+  }
+
+  vector<double> turns;
+  if (m_currentRouterType == RouterType::Vehicle || m_currentRouterType == RouterType::Bicycle ||
+      m_currentRouterType == RouterType::Taxi)
+  {
+    route.GetTurnsDistances(turns);
+  }
+
+  df::ColorConstant routeColor = df::kRouteColor;
+  df::RoutePattern pattern;
+  if (m_currentRouterType == RouterType::Pedestrian)
+  {
+    routeColor = df::kRoutePedestrian;
+    pattern = df::RoutePattern(4.0, 2.0);
+  }
+  else if (m_currentRouterType == RouterType::Bicycle)
+  {
+    routeColor = df::kRouteBicycle;
+    pattern = df::RoutePattern(8.0, 2.0);
+  }
+
+  m_drapeEngine->AddRoute(route.GetPoly(), turns, routeColor, route.GetTraffic(), pattern);
+}
+
+void RoutingManager::FollowRoute()
+{
+  ASSERT(m_drapeEngine != nullptr, ());
+
+  if (!m_routingSession.EnableFollowMode())
+    return;
+
+  m_delegate.OnRouteFollow(m_currentRouterType);
+  m_drapeEngine->SetRoutePoint(m2::PointD(), true /* isStart */, false /* isValid */);
+}
+
+void RoutingManager::CloseRouting()
+{
+  if (m_routingSession.IsBuilt())
+  {
+    m_routingSession.EmitCloseRoutingEvent();
+  }
+  m_routingSession.Reset();
+  RemoveRoute(true /* deactivateFollowing */);
+}
+
+void RoutingManager::SetLastUsedRouter(RouterType type)
+{
+  settings::Set(kRouterTypeKey, routing::ToString(type));
+}
+
+void RoutingManager::SetRouteStartPoint(m2::PointD const & pt, bool isValid)
+{
+  if (m_drapeEngine != nullptr)
+    m_drapeEngine->SetRoutePoint(pt, true /* isStart */, isValid);
+}
+
+void RoutingManager::SetRouteFinishPoint(m2::PointD const & pt, bool isValid)
+{
+  if (m_drapeEngine != nullptr)
+    m_drapeEngine->SetRoutePoint(pt, false /* isStart */, isValid);
+}
+
+void RoutingManager::GenerateTurnNotifications(vector<string> & turnNotifications)
+{
+  if (m_currentRouterType == routing::RouterType::Taxi)
+    return;
+
+  return m_routingSession.GenerateTurnNotifications(turnNotifications);
+}
+
+void RoutingManager::BuildRoute(m2::PointD const & finish, uint32_t timeoutSec)
+{
+  ASSERT_THREAD_CHECKER(m_threadChecker, ("BuildRoute"));
+  ASSERT(m_drapeEngine != nullptr, ());
+
+  m2::PointD start;
+  if (!m_drapeEngine->GetMyPosition(start))
+  {
+    CallRouteBuilded(IRouter::NoCurrentPosition, storage::TCountriesVec());
+    return;
+  }
+  BuildRoute(start, finish, false /* isP2P */, timeoutSec);
+}
+
+void RoutingManager::BuildRoute(m2::PointD const & start, m2::PointD const & finish, bool isP2P,
+                                uint32_t timeoutSec)
+{
+  ASSERT_THREAD_CHECKER(m_threadChecker, ("BuildRoute"));
+  ASSERT(m_drapeEngine != nullptr, ());
+
+  // Send tag to Push Woosh.
+  {
+    string tag;
+    switch (m_currentRouterType)
+    {
+    case RouterType::Vehicle:
+      tag = isP2P ? marketing::kRoutingP2PVehicleDiscovered : marketing::kRoutingVehicleDiscovered;
+      break;
+    case RouterType::Pedestrian:
+      tag = isP2P ? marketing::kRoutingP2PPedestrianDiscovered
+                  : marketing::kRoutingPedestrianDiscovered;
+      break;
+    case RouterType::Bicycle:
+      tag = isP2P ? marketing::kRoutingP2PBicycleDiscovered : marketing::kRoutingBicycleDiscovered;
+      break;
+    case RouterType::Taxi:
+      tag = isP2P ? marketing::kRoutingP2PTaxiDiscovered : marketing::kRoutingTaxiDiscovered;
+      break;
+    case RouterType::Count: CHECK(false, ("Bad router type", m_currentRouterType));
+    }
+    GetPlatform().GetMarketingService().SendPushWooshTag(tag);
+  }
+
+  if (IsRoutingActive())
+    CloseRouting();
+
+  m_routingSession.SetUserCurrentPosition(start);
+  m_routingSession.BuildRoute(start, finish, timeoutSec);
+}
+
+bool RoutingManager::DisableFollowMode()
+{
+  bool const disabled = m_routingSession.DisableFollowMode();
+  if (disabled && m_drapeEngine != nullptr)
+    m_drapeEngine->DeactivateRouteFollowing();
+
+  return disabled;
+}
+
+void RoutingManager::CheckLocationForRouting(location::GpsInfo const & info)
+{
+  if (!IsRoutingActive())
+    return;
+
+  auto const featureIndexGetterFn = m_callbacks.m_featureIndexGetter;
+  ASSERT(featureIndexGetterFn, ());
+  RoutingSession::State const state =
+      m_routingSession.OnLocationPositionChanged(info, featureIndexGetterFn());
+  if (state == RoutingSession::RouteNeedRebuild)
+  {
+    m_routingSession.RebuildRoute(
+        MercatorBounds::FromLatLon(info.m_latitude, info.m_longitude),
+        [&](Route const & route, IRouter::ResultCode code) { OnRebuildRouteReady(route, code); },
+        0 /* timeoutSec */, routing::RoutingSession::State::RouteRebuilding);
+  }
+}
+
+void RoutingManager::CallRouteBuilded(routing::IRouter::ResultCode code,
+                                      storage::TCountriesVec const & absentCountries)
+{
+  if (code == IRouter::Cancelled)
+    return;
+
+  m_routingCallback(code, absentCountries);
+}
+
+void RoutingManager::MatchLocationToRoute(location::GpsInfo & location,
+                                          location::RouteMatchingInfo & routeMatchingInfo) const
+{
+  if (!IsRoutingActive())
+    return;
+
+  m_routingSession.MatchLocationToRoute(location, routeMatchingInfo);
+}
+
+bool RoutingManager::HasRouteAltitude() const { return m_routingSession.HasRouteAltitude(); }
+bool RoutingManager::GenerateRouteAltitudeChart(uint32_t width, uint32_t height,
+                                                vector<uint8_t> & imageRGBAData,
+                                                int32_t & minRouteAltitude,
+                                                int32_t & maxRouteAltitude,
+                                                measurement_utils::Units & altitudeUnits) const
+{
+  feature::TAltitudes altitudes;
+  vector<double> segDistance;
+
+  if (!m_routingSession.GetRouteAltitudesAndDistancesM(segDistance, altitudes))
+    return false;
+  segDistance.insert(segDistance.begin(), 0.0);
+
+  if (altitudes.empty())
+    return false;
+
+  if (!maps::GenerateChart(width, height, segDistance, altitudes,
+                           GetStyleReader().GetCurrentStyle(), imageRGBAData))
+    return false;
+
+  auto const minMaxIt = minmax_element(altitudes.cbegin(), altitudes.cend());
+  feature::TAltitude const minRouteAltitudeM = *minMaxIt.first;
+  feature::TAltitude const maxRouteAltitudeM = *minMaxIt.second;
+
+  if (!settings::Get(settings::kMeasurementUnits, altitudeUnits))
+    altitudeUnits = measurement_utils::Units::Metric;
+
+  switch (altitudeUnits)
+  {
+  case measurement_utils::Units::Imperial:
+    minRouteAltitude = measurement_utils::MetersToFeet(minRouteAltitudeM);
+    maxRouteAltitude = measurement_utils::MetersToFeet(maxRouteAltitudeM);
+    break;
+  case measurement_utils::Units::Metric:
+    minRouteAltitude = minRouteAltitudeM;
+    maxRouteAltitude = maxRouteAltitudeM;
+    break;
+  }
+  return true;
+}
+
+bool RoutingManager::IsTrackingReporterEnabled() const
+{
+  if (m_currentRouterType != routing::RouterType::Vehicle)
+    return false;
+
+  if (!m_routingSession.IsFollowing())
+    return false;
+
+  bool enableTracking = false;
+  UNUSED_VALUE(settings::Get(tracking::Reporter::kEnableTrackingKey, enableTracking));
+  return enableTracking;
+}
+
+void RoutingManager::SetRouter(RouterType type)
+{
+  ASSERT_THREAD_CHECKER(m_threadChecker, ("SetRouter"));
+
+  if (m_currentRouterType == type)
+    return;
+
+  SetLastUsedRouter(type);
+  SetRouterImpl(type);
+}

map/routing_manager.hpp

@@ -0,0 +1,195 @@
+#include "drape/pointers.hpp"
+
+#include "routing/route.hpp"
+#include "routing/routing_session.hpp"
+
+#include "storage/index.hpp"
+
+#include "base/thread_checker.hpp"
+
+#include <functional>
+#include <memory>
+
+namespace df
+{
+class DrapeEngine;
+}
+
+namespace storage
+{
+class CountryInfoGetter;
+class Storage;
+}
+
+namespace routing
+{
+class NumMwmIds;
+}
+
+class Index;
+
+class RoutingManager final
+{
+public:
+  class Delegate
+  {
+  public:
+    virtual void OnRouteFollow(routing::RouterType type) = 0;
+    virtual void RegisterCountryFiles(std::shared_ptr<routing::NumMwmIds> ptr) const = 0;
+
+    virtual ~Delegate() = default;
+  };
+
+  struct Callbacks
+  {
+    using FeatureIndexGetterFn = std::function<Index &()>;
+    using CountryInfoGetterFn = std::function<storage::CountryInfoGetter &()>;
+    using VisualizerFn = std::function<void(m2::PointD const &)>;
+
+    Callbacks(FeatureIndexGetterFn && featureIndexGetter, CountryInfoGetterFn && countryInfoGetter,
+              VisualizerFn && visualizer)
+      : m_featureIndexGetter(std::move(featureIndexGetter))
+      , m_countryInfoGetter(std::move(countryInfoGetter))
+      , m_visualizer(std::move(visualizer))
+    {
+    }
+
+    FeatureIndexGetterFn m_featureIndexGetter;
+    CountryInfoGetterFn m_countryInfoGetter;
+    VisualizerFn m_visualizer;
+  };
+
+  using RouteBuildingCallback =
+      std::function<void(routing::IRouter::ResultCode, storage::TCountriesVec const &)>;
+  using RouteProgressCallback = std::function<void(float)>;
+
+  RoutingManager(Callbacks && callbacks, Delegate & delegate);
+
+  routing::RoutingSession const & RoutingSession() const { return m_routingSession; }
+  routing::RoutingSession & RoutingSession() { return m_routingSession; }
+  void SetRouter(routing::RouterType type);
+  routing::RouterType GetRouter() const { return m_currentRouterType; }
+  bool IsRoutingActive() const { return m_routingSession.IsActive(); }
+  bool IsRouteBuilt() const { return m_routingSession.IsBuilt(); }
+  bool IsRouteBuilding() const { return m_routingSession.IsBuilding(); }
+  bool IsRouteRebuildingOnly() const { return m_routingSession.IsRebuildingOnly(); }
+  bool IsRouteNotReady() const { return m_routingSession.IsNotReady(); }
+  bool IsRouteFinished() const { return m_routingSession.IsFinished(); }
+  bool IsOnRoute() const { return m_routingSession.IsOnRoute(); }
+  void BuildRoute(m2::PointD const & finish, uint32_t timeoutSec);
+  void BuildRoute(m2::PointD const & start, m2::PointD const & finish, bool isP2P,
+                  uint32_t timeoutSec);
+  // FollowRoute has a bug where the router follows the route even if the method hads't been called.
+  // This method was added because we do not want to break the behaviour that is familiar to our
+  // users.
+  bool DisableFollowMode();
+  /// @TODO(AlexZ): Warning! These two routing callbacks are the only callbacks which are not called
+  /// in the main thread context.
+  /// UI code should take it into an account. This is a result of current implementation, that can
+  /// be improved:
+  /// Drape core calls some RunOnGuiThread with "this" pointers, and it causes crashes on Android,
+  /// when Drape engine is destroyed
+  /// while switching between activities. Current workaround cleans all callbacks when destroying
+  /// Drape engine
+  /// (@see MwmApplication.clearFunctorsOnUiThread on Android). Better soulution can be fair copying
+  /// of all needed information into
+  /// lambdas/functors before calling RunOnGuiThread.
+  void SetRouteBuildingListener(RouteBuildingCallback const & buildingCallback)
+  {
+    m_routingCallback = buildingCallback;
+  }
+  /// See warning above.
+  void SetRouteProgressListener(RouteProgressCallback const & progressCallback)
+  {
+    m_routingSession.SetProgressCallback(progressCallback);
+  }
+  void FollowRoute();
+  void CloseRouting();
+  void GetRouteFollowingInfo(location::FollowingInfo & info) const
+  {
+    m_routingSession.GetRouteFollowingInfo(info);
+  }
+  m2::PointD GetRouteEndPoint() const { return m_routingSession.GetEndPoint(); }
+  /// Returns the most situable router engine type.
+  routing::RouterType GetBestRouter(m2::PointD const & startPoint,
+                                    m2::PointD const & finalPoint) const;
+  routing::RouterType GetLastUsedRouter() const;
+  void SetLastUsedRouter(routing::RouterType type);
+  // Sound notifications for turn instructions.
+  void EnableTurnNotifications(bool enable) { m_routingSession.EnableTurnNotifications(enable); }
+  bool AreTurnNotificationsEnabled() const
+  {
+    return m_routingSession.AreTurnNotificationsEnabled();
+  }
+  /// \brief Sets a locale for TTS.
+  /// \param locale is a string with locale code. For example "en", "ru", "zh-Hant" and so on.
+  /// \note See sound/tts/languages.txt for the full list of available locales.
+  void SetTurnNotificationsLocale(string const & locale)
+  {
+    m_routingSession.SetTurnNotificationsLocale(locale);
+  }
+  /// @return current TTS locale. For example "en", "ru", "zh-Hant" and so on.
+  /// In case of error returns an empty string.
+  /// \note The method returns correct locale after SetTurnNotificationsLocale has been called.
+  /// If not, it returns an empty string.
+  string GetTurnNotificationsLocale() const
+  {
+    return m_routingSession.GetTurnNotificationsLocale();
+  }
+  /// \brief When an end user is going to a turn he gets sound turn instructions.
+  /// If C++ part wants the client to pronounce an instruction GenerateTurnNotifications (in
+  /// turnNotifications) returns
+  /// an array of one of more strings. C++ part assumes that all these strings shall be pronounced
+  /// by the client's TTS.
+  /// For example if C++ part wants the client to pronounce "Make a right turn." this method returns
+  /// an array with one string "Make a right turn.". The next call of the method returns nothing.
+  /// GenerateTurnNotifications shall be called by the client when a new position is available.
+  void GenerateTurnNotifications(vector<string> & turnNotifications);
+
+  void SetRouteStartPoint(m2::PointD const & pt, bool isValid);
+  void SetRouteFinishPoint(m2::PointD const & pt, bool isValid);
+
+  void SetRouterImpl(routing::RouterType type);
+  void RemoveRoute(bool deactivateFollowing);
+
+  void InsertRoute(routing::Route const & route);
+  void CheckLocationForRouting(location::GpsInfo const & info);
+  void CallRouteBuilded(routing::IRouter::ResultCode code,
+                        storage::TCountriesVec const & absentCountries);
+  void MatchLocationToRoute(location::GpsInfo & info,
+                            location::RouteMatchingInfo & routeMatchingInfo) const;
+  void OnBuildRouteReady(routing::Route const & route, routing::IRouter::ResultCode code);
+  void OnRebuildRouteReady(routing::Route const & route, routing::IRouter::ResultCode code);
+
+  void SetDrapeEngine(ref_ptr<df::DrapeEngine> engine) { m_drapeEngine = engine; };
+  /// \returns true if altitude information along |m_route| is available and
+  /// false otherwise.
+  bool HasRouteAltitude() const;
+
+  /// \brief Generates 4 bytes per point image (RGBA) and put the data to |imageRGBAData|.
+  /// \param width is width of chart shall be generated in pixels.
+  /// \param height is height of chart shall be generated in pixels.
+  /// \param imageRGBAData is bits of result image in RGBA.
+  /// \param minRouteAltitude is min altitude along the route in altitudeUnits.
+  /// \param maxRouteAltitude is max altitude along the route in altitudeUnits.
+  /// \param altitudeUnits is units (meters or feet) which is used to pass min and max altitudes.
+  /// \returns If there is valid route info and the chart was generated returns true
+  /// and false otherwise. If the method returns true it is guaranteed that the size of
+  /// |imageRGBAData| is not zero.
+  /// \note If HasRouteAltitude() method returns true, GenerateRouteAltitudeChart(...)
+  /// could return false if route was deleted or rebuilt between the calls.
+  bool GenerateRouteAltitudeChart(uint32_t width, uint32_t height, vector<uint8_t> & imageRGBAData,
+                                  int32_t & minRouteAltitude, int32_t & maxRouteAltitude,
+                                  measurement_utils::Units & altitudeUnits) const;
+
+  bool IsTrackingReporterEnabled() const;
+
+private:
+  RouteBuildingCallback m_routingCallback = nullptr;
+  Callbacks m_callbacks;
+  ref_ptr<df::DrapeEngine> m_drapeEngine = nullptr;
+  routing::RouterType m_currentRouterType = routing::RouterType::Count;
+  routing::RoutingSession m_routingSession;
+  DECLARE_THREAD_CHECKER(m_threadChecker);
+  Delegate & m_delegate;
+};