Merge pull request #3449 from LuxoftSDL/fix/move_duplicate_conversion_functions_to_message_helper

Move duplicate conversion functions to Message Helper

24 files changed, 100 insertions, 776 deletions

diff --git a/src/components/application_manager/include/application_manager/application_manager_impl.h b/src/components/application_manager/include/application_manager/application_manager_impl.h
index b3b396026c..6c7deca849 100644
--- a/src/components/application_manager/include/application_manager/application_manager_impl.h
+++ b/src/components/application_manager/include/application_manager/application_manager_impl.h
@@ -1230,21 +1230,6 @@ class ApplicationManagerImpl
                          smart_objects::SmartObject& vrSynonym);
 
   /**
-   * @brief Method transforms string to AppHMIType
-   * @param str contains string AppHMIType
-   * @return enum AppHMIType
-   */
-  mobile_apis::AppHMIType::eType StringToAppHMIType(std::string str);
-
-  /**
-   * @brief Returns a string representation of AppHMIType
-   * @param type an enum value of AppHMIType
-   * @return string representation of the enum value
-   */
-  const std::string AppHMITypeToString(
-      mobile_apis::AppHMIType::eType type) const;
-
-  /**
    * @brief Method compares arrays of app HMI type
    * @param from_policy contains app HMI type from policy
    * @param from_application contains app HMI type from application
diff --git a/src/components/application_manager/include/application_manager/message_helper.h b/src/components/application_manager/include/application_manager/message_helper.h
index 380b14af1e..7af9bacf27 100644
--- a/src/components/application_manager/include/application_manager/message_helper.h
+++ b/src/components/application_manager/include/application_manager/message_helper.h
@@ -49,6 +49,7 @@
 #include "interfaces/MOBILE_API.h"
 #include "policy/policy_types.h"
 #include "protocol_handler/session_observer.h"
+#include "smart_objects/enum_schema_item.h"
 #include "smart_objects/smart_object.h"
 #include "transport_manager/common.h"
 #include "utils/macro.h"
@@ -103,6 +104,35 @@ struct ResetGlobalPropertiesResult {
 typedef std::map<std::string, mobile_apis::VehicleDataType::eType> VehicleData;
 
 /**
+ * @brief Converts stringified value to enum value
+ * @param str stringified value
+ * @return Enum value if succedeed, otherwise -
+ * INVALID_ENUM
+ */
+template <typename T>
+T StringToEnum(const std::string& str) {
+  using namespace ns_smart_device_link::ns_smart_objects;
+  T enum_value;
+  EnumConversionHelper<T>::StringToEnum(str, &enum_value);
+  return enum_value;
+}
+
+/**
+ * @brief Converts enum value to string
+ * @param enum_value enum value
+ * @return stringified value for enum if succedeed, otherwise - empty string
+ */
+template <typename T>
+std::string EnumToString(T enum_value) {
+  using namespace ns_smart_device_link::ns_smart_objects;
+  const char* str = 0;
+  if (EnumConversionHelper<T>::EnumToCString(enum_value, &str)) {
+    return str;
+  }
+  return std::string();
+}
+
+/**
  * @brief MessageHelper class
  **/
 class MessageHelper {
@@ -184,42 +214,9 @@ class MessageHelper {
    */
   static const VehicleData& vehicle_data();
 
-  /**
-   * @brief Converts HMI Result enum value to string
-   * @param hmi_result HMI Result enum value
-   * @return stringified value for enum if succedeed, otherwise - empty string
-   */
-  static std::string HMIResultToString(
-      hmi_apis::Common_Result::eType hmi_result);
-
-  /**
-   * @brief Converts string to HMI Result enum value
-   * @param hmi_result stringified value
-   * @return HMI Result enum value if succedeed, otherwise - INVALID_ENUM
-   * value
-   */
-  static hmi_apis::Common_Result::eType HMIResultFromString(
-      const std::string& hmi_result);
-
-  /**
-   * @brief Converts mobile Result enum value to string
-   * @param mobile_result mobile Result enum value
-   * @return stringified value for enum if succedeed, otherwise - empty string
-   */
-  static std::string MobileResultToString(
-      mobile_apis::Result::eType mobile_result);
-
   static std::string GetDeviceMacAddressForHandle(
       const transport_manager::DeviceHandle device_handle,
       const ApplicationManager& app_mngr);
-  /**
-   * @brief Converts string to mobile Result enum value
-   * @param mobile_result stringified value
-   * @return mobile Result enum value if succedeed, otherwise - INVALID_ENUM
-   * value
-   */
-  static mobile_api::Result::eType MobileResultFromString(
-      const std::string& mobile_result);
 
   /**
    * @brief Converts HMI Result enum value to mobile Result enum value
@@ -239,23 +236,6 @@ class MessageHelper {
       const mobile_api::Result::eType mobile_result);
 
   /**
-   * @brief Convert string to HMI level, if possible
-   * @param hmi_level Stringified HMI level
-   * @return Appropriate enum from HMI level, or INVALID_ENUM, if conversiion
-   * is not possible
-   */
-  static mobile_api::HMILevel::eType StringToHMILevel(
-      const std::string& hmi_level);
-
-  /**
-   * @brief Used to obtain string representation of app's
-   * HMI Level.
-   * @param hmi_level Desired HMI Level
-   */
-  static std::string StringifiedHMILevel(
-      const mobile_apis::HMILevel::eType hmi_level);
-
-  /**
    * @brief Used to obtain function name by its id
    * @param function_id Function ID
    */
@@ -888,29 +868,6 @@ class MessageHelper {
   }
 
   static const uint32_t GetPriorityCode(const std::string& priority);
-  /**
-   * @brief Convert common language to string representation
-   * @param language Common language
-   * @return Common language string representation
-   */
-  static std::string CommonLanguageToString(
-      hmi_apis::Common_Language::eType language);
-
-  /**
-   * @brief Converts mobile language to string representation
-   * @param language Mobile UI language
-   * @return Mobile language string representation
-   */
-  static std::string MobileLanguageToString(
-      mobile_apis::Language::eType language);
-
-  /**
-   * @brief Converts string to mobile language enum value
-   * @param language language as string
-   * @return Mobile language enum value
-   */
-  static mobile_apis::Language::eType MobileLanguageFromString(
-      const std::string& language);
 
   /**
    * @brief Converts mobile language enum to HMI language enum
@@ -963,17 +920,6 @@ class MessageHelper {
                              const std::string& icon_path,
                              ApplicationManager& application_manager);
 
-  static hmi_apis::Common_Language::eType CommonLanguageFromString(
-      const std::string& language);
-
-  /**
-   * @brief CommonLightNameFromString convert string to LightName enum value
-   * @param lightName string to convert
-   * @return value LightName enum value
-   */
-  static hmi_apis::Common_LightName::eType CommonLightNameFromString(
-      const std::string& lightName);
-
   static smart_objects::SmartObjectSPtr
   GetOnAppInterfaceUnregisteredNotificationToMobile(
       int32_t connection_key,
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/get_system_info_response.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/get_system_info_response.cc
index 77605b31c3..8229e1978c 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/get_system_info_response.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/get_system_info_response.cc
@@ -84,9 +84,10 @@ const SystemInfo GetSystemInfoResponse::GetSystemInfo() const {
   info.wers_country_code =
       (*message_)[strings::msg_params]["wersCountryCode"].asString();
 
-  const auto lang_code = static_cast<hmi_apis::Common_Language::eType>(
-      (*message_)[strings::msg_params]["language"].asUInt());
-  info.language = MessageHelper::CommonLanguageToString(lang_code);
+  const uint32_t lang_code =
+      (*message_)[strings::msg_params]["language"].asUInt();
+  info.language = application_manager::EnumToString(
+      static_cast<hmi_apis::Common_Language::eType>(lang_code));
 
   return info;
 }
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_driver_distraction_notification.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_driver_distraction_notification.cc
index f701713d96..167176aa0f 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_driver_distraction_notification.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_driver_distraction_notification.cc
@@ -78,8 +78,7 @@ struct OnDriverDistractionProcessor {
       if (is_lock_screen_dismissal_exists &&
           msg_params[mobile_notification::lock_screen_dismissal_enabled]
               .asBool()) {
-        const auto language =
-            MessageHelper::MobileLanguageToString(application->ui_language());
+        const auto language = EnumToString(application->ui_language());
 
         const auto warning_message =
             application_manager_.GetPolicyHandler()
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_system_info_changed_notification.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_system_info_changed_notification.cc
index 6a3b814d05..48071cc1b2 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_system_info_changed_notification.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_system_info_changed_notification.cc
@@ -60,9 +60,8 @@ void OnSystemInfoChangedNotification::Run() {
   SDL_LOG_AUTO_TRACE();
   uint32_t lang_code =
       (*message_)[strings::msg_params][strings::language].asUInt();
-  const std::string language =
-      application_manager::MessageHelper::CommonLanguageToString(
-          static_cast<hmi_apis::Common_Language::eType>(lang_code));
+  const std::string language = application_manager::EnumToString(
+      static_cast<hmi_apis::Common_Language::eType>(lang_code));
 
   policy_handler_.OnSystemInfoChanged(language);
 }
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/sdl_get_user_friendly_message_request.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/sdl_get_user_friendly_message_request.cc
index e58961e581..57831bbc4a 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/sdl_get_user_friendly_message_request.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/sdl_get_user_friendly_message_request.cc
@@ -86,15 +86,13 @@ void SDLGetUserFriendlyMessageRequest::Run() {
   if ((*message_)[strings::msg_params].keyExists(strings::language)) {
     uint32_t lang_code =
         (*message_)[strings::msg_params][strings::language].asUInt();
-    required_language =
-        application_manager::MessageHelper::CommonLanguageToString(
-            static_cast<hmi_apis::Common_Language::eType>(lang_code));
+    required_language = application_manager::EnumToString(
+        static_cast<hmi_apis::Common_Language::eType>(lang_code));
   } else {
     hmi_apis::Common_Language::eType ui_language =
         hmi_capabilities_.active_ui_language();
 
-    required_language =
-        application_manager::MessageHelper::CommonLanguageToString(ui_language);
+    required_language = application_manager::EnumToString(ui_language);
   }
 
   policy_handler_.OnGetUserFriendlyMessage(
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/delete_command_request.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/delete_command_request.cc
index e6bdd50350..358a002606 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/delete_command_request.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/delete_command_request.cc
@@ -155,7 +155,7 @@ void DeleteCommandRequest::on_event(const event_engine::Event& event) {
       ui_result_ = static_cast<hmi_apis::Common_Result::eType>(
           message[strings::params][hmi_response::code].asInt());
       SDL_LOG_DEBUG("Received UI_DeleteCommand event with result "
-                    << MessageHelper::HMIResultToString(ui_result_));
+                    << EnumToString(ui_result_));
       GetInfo(message, ui_info_);
       break;
     }
@@ -165,7 +165,7 @@ void DeleteCommandRequest::on_event(const event_engine::Event& event) {
       vr_result_ = static_cast<hmi_apis::Common_Result::eType>(
           message[strings::params][hmi_response::code].asInt());
       SDL_LOG_DEBUG("Received VR_DeleteCommand event with result "
-                    << MessageHelper::HMIResultToString(vr_result_));
+                    << EnumToString(vr_result_));
       GetInfo(message, vr_info_);
       break;
     }
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/register_app_interface_request.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/register_app_interface_request.cc
index 72faad8668..acc7b33b17 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/register_app_interface_request.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/register_app_interface_request.cc
@@ -56,66 +56,14 @@
 namespace {
 namespace custom_str = utils::custom_string;
 
-mobile_apis::AppHMIType::eType StringToAppHMIType(const std::string& str) {
-  if ("DEFAULT" == str) {
-    return mobile_apis::AppHMIType::DEFAULT;
-  } else if ("COMMUNICATION" == str) {
-    return mobile_apis::AppHMIType::COMMUNICATION;
-  } else if ("MEDIA" == str) {
-    return mobile_apis::AppHMIType::MEDIA;
-  } else if ("MESSAGING" == str) {
-    return mobile_apis::AppHMIType::MESSAGING;
-  } else if ("NAVIGATION" == str) {
-    return mobile_apis::AppHMIType::NAVIGATION;
-  } else if ("INFORMATION" == str) {
-    return mobile_apis::AppHMIType::INFORMATION;
-  } else if ("SOCIAL" == str) {
-    return mobile_apis::AppHMIType::SOCIAL;
-  } else if ("BACKGROUND_PROCESS" == str) {
-    return mobile_apis::AppHMIType::BACKGROUND_PROCESS;
-  } else if ("TESTING" == str) {
-    return mobile_apis::AppHMIType::TESTING;
-  } else if ("SYSTEM" == str) {
-    return mobile_apis::AppHMIType::SYSTEM;
-  } else if ("PROJECTION" == str) {
-    return mobile_apis::AppHMIType::PROJECTION;
-  } else if ("REMOTE_CONTROL" == str) {
-    return mobile_apis::AppHMIType::REMOTE_CONTROL;
-  } else if ("WEB_VIEW" == str) {
-    return mobile_apis::AppHMIType::WEB_VIEW;
-  } else {
-    return mobile_apis::AppHMIType::INVALID_ENUM;
-  }
-}
-
-std::string AppHMITypeToString(mobile_apis::AppHMIType::eType type) {
-  const std::map<mobile_apis::AppHMIType::eType, std::string> app_hmi_type_map =
-      {{mobile_apis::AppHMIType::DEFAULT, "DEFAULT"},
-       {mobile_apis::AppHMIType::REMOTE_CONTROL, "REMOTE_CONTROL"},
-       {mobile_apis::AppHMIType::COMMUNICATION, "COMMUNICATION"},
-       {mobile_apis::AppHMIType::MEDIA, "MEDIA"},
-       {mobile_apis::AppHMIType::MESSAGING, "MESSAGING"},
-       {mobile_apis::AppHMIType::NAVIGATION, "NAVIGATION"},
-       {mobile_apis::AppHMIType::INFORMATION, "INFORMATION"},
-       {mobile_apis::AppHMIType::SOCIAL, "SOCIAL"},
-       {mobile_apis::AppHMIType::BACKGROUND_PROCESS, "BACKGROUND_PROCESS"},
-       {mobile_apis::AppHMIType::TESTING, "TESTING"},
-       {mobile_apis::AppHMIType::SYSTEM, "SYSTEM"},
-       {mobile_apis::AppHMIType::PROJECTION, "PROJECTION"},
-       {mobile_apis::AppHMIType::WEB_VIEW, "WEB_VIEW"}};
-
-  std::map<mobile_apis::AppHMIType::eType, std::string>::const_iterator iter =
-      app_hmi_type_map.find(type);
-
-  return app_hmi_type_map.end() != iter ? iter->second : std::string("");
-}
-
 struct AppHMITypeInserter {
   explicit AppHMITypeInserter(smart_objects::SmartObject& so_array)
       : index_(0), so_array_(so_array) {}
 
   bool operator()(const std::string& app_hmi_type) {
-    so_array_[index_] = StringToAppHMIType(app_hmi_type);
+    so_array_[index_] =
+        application_manager::StringToEnum<mobile_apis::AppHMIType::eType>(
+            app_hmi_type);
     ++index_;
     return true;
   }
@@ -131,7 +79,7 @@ struct CheckMissedTypes {
       : policy_app_types_(policy_app_types), log_(log) {}
 
   bool operator()(const smart_objects::SmartArray::value_type& value) {
-    std::string app_type_str = AppHMITypeToString(
+    std::string app_type_str = application_manager::EnumToString(
         static_cast<mobile_apis::AppHMIType::eType>(value.asInt()));
     if (!app_type_str.empty()) {
       policy::StringArray::const_iterator it = policy_app_types_.begin();
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/get_system_info_response_test.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/get_system_info_response_test.cc
index 30d125ff46..8cdce4fa74 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/get_system_info_response_test.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/get_system_info_response_test.cc
@@ -69,8 +69,7 @@ namespace {
 const uint32_t kConnectionKey = 2u;
 const std::string ccpu_version("4.1.3.B_EB355B");
 const std::string wers_country_code("WAEGB");
-const uint32_t lang_code = 0u;
-const std::string kLanguage = "";
+const std::string lang_code("EN-US");
 }  // namespace
 
 class GetSystemInfoResponseTest
@@ -99,15 +98,8 @@ TEST_F(GetSystemInfoResponseTest, GetSystemInfo_SUCCESS) {
 
   ResponseFromHMIPtr command(CreateCommand<GetSystemInfoResponse>(command_msg));
 
-  std::string language;
-  EXPECT_CALL(mock_message_helper_,
-              CommonLanguageToString(
-                  static_cast<hmi_apis::Common_Language::eType>(lang_code)))
-      .WillOnce(Return(language));
-  EXPECT_EQ(kLanguage, language);
-
   EXPECT_CALL(mock_policy_handler_,
-              OnGetSystemInfo(ccpu_version, wers_country_code, kLanguage));
+              OnGetSystemInfo(ccpu_version, wers_country_code, lang_code));
 
   command->Run();
 }
@@ -121,11 +113,6 @@ TEST_F(GetSystemInfoResponseTest, GetSystemInfo_UNSUCCESS) {
 
   ResponseFromHMIPtr command(CreateCommand<GetSystemInfoResponse>(command_msg));
 
-  EXPECT_CALL(mock_message_helper_,
-              CommonLanguageToString(
-                  static_cast<hmi_apis::Common_Language::eType>(lang_code)))
-      .Times(0);
-
   EXPECT_CALL(mock_hmi_capabilities_, UpdateCachedCapabilities());
   EXPECT_CALL(mock_policy_handler_, SetPreloadedPtFlag(false));
 
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/hmi_notifications_test.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/hmi_notifications_test.cc
index 20ca4d3dff..3efdee405a 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/hmi_notifications_test.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/hmi_notifications_test.cc
@@ -256,8 +256,6 @@ class HMICommandsNotificationsTest
     ON_CALL(app_mngr_, application_by_hmi_app(_)).WillByDefault(Return(app_));
     ON_CALL(*app_ptr_, app_id()).WillByDefault(Return(kAppId_));
     ON_CALL(app_mngr_, application(kConnectionKey)).WillByDefault(Return(app_));
-    ON_CALL(mock_message_helper_, MobileLanguageToString(kMobileLanguage))
-        .WillByDefault(Return(kDefaultLanguage));
     ON_CALL(app_mngr_, connection_handler())
         .WillByDefault(ReturnRef(mock_connection_handler_));
   }
@@ -786,7 +784,6 @@ TEST_F(HMICommandsNotificationsTest,
   std::shared_ptr<Command> command =
       CreateCommand<OnSystemInfoChangedNotification>(message);
 
-  EXPECT_CALL(mock_message_helper_, CommonLanguageToString(_));
   EXPECT_CALL(mock_policy_handler_, OnSystemInfoChanged(_));
   command->Run();
 }
@@ -1842,7 +1839,7 @@ TEST_F(HMICommandsNotificationsTest, OnDriverDistractionNotificationEmptyData) {
 
   ON_CALL(mock_policy_handler_, LockScreenDismissalEnabledState())
       .WillByDefault(Return(OptionalBool(true)));
-  std::string required_language = "en-us";
+  std::string required_language = "EN-US";
   ON_CALL(mock_policy_handler_,
           LockScreenDismissalWarningMessage(required_language))
       .WillByDefault(Return(
@@ -1872,7 +1869,7 @@ TEST_F(HMICommandsNotificationsTest,
   typedef boost::optional<bool> OptionalBool;
   ON_CALL(mock_policy_handler_, LockScreenDismissalEnabledState())
       .WillByDefault(Return(OptionalBool(true)));
-  std::string required_language = "en-us";
+  std::string required_language = "EN-US";
   ON_CALL(mock_policy_handler_,
           LockScreenDismissalWarningMessage(required_language))
       .WillByDefault(Return(
@@ -1900,7 +1897,9 @@ TEST_F(HMICommandsNotificationsTest, OnDriverDistractionNotificationValidApp) {
   typedef boost::optional<bool> OptionalBool;
   ON_CALL(mock_policy_handler_, LockScreenDismissalEnabledState())
       .WillByDefault(Return(OptionalBool(true)));
-  std::string required_language = "en-us";
+  std::string required_language = "EN-US";
+  ON_CALL(*app_ptr_, ui_language()).WillByDefault(ReturnRef(kMobileLanguage));
+
   ON_CALL(mock_policy_handler_,
           LockScreenDismissalWarningMessage(required_language))
       .WillByDefault(Return(
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/on_driver_distraction_notification_test.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/on_driver_distraction_notification_test.cc
index fe6ba7c4e3..642b4e651d 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/on_driver_distraction_notification_test.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/on_driver_distraction_notification_test.cc
@@ -95,8 +95,6 @@ class HMIOnDriverDistractionNotificationTest
         .WillByDefault(ReturnRef(kMobileLanguage));
     ON_CALL(app_mngr_, application(kConnectionKey))
         .WillByDefault(Return(mock_app_));
-    ON_CALL(mock_message_helper_, MobileLanguageToString(kMobileLanguage))
-        .WillByDefault(Return(kDefaultLanguage));
   }
 
   MockAppPtr mock_app_;
@@ -327,8 +325,6 @@ TEST_F(HMIOnDriverDistractionNotificationTest,
       mobile_apis::Language::FR_FR;
   std::string required_language = "FR-FR";
   ON_CALL(*mock_app_, ui_language()).WillByDefault(ReturnRef(mobile_language));
-  ON_CALL(mock_message_helper_, MobileLanguageToString(mobile_language))
-      .WillByDefault(Return(required_language));
 
   policy::CheckPermissionResult result;
   result.hmi_level_permitted = policy::kRpcAllowed;
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/sdl_get_user_friendly_message_request_test.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/sdl_get_user_friendly_message_request_test.cc
index 0e87acef1f..d457b2a697 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/sdl_get_user_friendly_message_request_test.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/hmi/sdl_get_user_friendly_message_request_test.cc
@@ -62,8 +62,8 @@ using testing::ReturnRef;
 namespace {
 const uint32_t kCorrelationID = 1u;
 const uint32_t kAppID = 2u;
-const std::string kLanguageDe = "de-de";
-const std::string kLanguageEn = "en-gb";
+const std::string kLanguageDe = "DE-DE";
+const std::string kLanguageEn = "EN-GB";
 const std::string kMessageCodes = "messageCodes";
 const hmi_apis::Common_Language::eType kLanguage =
     hmi_apis::Common_Language::EN_GB;
@@ -102,8 +102,6 @@ TEST_F(SDLGetUserFriendlyMessageRequestTest, Run_LanguageSet_SUCCESS) {
   std::shared_ptr<SDLGetUserFriendlyMessageRequest> command(
       CreateCommand<SDLGetUserFriendlyMessageRequest>(msg));
 
-  EXPECT_CALL(mock_message_helper_, CommonLanguageToString(kLanguage))
-      .WillOnce(Return(kLanguageEn));
   std::vector<std::string> msg_codes;
   msg_codes.push_back(kLanguageDe);
   msg_codes.push_back(kLanguageEn);
@@ -129,8 +127,6 @@ TEST_F(SDLGetUserFriendlyMessageRequestTest, Run_LanguageNotSet_SUCCESS) {
 
   EXPECT_CALL(mock_hmi_capabilities_, active_ui_language())
       .WillOnce(Return(kLanguage));
-  EXPECT_CALL(mock_message_helper_, CommonLanguageToString(kLanguage))
-      .WillOnce(Return(kLanguageEn));
   std::vector<std::string> msg_codes;
   msg_codes.push_back(kLanguageDe);
   msg_codes.push_back(kLanguageEn);
@@ -149,7 +145,6 @@ TEST_F(SDLGetUserFriendlyMessageRequestTest, Run_NoMsgCodes_Canceled) {
   std::shared_ptr<SDLGetUserFriendlyMessageRequest> command(
       CreateCommand<SDLGetUserFriendlyMessageRequest>(msg));
 
-  EXPECT_CALL(mock_message_helper_, CommonLanguageToString(_)).Times(0);
   EXPECT_CALL(mock_policy_handler_, OnGetUserFriendlyMessage(_, _, _)).Times(0);
 
   command->Init();
@@ -181,7 +176,6 @@ TEST_F(
   std::shared_ptr<SDLGetUserFriendlyMessageRequest> command(
       CreateCommand<SDLGetUserFriendlyMessageRequest>(msg));
 
-  EXPECT_CALL(mock_message_helper_, CommonLanguageToString(_)).Times(0);
   EXPECT_CALL(mock_policy_handler_, OnGetUserFriendlyMessage(_, _, _)).Times(0);
 
   command->Init();
diff --git a/src/components/application_manager/src/application_manager_impl.cc b/src/components/application_manager/src/application_manager_impl.cc
index 90855fa9ee..4a206e19cd 100644
--- a/src/components/application_manager/src/application_manager_impl.cc
+++ b/src/components/application_manager/src/application_manager_impl.cc
@@ -1813,8 +1813,8 @@ bool ApplicationManagerImpl::CheckResumptionRequiredTransportAvailable(
   } else {
     // check all AppHMITypes that the app has
     for (size_t i = 0; i < app_types_array->length(); i++) {
-      const std::string app_type_string =
-          AppHMITypeToString(static_cast<mobile_apis::AppHMIType::eType>(
+      std::string app_type_string =
+          EnumToString(static_cast<mobile_apis::AppHMIType::eType>(
               app_types_array->getElement(i).asUInt()));
       bool transport_is_found = false;
 
@@ -2703,8 +2703,7 @@ void ApplicationManagerImpl::PullLanguagesInfo(const SmartObject& app_data,
   }
 
   const HMICapabilities& hmi_cap = hmi_capabilities();
-  std::string cur_vr_lang(
-      MessageHelper::CommonLanguageToString(hmi_cap.active_vr_language()));
+  std::string cur_vr_lang(EnumToString(hmi_cap.active_vr_language()));
   const SmartObject& languages = app_data[json::languages];
 
   std::transform(
@@ -3348,8 +3347,8 @@ mobile_apis::Result::eType ApplicationManagerImpl::CheckPolicyPermissions(
 #ifdef ENABLE_LOG
   const std::string log_msg =
       "Application: " + app->policy_app_id() + ", RPC: " + function_id +
-      ", window_id: " + std::to_string(window_id) + ", HMI status: " +
-      MessageHelper::StringifiedHMILevel(app->hmi_level(window_id));
+      ", window_id: " + std::to_string(window_id) +
+      ", HMI status: " + EnumToString(app->hmi_level(window_id));
 #endif  // ENABLE_LOG
   if (result.hmi_level_permitted != policy::kRpcAllowed) {
     SDL_LOG_WARN("Request is blocked by policies. " << log_msg);
@@ -4283,69 +4282,6 @@ ApplicationManagerImpl::CreateAllAppGlobalPropsIDList(
   return global_properties;
 }
 
-mobile_apis::AppHMIType::eType ApplicationManagerImpl::StringToAppHMIType(
-    std::string str) {
-  SDL_LOG_AUTO_TRACE();
-  if ("DEFAULT" == str) {
-    return mobile_apis::AppHMIType::DEFAULT;
-  } else if ("COMMUNICATION" == str) {
-    return mobile_apis::AppHMIType::COMMUNICATION;
-  } else if ("MEDIA" == str) {
-    return mobile_apis::AppHMIType::MEDIA;
-  } else if ("MESSAGING" == str) {
-    return mobile_apis::AppHMIType::MESSAGING;
-  } else if ("NAVIGATION" == str) {
-    return mobile_apis::AppHMIType::NAVIGATION;
-  } else if ("PROJECTION" == str) {
-    return mobile_apis::AppHMIType::PROJECTION;
-  } else if ("INFORMATION" == str) {
-    return mobile_apis::AppHMIType::INFORMATION;
-  } else if ("SOCIAL" == str) {
-    return mobile_apis::AppHMIType::SOCIAL;
-  } else if ("BACKGROUND_PROCESS" == str) {
-    return mobile_apis::AppHMIType::BACKGROUND_PROCESS;
-  } else if ("TESTING" == str) {
-    return mobile_apis::AppHMIType::TESTING;
-  } else if ("SYSTEM" == str) {
-    return mobile_apis::AppHMIType::SYSTEM;
-  } else {
-    return mobile_apis::AppHMIType::INVALID_ENUM;
-  }
-}
-
-const std::string ApplicationManagerImpl::AppHMITypeToString(
-    mobile_apis::AppHMIType::eType type) const {
-  SDL_LOG_AUTO_TRACE();
-  switch (type) {
-    case mobile_apis::AppHMIType::DEFAULT:
-      return "DEFAULT";
-    case mobile_apis::AppHMIType::COMMUNICATION:
-      return "COMMUNICATION";
-    case mobile_apis::AppHMIType::MEDIA:
-      return "MEDIA";
-    case mobile_apis::AppHMIType::MESSAGING:
-      return "MESSAGING";
-    case mobile_apis::AppHMIType::NAVIGATION:
-      return "NAVIGATION";
-    case mobile_apis::AppHMIType::INFORMATION:
-      return "INFORMATION";
-    case mobile_apis::AppHMIType::SOCIAL:
-      return "SOCIAL";
-    case mobile_apis::AppHMIType::BACKGROUND_PROCESS:
-      return "BACKGROUND_PROCESS";
-    case mobile_apis::AppHMIType::TESTING:
-      return "TESTING";
-    case mobile_apis::AppHMIType::SYSTEM:
-      return "SYSTEM";
-    case mobile_apis::AppHMIType::PROJECTION:
-      return "PROJECTION";
-    case mobile_apis::AppHMIType::REMOTE_CONTROL:
-      return "REMOTE_CONTROL";
-    default:
-      return "INVALID_ENUM";
-  }
-}
-
 bool ApplicationManagerImpl::CompareAppHMIType(
     const smart_objects::SmartObject& from_policy,
     const smart_objects::SmartObject& from_application) {
@@ -4396,7 +4332,8 @@ void ApplicationManagerImpl::OnUpdateHMIAppType(
 
       for (uint32_t i = 0; i < hmi_types_from_policy.size(); ++i) {
         transform_app_hmi_types[i] =
-            StringToAppHMIType(hmi_types_from_policy[i]);
+            StringToEnum<mobile_api::AppHMIType::eType>(
+                hmi_types_from_policy[i]);
       }
 
       ApplicationConstSharedPtr app = *it;
@@ -4543,8 +4480,7 @@ void ApplicationManagerImpl::SendDriverDistractionState(
             driver_distraction_state()) {
       bool dismissal_enabled = *lock_screen_dismissal;
       if (dismissal_enabled) {
-        const auto language =
-            MessageHelper::MobileLanguageToString(application->ui_language());
+        const auto language = EnumToString(application->ui_language());
 
         const auto warning_message =
             policy_handler_->LockScreenDismissalWarningMessage(language);
diff --git a/src/components/application_manager/src/hmi_capabilities_impl.cc b/src/components/application_manager/src/hmi_capabilities_impl.cc
index c207f7fa00..116732d13d 100644
--- a/src/components/application_manager/src/hmi_capabilities_impl.cc
+++ b/src/components/application_manager/src/hmi_capabilities_impl.cc
@@ -745,7 +745,6 @@ bool HMICapabilitiesImpl::LoadCapabilitiesFromFile() {
 
     JsonCapabilitiesGetter json_root_getter(root_json, root_json_override);
     // UI
-
     if (json_root_getter.IsInterfaceJsonMemberExists(hmi_interface::ui)) {
       auto json_ui_getter =
           GetInterfaceGetter(hmi_interface::ui, json_root_getter);
@@ -757,7 +756,8 @@ bool HMICapabilitiesImpl::LoadCapabilitiesFromFile() {
 
       if (!ui_language_node.isNull()) {
         const std::string lang = ui_language_node.asString();
-        set_active_ui_language(MessageHelper::CommonLanguageFromString(lang));
+        set_active_ui_language(
+            StringToEnum<hmi_apis::Common_Language::eType>(lang));
       }
 
       auto ui_languages_node = json_ui_getter.GetJsonMember(
@@ -1045,6 +1045,7 @@ bool HMICapabilitiesImpl::LoadCapabilitiesFromFile() {
             set_video_streaming_supported(true);
           }
         }
+
         if (JsonIsMemberSafe(ui_system_capabilities_node,
                              strings::driver_distraction_capability)) {
           Json::Value dd_capability = ui_system_capabilities_node.get(
@@ -1086,7 +1087,7 @@ bool HMICapabilitiesImpl::LoadCapabilitiesFromFile() {
             auto it = lights.asArray()->begin();
             for (; it != lights.asArray()->end(); ++it) {
               smart_objects::SmartObject& light_name_so = (*it)[strings::name];
-              auto light_name = MessageHelper::CommonLightNameFromString(
+              auto light_name = StringToEnum<hmi_apis::Common_LightName::eType>(
                   light_name_so.asString());
               light_name_so = light_name;
             }
@@ -1129,7 +1130,8 @@ bool HMICapabilitiesImpl::LoadCapabilitiesFromFile() {
                                        requests_required_for_capabilities_);
       if (!vr_language_node.isNull()) {
         const std::string lang = vr_language_node.asString();
-        set_active_vr_language(MessageHelper::CommonLanguageFromString(lang));
+        set_active_vr_language(
+            StringToEnum<hmi_apis::Common_Language::eType>(lang));
       }
 
       auto vr_languages_node = json_vr_getter.GetJsonMember(
@@ -1170,7 +1172,8 @@ bool HMICapabilitiesImpl::LoadCapabilitiesFromFile() {
                                         requests_required_for_capabilities_);
       if (!tts_language_node.isNull()) {
         const std::string lang = tts_language_node.asString();
-        set_active_tts_language(MessageHelper::CommonLanguageFromString(lang));
+        set_active_tts_language(
+            StringToEnum<hmi_apis::Common_Language::eType>(lang));
       }
 
       auto tts_languages_node = json_tts_getter.GetJsonMember(
@@ -1277,7 +1280,7 @@ bool HMICapabilitiesImpl::LoadCapabilitiesFromFile() {
     return false;
   }
   return true;
-}
+}  // namespace application_manager
 
 hmi_apis::Common_Language::eType
 HMICapabilitiesImpl::GetActiveLanguageForInterface(
@@ -1366,8 +1369,8 @@ bool HMICapabilitiesImpl::AllFieldsSaved(
           GetActiveLanguageForInterface(interface_name);
       const auto json_language = interface_node[hmi_response::language];
 
-      if (active_language !=
-          MessageHelper::CommonLanguageFromString(json_language.asString())) {
+      if (active_language != StringToEnum<hmi_apis::Common_Language::eType>(
+                                 json_language.asString())) {
         SDL_LOG_DEBUG("Active " << interface_name
                                 << " language is not the same as the persisted "
                                    "one. Field should be overwritten");
@@ -1506,8 +1509,7 @@ void HMICapabilitiesImpl::PrepareUiJsonValueForSaving(
     }
 
     else if (section_to_update == hmi_response::language) {
-      out_node[hmi_response::language] =
-          MessageHelper::CommonLanguageToString(active_ui_language());
+      out_node[hmi_response::language] = EnumToString(active_ui_language());
     }
 
     else if (section_to_update == hmi_response::languages) {
@@ -1530,8 +1532,7 @@ void HMICapabilitiesImpl::PrepareVrJsonValueForSaving(
 
   for (const auto& section_to_update : sections_to_update) {
     if (section_to_update == hmi_response::language) {
-      out_node[hmi_response::language] =
-          MessageHelper::CommonLanguageToString(active_vr_language());
+      out_node[hmi_response::language] = EnumToString(active_vr_language());
     }
 
     if (section_to_update == hmi_response::languages) {
@@ -1554,8 +1555,7 @@ void HMICapabilitiesImpl::PrepareTtsJsonValueForSaving(
 
   for (const auto& section_to_update : sections_to_update) {
     if (section_to_update == hmi_response::language) {
-      out_node[hmi_response::language] =
-          MessageHelper::CommonLanguageToString(active_tts_language());
+      out_node[hmi_response::language] = EnumToString(active_tts_language());
     }
 
     if (section_to_update == hmi_response::languages) {
@@ -1820,8 +1820,8 @@ void HMICapabilitiesImpl::convert_json_languages_to_obj(
     const Json::Value& json_languages,
     smart_objects::SmartObject& languages) const {
   for (uint32_t i = 0, j = 0; i < json_languages.size(); ++i) {
-    languages[j++] =
-        MessageHelper::CommonLanguageFromString(json_languages[i].asString());
+    languages[j++] = StringToEnum<hmi_apis::Common_Language::eType>(
+        json_languages[i].asString());
   }
 }
 
diff --git a/src/components/application_manager/src/message_helper/message_helper.cc b/src/components/application_manager/src/message_helper/message_helper.cc
index ed8b801377..b66742a7f5 100644
--- a/src/components/application_manager/src/message_helper/message_helper.cc
+++ b/src/components/application_manager/src/message_helper/message_helper.cc
@@ -301,28 +301,6 @@ const uint32_t MessageHelper::GetPriorityCode(const std::string& priority) {
   return static_cast<uint32_t>(hmi_apis::Common_AppPriority::INVALID_ENUM);
 }
 
-hmi_apis::Common_Language::eType MessageHelper::CommonLanguageFromString(
-    const std::string& language) {
-  using namespace ns_smart_device_link::ns_smart_objects;
-  hmi_apis::Common_Language::eType value;
-  if (EnumConversionHelper<hmi_apis::Common_Language::eType>::StringToEnum(
-          language, &value)) {
-    return value;
-  }
-  return hmi_apis::Common_Language::INVALID_ENUM;
-}
-
-hmi_apis::Common_LightName::eType MessageHelper::CommonLightNameFromString(
-    const std::string& lightName) {
-  using namespace ns_smart_device_link::ns_smart_objects;
-  hmi_apis::Common_LightName::eType value;
-  if (EnumConversionHelper<hmi_apis::Common_LightName::eType>::StringToEnum(
-          lightName, &value)) {
-    return value;
-  }
-  return hmi_apis::Common_LightName::INVALID_ENUM;
-}
-
 std::string MessageHelper::GetDeviceMacAddressForHandle(
     const transport_manager::DeviceHandle device_handle,
     const ApplicationManager& app_mngr) {
@@ -333,26 +311,6 @@ std::string MessageHelper::GetDeviceMacAddressForHandle(
   return device_mac_address;
 }
 
-std::string MessageHelper::CommonLanguageToString(
-    hmi_apis::Common_Language::eType language) {
-  using namespace ns_smart_device_link::ns_smart_objects;
-  const char* str = 0;
-  if (EnumConversionHelper<hmi_apis::Common_Language::eType>::EnumToCString(
-          language, &str)) {
-    return str ? str : "";
-  }
-  return std::string();
-}
-
-std::string MessageHelper::MobileLanguageToString(
-    mobile_apis::Language::eType language) {
-  using namespace ns_smart_device_link::ns_smart_objects;
-  const char* str = 0;
-  EnumConversionHelper<mobile_apis::Language::eType>::EnumToCString(language,
-                                                                    &str);
-  return str ? str : std::string();
-}
-
 smart_objects::SmartObjectSPtr MessageHelper::CreateMessageForHMI(
     const hmi_apis::messageType::eType message_type,
     const uint32_t correlation_id) {
@@ -846,66 +804,22 @@ const VehicleData& MessageHelper::vehicle_data() {
   return vehicle_data_;
 }
 
-std::string MessageHelper::HMIResultToString(
-    hmi_apis::Common_Result::eType hmi_result) {
-  using namespace ns_smart_device_link::ns_smart_objects;
-  const char* str = 0;
-  if (EnumConversionHelper<hmi_apis::Common_Result::eType>::EnumToCString(
-          hmi_result, &str)) {
-    return str;
-  }
-  return std::string();
-}
-
-hmi_apis::Common_Result::eType MessageHelper::HMIResultFromString(
-    const std::string& hmi_result) {
-  using namespace ns_smart_device_link::ns_smart_objects;
-  hmi_apis::Common_Result::eType value;
-  if (EnumConversionHelper<hmi_apis::Common_Result::eType>::StringToEnum(
-          hmi_result, &value)) {
-    return value;
-  }
-  return hmi_apis::Common_Result::INVALID_ENUM;
-}
-
-std::string MessageHelper::MobileResultToString(
-    mobile_apis::Result::eType mobile_result) {
-  using namespace ns_smart_device_link::ns_smart_objects;
-  const char* str = 0;
-  if (EnumConversionHelper<mobile_apis::Result::eType>::EnumToCString(
-          mobile_result, &str)) {
-    return str;
-  }
-  return std::string();
-}
-
-mobile_apis::Result::eType MessageHelper::MobileResultFromString(
-    const std::string& mobile_result) {
-  using namespace ns_smart_device_link::ns_smart_objects;
-  mobile_apis::Result::eType value;
-  if (EnumConversionHelper<mobile_apis::Result::eType>::StringToEnum(
-          mobile_result, &value)) {
-    return value;
-  }
-  return mobile_apis::Result::INVALID_ENUM;
-}
-
 mobile_apis::Result::eType MessageHelper::HMIToMobileResult(
     const hmi_apis::Common_Result::eType hmi_result) {
-  const std::string result = HMIResultToString(hmi_result);
+  const std::string result = EnumToString(hmi_result);
   if (result.empty()) {
     return mobile_api::Result::INVALID_ENUM;
   }
-  return MobileResultFromString(result);
+  return StringToEnum<mobile_apis::Result::eType>(result);
 }
 
 hmi_apis::Common_Result::eType MessageHelper::MobileToHMIResult(
     const mobile_apis::Result::eType mobile_result) {
-  const std::string result = MobileResultToString(mobile_result);
+  const std::string result = EnumToString(mobile_result);
   if (result.empty()) {
     return hmi_apis::Common_Result::INVALID_ENUM;
   }
-  return HMIResultFromString(result);
+  return StringToEnum<hmi_apis::Common_Result::eType>(result);
 }
 
 smart_objects::SmartObjectSPtr MessageHelper::CreateHMIStatusNotification(
@@ -999,28 +913,6 @@ void MessageHelper::SendActivateAppToHMI(
   application_manager.GetRPCService().ManageHMICommand(message);
 }
 
-mobile_apis::HMILevel::eType MessageHelper::StringToHMILevel(
-    const std::string& hmi_level) {
-  using namespace ns_smart_device_link::ns_smart_objects;
-  mobile_apis::HMILevel::eType value;
-  if (EnumConversionHelper<mobile_apis::HMILevel::eType>::StringToEnum(
-          hmi_level, &value)) {
-    return value;
-  }
-  return mobile_apis::HMILevel::INVALID_ENUM;
-}
-
-std::string MessageHelper::StringifiedHMILevel(
-    const mobile_apis::HMILevel::eType hmi_level) {
-  using namespace ns_smart_device_link::ns_smart_objects;
-  const char* str = 0;
-  if (EnumConversionHelper<mobile_apis::HMILevel::eType>::EnumToCString(
-          hmi_level, &str)) {
-    return str;
-  }
-  return std::string();
-}
-
 std::string MessageHelper::StringifiedFunctionID(
     mobile_apis::FunctionID::eType function_id) {
   SDL_LOG_AUTO_TRACE();
diff --git a/src/components/application_manager/src/policies/policy_handler.cc b/src/components/application_manager/src/policies/policy_handler.cc
index 280e1cace5..e4e78c6f7e 100644
--- a/src/components/application_manager/src/policies/policy_handler.cc
+++ b/src/components/application_manager/src/policies/policy_handler.cc
@@ -756,9 +756,8 @@ void PolicyHandler::OnGetUserFriendlyMessage(
   POLICY_LIB_CHECK_VOID();
 
 #ifdef EXTERNAL_PROPRIETARY_MODE
-  const std::string active_hmi_language =
-      application_manager::MessageHelper::CommonLanguageToString(
-          application_manager_.hmi_capabilities().active_ui_language());
+  const std::string active_hmi_language = application_manager::EnumToString(
+      application_manager_.hmi_capabilities().active_ui_language());
   const std::vector<UserFriendlyMessage> result =
       policy_manager_->GetUserFriendlyMessages(
           message_codes, language, active_hmi_language);
@@ -1492,8 +1491,7 @@ void PolicyHandler::OnPermissionsUpdated(const std::string& device_id,
   // level to default
   mobile_apis::HMILevel::eType current_hmi_level =
       app->hmi_level(mobile_apis::PredefinedWindows::DEFAULT_WINDOW);
-  mobile_apis::HMILevel::eType hmi_level =
-      MessageHelper::StringToHMILevel(default_hmi);
+  auto hmi_level = StringToEnum<mobile_apis::HMILevel::eType>(default_hmi);
 
   if (mobile_apis::HMILevel::INVALID_ENUM == hmi_level) {
     SDL_LOG_WARN("Couldn't convert default hmi level " << default_hmi
@@ -1705,7 +1703,7 @@ void PolicyHandler::CheckPermissions(
     CheckPermissionResult& result) {
   POLICY_LIB_CHECK_VOID();
   const std::string hmi_level =
-      MessageHelper::StringifiedHMILevel(app->hmi_level(window_id));
+      application_manager::EnumToString(app->hmi_level(window_id));
   if (hmi_level.empty()) {
     SDL_LOG_WARN("HMI level for " << app->policy_app_id() << " is invalid, rpc "
                                   << rpc << " is not allowed.");
@@ -2721,8 +2719,7 @@ void PolicyHandler::OnUpdateHMIStatus(const std::string& device_id,
                                                 << policy_app_id);
     return;
   }
-  mobile_apis::HMILevel::eType level =
-      MessageHelper::StringToHMILevel(hmi_level);
+  auto level = StringToEnum<mobile_apis::HMILevel::eType>(hmi_level);
   if (mobile_apis::HMILevel::INVALID_ENUM == level) {
     SDL_LOG_WARN("Couldn't convert default hmi level " << hmi_level
                                                        << " to enum.");
@@ -2795,8 +2792,7 @@ void PolicyHandler::OnUpdateHMILevel(const std::string& device_id,
                                                 << policy_app_id);
     return;
   }
-  mobile_apis::HMILevel::eType level =
-      MessageHelper::StringToHMILevel(hmi_level);
+  auto level = StringToEnum<mobile_apis::HMILevel::eType>(hmi_level);
   if (mobile_apis::HMILevel::INVALID_ENUM == level) {
     SDL_LOG_WARN("Couldn't convert default hmi level " << hmi_level
                                                        << " to enum.");
diff --git a/src/components/application_manager/src/request_tracker.cc b/src/components/application_manager/src/request_tracker.cc
index 5f92a107b5..2ad504aadf 100644
--- a/src/components/application_manager/src/request_tracker.cc
+++ b/src/components/application_manager/src/request_tracker.cc
@@ -49,8 +49,7 @@ TrackResult RequestTracker::Track(const ApplicationID& app_id,
   SDL_LOG_AUTO_TRACE();
   bool track_result = false;
 
-  SDL_LOG_DEBUG("Tracking request for level: "
-                << MessageHelper::StringifiedHMILevel(level));
+  SDL_LOG_DEBUG("Tracking request for level: " << EnumToString(level));
 
   if (mobile_apis::HMILevel::HMI_NONE == level) {
     track_result = Track(app_id,
diff --git a/src/components/application_manager/src/resumption/resumption_data_processor_impl.cc b/src/components/application_manager/src/resumption/resumption_data_processor_impl.cc
index a490429197..d3ac9c24e1 100644
--- a/src/components/application_manager/src/resumption/resumption_data_processor_impl.cc
+++ b/src/components/application_manager/src/resumption/resumption_data_processor_impl.cc
@@ -49,14 +49,6 @@ namespace commands = app_mngr::commands;
 namespace message_params = rc_rpc_plugin::message_params;
 
 SDL_CREATE_LOG_VARIABLE("Resumption")
-std::map<hmi_apis::Common_ModuleType::eType, std::string>
-    module_types_str_mapping{
-        {hmi_apis::Common_ModuleType::eType::CLIMATE, {"CLIMATE"}},
-        {hmi_apis::Common_ModuleType::eType::RADIO, {"RADIO"}},
-        {hmi_apis::Common_ModuleType::eType::SEAT, {"SEAT"}},
-        {hmi_apis::Common_ModuleType::eType::AUDIO, {"AUDIO"}},
-        {hmi_apis::Common_ModuleType::eType::LIGHT, {"LIGHT"}},
-        {hmi_apis::Common_ModuleType::eType::HMI_SETTINGS, {"HMI_SETTINGS"}}};
 
 bool ResumptionRequestID::operator<(const ResumptionRequestID& other) const {
   return correlation_id < other.correlation_id ||
@@ -1117,7 +1109,7 @@ void ResumptionDataProcessorImpl::CheckModuleDataSubscription(
           response_module_data_so[message_params::kModuleType].asUInt());
 
   const auto responsed_module_type_str =
-      module_types_str_mapping[responsed_module_type_int];
+      application_manager::EnumToString(responsed_module_type_int);
 
   const auto response_module_id =
       response_module_data_so[message_params::kModuleId].asString();
diff --git a/src/components/application_manager/test/application_manager_impl_test.cc b/src/components/application_manager/test/application_manager_impl_test.cc
index 493d4a18fc..78bd956316 100644
--- a/src/components/application_manager/test/application_manager_impl_test.cc
+++ b/src/components/application_manager/test/application_manager_impl_test.cc
@@ -1576,7 +1576,7 @@ TEST_F(ApplicationManagerImplTest,
   // - .ini file specifies TCP_WIFI for EMPTY_APP entry.
   //   -> The app does not have required transport.
   bool result = CheckResumptionRequiredTransportAvailableTest(
-      NULL,
+      nullptr,
       primary_device_handle,
       primary_transport_device_string,
       secondary_device_handle,
diff --git a/src/components/application_manager/test/hmi_capabilities_test.cc b/src/components/application_manager/test/hmi_capabilities_test.cc
index 73e86fc7a7..4e2e948335 100644
--- a/src/components/application_manager/test/hmi_capabilities_test.cc
+++ b/src/components/application_manager/test/hmi_capabilities_test.cc
@@ -80,45 +80,6 @@ using ::testing::ReturnRef;
 
 using namespace application_manager;
 
-typedef std::map<std::string, hmi_apis::Common_Language::eType>
-    LanguageCStringToEnumMap;
-
-typedef std::map<std::string, hmi_apis::Common_LightName::eType>
-    LightNameCStringToEnumMap;
-
-static LanguageCStringToEnumMap languages_map;
-static LightNameCStringToEnumMap light_names_map;
-
-const std::vector<std::string> language_string_values{
-    {"EN-US"}, {"ES-MX"}, {"FR-CA"}, {"DE-DE"}, {"ES-ES"}, {"EN-GB"}, {"RU-RU"},
-    {"TR-TR"}, {"PL-PL"}, {"FR-FR"}, {"IT-IT"}, {"SV-SE"}, {"PT-PT"}, {"NL-NL"},
-    {"EN-AU"}, {"ZH-CN"}, {"ZH-TW"}, {"JA-JP"}, {"AR-SA"}, {"KO-KR"}, {"PT-BR"},
-    {"CS-CZ"}, {"DA-DK"}, {"NO-NO"}, {"NL-BE"}, {"EL-GR"}, {"HU-HU"}, {"FI-FI"},
-    {"SK-SK"}, {"EN-IN"}, {"TH-TH"}, {"EN-SA"}, {"HE-IL"}, {"RO-RO"}, {"UK-UA"},
-    {"ID-ID"}, {"VI-VN"}, {"MS-MY"}, {"HI-IN"}};
-
-const std::vector<hmi_apis::Common_Language::eType> language_enum_values{
-    hmi_apis::Common_Language::EN_US, hmi_apis::Common_Language::ES_MX,
-    hmi_apis::Common_Language::FR_CA, hmi_apis::Common_Language::DE_DE,
-    hmi_apis::Common_Language::ES_ES, hmi_apis::Common_Language::EN_GB,
-    hmi_apis::Common_Language::RU_RU, hmi_apis::Common_Language::TR_TR,
-    hmi_apis::Common_Language::PL_PL, hmi_apis::Common_Language::FR_FR,
-    hmi_apis::Common_Language::IT_IT, hmi_apis::Common_Language::SV_SE,
-    hmi_apis::Common_Language::PT_PT, hmi_apis::Common_Language::NL_NL,
-    hmi_apis::Common_Language::EN_AU, hmi_apis::Common_Language::ZH_CN,
-    hmi_apis::Common_Language::ZH_TW, hmi_apis::Common_Language::JA_JP,
-    hmi_apis::Common_Language::AR_SA, hmi_apis::Common_Language::KO_KR,
-    hmi_apis::Common_Language::PT_BR, hmi_apis::Common_Language::CS_CZ,
-    hmi_apis::Common_Language::DA_DK, hmi_apis::Common_Language::NO_NO,
-    hmi_apis::Common_Language::NL_BE, hmi_apis::Common_Language::EL_GR,
-    hmi_apis::Common_Language::HU_HU, hmi_apis::Common_Language::FI_FI,
-    hmi_apis::Common_Language::SK_SK, hmi_apis::Common_Language::EN_IN,
-    hmi_apis::Common_Language::TH_TH, hmi_apis::Common_Language::EN_SA,
-    hmi_apis::Common_Language::HE_IL, hmi_apis::Common_Language::RO_RO,
-    hmi_apis::Common_Language::UK_UA, hmi_apis::Common_Language::ID_ID,
-    hmi_apis::Common_Language::VI_VN, hmi_apis::Common_Language::MS_MY,
-    hmi_apis::Common_Language::HI_IN};
-
 const std::vector<hmi_apis::Common_LightName::eType> light_name_enum_values{
     hmi_apis::Common_LightName::eType::FRONT_LEFT_HIGH_BEAM,
     hmi_apis::Common_LightName::eType::FRONT_RIGHT_HIGH_BEAM,
@@ -169,109 +130,6 @@ const std::vector<hmi_apis::Common_LightName::eType> light_name_enum_values{
     hmi_apis::Common_LightName::eType::EXTERIOR_RIGHT_LIGHTS,
     hmi_apis::Common_LightName::eType::EXTERIOR_ALL_LIGHTS};
 
-const std::vector<std::string> light_name_string_values{
-    {"FRONT_LEFT_HIGH_BEAM"},
-    {"FRONT_RIGHT_HIGH_BEAM"},
-    {"FRONT_LEFT_LOW_BEAM"},
-    {"FRONT_RIGHT_LOW_BEAM"},
-    {"FRONT_LEFT_PARKING_LIGHT"},
-    {"FRONT_RIGHT_PARKING_LIGHT"},
-    {"FRONT_LEFT_FOG_LIGHT"},
-    {"FRONT_RIGHT_FOG_LIGHT"},
-    {"FRONT_LEFT_DAYTIME_RUNNING_LIGHT"},
-    {"FRONT_RIGHT_DAYTIME_RUNNING_LIGHT"},
-    {"FRONT_LEFT_TURN_LIGHT"},
-    {"FRONT_RIGHT_TURN_LIGHT"},
-    {"REAR_LEFT_FOG_LIGHT"},
-    {"REAR_RIGHT_FOG_LIGHT"},
-    {"REAR_LEFT_TAIL_LIGHT"},
-    {"REAR_RIGHT_TAIL_LIGHT"},
-    {"REAR_LEFT_BRAKE_LIGHT"},
-    {"REAR_RIGHT_BRAKE_LIGHT"},
-    {"REAR_LEFT_TURN_LIGHT"},
-    {"REAR_RIGHT_TURN_LIGHT"},
-    {"REAR_REGISTRATION_PLATE_LIGHT"},
-    {"HIGH_BEAMS"},
-    {"LOW_BEAMS"},
-    {"FOG_LIGHTS"},
-    {"RUNNING_LIGHTS"},
-    {"PARKING_LIGHTS"},
-    {"BRAKE_LIGHTS"},
-    {"REAR_REVERSING_LIGHTS"},
-    {"SIDE_MARKER_LIGHTS"},
-    {"LEFT_TURN_LIGHTS"},
-    {"RIGHT_TURN_LIGHTS"},
-    {"HAZARD_LIGHTS"},
-    {"REAR_CARGO_LIGHTS"},
-    {"REAR_TRUCK_BED_LIGHTS"},
-    {"REAR_TRAILER_LIGHTS"},
-    {"LEFT_SPOT_LIGHTS"},
-    {"RIGHT_SPOT_LIGHTS"},
-    {"LEFT_PUDDLE_LIGHTS"},
-    {"RIGHT_PUDDLE_LIGHTS"},
-    {"AMBIENT_LIGHTS"},
-    {"OVERHEAD_LIGHTS"},
-    {"READING_LIGHTS"},
-    {"TRUNK_LIGHTS"},
-    {"EXTERIOR_FRONT_LIGHTS"},
-    {"EXTERIOR_REAR_LIGHTS"},
-    {"EXTERIOR_LEFT_LIGHTS"},
-    {"EXTERIOR_RIGHT_LIGHTS"},
-    {"EXTERIOR_ALL_LIGHTS"}};
-
-void InitLightNameStringToEnumMap(
-    LightNameCStringToEnumMap& out_light_names_map) {
-  for (size_t i = 0; i < light_name_string_values.size(); ++i) {
-    out_light_names_map[light_name_string_values[i]] =
-        light_name_enum_values[i];
-  }
-}
-
-bool LightNameStringToEnum(const std::string& light_name_str,
-                           hmi_apis::Common_LightName::eType& out_value) {
-  auto it = light_names_map.find(light_name_str);
-  if (it == light_names_map.end()) {
-    return false;
-  }
-  out_value = it->second;
-  return true;
-}
-
-void InitLanguageStringToEnumMap(LanguageCStringToEnumMap& out_languages_map) {
-  for (size_t i = 0; i < language_string_values.size(); ++i) {
-    out_languages_map[language_string_values[i]] = language_enum_values[i];
-  }
-}
-
-bool LanguageStringToEnum(const std::string& language_str,
-                          hmi_apis::Common_Language::eType& out_value) {
-  LanguageCStringToEnumMap::const_iterator it =
-      languages_map.find(language_str);
-  if (it == languages_map.end()) {
-    return false;
-  }
-  out_value = it->second;
-  return true;
-}
-
-hmi_apis::Common_Language::eType TestCommonLanguageFromString(
-    const std::string& language) {
-  hmi_apis::Common_Language::eType value;
-  if (LanguageStringToEnum(language, value)) {
-    return value;
-  }
-  return hmi_apis::Common_Language::INVALID_ENUM;
-}
-
-hmi_apis::Common_LightName::eType TestCommonLightNameFromString(
-    const std::string& light_name_str) {
-  hmi_apis::Common_LightName::eType value;
-  if (LightNameStringToEnum(light_name_str, value)) {
-    return value;
-  }
-  return hmi_apis::Common_LightName::INVALID_ENUM;
-}
-
 bool IsLightNameExists(const hmi_apis::Common_LightName::eType& light_name) {
   auto it = std::find(
       light_name_enum_values.begin(), light_name_enum_values.end(), light_name);
@@ -283,14 +141,7 @@ class HMICapabilitiesTest : public ::testing::Test {
   HMICapabilitiesTest()
       : last_state_wrapper_(std::make_shared<resumption::LastStateWrapperImpl>(
             std::make_shared<resumption::LastStateImpl>(kAppStorageFolder,
-                                                        kAppInfoStorage))) {
-    if (languages_map.empty()) {
-      InitLanguageStringToEnumMap(languages_map);
-    }
-    if (light_names_map.empty()) {
-      InitLightNameStringToEnumMap(light_names_map);
-    }
-  }
+                                                        kAppInfoStorage))) {}
 
   void SetUp() OVERRIDE {
     ON_CALL(mock_app_mngr_, event_dispatcher())
@@ -325,13 +176,6 @@ class HMICapabilitiesTest : public ::testing::Test {
 
   void SetUpLanguageAndLightCapabilitiesExpectation() {
     ON_CALL(mock_app_mngr_, IsSOStructValid(_, _)).WillByDefault(Return(true));
-
-    EXPECT_CALL(*(MockMessageHelper::message_helper_mock()),
-                CommonLanguageFromString(_))
-        .WillRepeatedly(Invoke(TestCommonLanguageFromString));
-    EXPECT_CALL(*(MockMessageHelper::message_helper_mock()),
-                CommonLightNameFromString(_))
-        .WillRepeatedly(Invoke(TestCommonLightNameFromString));
   }
 
   std::shared_ptr<HMICapabilitiesImpl> hmi_capabilities_;
@@ -1011,10 +855,6 @@ TEST_F(HMICapabilitiesTest,
   ON_CALL(mock_application_manager_settings_, hmi_capabilities_file_name())
       .WillByDefault(ReturnRef(hmi_capabilities_file));
 
-  EXPECT_CALL(*(MockMessageHelper::message_helper_mock()),
-              CommonLanguageFromString(_))
-      .WillRepeatedly(Invoke(TestCommonLanguageFromString));
-
   hmi_capabilities_->Init(last_state_wrapper_);
 
   // with old audio pass thru format, the object is an array containing a single
@@ -1201,10 +1041,7 @@ TEST_F(
     HMICapabilitiesTest,
     SaveCachedCapabilitiesToFile_LanguageIsNotTheSameAsPersisted_SaveNewLanguageToCache) {
   SetUpLanguageAndLightCapabilitiesExpectation();
-  const std::string new_language = "RU_RU";
-  ON_CALL(*(MockMessageHelper::message_helper_mock()),
-          CommonLanguageToString(_))
-      .WillByDefault(Return(new_language));
+  const std::string new_language = "RU-RU";
 
   hmi_capabilities_->Init(last_state_wrapper_);
   hmi_capabilities_->set_active_tts_language(hmi_apis::Common_Language::RU_RU);
diff --git a/src/components/application_manager/test/include/application_manager/mock_message_helper.h b/src/components/application_manager/test/include/application_manager/mock_message_helper.h
index 3b4df0af1b..d7919a374b 100644
--- a/src/components/application_manager/test/include/application_manager/mock_message_helper.h
+++ b/src/components/application_manager/test/include/application_manager/mock_message_helper.h
@@ -57,22 +57,12 @@ class MockMessageHelper {
                smart_objects::SmartObjectSPtr(const uint32_t app_id));
   MOCK_METHOD2(SendHashUpdateNotification,
                void(const uint32_t app_id, ApplicationManager& app_mngr));
-  MOCK_METHOD1(HMIResultToString,
-               std::string(hmi_apis::Common_Result::eType hmi_result));
-  MOCK_METHOD1(HMIResultFromString,
-               hmi_apis::Common_Result::eType(const std::string& hmi_result));
-  MOCK_METHOD1(MobileResultToString,
-               std::string(mobile_apis::Result::eType mobile_result));
-  MOCK_METHOD1(MobileResultFromString,
-               mobile_api::Result::eType(const std::string& mobile_result));
   MOCK_METHOD1(HMIToMobileResult,
                mobile_api::Result::eType(
                    const hmi_apis::Common_Result::eType hmi_result));
   MOCK_METHOD1(MobileToHMIResult,
                hmi_apis::Common_Result::eType(
                    const mobile_api::Result::eType mobile_result));
-  MOCK_METHOD1(StringToHMILevel,
-               mobile_api::HMILevel::eType(const std::string& hmi_level));
   MOCK_METHOD3(CreateDeviceListSO,
                smart_objects::SmartObjectSPtr(
                    const connection_handler::DeviceMap& devices,
@@ -177,14 +167,6 @@ class MockMessageHelper {
                     const std::vector<uint8_t>& policy_data,
                     const std::string& url,
                     ApplicationManager& app_mngr));
-  MOCK_METHOD1(CommonLanguageFromString,
-               hmi_apis::Common_Language::eType(const std::string& language));
-  MOCK_METHOD1(CommonLightNameFromString,
-               hmi_apis::Common_LightName::eType(const std::string& lightName));
-  MOCK_METHOD1(CommonLanguageToString,
-               std::string(hmi_apis::Common_Language::eType));
-  MOCK_METHOD1(MobileLanguageToString,
-               std::string(mobile_apis::Language::eType));
   MOCK_METHOD2(CreateModuleInfoSO,
                smart_objects::SmartObjectSPtr(uint32_t function_id,
                                               ApplicationManager& app_mngr));
@@ -340,8 +322,6 @@ class MockMessageHelper {
                void(const uint32_t app_id,
                     const std::string& icon_path,
                     ApplicationManager& application_manager));
-  MOCK_METHOD1(StringifiedHMILevel,
-               std::string(const mobile_apis::HMILevel::eType hmi_level));
   MOCK_METHOD2(GetDeviceMacAddressForHandle,
                std::string(const transport_manager::DeviceHandle device_handle,
                            const ApplicationManager& app_mngr));
diff --git a/src/components/application_manager/test/message_helper/message_helper_test.cc b/src/components/application_manager/test/message_helper/message_helper_test.cc
index 273775bebf..c380805bc2 100644
--- a/src/components/application_manager/test/message_helper/message_helper_test.cc
+++ b/src/components/application_manager/test/message_helper/message_helper_test.cc
@@ -641,41 +641,6 @@ class MessageHelperTest : public ::testing::Test {
   const size_t delta_from_functions_id;
 };
 
-TEST_F(MessageHelperTest,
-       CommonLanguageFromString_StringValueOfEnum_CorrectEType) {
-  HmiLanguage::eType enum_value;
-  HmiLanguage::eType enum_from_string_value;
-  // Check all languages >= 0
-  for (size_t array_index = 0; array_index < language_strings.size();
-       ++array_index) {
-    enum_value = static_cast<HmiLanguage::eType>(array_index);
-    enum_from_string_value =
-        MessageHelper::CommonLanguageFromString(language_strings[array_index]);
-    EXPECT_EQ(enum_value, enum_from_string_value);
-  }
-  // Check InvalidEnum == -1
-  enum_value = HmiLanguage::INVALID_ENUM;
-  enum_from_string_value = MessageHelper::CommonLanguageFromString("");
-  EXPECT_EQ(enum_value, enum_from_string_value);
-}
-
-TEST_F(MessageHelperTest,
-       CommonLanguageToString_ETypeValueOfEnum_CorrectString) {
-  std::string string_from_enum;
-  HmiLanguage::eType casted_enum;
-  // Check all languages >=0
-  for (size_t array_index = 0; array_index < language_strings.size();
-       ++array_index) {
-    casted_enum = static_cast<HmiLanguage::eType>(array_index);
-    string_from_enum = MessageHelper::CommonLanguageToString(casted_enum);
-    EXPECT_EQ(language_strings[array_index], string_from_enum);
-  }
-  // Check InvalidEnum == -1
-  string_from_enum =
-      MessageHelper::CommonLanguageToString(HmiLanguage::INVALID_ENUM);
-  EXPECT_EQ("", string_from_enum);
-}
-
 TEST_F(MessageHelperTest, ConvertEnumAPINoCheck_AnyEnumType_AnotherEnumType) {
   hmi_apis::Common_LayoutMode::eType tested_enum_value =
       hmi_apis::Common_LayoutMode::ICON_ONLY;
@@ -686,38 +651,6 @@ TEST_F(MessageHelperTest, ConvertEnumAPINoCheck_AnyEnumType_AnotherEnumType) {
   EXPECT_EQ(hmi_apis::Common_AppHMIType::DEFAULT, converted);
 }
 
-TEST_F(MessageHelperTest, HMIResultFromString_StringValueOfEnum_CorrectEType) {
-  HmiResults::eType enum_value;
-  HmiResults::eType enum_from_string_value;
-  // Check all results >= 0
-  for (size_t array_index = 0; array_index < hmi_result_strings.size();
-       ++array_index) {
-    enum_value = static_cast<HmiResults::eType>(array_index);
-    enum_from_string_value =
-        MessageHelper::HMIResultFromString(hmi_result_strings[array_index]);
-    EXPECT_EQ(enum_value, enum_from_string_value);
-  }
-  // Check InvalidEnum == -1
-  enum_value = HmiResults::INVALID_ENUM;
-  enum_from_string_value = MessageHelper::HMIResultFromString("");
-  EXPECT_EQ(enum_value, enum_from_string_value);
-}
-
-TEST_F(MessageHelperTest, HMIResultToString_ETypeValueOfEnum_CorrectString) {
-  std::string string_from_enum;
-  HmiResults::eType casted_enum;
-  // Check all results >=0
-  for (size_t array_index = 0; array_index < hmi_result_strings.size();
-       ++array_index) {
-    casted_enum = static_cast<HmiResults::eType>(array_index);
-    string_from_enum = MessageHelper::HMIResultToString(casted_enum);
-    EXPECT_EQ(hmi_result_strings[array_index], string_from_enum);
-  }
-  // Check InvalidEnum == -1
-  string_from_enum = MessageHelper::HMIResultToString(HmiResults::INVALID_ENUM);
-  EXPECT_EQ("", string_from_enum);
-}
-
 TEST_F(MessageHelperTest,
        HMIToMobileResult_HmiResultEType_GetCorrectMobileResultEType) {
   MobileResults::eType tested_enum;
@@ -727,7 +660,7 @@ TEST_F(MessageHelperTest,
   for (size_t enum_index = 0; enum_index < hmi_result_strings.size();
        ++enum_index) {
     tested_enum =
-        MessageHelper::MobileResultFromString(hmi_result_strings[enum_index]);
+        StringToEnum<MobileResults::eType>(hmi_result_strings[enum_index]);
     casted_hmi_enum = static_cast<HmiResults::eType>(enum_index);
     converted_enum = MessageHelper::HMIToMobileResult(casted_hmi_enum);
     EXPECT_EQ(tested_enum, converted_enum);
@@ -955,27 +888,6 @@ TEST_F(MessageHelperTest,
   }
 }
 
-TEST_F(MessageHelperTest,
-       StringifiedHmiLevel_LevelEnum_EqualsWithStringsInArray) {
-  mobile_apis::HMILevel::eType casted_enum;
-  std::string converted_value;
-  for (size_t i = 0; i < hmi_level_strings.size(); ++i) {
-    casted_enum = static_cast<mobile_apis::HMILevel::eType>(i);
-    converted_value = MessageHelper::StringifiedHMILevel(casted_enum);
-    EXPECT_EQ(hmi_level_strings[i], converted_value);
-  }
-}
-
-TEST_F(MessageHelperTest, StringToHmiLevel_LevelString_EqEType) {
-  mobile_apis::HMILevel::eType tested_enum;
-  mobile_apis::HMILevel::eType converted_enum;
-  for (size_t i = 0; i < hmi_level_strings.size(); ++i) {
-    tested_enum = static_cast<mobile_apis::HMILevel::eType>(i);
-    converted_enum = MessageHelper::StringToHMILevel(hmi_level_strings[i]);
-    EXPECT_EQ(tested_enum, converted_enum);
-  }
-}
-
 TEST_F(MessageHelperTest, SubscribeApplicationToSoftButton_CallFromApp) {
   // Create application mock
   MockApplicationSharedPtr appSharedPtr = std::make_shared<MockApplication>();
diff --git a/src/components/application_manager/test/mock_message_helper.cc b/src/components/application_manager/test/mock_message_helper.cc
index fdad51ad63..91f953eaf5 100644
--- a/src/components/application_manager/test/mock_message_helper.cc
+++ b/src/components/application_manager/test/mock_message_helper.cc
@@ -102,30 +102,6 @@ smart_objects::SmartObjectSPtr GetHashUpdateNotification(
       app_id);
 }
 
-std::string MessageHelper::HMIResultToString(
-    hmi_apis::Common_Result::eType hmi_result) {
-  return MockMessageHelper::message_helper_mock()->HMIResultToString(
-      hmi_result);
-}
-
-hmi_apis::Common_Result::eType MessageHelper::HMIResultFromString(
-    const std::string& hmi_result) {
-  return MockMessageHelper::message_helper_mock()->HMIResultFromString(
-      hmi_result);
-}
-
-std::string MessageHelper::MobileResultToString(
-    mobile_apis::Result::eType mobile_result) {
-  return MockMessageHelper::message_helper_mock()->MobileResultToString(
-      mobile_result);
-}
-
-mobile_api::Result::eType MessageHelper::MobileResultFromString(
-    const std::string& mobile_result) {
-  return MockMessageHelper::message_helper_mock()->MobileResultFromString(
-      mobile_result);
-}
-
 mobile_api::Result::eType MessageHelper::HMIToMobileResult(
     const hmi_apis::Common_Result::eType hmi_result) {
   return MockMessageHelper::message_helper_mock()->HMIToMobileResult(
@@ -138,11 +114,6 @@ hmi_apis::Common_Result::eType MessageHelper::MobileToHMIResult(
       mobile_result);
 }
 
-mobile_api::HMILevel::eType MessageHelper::StringToHMILevel(
-    const std::string& hmi_level) {
-  return MockMessageHelper::message_helper_mock()->StringToHMILevel(hmi_level);
-}
-
 smart_objects::SmartObjectSPtr MessageHelper::CreateDeviceListSO(
     const connection_handler::DeviceMap& devices,
     const policy::PolicyHandlerInterface& policy_handler,
@@ -286,18 +257,6 @@ void MessageHelper::SendUpdateSDLResponse(const std::string& result,
       result, correlation_id, app_mngr);
 }
 
-hmi_apis::Common_Language::eType MessageHelper::CommonLanguageFromString(
-    const std::string& language) {
-  return MockMessageHelper::message_helper_mock()->CommonLanguageFromString(
-      language);
-}
-
-hmi_apis::Common_LightName::eType MessageHelper::CommonLightNameFromString(
-    const std::string& lightName) {
-  return MockMessageHelper::message_helper_mock()->CommonLightNameFromString(
-      lightName);
-}
-
 smart_objects::SmartObjectSPtr MessageHelper::CreateModuleInfoSO(
     uint32_t function_id, ApplicationManager& app_mngr) {
   return MockMessageHelper::message_helper_mock()->CreateModuleInfoSO(
@@ -376,16 +335,6 @@ mobile_apis::Result::eType MessageHelper::VerifyImageFiles(
       message, app, app_mngr);
 }
 
-std::string MessageHelper::CommonLanguageToString(
-    hmi_apis::Common_Language::eType lang) {
-  return MockMessageHelper::message_helper_mock()->CommonLanguageToString(lang);
-}
-
-std::string MessageHelper::MobileLanguageToString(
-    mobile_apis::Language::eType lang) {
-  return MockMessageHelper::message_helper_mock()->MobileLanguageToString(lang);
-}
-
 smart_objects::SmartObjectSPtr MessageHelper::GetBCActivateAppRequestToHMI(
     ApplicationConstSharedPtr app,
     const policy::PolicyHandlerInterface& policy_handler,
@@ -574,12 +523,6 @@ void MessageHelper::SendSetAppIcon(const uint32_t app_id,
       app_id, icon_path, application_manager);
 }
 
-std::string MessageHelper::StringifiedHMILevel(
-    const mobile_apis::HMILevel::eType hmi_level) {
-  return MockMessageHelper::message_helper_mock()->StringifiedHMILevel(
-      hmi_level);
-}
-
 std::string MessageHelper::GetDeviceMacAddressForHandle(
     const transport_manager::DeviceHandle device_handle,
     const ApplicationManager& app_mngr) {
diff --git a/src/components/application_manager/test/policy_handler_test.cc b/src/components/application_manager/test/policy_handler_test.cc
index 35fa7d912e..d25a3fbfed 100644
--- a/src/components/application_manager/test/policy_handler_test.cc
+++ b/src/components/application_manager/test/policy_handler_test.cc
@@ -248,8 +248,6 @@ class PolicyHandlerTest : public ::testing::Test {
     EXPECT_CALL(*mock_app_, hmi_level(kDefaultWindowId))
         .WillOnce(Return(mobile_apis::HMILevel::HMI_NONE));
 
-    EXPECT_CALL(mock_message_helper_, StringToHMILevel(default_hmi_level))
-        .WillOnce(Return(hmi_level));
     ChangePolicyManagerToMock();
     const policy::EncryptionRequired require_encryption;
     EXPECT_CALL(*mock_policy_manager_, GetAppEncryptionRequired(kPolicyAppId_))
@@ -593,16 +591,13 @@ TEST_F(PolicyHandlerTest,
 TEST_F(PolicyHandlerTest,
        OnPermissionsUpdated_MethodWith3Parameters_FromNONE_ToFULL) {
   // Set hmi level from NONE to FULL
-  const std::string new_kHmiLevel_string = "HMI_FULL";
+  const std::string new_kHmiLevel_string = "FULL";
   mobile_apis::HMILevel::eType new_hmi_level = mobile_apis::HMILevel::HMI_FULL;
   // Check expectations
   EXPECT_CALL(app_manager_, application(kDeviceId, kPolicyAppId_))
       .Times(2)
       .WillRepeatedly(Return(mock_app_));
   EXPECT_CALL(*mock_app_, app_id()).WillOnce(Return(kAppId1_));
-  EXPECT_CALL(mock_message_helper_, StringToHMILevel(new_kHmiLevel_string))
-      .WillOnce(Return(new_hmi_level));
-
   EXPECT_CALL(*mock_app_, hmi_level(kDefaultWindowId))
       .WillOnce(Return(mobile_apis::HMILevel::HMI_NONE));
   ChangePolicyManagerToMock();
@@ -625,7 +620,7 @@ TEST_F(PolicyHandlerTest,
 TEST_F(PolicyHandlerTest,
        OnPermissionsUpdated_MethodWith3Parameters_FromNONE_ToNotFull) {
   // Set hmi level from NONE to Limited
-  const std::string new_kHmiLevel_string = "HMI_LIMITED";
+  const std::string new_kHmiLevel_string = "LIMITED";
   mobile_apis::HMILevel::eType new_hmi_level =
       mobile_apis::HMILevel::HMI_LIMITED;
   // Check expectations
@@ -633,9 +628,6 @@ TEST_F(PolicyHandlerTest,
       .Times(2)
       .WillRepeatedly(Return(mock_app_));
   EXPECT_CALL(*mock_app_, app_id()).WillOnce(Return(kAppId1_));
-  EXPECT_CALL(mock_message_helper_, StringToHMILevel(new_kHmiLevel_string))
-      .WillOnce(Return(new_hmi_level));
-
   EXPECT_CALL(*mock_app_, hmi_level(kDefaultWindowId))
       .WillOnce(Return(mobile_apis::HMILevel::HMI_NONE));
   ChangePolicyManagerToMock();
@@ -658,15 +650,12 @@ TEST_F(PolicyHandlerTest,
 TEST_F(PolicyHandlerTest,
        OnPermissionsUpdated_MethodWith3Parameters_FromNotNONE) {
   // Set hmi level from LIMITED to FULL
-  std::string new_kHmiLevel_string = "HMI_FULL";
-  mobile_apis::HMILevel::eType new_hmi_level = mobile_apis::HMILevel::HMI_FULL;
+  std::string new_kHmiLevel_string = "FULL";
   // Check expectations
   EXPECT_CALL(app_manager_, application(kDeviceId, kPolicyAppId_))
       .Times(2)
       .WillRepeatedly(Return(mock_app_));
   EXPECT_CALL(*mock_app_, app_id()).WillOnce(Return(kAppId1_));
-  EXPECT_CALL(mock_message_helper_, StringToHMILevel(new_kHmiLevel_string))
-      .WillOnce(Return(new_hmi_level));
 
   EXPECT_CALL(*mock_app_, hmi_level(kDefaultWindowId))
       .WillOnce(Return(mobile_apis::HMILevel::HMI_LIMITED));
@@ -716,8 +705,6 @@ TEST_F(PolicyHandlerTest, CheckPermissions) {
               CheckPermissions(
                   kDeviceId, kPolicyAppId_, kHmiLevel_, kRpc_, kRpc_params, _));
 #endif  // EXTERNAL_PROPRIETARY_MODE
-  EXPECT_CALL(mock_message_helper_, StringifiedHMILevel(hmi_level))
-      .WillOnce(Return(kHmiLevel_));
   EXPECT_CALL(mock_message_helper_, GetDeviceMacAddressForHandle(device, _))
       .WillOnce(Return(kDeviceId));
   // Act
@@ -1248,17 +1235,15 @@ TEST_F(PolicyHandlerTest, OnGetUserFriendlyMessage) {
   ChangePolicyManagerToMock();
   // Check expectations
   std::vector<std::string> message_codes;
-  const std::string language("ru-ru");
+  const std::string language("RU-RU");
   const uint32_t correlation_id = 2;
 #ifdef EXTERNAL_PROPRIETARY_MODE
   const hmi_apis::Common_Language::eType default_language =
       hmi_apis::Common_Language::EN_US;
-  const std::string default_language_string = "EN_US";
+  const std::string default_language_string = "EN-US";
   application_manager_test::MockHMICapabilities mock_hmi_capabilities;
   EXPECT_CALL(app_manager_, hmi_capabilities())
       .WillOnce(ReturnRef(mock_hmi_capabilities));
-  EXPECT_CALL(mock_message_helper_, CommonLanguageToString(default_language))
-      .WillOnce(Return(default_language_string));
   EXPECT_CALL(mock_hmi_capabilities, active_ui_language())
       .WillOnce(Return(default_language));
   EXPECT_CALL(