diff --git a/generator/osm2meta.hpp b/generator/osm2meta.hpp
index 474b9ea722..0297a29435 100644
--- a/generator/osm2meta.hpp
+++ b/generator/osm2meta.hpp
@@ -39,6 +39,12 @@ public:
       if (!value.empty())
         md.Add(Metadata::FMD_PHONE_NUMBER, value);
     }
+    else if (k == "maxspeed")
+    {
+      string const & value = ValidateAndFormat_maxspeed(v);
+      if (!value.empty())
+        md.Add(Metadata::FMD_MAXSPEED, value);
+    }
     else if (k == "stars")
     {
       string const & value = ValidateAndFormat_stars(v);
@@ -117,6 +123,15 @@ public:
 protected:
   /// Validation and formatting functions
 
+  string ValidateAndFormat_maxspeed(string const & v) const
+  {
+    static ftypes::IsSpeedCamChecker const IsSpeedCam;
+    if (!IsSpeedCam(m_params.m_Types))
+      return string();
+
+    return v;
+  }
+
   string ValidateAndFormat_stars(string const & v) const
   {
     if (v.empty())
diff --git a/generator/osm_translator.hpp b/generator/osm_translator.hpp
index d9fbe7f26c..51886e4a99 100644
--- a/generator/osm_translator.hpp
+++ b/generator/osm_translator.hpp
@@ -142,7 +142,7 @@ protected:
     for (auto const & p : e.tags)
     {
       // Store only this tags to use it in railway stations processing for the particular city.
-      if (p.first == "network" || p.first == "operator" || p.first == "route")
+      if (p.first == "network" || p.first == "operator" || p.first == "route" || p.first == "maxspeed")
         if (!TBase::IsKeyTagExists(p.first))
           TBase::m_current->AddTag(p.first, p.second);
     }
diff --git a/indexer/feature_meta.hpp b/indexer/feature_meta.hpp
index f81ef76198..13f447e0b9 100644
--- a/indexer/feature_meta.hpp
+++ b/indexer/feature_meta.hpp
@@ -35,6 +35,7 @@ namespace feature
       FMD_EMAIL = 14,
       FMD_POSTCODE = 15,
       FMD_WIKIPEDIA = 16,
+      FMD_MAXSPEED = 17,
       FMD_COUNT
     };
 
diff --git a/indexer/ftypes_matcher.cpp b/indexer/ftypes_matcher.cpp
index b52cb4fb0d..6527dc8347 100644
--- a/indexer/ftypes_matcher.cpp
+++ b/indexer/ftypes_matcher.cpp
@@ -70,6 +70,18 @@ IsATMChecker const & IsATMChecker::Instance()
   return inst;
 }
 
+IsSpeedCamChecker::IsSpeedCamChecker()
+{
+  Classificator const & c = classif();
+  m_types.push_back(c.GetTypeByPath({ "highway", "speed_camera"}));
+}
+
+IsSpeedCamChecker const & IsSpeedCamChecker::Instance()
+{
+  static const IsSpeedCamChecker inst;
+  return inst;
+}
+
 IsFuelStationChecker::IsFuelStationChecker()
 {
   Classificator const & c = classif();
diff --git a/indexer/ftypes_matcher.hpp b/indexer/ftypes_matcher.hpp
index 0e8b4ada31..6a2a98b698 100644
--- a/indexer/ftypes_matcher.hpp
+++ b/indexer/ftypes_matcher.hpp
@@ -46,6 +46,14 @@ public:
   static IsATMChecker const & Instance();
 };
 
+class IsSpeedCamChecker : public BaseChecker
+{
+public:
+  IsSpeedCamChecker();
+
+  static IsSpeedCamChecker const & Instance();
+};
+
 class IsFuelStationChecker : public BaseChecker
 {
 public:
diff --git a/map/framework.hpp b/map/framework.hpp
index 2d30557cd8..a91f31afbc 100644
--- a/map/framework.hpp
+++ b/map/framework.hpp
@@ -595,7 +595,7 @@ public:
   void SetRouteProgressListener(TRouteProgressCallback const & progressCallback) { m_progressCallback = progressCallback; }
   void FollowRoute();
   void CloseRouting();
-  void GetRouteFollowingInfo(location::FollowingInfo & info) const { m_routingSession.GetRouteFollowingInfo(info); }
+  void GetRouteFollowingInfo(location::FollowingInfo & info) const { m_routingSession.GetRouteFollowingInfo(info, m_model.GetIndex()); }
   m2::PointD GetRouteEndPoint() const { return m_routingSession.GetEndPoint(); }
   void SetLastUsedRouter(routing::RouterType type);
   /// Returns the most situable router engine type. Bases on distance and the last used router.
diff --git a/platform/location.hpp b/platform/location.hpp
index 65e14dd2dc..6132896dd0 100644
--- a/platform/location.hpp
+++ b/platform/location.hpp
@@ -101,6 +101,7 @@ namespace location
           m_exitNum(0),
           m_time(0),
           m_completionPercent(0),
+          m_speedWarningSignal(false),
           m_pedestrianTurn(routing::turns::PedestrianDirection::None),
           m_pedestrianDirectionPos(0., 0.)
     {
@@ -156,6 +157,9 @@ namespace location
     // Percentage of the route completion.
     double m_completionPercent;
 
+    // Speed cam warning signal.
+    bool m_speedWarningSignal;
+
     /// @name Pedestrian direction information
     //@{
     routing::turns::PedestrianDirection m_pedestrianTurn;
diff --git a/routing/route.cpp b/routing/route.cpp
index 602ff31dac..c12e42a721 100644
--- a/routing/route.cpp
+++ b/routing/route.cpp
@@ -1,5 +1,6 @@
 #include "route.hpp"
 #include "turns_generator.hpp"
+#include "speed_camera.hpp"
 
 #include "indexer/mercator.hpp"
 
@@ -27,7 +28,7 @@ double constexpr kOnEndToleranceM = 10.0;
 
 Route::Route(string const & router, vector<m2::PointD> const & points, string const & name)
   : m_router(router), m_routingSettings(GetCarRoutingSettings()),
-    m_name(name), m_poly(points.begin(), points.end())
+    m_name(name), m_poly(points.begin(), points.end()),m_lastCheckedCamera(0)
 {
   Update();
 }
@@ -43,6 +44,7 @@ void Route::Swap(Route & rhs)
   swap(m_turns, rhs.m_turns);
   swap(m_times, rhs.m_times);
   m_absentCountries.swap(rhs.m_absentCountries);
+  m_lastCheckedCamera = rhs.m_lastCheckedCamera;
 }
 
 double Route::GetTotalDistanceMeters() const
@@ -148,6 +150,24 @@ Route::TTurns::const_iterator Route::GetCurrentTurn() const
          });
 }
 
+double Route::GetCurrentCam(SpeedCameraRestriction & camera, Index const & index) const
+{
+  size_t current_index = max(m_poly.GetCurrentIter().m_ind, m_lastCheckedCamera);
+  SpeedCameraRestriction cam(static_cast<uint32_t>(current_index), 0 /* maxspeed */);
+  for (size_t i = current_index; i < m_poly.GetPolyline().GetSize(); ++i)
+  {
+    uint8_t speed = CheckCameraInPoint(m_poly.GetPolyline().GetPoint(i), index);
+    if (speed != kNoSpeedCamera)
+    {
+      camera = SpeedCameraRestriction(static_cast<uint32_t>(i), speed);
+      m_lastCheckedCamera = i;
+      return m_poly.GetDistanceM(m_poly.GetCurrentIter(), m_poly.GetIterToIndex(i));
+    }
+  }
+  m_lastCheckedCamera = m_poly.GetPolyline().GetSize();
+  return kInvalidSpeedCameraDistance;
+}
+
 bool Route::GetCurrentTurn(double & distanceToTurnMeters, turns::TurnItem & turn) const
 {
   auto it = GetCurrentTurn();
diff --git a/routing/route.hpp b/routing/route.hpp
index e2347f6ebe..7260282922 100644
--- a/routing/route.hpp
+++ b/routing/route.hpp
@@ -17,9 +17,20 @@ namespace location
   class RouteMatchingInfo;
 }
 
+class Index;
+
 namespace routing
 {
 
+/// Speed cameras structure. First is reference to point, second is a speed limit.
+struct SpeedCameraRestriction
+{
+  uint32_t m_index;
+  uint8_t m_maxSpeed;
+
+  SpeedCameraRestriction(uint32_t index, uint8_t maxSpeed) : m_index(index), m_maxSpeed(maxSpeed) {}
+};
+
 class Route
 {
 public:
@@ -27,12 +38,15 @@ public:
   typedef pair<uint32_t, double> TTimeItem;
   typedef vector<TTimeItem> TTimes;
 
+  static double constexpr kInvalidSpeedCameraDistance = -1;
+
   explicit Route(string const & router)
     : m_router(router), m_routingSettings(GetCarRoutingSettings()) {}
 
   template <class TIter>
   Route(string const & router, TIter beg, TIter end)
-    : m_router(router), m_routingSettings(GetCarRoutingSettings()), m_poly(beg, end)
+    : m_router(router), m_routingSettings(GetCarRoutingSettings()), m_poly(beg, end),
+      m_lastCheckedCamera(0)
   {
     Update();
   }
@@ -85,6 +99,8 @@ public:
   /// \brief Extract information about zero, one or two nearest turns depending on current position.
   /// @return true if its parameter is filled with correct result. (At least with one element.)
   bool GetNextTurns(vector<turns::TurnItemDist> & turns) const;
+  /// Returns nearest speed camera and distance to it.
+  double GetCurrentCam(SpeedCameraRestriction & camera, Index const & index) const;
 
   void GetCurrentDirectionPoint(m2::PointD & pt) const;
 
@@ -131,6 +147,7 @@ private:
   TTimes m_times;
 
   mutable double m_currentTime;
+  mutable size_t m_lastCheckedCamera;
 };
 
 } // namespace routing
diff --git a/routing/routing.pro b/routing/routing.pro
index 79cb3c65df..9d904325b6 100644
--- a/routing/routing.pro
+++ b/routing/routing.pro
@@ -36,6 +36,7 @@ SOURCES += \
     routing_algorithm.cpp \
     routing_mapping.cpp \
     routing_session.cpp \
+    speed_camera.cpp \
     turns.cpp \
     turns_generator.cpp \
     turns_sound.cpp \
@@ -71,6 +72,7 @@ HEADERS += \
     routing_mapping.hpp \
     routing_session.hpp \
     routing_settings.hpp \
+    speed_camera.hpp \
     turns.hpp \
     turns_generator.hpp \
     turns_sound.hpp \
diff --git a/routing/routing_mapping.hpp b/routing/routing_mapping.hpp
index 866de8ea9b..c3efddf621 100644
--- a/routing/routing_mapping.hpp
+++ b/routing/routing_mapping.hpp
@@ -3,6 +3,7 @@
 #include "osrm2feature_map.hpp"
 #include "osrm_data_facade.hpp"
 #include "router.hpp"
+#include "speed_camera.hpp"
 
 #include "indexer/index.hpp"
 
diff --git a/routing/routing_session.cpp b/routing/routing_session.cpp
index c5bb64c5fd..c0e2f50d61 100644
--- a/routing/routing_session.cpp
+++ b/routing/routing_session.cpp
@@ -27,6 +27,12 @@ double constexpr kShowTheTurnAfterTheNextM = 500.;
 // @todo(kshalnev) The distance may depend on the current speed.
 double constexpr kShowPedestrianTurnInMeters = 5.;
 
+// Minimal distance to speed camera to make sound bell on overspeed.
+double constexpr kSpeedCameraMinimalWarningMeters = 200.;
+// Seconds to warning user before speed camera for driving with current speed.
+double constexpr kSpeedCameraWarningSeconds = 30;
+
+double constexpr kMpsToKmh = 1000. / 3600.;
 }  // namespace
 
 namespace routing
@@ -37,6 +43,7 @@ RoutingSession::RoutingSession()
       m_route(string()),
       m_state(RoutingNotActive),
       m_endPoint(m2::PointD::Zero()),
+      m_speedMpS(0),
       m_passedDistanceOnRouteMeters(0.0)
 {
 }
@@ -123,6 +130,7 @@ void RoutingSession::Reset()
   m_turnsSound.Reset();
 
   m_passedDistanceOnRouteMeters = 0.0;
+  m_lastWarnedSpeedCamera = 0;
 }
 
 RoutingSession::State RoutingSession::OnLocationPositionChanged(m2::PointD const & position,
@@ -140,6 +148,7 @@ RoutingSession::State RoutingSession::OnLocationPositionChanged(m2::PointD const
   ASSERT(m_route.IsValid(), ());
 
   m_turnsSound.SetSpeedMetersPerSecond(info.m_speed);
+  m_speedMpS = info.m_speed;
 
   if (m_route.MoveIterator(info))
   {
@@ -185,7 +194,7 @@ RoutingSession::State RoutingSession::OnLocationPositionChanged(m2::PointD const
   return m_state;
 }
 
-void RoutingSession::GetRouteFollowingInfo(FollowingInfo & info) const
+void RoutingSession::GetRouteFollowingInfo(FollowingInfo & info, Index const & index) const
 {
   auto formatDistFn = [](double dist, string & value, string & suffix)
   {
@@ -201,73 +210,89 @@ void RoutingSession::GetRouteFollowingInfo(FollowingInfo & info) const
   threads::MutexGuard guard(m_routeSessionMutex);
   UNUSED_VALUE(guard);
 
-  if (m_route.IsValid() && IsNavigable())
+  if (!m_route.IsValid() || !IsNavigable())
   {
-    formatDistFn(m_route.GetCurrentDistanceToEndMeters(), info.m_distToTarget, info.m_targetUnitsSuffix);
+    // nothing should be displayed on the screen about turns if these lines are executed
+    info = FollowingInfo();
+    return;
+  }
 
-    double distanceToTurnMeters = 0., distanceToNextTurnMeters = 0.;
-    turns::TurnItem turn;
-    turns::TurnItem nextTurn;
-    m_route.GetCurrentTurn(distanceToTurnMeters, turn);
-    formatDistFn(distanceToTurnMeters, info.m_distToTurn, info.m_turnUnitsSuffix);
-    info.m_turn = turn.m_turn;
+  formatDistFn(m_route.GetCurrentDistanceToEndMeters(), info.m_distToTarget, info.m_targetUnitsSuffix);
 
-    // The turn after the next one.
-    if (m_route.GetNextTurn(distanceToNextTurnMeters, nextTurn))
+  double distanceToTurnMeters = 0., distanceToNextTurnMeters = 0.;
+  turns::TurnItem turn;
+  turns::TurnItem nextTurn;
+  m_route.GetCurrentTurn(distanceToTurnMeters, turn);
+  formatDistFn(distanceToTurnMeters, info.m_distToTurn, info.m_turnUnitsSuffix);
+  info.m_turn = turn.m_turn;
+
+  // The turn after the next one.
+  if (m_route.GetNextTurn(distanceToNextTurnMeters, nextTurn))
+  {
+    double const distBetweenTurnsM = distanceToNextTurnMeters - distanceToTurnMeters;
+    ASSERT_LESS_OR_EQUAL(0, distBetweenTurnsM, ());
+
+    if (m_routingSettings.m_showTurnAfterNext &&
+        distanceToTurnMeters < kShowTheTurnAfterTheNextM && distBetweenTurnsM < turns::kMaxTurnDistM)
     {
-      double const distBetweenTurnsM = distanceToNextTurnMeters - distanceToTurnMeters;
-      ASSERT_LESS_OR_EQUAL(0, distBetweenTurnsM, ());
-
-      if (m_routingSettings.m_showTurnAfterNext &&
-          distanceToTurnMeters < kShowTheTurnAfterTheNextM && distBetweenTurnsM < turns::kMaxTurnDistM)
-      {
-        info.m_nextTurn = nextTurn.m_turn;
-      }
-      else
-      {
-        info.m_nextTurn = routing::turns::TurnDirection::NoTurn;
-      }
+      info.m_nextTurn = nextTurn.m_turn;
     }
     else
     {
       info.m_nextTurn = routing::turns::TurnDirection::NoTurn;
     }
-    info.m_exitNum = turn.m_exitNum;
-    info.m_time = m_route.GetCurrentTimeToEndSec();
-    info.m_sourceName = turn.m_sourceName;
-    info.m_targetName = turn.m_targetName;
-    info.m_completionPercent = 100.0 *
-      (m_passedDistanceOnRouteMeters + m_route.GetCurrentDistanceFromBeginMeters()) /
-      (m_passedDistanceOnRouteMeters + m_route.GetTotalDistanceMeters());
-
-    // Lane information.
-    if (distanceToTurnMeters < kShowLanesDistInMeters)
-    {
-      // There are two nested loops below. Outer one is for lanes and inner one (ctor of
-      // SingleLaneInfo) is
-      // for each lane's directions. The size of turn.m_lanes is relatively small. Less than 10 in
-      // most cases.
-      info.m_lanes.clear();
-      for (size_t j = 0; j < turn.m_lanes.size(); ++j)
-        info.m_lanes.emplace_back(turn.m_lanes[j]);
-    }
-    else
-    {
-      info.m_lanes.clear();
-    }
-
-    // Pedestrian info
-    m2::PointD pos;
-    m_route.GetCurrentDirectionPoint(pos);
-    info.m_pedestrianDirectionPos = MercatorBounds::ToLatLon(pos);
-    info.m_pedestrianTurn =
-        (distanceToTurnMeters < kShowPedestrianTurnInMeters) ? turn.m_pedestrianTurn : turns::PedestrianDirection::None;
   }
   else
   {
-    // nothing should be displayed on the screen about turns if these lines are executed
-    info = FollowingInfo();
+    info.m_nextTurn = routing::turns::TurnDirection::NoTurn;
   }
+  info.m_exitNum = turn.m_exitNum;
+  info.m_time = m_route.GetCurrentTimeToEndSec();
+  info.m_sourceName = turn.m_sourceName;
+  info.m_targetName = turn.m_targetName;
+  info.m_completionPercent = 100.0 *
+    (m_passedDistanceOnRouteMeters + m_route.GetCurrentDistanceFromBeginMeters()) /
+    (m_passedDistanceOnRouteMeters + m_route.GetTotalDistanceMeters());
+
+  // Lane information.
+  if (distanceToTurnMeters < kShowLanesDistInMeters)
+  {
+    // There are two nested loops below. Outer one is for lanes and inner one (ctor of
+    // SingleLaneInfo) is
+    // for each lane's directions. The size of turn.m_lanes is relatively small. Less than 10 in
+    // most cases.
+    info.m_lanes.clear();
+    for (size_t j = 0; j < turn.m_lanes.size(); ++j)
+      info.m_lanes.emplace_back(turn.m_lanes[j]);
+  }
+  else
+  {
+    info.m_lanes.clear();
+  }
+
+  // Warning signals checks
+  if (m_routingSettings.m_speedCameraWarning)
+  {
+    double const warningDistanceM = max(kSpeedCameraMinimalWarningMeters,
+                                        m_speedMpS * kSpeedCameraWarningSeconds);
+    SpeedCameraRestriction cam(0, 0);
+    double const camDistance = m_route.GetCurrentCam(cam, index);
+    if (Route::kInvalidSpeedCameraDistance != camDistance && camDistance < warningDistanceM)
+    {
+      if (cam.m_index > m_lastWarnedSpeedCamera && m_speedMpS > cam.m_maxSpeed * kMpsToKmh)
+      {
+        info.m_speedWarningSignal = true;
+        m_lastWarnedSpeedCamera = cam.m_index;
+      }
+    }
+  }
+
+  // Pedestrian info
+  m2::PointD pos;
+  m_route.GetCurrentDirectionPoint(pos);
+  info.m_pedestrianDirectionPos = MercatorBounds::ToLatLon(pos);
+  info.m_pedestrianTurn =
+      (distanceToTurnMeters < kShowPedestrianTurnInMeters) ? turn.m_pedestrianTurn : turns::PedestrianDirection::None;
 }
 
 void RoutingSession::GenerateTurnSound(vector<string> & turnNotifications)
@@ -305,6 +330,7 @@ void RoutingSession::AssignRoute(Route & route, IRouter::ResultCode e)
 
   route.SetRoutingSettings(m_routingSettings);
   m_route.Swap(route);
+  m_lastWarnedSpeedCamera = 0;
 }
 
 void RoutingSession::SetRouter(unique_ptr<IRouter> && router,
diff --git a/routing/routing_session.hpp b/routing/routing_session.hpp
index e251291289..f6880f944b 100644
--- a/routing/routing_session.hpp
+++ b/routing/routing_session.hpp
@@ -78,7 +78,7 @@ public:
   void Reset();
 
   State OnLocationPositionChanged(m2::PointD const & position, location::GpsInfo const & info);
-  void GetRouteFollowingInfo(location::FollowingInfo & info) const;
+  void GetRouteFollowingInfo(location::FollowingInfo & info, Index const & index) const;
 
   void MatchLocationToRoute(location::GpsInfo & location,
                             location::RouteMatchingInfo & routeMatchingInfo) const;
@@ -124,6 +124,8 @@ private:
   Route m_route;
   State m_state;
   m2::PointD m_endPoint;
+  double m_speedMpS;
+  mutable size_t m_lastWarnedSpeedCamera;
 
   mutable threads::Mutex m_routeSessionMutex;
 
diff --git a/routing/routing_settings.hpp b/routing/routing_settings.hpp
index bbf408d4d1..1eba59bb9f 100644
--- a/routing/routing_settings.hpp
+++ b/routing/routing_settings.hpp
@@ -32,19 +32,22 @@ struct RoutingSettings
   /// \brief if m_showTurnAfterNext is equal to true end users see a notification
   /// about the turn after the next in some cases.
   bool m_showTurnAfterNext;
+
+  /// \brief m_speedCameraWarning is a flag for enabling user notifications about speed cameras.
+  bool m_speedCameraWarning;
 };
 
 inline RoutingSettings GetPedestrianRoutingSettings()
 {
   return RoutingSettings({ false /* m_matchRoute */, false /* m_soundDirection */,
                            20. /* m_matchingThresholdM */, true /* m_keepPedestrianInfo */,
-                           false /* m_showTurnAfterNext */});
+                           false /* m_showTurnAfterNext */, false /* m_speedCameraWarning*/});
 }
 
 inline RoutingSettings GetCarRoutingSettings()
 {
   return RoutingSettings({ true /* m_matchRoute */, true /* m_soundDirection */,
                            50. /* m_matchingThresholdM */, false /* m_keepPedestrianInfo */,
-                           true /* m_showTurnAfterNext */});
+                           true /* m_showTurnAfterNext */, true /* m_speedCameraWarning*/});
 }
 }  // namespace routing
diff --git a/routing/speed_camera.cpp b/routing/speed_camera.cpp
new file mode 100644
index 0000000000..ed72b88832
--- /dev/null
+++ b/routing/speed_camera.cpp
@@ -0,0 +1,67 @@
+#include "speed_camera.hpp"
+
+#include "indexer/classificator.hpp"
+#include "indexer/ftypes_matcher.hpp"
+#include "indexer/index.hpp"
+#include "indexer/scales.hpp"
+
+#include "coding/reader.hpp"
+#include "coding/writer.hpp"
+#include "coding/read_write_utils.hpp"
+
+#include "base/string_utils.hpp"
+
+namespace
+{
+double constexpr kMwmReadingRadiusMeters = 2.0;
+}  // namespace
+
+namespace routing
+{
+uint8_t ReadCamRestriction(FeatureType & ft)
+{
+  using feature::Metadata;
+  ft.ParseMetadata();
+  feature::Metadata const & mt = ft.GetMetadata();
+  string const & speed = mt.Get(Metadata::FMD_MAXSPEED);
+  if (!speed.length())
+    return 0;
+  int result;
+  strings::to_int(speed, result);
+  return result;
+}
+
+uint8_t CheckCameraInPoint(m2::PointD const & point, Index const & index)
+{
+  Classificator & c = classif();
+  uint32_t const req = c.GetTypeByPath({"highway", "speed_camera"});
+
+  uint32_t speedLimit = kNoSpeedCamera;
+
+  auto const f = [&req, &c, &point, &speedLimit](FeatureType & ft)
+  {
+    if (ft.GetFeatureType() != feature::GEOM_POINT)
+      return;
+
+    feature::TypesHolder hl = ft;
+    for (uint32_t t : hl)
+    {
+      uint32_t const type = ftypes::BaseChecker::PrepareToMatch(t, 2);
+      if (type == req)
+      {
+        ft.ParseGeometry(FeatureType::BEST_GEOMETRY);
+        if (ft.GetCenter() == point)
+        {
+          speedLimit = ReadCamRestriction(ft);
+          return;
+        }
+      }
+    }
+  };
+
+  index.ForEachInRect(f,
+                      MercatorBounds::RectByCenterXYAndSizeInMeters(point, kMwmReadingRadiusMeters),
+                      scales::GetUpperScale());
+  return speedLimit;
+}
+}  // namespace routing
diff --git a/routing/speed_camera.hpp b/routing/speed_camera.hpp
new file mode 100644
index 0000000000..693048d231
--- /dev/null
+++ b/routing/speed_camera.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "geometry/point2d.hpp"
+
+#include "base/base.hpp"
+
+#include "std/limits.hpp"
+
+class Index;
+
+namespace routing
+{
+uint8_t constexpr kNoSpeedCamera = numeric_limits<uint8_t>::max();
+uint8_t CheckCameraInPoint(m2::PointD const & point, Index const & index);
+}  // namespace routing
diff --git a/xcode/routing/routing.xcodeproj/project.pbxproj b/xcode/routing/routing.xcodeproj/project.pbxproj
index c604234f33..fb25ed31db 100644
--- a/xcode/routing/routing.xcodeproj/project.pbxproj
+++ b/xcode/routing/routing.xcodeproj/project.pbxproj
@@ -70,6 +70,8 @@
 		A1616E2B1B6B60AB003F078E /* router_delegate.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A1616E291B6B60AB003F078E /* router_delegate.cpp */; };
 		A1616E2C1B6B60AB003F078E /* router_delegate.hpp in Headers */ = {isa = PBXBuildFile; fileRef = A1616E2A1B6B60AB003F078E /* router_delegate.hpp */; };
 		A1616E2E1B6B60B3003F078E /* astar_progress.hpp in Headers */ = {isa = PBXBuildFile; fileRef = A1616E2D1B6B60B3003F078E /* astar_progress.hpp */; };
+		A1876BC61BB19C4300C9C743 /* speed_camera.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A1876BC41BB19C4300C9C743 /* speed_camera.cpp */; settings = {ASSET_TAGS = (); }; };
+		A1876BC71BB19C4300C9C743 /* speed_camera.hpp in Headers */ = {isa = PBXBuildFile; fileRef = A1876BC51BB19C4300C9C743 /* speed_camera.hpp */; settings = {ASSET_TAGS = (); }; };
 /* End PBXBuildFile section */
 
 /* Begin PBXFileReference section */
@@ -138,6 +140,8 @@
 		A1616E291B6B60AB003F078E /* router_delegate.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = router_delegate.cpp; sourceTree = "<group>"; };
 		A1616E2A1B6B60AB003F078E /* router_delegate.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = router_delegate.hpp; sourceTree = "<group>"; };
 		A1616E2D1B6B60B3003F078E /* astar_progress.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = astar_progress.hpp; sourceTree = "<group>"; };
+		A1876BC41BB19C4300C9C743 /* speed_camera.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = speed_camera.cpp; sourceTree = "<group>"; };
+		A1876BC51BB19C4300C9C743 /* speed_camera.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = speed_camera.hpp; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -182,6 +186,8 @@
 		675343FA1A3F640D00A0A8C3 /* routing */ = {
 			isa = PBXGroup;
 			children = (
+				A1876BC41BB19C4300C9C743 /* speed_camera.cpp */,
+				A1876BC51BB19C4300C9C743 /* speed_camera.hpp */,
 				671F58BA1B874EA20032311E /* base */,
 				67AB92E01B7B3E6E00AB5194 /* routing_mapping.hpp */,
 				67AB92E11B7B3E6E00AB5194 /* turns_tts_text.cpp */,
@@ -281,6 +287,7 @@
 				6753441D1A3F644F00A0A8C3 /* router.hpp in Headers */,
 				A1616E2E1B6B60B3003F078E /* astar_progress.hpp in Headers */,
 				670EE5721B664796001E8064 /* directions_engine.hpp in Headers */,
+				A1876BC71BB19C4300C9C743 /* speed_camera.hpp in Headers */,
 				67C7D42A1B4EB48F00FE41AA /* car_model.hpp in Headers */,
 				670D049F1B0B4A970013A7AC /* nearest_edge_finder.hpp in Headers */,
 				A120B34F1B4A7C0A002F3808 /* online_absent_fetcher.hpp in Headers */,
@@ -359,6 +366,7 @@
 				674F9BD61B0A580E00704FFA /* turns_generator.cpp in Sources */,
 				675344171A3F644F00A0A8C3 /* osrm_router.cpp in Sources */,
 				674F9BD21B0A580E00704FFA /* road_graph_router.cpp in Sources */,
+				A1876BC61BB19C4300C9C743 /* speed_camera.cpp in Sources */,
 				671F58BD1B874EC80032311E /* followed_polyline.cpp in Sources */,
 				670EE55D1B6001E7001E8064 /* routing_session.cpp in Sources */,
 				A120B3451B4A7BE5002F3808 /* cross_mwm_road_graph.cpp in Sources */,