[omim] Refactored measurement_utils.

9 files changed, 102 insertions, 79 deletions

diff --git a/routing/routing_session.cpp b/routing/routing_session.cpp
index 177caf38eb..720f22996d 100644
--- a/routing/routing_session.cpp
+++ b/routing/routing_session.cpp
@@ -247,7 +247,7 @@ void RoutingSession::GetRouteFollowingInfo(FollowingInfo & info) const
   auto formatDistFn = [](double dist, string & value, string & suffix)
   {
     /// @todo Make better formatting of distance and units.
-    MeasurementUtils::FormatDistance(dist, value);
+    UNUSED_VALUE(measurement_utils::FormatDistance(dist, value));
 
     size_t const delim = value.find(' ');
     ASSERT(delim != string::npos, ());
@@ -457,7 +457,7 @@ bool RoutingSession::AreTurnNotificationsEnabled() const
   return m_turnNotificationsMgr.IsEnabled();
 }
 
-void RoutingSession::SetTurnNotificationsUnits(settings::Units const units)
+void RoutingSession::SetTurnNotificationsUnits(measurement_utils::Units const units)
 {
   threads::MutexGuard guard(m_routeSessionMutex);
   UNUSED_VALUE(guard);
diff --git a/routing/routing_session.hpp b/routing/routing_session.hpp
index ecc3cb3e39..478d4c9f98 100644
--- a/routing/routing_session.hpp
+++ b/routing/routing_session.hpp
@@ -7,6 +7,7 @@
 #include "routing/turns_notification_manager.hpp"
 
 #include "platform/location.hpp"
+#include "platform/measurement_utils.hpp"
 
 #include "geometry/point2d.hpp"
 #include "geometry/polyline2d.hpp"
@@ -130,7 +131,7 @@ public:
   // Sound notifications for turn instructions.
   void EnableTurnNotifications(bool enable);
   bool AreTurnNotificationsEnabled() const;
-  void SetTurnNotificationsUnits(settings::Units const units);
+  void SetTurnNotificationsUnits(measurement_utils::Units const units);
   void SetTurnNotificationsLocale(string const & locale);
   string GetTurnNotificationsLocale() const;
   void GenerateTurnNotifications(vector<string> & turnNotifications);
diff --git a/routing/routing_tests/turns_sound_test.cpp b/routing/routing_tests/turns_sound_test.cpp
index f362c9e5cf..b0f7519095 100644
--- a/routing/routing_tests/turns_sound_test.cpp
+++ b/routing/routing_tests/turns_sound_test.cpp
@@ -26,7 +26,7 @@ UNIT_TEST(TurnNotificationSettingsMetersTest)
                           25 /* m_minStartBeforeMeters */, 150 /* m_maxStartBeforeMeters */,
                           170 /* m_minDistToSayNotificationMeters */,
                           {100, 200, 300, 400, 500, 600, 700} /* soundedDistancesUnits */,
-                          ::settings::Metric /* lengthUnits */);
+                          measurement_utils::Units::Metric /* lengthUnits */);
 
   TEST(settings.IsValid(), ());
   TEST(my::AlmostEqualAbs(
@@ -57,7 +57,7 @@ UNIT_TEST(TurnNotificationSettingsFeetTest)
                           25 /* m_minStartBeforeMeters */, 150 /* m_maxStartBeforeMeters */,
                           170 /* m_minDistToSayNotificationMeters */,
                           {200, 400, 600, 800, 1000, 1500, 2000} /* soundedDistancesUnits */,
-                          ::settings::Foot /* lengthUnits */);
+                          measurement_utils::Units::Imperial /* lengthUnits */);
 
   TEST(settings.IsValid(), ());
   TEST(my::AlmostEqualAbs(
@@ -76,7 +76,7 @@ UNIT_TEST(TurnNotificationSettingsNotValidTest)
                      25 /* m_minStartBeforeMeters */, 150 /* m_maxStartBeforeMeters */,
                      170 /* m_minDistToSayNotificationMeters */,
                      {200, 400, 800, 600, 1000, 1500, 2000} /* soundedDistancesUnits */,
-                     ::settings::Foot /* lengthUnits */);
+                     measurement_utils::Units::Imperial /* lengthUnits */);
   TEST(!settings1.IsValid(), ());
 
   Settings settings2(20 /* notificationTimeSeconds */, 5000 /* minNotificationDistanceUnits */,
@@ -84,7 +84,7 @@ UNIT_TEST(TurnNotificationSettingsNotValidTest)
                      25 /* m_minStartBeforeMeters */, 150 /* m_maxStartBeforeMeters */,
                      170 /* m_minDistToSayNotificationMeters */,
                      {200, 400, 600, 800, 1000, 1500, 2000} /* soundedDistancesUnits */,
-                     ::settings::Metric /* lengthUnits */);
+                     measurement_utils::Units::Metric /* lengthUnits */);
   TEST(!settings2.IsValid(), ());
 }
 
@@ -94,7 +94,7 @@ UNIT_TEST(TurnsSoundMetersTest)
                                           100 /* maxStartBeforeMeters */,
                                           100 /* minDistToSayNotificationMeters */);
   notificationManager.Enable(true);
-  notificationManager.SetLengthUnits(::settings::Metric);
+  notificationManager.SetLengthUnits(measurement_utils::Units::Metric);
   string const engShortJson =
       "\
       {\
@@ -192,7 +192,7 @@ UNIT_TEST(TurnsSoundMetersTwoTurnsTest)
                                           100 /* maxStartBeforeMeters */,
                                           100 /* minDistToSayNotificationMeters */);
   notificationManager.Enable(true);
-  notificationManager.SetLengthUnits(::settings::Metric);
+  notificationManager.SetLengthUnits(measurement_utils::Units::Metric);
   string const engShortJson =
       "\
       {\
@@ -269,7 +269,7 @@ UNIT_TEST(TurnsSoundFeetTest)
                                           100 /* maxStartBeforeMeters */,
                                           100 /* minDistToSayNotificationMeters */);
   notificationManager.Enable(true);
-  notificationManager.SetLengthUnits(::settings::Foot);
+  notificationManager.SetLengthUnits(measurement_utils::Units::Imperial);
   string const engShortJson =
       "\
       {\
@@ -352,7 +352,7 @@ UNIT_TEST(TurnsSoundComposedTurnTest)
                                           100 /* maxStartBeforeMeters */,
                                           100 /* minDistToSayNotificationMeters */);
   notificationManager.Enable(true);
-  notificationManager.SetLengthUnits(::settings::Metric);
+  notificationManager.SetLengthUnits(measurement_utils::Units::Metric);
   string const engShortJson =
       "\
       {\
@@ -429,7 +429,7 @@ UNIT_TEST(TurnsSoundRoundaboutTurnTest)
                                           100 /* maxStartBeforeMeters */,
                                           100 /* minDistToSayNotificationMeters */);
   notificationManager.Enable(true);
-  notificationManager.SetLengthUnits(::settings::Metric);
+  notificationManager.SetLengthUnits(measurement_utils::Units::Metric);
   string const engShortJson =
       "\
       {\
diff --git a/routing/routing_tests/turns_tts_text_tests.cpp b/routing/routing_tests/turns_tts_text_tests.cpp
index a2fbb7d113..dc2d968d6d 100644
--- a/routing/routing_tests/turns_tts_text_tests.cpp
+++ b/routing/routing_tests/turns_tts_text_tests.cpp
@@ -20,13 +20,17 @@ UNIT_TEST(GetDistanceTextIdMetersTest)
 {
   // Notification(uint32_t distanceUnits, uint8_t exitNum, bool useThenInsteadOfDistance,
   //    TurnDirection turnDir, ::Settings::Units lengthUnits)
-  Notification const notification1(500, 0, false, TurnDirection::TurnRight, ::settings::Metric);
+  Notification const notification1(500, 0, false, TurnDirection::TurnRight,
+                                   measurement_utils::Units::Metric);
   TEST_EQUAL(GetDistanceTextId(notification1), "in_500_meters", ());
-  Notification const notification2(500, 0, true, TurnDirection::TurnRight, ::settings::Metric);
+  Notification const notification2(500, 0, true, TurnDirection::TurnRight,
+                                   measurement_utils::Units::Metric);
   TEST_EQUAL(GetDistanceTextId(notification2), "then", ());
-  Notification const notification3(200, 0, false, TurnDirection::TurnRight, ::settings::Metric);
+  Notification const notification3(200, 0, false, TurnDirection::TurnRight,
+                                   measurement_utils::Units::Metric);
   TEST_EQUAL(GetDistanceTextId(notification3), "in_200_meters", ());
-  Notification const notification4(2000, 0, false, TurnDirection::TurnRight, ::settings::Metric);
+  Notification const notification4(2000, 0, false, TurnDirection::TurnRight,
+                                   measurement_utils::Units::Metric);
   TEST_EQUAL(GetDistanceTextId(notification4), "in_2_kilometers", ());
 }
 
@@ -34,13 +38,17 @@ UNIT_TEST(GetDistanceTextIdFeetTest)
 {
   // Notification(uint32_t distanceUnits, uint8_t exitNum, bool useThenInsteadOfDistance,
   //    TurnDirection turnDir, ::Settings::Units lengthUnits)
-  Notification const notification1(500, 0, false, TurnDirection::TurnRight, ::settings::Foot);
+  Notification const notification1(500, 0, false, TurnDirection::TurnRight,
+                                   measurement_utils::Units::Imperial);
   TEST_EQUAL(GetDistanceTextId(notification1), "in_500_feet", ());
-  Notification const notification2(500, 0, true, TurnDirection::TurnRight, ::settings::Foot);
+  Notification const notification2(500, 0, true, TurnDirection::TurnRight,
+                                   measurement_utils::Units::Imperial);
   TEST_EQUAL(GetDistanceTextId(notification2), "then", ());
-  Notification const notification3(800, 0, false, TurnDirection::TurnRight, ::settings::Foot);
+  Notification const notification3(800, 0, false, TurnDirection::TurnRight,
+                                   measurement_utils::Units::Imperial);
   TEST_EQUAL(GetDistanceTextId(notification3), "in_800_feet", ());
-  Notification const notification4(5000, 0, false, TurnDirection::TurnRight, ::settings::Foot);
+  Notification const notification4(5000, 0, false, TurnDirection::TurnRight,
+                                   measurement_utils::Units::Imperial);
   TEST_EQUAL(GetDistanceTextId(notification4), "in_5000_feet", ());
 }
 
@@ -48,13 +56,17 @@ UNIT_TEST(GetRoundaboutTextIdTest)
 {
   // Notification(uint32_t distanceUnits, uint8_t exitNum, bool useThenInsteadOfDistance,
   //    TurnDirection turnDir, ::Settings::Units lengthUnits)
-  Notification const notification1(500, 0, false, TurnDirection::LeaveRoundAbout, ::settings::Foot);
+  Notification const notification1(500, 0, false, TurnDirection::LeaveRoundAbout,
+                                   measurement_utils::Units::Imperial);
   TEST_EQUAL(GetRoundaboutTextId(notification1), "leave_the_roundabout", ());
-  Notification const notification2(0, 3, true, TurnDirection::LeaveRoundAbout, ::settings::Foot);
+  Notification const notification2(0, 3, true, TurnDirection::LeaveRoundAbout,
+                                   measurement_utils::Units::Imperial);
   TEST_EQUAL(GetRoundaboutTextId(notification2), "take_the_3_exit", ());
-  Notification const notification3(0, 7, true, TurnDirection::LeaveRoundAbout, ::settings::Metric);
+  Notification const notification3(0, 7, true, TurnDirection::LeaveRoundAbout,
+                                   measurement_utils::Units::Metric);
   TEST_EQUAL(GetRoundaboutTextId(notification3), "take_the_7_exit", ());
-  Notification const notification4(0, 15, true, TurnDirection::LeaveRoundAbout, ::settings::Metric);
+  Notification const notification4(0, 15, true, TurnDirection::LeaveRoundAbout,
+                                   measurement_utils::Units::Metric);
   TEST_EQUAL(GetRoundaboutTextId(notification4), "leave_the_roundabout", ());
 }
 
@@ -62,11 +74,14 @@ UNIT_TEST(GetYouArriveTextIdTest)
 {
   // Notification(uint32_t distanceUnits, uint8_t exitNum, bool useThenInsteadOfDistance,
   //    TurnDirection turnDir, ::Settings::Units lengthUnits)
-  Notification const notification1(500, 0, false, TurnDirection::ReachedYourDestination, ::settings::Foot);
+  Notification const notification1(500, 0, false, TurnDirection::ReachedYourDestination,
+                                   measurement_utils::Units::Imperial);
   TEST_EQUAL(GetYouArriveTextId(notification1), "destination", ());
-  Notification const notification2(0, 0, false, TurnDirection::ReachedYourDestination, ::settings::Metric);
+  Notification const notification2(0, 0, false, TurnDirection::ReachedYourDestination,
+                                   measurement_utils::Units::Metric);
   TEST_EQUAL(GetYouArriveTextId(notification2), "you_have_reached_the_destination", ());
-  Notification const notification3(0, 0, true, TurnDirection::ReachedYourDestination, ::settings::Metric);
+  Notification const notification3(0, 0, true, TurnDirection::ReachedYourDestination,
+                                   measurement_utils::Units::Metric);
   TEST_EQUAL(GetYouArriveTextId(notification3), "destination", ());
 }
 
@@ -74,15 +89,20 @@ UNIT_TEST(GetDirectionTextIdTest)
 {
   // Notification(uint32_t distanceUnits, uint8_t exitNum, bool useThenInsteadOfDistance,
   //    TurnDirection turnDir, ::Settings::Units lengthUnits)
-  Notification const notification1(500, 0, false, TurnDirection::TurnRight, ::settings::Foot);
+  Notification const notification1(500, 0, false, TurnDirection::TurnRight,
+                                   measurement_utils::Units::Imperial);
   TEST_EQUAL(GetDirectionTextId(notification1), "make_a_right_turn", ());
-  Notification const notification2(1000, 0, false, TurnDirection::GoStraight, ::settings::Metric);
+  Notification const notification2(1000, 0, false, TurnDirection::GoStraight,
+                                   measurement_utils::Units::Metric);
   TEST_EQUAL(GetDirectionTextId(notification2), "go_straight", ());
-  Notification const notification3(700, 0, false, TurnDirection::UTurnLeft, ::settings::Metric);
+  Notification const notification3(700, 0, false, TurnDirection::UTurnLeft,
+                                   measurement_utils::Units::Metric);
   TEST_EQUAL(GetDirectionTextId(notification3), "make_a_u_turn", ());
-  Notification const notification4(200, 0, false, TurnDirection::ReachedYourDestination, ::settings::Metric);
+  Notification const notification4(200, 0, false, TurnDirection::ReachedYourDestination,
+                                   measurement_utils::Units::Metric);
   TEST_EQUAL(GetDirectionTextId(notification4), "destination", ());
-  Notification const notification5(0, 0, false, TurnDirection::ReachedYourDestination, ::settings::Metric);
+  Notification const notification5(0, 0, false, TurnDirection::ReachedYourDestination,
+                                   measurement_utils::Units::Metric);
   TEST_EQUAL(GetDirectionTextId(notification5), "you_have_reached_the_destination", ());
 }
 
@@ -113,11 +133,14 @@ UNIT_TEST(GetTtsTextTest)
   GetTtsText getTtsText;
   // Notification(uint32_t distanceUnits, uint8_t exitNum, bool useThenInsteadOfDistance,
   //    TurnDirection turnDir, Settings::Units lengthUnits)
-  Notification const notification1(500, 0, false, TurnDirection::TurnRight, ::settings::Metric);
-  Notification const notification2(300, 0, false, TurnDirection::TurnLeft, ::settings::Metric);
+  Notification const notification1(500, 0, false, TurnDirection::TurnRight,
+                                   measurement_utils::Units::Metric);
+  Notification const notification2(300, 0, false, TurnDirection::TurnLeft,
+                                   measurement_utils::Units::Metric);
   Notification const notification3(0, 0, false, TurnDirection::ReachedYourDestination,
-                                  ::settings::Metric);
-  Notification const notification4(0, 0, true, TurnDirection::TurnLeft, ::settings::Metric);
+                                   measurement_utils::Units::Metric);
+  Notification const notification4(0, 0, true, TurnDirection::TurnLeft,
+                                   measurement_utils::Units::Metric);
 
   getTtsText.ForTestingSetLocaleWithJson(engShortJson, "en");
   TEST_EQUAL(getTtsText(notification1), "In 500 meters. Make a right turn.", ());
diff --git a/routing/turns_notification_manager.cpp b/routing/turns_notification_manager.cpp
index fd4b01632c..2377fcd5c1 100644
--- a/routing/turns_notification_manager.cpp
+++ b/routing/turns_notification_manager.cpp
@@ -30,7 +30,7 @@ namespace sound
 {
 string NotificationManager::GenerateTurnText(uint32_t distanceUnits, uint8_t exitNum,
                                              bool useThenInsteadOfDistance, TurnDirection turnDir,
-                                             ::settings::Units lengthUnits) const
+                                             measurement_utils::Units lengthUnits) const
 {
   Notification const notification(distanceUnits, exitNum, useThenInsteadOfDistance, turnDir,
                                   lengthUnits);
@@ -151,22 +151,22 @@ void NotificationManager::Enable(bool enable)
   m_enabled = enable;
 }
 
-void NotificationManager::SetLengthUnits(::settings::Units units)
+void NotificationManager::SetLengthUnits(measurement_utils::Units units)
 {
   m_settings.SetLengthUnits(units);
   switch (units)
   {
-  case ::settings::Metric:
+  case measurement_utils::Units::Metric:
     m_settings.SetState(30 /* notificationTimeSeconds */, 200 /* minNotificationDistanceUnits */,
                         2000 /* maxNotificationDistanceUnits */,
                         GetSoundedDistMeters() /* soundedDistancesUnits */,
-                        ::settings::Metric /* lengthUnits */);
+                        measurement_utils::Units::Metric /* lengthUnits */);
     return;
-  case ::settings::Foot:
+  case measurement_utils::Units::Imperial:
     m_settings.SetState(30 /* notificationTimeSeconds */, 500 /* minNotificationDistanceUnits */,
                         5000 /* maxNotificationDistanceUnits */,
                         GetSoundedDistFeet() /* soundedDistancesUnits */,
-                        ::settings::Foot /* lengthUnits */);
+                        measurement_utils::Units::Imperial /* lengthUnits */);
     return;
   }
 }
diff --git a/routing/turns_notification_manager.hpp b/routing/turns_notification_manager.hpp
index 95f7d83ead..5822d1fa34 100644
--- a/routing/turns_notification_manager.hpp
+++ b/routing/turns_notification_manager.hpp
@@ -3,6 +3,7 @@
 #include "routing/turns_sound_settings.hpp"
 #include "routing/turns_tts_text.hpp"
 
+#include "platform/measurement_utils.hpp"
 #include "platform/settings.hpp"
 
 #include "std/string.hpp"
@@ -100,7 +101,7 @@ class NotificationManager
   uint32_t m_secondTurnNotificationIndex;
 
   string GenerateTurnText(uint32_t distanceUnits, uint8_t exitNum, bool useThenInsteadOfDistance,
-                          TurnDirection turnDir, ::settings::Units lengthUnits) const;
+                          TurnDirection turnDir, measurement_utils::Units lengthUnits) const;
   /// Generates turn sound notification for the nearest to the current position turn.
   string GenerateFirstTurnSound(TurnItem const & turn, double distanceToTurnMeters);
   /// Changes the state of the class to emulate that first turn notification is pronouned
@@ -130,8 +131,8 @@ public:
 
   bool IsEnabled() const { return m_enabled; }
   void Enable(bool enable);
-  void SetLengthUnits(::settings::Units units);
-  inline ::settings::Units GetLengthUnits() const { return m_settings.GetLengthUnits(); }
+  void SetLengthUnits(measurement_utils::Units units);
+  inline measurement_utils::Units GetLengthUnits() const { return m_settings.GetLengthUnits(); }
   inline void SetLocale(string const & locale) { m_getTtsText.SetLocale(locale); }
   inline string GetLocale() const { return m_getTtsText.GetLocale(); }
   void SetSpeedMetersPerSecond(double speed);
diff --git a/routing/turns_sound_settings.cpp b/routing/turns_sound_settings.cpp
index 91481c08b7..1c24102a80 100644
--- a/routing/turns_sound_settings.cpp
+++ b/routing/turns_sound_settings.cpp
@@ -6,6 +6,8 @@
 
 #include "std/algorithm.hpp"
 
+using namespace measurement_utils;
+
 namespace routing
 {
 namespace turns
@@ -15,7 +17,7 @@ namespace sound
 void Settings::SetState(uint32_t notificationTimeSeconds, uint32_t minNotificationDistanceUnits,
                         uint32_t maxNotificationDistanceUnits,
                         vector<uint32_t> const & soundedDistancesUnits,
-                        ::settings::Units lengthUnits)
+                        measurement_utils::Units lengthUnits)
 {
   m_timeSeconds = notificationTimeSeconds;
   m_minDistanceUnits = minNotificationDistanceUnits;
@@ -64,10 +66,8 @@ double Settings::ConvertMetersPerSecondToUnitsPerSecond(double speedInMetersPerS
 {
   switch (m_lengthUnits)
   {
-    case ::settings::Metric:
-      return speedInMetersPerSecond;
-    case ::settings::Foot:
-      return MeasurementUtils::MetersToFeet(speedInMetersPerSecond);
+  case Units::Metric: return speedInMetersPerSecond;
+  case Units::Imperial: return MetersToFeet(speedInMetersPerSecond);
   }
 
   ASSERT(false, ("m_lengthUnits is equal to unknown value."));
@@ -78,10 +78,8 @@ double Settings::ConvertUnitsToMeters(double distanceInUnits) const
 {
   switch (m_lengthUnits)
   {
-    case ::settings::Metric:
-      return distanceInUnits;
-    case ::settings::Foot:
-      return MeasurementUtils::FeetToMeters(distanceInUnits);
+  case Units::Metric: return distanceInUnits;
+  case Units::Imperial: return FeetToMeters(distanceInUnits);
   }
 
   ASSERT(false, ());
@@ -92,10 +90,8 @@ double Settings::ConvertMetersToUnits(double distanceInMeters) const
 {
   switch (m_lengthUnits)
   {
-    case ::settings::Metric:
-      return distanceInMeters;
-    case ::settings::Foot:
-      return MeasurementUtils::MetersToFeet(distanceInMeters);
+  case Units::Metric: return distanceInMeters;
+  case Units::Imperial: return MetersToFeet(distanceInMeters);
   }
 
   ASSERT(false, ());
@@ -112,12 +108,13 @@ uint32_t Settings::ComputeDistToPronounceDistM(double speedMetersPerSecond) cons
 
 string DebugPrint(Notification const & notification)
 {
+  string units;
   stringstream out;
   out << "Notification [ m_distanceUnits == " << notification.m_distanceUnits
       << ", m_exitNum == " << notification.m_exitNum
       << ", m_useThenInsteadOfDistance == " << notification.m_useThenInsteadOfDistance
       << ", m_turnDir == " << DebugPrint(notification.m_turnDir)
-      << ", m_lengthUnits == " << notification.m_lengthUnits << " ]" << endl;
+      << ", m_lengthUnits == " << DebugPrint(notification.m_lengthUnits) << " ]" << endl;
   return out.str();
 }
 
diff --git a/routing/turns_sound_settings.hpp b/routing/turns_sound_settings.hpp
index bf205a76e3..d533708563 100644
--- a/routing/turns_sound_settings.hpp
+++ b/routing/turns_sound_settings.hpp
@@ -2,7 +2,7 @@
 
 #include "routing/turns.hpp"
 
-#include "platform/settings.hpp"
+#include "platform/measurement_utils.hpp"
 
 #include "std/vector.hpp"
 
@@ -47,14 +47,14 @@ class Settings
   /// \brief m_distancesToPronounce is a list of distances in m_lengthUnits
   ///  which are ready to be pronounced.
   vector<uint32_t> m_soundedDistancesUnits;
-  ::settings::Units m_lengthUnits;
+  measurement_utils::Units m_lengthUnits;
 
   // This constructor is for testing only.
   Settings(uint32_t notificationTimeSeconds, uint32_t minNotificationDistanceUnits,
            uint32_t maxNotificationDistanceUnits, uint32_t startBeforeSeconds,
            uint32_t minStartBeforeMeters, uint32_t maxStartBeforeMeters,
            uint32_t minDistToSayNotificationMeters, vector<uint32_t> const & soundedDistancesUnits,
-           ::settings::Units lengthUnits)
+           measurement_utils::Units lengthUnits)
     : m_timeSeconds(notificationTimeSeconds)
     , m_minDistanceUnits(minNotificationDistanceUnits)
     , m_maxDistanceUnits(maxNotificationDistanceUnits)
@@ -78,13 +78,14 @@ public:
     , m_minStartBeforeMeters(minStartBeforeMeters)
     , m_maxStartBeforeMeters(maxStartBeforeMeters)
     , m_minDistToSayNotificationMeters(minDistToSayNotificationMeters)
-    , m_lengthUnits(::settings::Metric)
+    , m_lengthUnits(measurement_utils::Units::Metric)
   {
   }
 
   void SetState(uint32_t notificationTimeSeconds, uint32_t minNotificationDistanceUnits,
                 uint32_t maxNotificationDistanceUnits,
-                vector<uint32_t> const & soundedDistancesUnits, ::settings::Units lengthUnits);
+                vector<uint32_t> const & soundedDistancesUnits,
+                measurement_utils::Units lengthUnits);
 
   /// \brief IsValid checks if Settings data is consistent.
   /// \warning The complexity is up to linear in size of m_soundedDistancesUnits.
@@ -112,8 +113,8 @@ public:
   /// The result will be one of the m_soundedDistancesUnits values.
   uint32_t RoundByPresetSoundedDistancesUnits(uint32_t turnNotificationUnits) const;
 
-  inline ::settings::Units GetLengthUnits() const { return m_lengthUnits; }
-  inline void SetLengthUnits(::settings::Units units) { m_lengthUnits = units; }
+  inline measurement_utils::Units GetLengthUnits() const { return m_lengthUnits; }
+  inline void SetLengthUnits(measurement_utils::Units units) { m_lengthUnits = units; }
   double ConvertMetersPerSecondToUnitsPerSecond(double speedInMetersPerSecond) const;
   double ConvertUnitsToMeters(double distanceInUnits) const;
   double ConvertMetersToUnits(double distanceInMeters) const;
@@ -133,15 +134,15 @@ struct Notification
   /// The word "Then" shall be pronounced intead of the distance.
   bool m_useThenInsteadOfDistance;
   TurnDirection m_turnDir;
-  ::settings::Units m_lengthUnits;
+  measurement_utils::Units m_lengthUnits;
 
   Notification(uint32_t distanceUnits, uint8_t exitNum, bool useThenInsteadOfDistance,
-               TurnDirection turnDir, ::settings::Units lengthUnits)
-      : m_distanceUnits(distanceUnits),
-        m_exitNum(exitNum),
-        m_useThenInsteadOfDistance(useThenInsteadOfDistance),
-        m_turnDir(turnDir),
-        m_lengthUnits(lengthUnits)
+               TurnDirection turnDir, measurement_utils::Units lengthUnits)
+    : m_distanceUnits(distanceUnits)
+    , m_exitNum(exitNum)
+    , m_useThenInsteadOfDistance(useThenInsteadOfDistance)
+    , m_turnDir(turnDir)
+    , m_lengthUnits(lengthUnits)
   {
   }
   bool operator==(Notification const & rhv) const
diff --git a/routing/turns_tts_text.cpp b/routing/turns_tts_text.cpp
index b30a3b6268..60175a8134 100644
--- a/routing/turns_tts_text.cpp
+++ b/routing/turns_tts_text.cpp
@@ -88,12 +88,12 @@ string GetDistanceTextId(Notification const & notification)
 
   switch (notification.m_lengthUnits)
   {
-    case ::settings::Metric:
-      return DistToTextId(GetAllSoundedDistMeters().cbegin(), GetAllSoundedDistMeters().cend(),
-                          notification.m_distanceUnits);
-    case ::settings::Foot:
-      return DistToTextId(GetAllSoundedDistFeet().cbegin(), GetAllSoundedDistFeet().cend(),
-                          notification.m_distanceUnits);
+  case measurement_utils::Units::Metric:
+    return DistToTextId(GetAllSoundedDistMeters().cbegin(), GetAllSoundedDistMeters().cend(),
+                        notification.m_distanceUnits);
+  case measurement_utils::Units::Imperial:
+    return DistToTextId(GetAllSoundedDistFeet().cbegin(), GetAllSoundedDistFeet().cend(),
+                        notification.m_distanceUnits);
   }
   ASSERT(false, ());
   return string();