Merge branch 'develop' into feature/boost_lock_implementation

3 files changed, 415 insertions, 19 deletions

diff --git a/src/components/config_profile/include/config_profile/profile.h b/src/components/config_profile/include/config_profile/profile.h
index 61dddf55b0..4c2be53228 100644
--- a/src/components/config_profile/include/config_profile/profile.h
+++ b/src/components/config_profile/include/config_profile/profile.h
@@ -37,6 +37,7 @@
 #include <string>
 #include <vector>
 #include <list>
+#include <map>
 #include "utils/macro.h"
 #include "protocol_handler/protocol_handler_settings.h"
 #include "connection_handler/connection_handler_settings.h"
@@ -385,6 +386,12 @@ class Profile : public protocol_handler::ProtocolHandlerSettings,
    */
   uint16_t transport_manager_tcp_adapter_port() const OVERRIDE;
 
+  /**
+   * @brief Returns the network interface name for TCP transport adapter
+   */
+  const std::string& transport_manager_tcp_adapter_network_interface()
+      const OVERRIDE;
+
   // TransportManageMMESettings interface
 
   const std::string& event_mq_name() const OVERRIDE;
@@ -466,17 +473,39 @@ class Profile : public protocol_handler::ProtocolHandlerSettings,
   size_t update_before_hours() const;
 
 #endif  // ENABLE_SECURITY
-        /**
-         * @brief Reads a string value from the profile
-         *
-         * @param value         Result value
-         * @param default_value Value to use key wasn't found
-         * @param pSection      The section to read the value in
-         * @param pKey          The key whose value needs to be read out
-         *
-         * @return FALSE if could not read the value out of the profile
-         * (then the value is equal \c default_value)
-         */
+
+  /**
+   * @brief Returns true multiple transports is enabled
+   */
+  const bool multiple_transports_enabled() const OVERRIDE;
+
+  /**
+   * @brief Returns list of secondary transports available
+   * for the named primary transport
+   */
+  const std::vector<std::string>& secondary_transports_for_bluetooth()
+      const OVERRIDE;
+  const std::vector<std::string>& secondary_transports_for_usb() const OVERRIDE;
+  const std::vector<std::string>& secondary_transports_for_wifi()
+      const OVERRIDE;
+
+  /**
+   * @brief Returns list of allowed transports for the named service
+   */
+  const std::vector<std::string>& audio_service_transports() const OVERRIDE;
+  const std::vector<std::string>& video_service_transports() const OVERRIDE;
+
+  /**
+   * @brief Reads a string value from the profile
+   *
+   * @param value         Result value
+   * @param default_value Value to use key wasn't found
+   * @param pSection      The section to read the value in
+   * @param pKey          The key whose value needs to be read out
+   *
+   * @return FALSE if could not read the value out of the profile
+   * (then the value is equal \c default_value)
+   */
   bool ReadStringValue(std::string* value,
                        const char* default_value,
                        const char* const pSection,
@@ -520,13 +549,17 @@ class Profile : public protocol_handler::ProtocolHandlerSettings,
    * @param pKey          The key whose value needs to be read out
    * @param out_result    Pointer to bool value for result reading Section
    * (could be NULL)
+   * @param allow_empty   If true, then out_result will be true when the value
+   *                      contains an empty string.
+   *                      If false, then out_result will be false in such case.
    *
    * @return container of values or empty continer
    * if could not read the value out of the profile
    */
   std::vector<std::string> ReadStringContainer(const char* const pSection,
                                                const char* const pKey,
-                                               bool* out_result) const;
+                                               bool* out_result,
+                                               bool allow_empty = false) const;
   /**
    * @brief Reads an container of hex int values from the profile,
    * which handle as "0x01, 0xA0, 0XFF"
@@ -618,6 +651,33 @@ class Profile : public protocol_handler::ProtocolHandlerSettings,
   uint16_t open_attempt_timeout_ms_resumption_db() const;
 
   /**
+   * @brief Returns "transport required for resumption" map
+   *
+   * Keys of the map are AppHMIType strings, i.e. "DEFAULT", "COMMUNICATION",
+   * "MEDIA", and so on. The map may contain a special key "EMPTY_APP" for apps
+   * that does not specify any AppHMIType.
+   */
+  const std::map<std::string, std::vector<std::string> >&
+  transport_required_for_resumption_map() const OVERRIDE;
+
+  /**
+   * @brief Returns HMI level for resumption of a NAVIGATION app
+   */
+  const std::string& navigation_lowbandwidth_resumption_level() const OVERRIDE;
+
+  /**
+   * @brief Returns HMI level for resumption of a PROJECTION app
+   */
+  const std::string& projection_lowbandwidth_resumption_level() const OVERRIDE;
+
+  /**
+   * @brief Returns HMI level for resumption of a media app
+   *
+   * Note: this is *not* for AppHMIType = MEDIA.
+   */
+  const std::string& media_lowbandwidth_resumption_level() const OVERRIDE;
+
+  /**
    * @brief Returns wait time after device connection
    * before app launch request
    */
@@ -714,13 +774,29 @@ class Profile : public protocol_handler::ProtocolHandlerSettings,
    * @param pKey       The key whose value needs to be read out
    *
    * @return FALSE if could not read the value out of the profile
-   * (then the value is not changed)
+   * (then the value is not changed) or the value was empty
    */
   bool ReadValue(std::string* value,
                  const char* const pSection,
                  const char* const pKey) const;
 
   /**
+   * @brief Reads a string value from the profile
+   *
+   * This is same as ReadValue(), except that this method will accept an empty
+   * string.
+   *
+   * @param value      The value to return
+   * @param pSection   The section to read the value in
+   * @param pKey       The key whose value needs to be read out
+   *
+   * @return TRUE if the value is read, FALSE if the value is not found
+   */
+  bool ReadValueEmpty(std::string* value,
+                      const char* const pSection,
+                      const char* const pKey) const;
+
+  /**
    * @brief Reads a boolean value from the profile
    *
    * @param value      The value to return
@@ -859,6 +935,7 @@ class Profile : public protocol_handler::ProtocolHandlerSettings,
   std::vector<uint32_t> supported_diag_modes_;
   std::string system_files_path_;
   uint16_t transport_manager_tcp_adapter_port_;
+  std::string transport_manager_tcp_adapter_network_interface_;
   std::string tts_delimiter_;
   uint32_t audio_data_stopped_timeout_;
   uint32_t video_data_stopped_timeout_;
@@ -919,6 +996,11 @@ class Profile : public protocol_handler::ProtocolHandlerSettings,
   bool use_db_for_resumption_;
   uint16_t attempts_to_open_resumption_db_;
   uint16_t open_attempt_timeout_ms_resumption_db_;
+  std::map<std::string, std::vector<std::string> >
+      transport_required_for_resumption_map_;
+  std::string navigation_lowbandwidth_resumption_level_;
+  std::string projection_lowbandwidth_resumption_level_;
+  std::string media_lowbandwidth_resumption_level_;
   uint16_t app_launch_wait_time_;
   uint16_t app_launch_max_retry_attempt_;
   uint16_t app_launch_retry_wait_time_;
@@ -928,6 +1010,12 @@ class Profile : public protocol_handler::ProtocolHandlerSettings,
   bool enable_app_launch_ios_;
   uint32_t app_tranport_change_timer_;
   uint32_t app_tranport_change_timer_addition_;
+  bool multiple_transports_enabled_;
+  std::vector<std::string> secondary_transports_for_bluetooth_;
+  std::vector<std::string> secondary_transports_for_usb_;
+  std::vector<std::string> secondary_transports_for_wifi_;
+  std::vector<std::string> audio_service_transports_;
+  std::vector<std::string> video_service_transports_;
   bool error_occured_;
   std::string error_description_;
 
diff --git a/src/components/config_profile/src/profile.cc b/src/components/config_profile/src/profile.cc
index 4137476d63..3f3ec7eb63 100644
--- a/src/components/config_profile/src/profile.cc
+++ b/src/components/config_profile/src/profile.cc
@@ -33,6 +33,7 @@
 #include "config_profile/profile.h"
 
 #include <errno.h>
+#include <numeric>
 #include <string.h>
 #include <stdlib.h>
 #include <sstream>
@@ -88,6 +89,12 @@ const char* kSDL4Section = "SDL4";
 const char* kSDL5Section = "SDL5";
 const char* kResumptionSection = "Resumption";
 const char* kAppLaunchSection = "AppLaunch";
+const char* kMultipleTransportsSection = "MultipleTransports";
+const char* kServicesMapSection = "ServicesMap";
+const char* kTransportRequiredForResumptionSection =
+    "TransportRequiredForResumption";
+const char* kLowBandwidthTransportResumptionLevelSection =
+    "LowBandwidthTransportResumptionLevel";
 
 const char* kSDLVersionKey = "SDLVersion";
 const char* kHmiCapabilitiesKey = "HMICapabilities";
@@ -146,6 +153,7 @@ const char* kHeartBeatTimeoutKey = "HeartBeatTimeout";
 const char* kMaxSupportedProtocolVersionKey = "MaxSupportedProtocolVersion";
 const char* kUseLastStateKey = "UseLastState";
 const char* kTCPAdapterPortKey = "TCPAdapterPort";
+const char* kTCPAdapterNetworkInterfaceKey = "TCPAdapterNetworkInterface";
 const char* kServerPortKey = "ServerPort";
 const char* kVideoStreamingPortKey = "VideoStreamingPort";
 const char* kAudioStreamingPortKey = "AudioStreamingPort";
@@ -214,6 +222,60 @@ const char* kEnableAppLaunchIOSKey = "EnableAppLaunchIOS";
 const char* kAppTransportChangeTimerKey = "AppTransportChangeTimer";
 const char* kAppTransportChangeTimerAdditionKey =
     "AppTransportChangeTimerAddition";
+const char* kMultipleTransportsEnabledKey = "MultipleTransportsEnabled";
+const char* kSecondaryTransportForBluetoothKey =
+    "SecondaryTransportForBluetooth";
+const char* kSecondaryTransportForUSBKey = "SecondaryTransportForUSB";
+const char* kSecondaryTransportForWiFiKey = "SecondaryTransportForWiFi";
+const char* kAudioServiceTransportsKey = "AudioServiceTransports";
+const char* kVideoServiceTransportsKey = "VideoServiceTransports";
+
+const char* kDefaultTransportRequiredForResumptionKey =
+    "DefaultTransportRequiredForResumption";
+const char* kAppHMITypeDefault = "DEFAULT";
+const char* kCommunicationTransportRequiredForResumptionKey =
+    "CommunicationTransportRequiredForResumption";
+const char* kAppHMITypeCommunication = "COMMUNICATION";
+const char* kMediaTransportRequiredForResumptionKey =
+    "MediaTransportRequiredForResumption";
+const char* kAppHMITypeMedia = "MEDIA";
+const char* kMessagingTransportRequiredForResumptionKey =
+    "MessagingTransportRequiredForResumption";
+const char* kAppHMITypeMessaging = "MESSAGING";
+const char* kNavigationTransportRequiredForResumptionKey =
+    "NavigationTransportRequiredForResumption";
+const char* kAppHMITypeNavigation = "NAVIGATION";
+const char* kInformationTransportRequiredForResumptionKey =
+    "InformationTransportRequiredForResumption";
+const char* kAppHMITypeInformation = "INFORMATION";
+const char* kSocialTransportRequiredForResumptionKey =
+    "SocialTransportRequiredForResumption";
+const char* kAppHMITypeSocial = "SOCIAL";
+const char* kBackgroundProcessTransportRequiredForResumptionKey =
+    "BackgroundProcessTransportRequiredForResumption";
+const char* kAppHMITypeBackgroundProcess = "BACKGROUND_PROCESS";
+const char* kTestingTransportRequiredForResumptionKey =
+    "TestingTransportRequiredForResumption";
+const char* kAppHMITypeTesting = "TESTING";
+const char* kSystemTransportRequiredForResumptionKey =
+    "SystemTransportRequiredForResumption";
+const char* kAppHMITypeSystem = "SYSTEM";
+const char* kProjectionTransportRequiredForResumptionKey =
+    "ProjectionTransportRequiredForResumption";
+const char* kAppHMITypeProjection = "PROJECTION";
+const char* kRemoteControlTransportRequiredForResumptionKey =
+    "RemoteControlTransportRequiredForResumption";
+const char* kAppHMITypeRemoteControl = "REMOTE_CONTROL";
+const char* kEmptyAppTransportRequiredForResumptionKey =
+    "EmptyAppTransportRequiredForResumption";
+const char* kAppHMITypeEmptyApp = "EMPTY_APP";
+const char* kNavigationLowBandwidthResumptionLevelKey =
+    "NavigationLowBandwidthResumptionLevel";
+const char* kProjectionLowBandwidthResumptionLevelKey =
+    "ProjectionLowBandwidthResumptionLevel";
+const char* kMediaLowBandwidthResumptionLevelKey =
+    "MediaLowBandwidthResumptionLevel";
+
 #ifdef WEB_HMI
 const char* kDefaultLinkToWebHMI = "HMI/index.html";
 #endif  // WEB_HMI
@@ -237,6 +299,7 @@ const char* kDefaultHubProtocolMask = "com.smartdevicelink.prot";
 const char* kDefaultPoolProtocolMask = "com.smartdevicelink.prot";
 const char* kDefaultIAPSystemConfig = "/fs/mp/etc/mm/ipod.cfg";
 const char* kDefaultIAP2SystemConfig = "/fs/mp/etc/mm/iap2.cfg";
+const char* kDefaultTransportManagerTCPAdapterNetworkInterface = "";
 
 #ifdef ENABLE_SECURITY
 const char* kDefaultSecurityProtocol = "TLSv1.2";
@@ -311,6 +374,8 @@ const uint32_t kDefaultAppTransportChangeTimer = 500u;
 const uint32_t kDefaultAppTransportChangeTimerAddition = 0u;
 const std::string kAllowedSymbols =
     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890_.-";
+const bool kDefaultMultipleTransportsEnabled = false;
+const char* kDefaultLowBandwidthResumptionLevel = "NONE";
 }  // namespace
 
 namespace profile {
@@ -403,6 +468,11 @@ Profile::Profile()
     , attempts_to_open_resumption_db_(kDefaultAttemptsToOpenResumptionDB)
     , open_attempt_timeout_ms_resumption_db_(
           kDefaultOpenAttemptTimeoutMsResumptionDB)
+    , navigation_lowbandwidth_resumption_level_(
+          kDefaultLowBandwidthResumptionLevel)
+    , projection_lowbandwidth_resumption_level_(
+          kDefaultLowBandwidthResumptionLevel)
+    , media_lowbandwidth_resumption_level_(kDefaultLowBandwidthResumptionLevel)
     , app_launch_wait_time_(kDefaultAppLaunchWaitTime)
     , app_launch_max_retry_attempt_(kDefaultAppLaunchMaxRetryAttempt)
     , app_launch_retry_wait_time_(kDefaultAppLaunchRetryWaitTime)
@@ -413,6 +483,7 @@ Profile::Profile()
     , app_tranport_change_timer_(kDefaultAppTransportChangeTimer)
     , app_tranport_change_timer_addition_(
           kDefaultAppTransportChangeTimerAddition)
+    , multiple_transports_enabled_(kDefaultMultipleTransportsEnabled)
     , error_occured_(false)
     , error_description_() {
   // SDL version
@@ -682,6 +753,11 @@ uint16_t Profile::transport_manager_tcp_adapter_port() const {
   return transport_manager_tcp_adapter_port_;
 }
 
+const std::string& Profile::transport_manager_tcp_adapter_network_interface()
+    const {
+  return transport_manager_tcp_adapter_network_interface_;
+}
+
 const std::string& Profile::tts_delimiter() const {
   return tts_delimiter_;
 }
@@ -899,6 +975,23 @@ uint16_t Profile::open_attempt_timeout_ms_resumption_db() const {
   return open_attempt_timeout_ms_resumption_db_;
 }
 
+const std::map<std::string, std::vector<std::string> >&
+Profile::transport_required_for_resumption_map() const {
+  return transport_required_for_resumption_map_;
+}
+
+const std::string& Profile::navigation_lowbandwidth_resumption_level() const {
+  return navigation_lowbandwidth_resumption_level_;
+}
+
+const std::string& Profile::projection_lowbandwidth_resumption_level() const {
+  return projection_lowbandwidth_resumption_level_;
+}
+
+const std::string& Profile::media_lowbandwidth_resumption_level() const {
+  return media_lowbandwidth_resumption_level_;
+}
+
 const uint16_t Profile::app_launch_max_retry_attempt() const {
   return app_launch_max_retry_attempt_;
 }
@@ -935,6 +1028,31 @@ const uint16_t Profile::wait_time_between_apps() const {
   return wait_time_between_apps_;
 }
 
+const bool Profile::multiple_transports_enabled() const {
+  return multiple_transports_enabled_;
+}
+
+const std::vector<std::string>& Profile::secondary_transports_for_bluetooth()
+    const {
+  return secondary_transports_for_bluetooth_;
+}
+
+const std::vector<std::string>& Profile::secondary_transports_for_usb() const {
+  return secondary_transports_for_usb_;
+}
+
+const std::vector<std::string>& Profile::secondary_transports_for_wifi() const {
+  return secondary_transports_for_wifi_;
+}
+
+const std::vector<std::string>& Profile::audio_service_transports() const {
+  return audio_service_transports_;
+}
+
+const std::vector<std::string>& Profile::video_service_transports() const {
+  return video_service_transports_;
+}
+
 const bool Profile::ErrorOccured() const {
   return error_occured_;
 }
@@ -1610,6 +1728,16 @@ void Profile::UpdateValues() {
                     kTCPAdapterPortKey,
                     kTransportManagerSection);
 
+  // Transport manager TCP network interface
+  ReadStringValue(&transport_manager_tcp_adapter_network_interface_,
+                  kDefaultTransportManagerTCPAdapterNetworkInterface,
+                  kTransportManagerSection,
+                  kTCPAdapterNetworkInterfaceKey);
+
+  LOG_UPDATED_VALUE(transport_manager_tcp_adapter_network_interface_,
+                    kTCPAdapterNetworkInterfaceKey,
+                    kTransportManagerSection);
+
   // Event MQ
   ReadStringValue(
       &event_mq_name_, kDefaultEventMQ, kTransportManagerSection, kEventMQKey);
@@ -1841,6 +1969,84 @@ void Profile::UpdateValues() {
                     kOpenAttemptTimeoutMsResumptionDBKey,
                     kResumptionSection);
 
+  {  // read parameters from TransportRequiredForResumption section
+    struct KeyPair {
+      const char* ini_key_name;
+      const char* map_key_name;
+    } keys[] = {
+        {kDefaultTransportRequiredForResumptionKey, kAppHMITypeDefault},
+        {kCommunicationTransportRequiredForResumptionKey,
+         kAppHMITypeCommunication},
+        {kMediaTransportRequiredForResumptionKey, kAppHMITypeMedia},
+        {kMessagingTransportRequiredForResumptionKey, kAppHMITypeMessaging},
+        {kNavigationTransportRequiredForResumptionKey, kAppHMITypeNavigation},
+        {kInformationTransportRequiredForResumptionKey, kAppHMITypeInformation},
+        {kSocialTransportRequiredForResumptionKey, kAppHMITypeSocial},
+        {kBackgroundProcessTransportRequiredForResumptionKey,
+         kAppHMITypeBackgroundProcess},
+        {kTestingTransportRequiredForResumptionKey, kAppHMITypeTesting},
+        {kSystemTransportRequiredForResumptionKey, kAppHMITypeSystem},
+        {kProjectionTransportRequiredForResumptionKey, kAppHMITypeProjection},
+        {kRemoteControlTransportRequiredForResumptionKey,
+         kAppHMITypeRemoteControl},
+        {kEmptyAppTransportRequiredForResumptionKey, kAppHMITypeEmptyApp},
+        {NULL, NULL}};
+    struct KeyPair* entry = keys;
+
+    while (entry->ini_key_name != NULL) {
+      bool exist = false;
+      std::vector<std::string> transport_list =
+          ReadStringContainer(kTransportRequiredForResumptionSection,
+                              entry->ini_key_name,
+                              &exist,
+                              true);
+      if (exist) {
+        transport_required_for_resumption_map_[entry->map_key_name] =
+            transport_list;
+
+        const std::string list_with_comma = std::accumulate(
+            transport_list.begin(),
+            transport_list.end(),
+            std::string(""),
+            [](std::string& first, std::string& second) {
+              return first.empty() ? second : first + ", " + second;
+            });
+        LOG_UPDATED_VALUE(list_with_comma,
+                          entry->ini_key_name,
+                          kTransportRequiredForResumptionSection);
+      }
+      entry++;
+    }
+  }
+
+  // Read parameters from LowBandwidthTransportResumptionLevel section
+  ReadStringValue(&navigation_lowbandwidth_resumption_level_,
+                  kDefaultLowBandwidthResumptionLevel,
+                  kLowBandwidthTransportResumptionLevelSection,
+                  kNavigationLowBandwidthResumptionLevelKey);
+
+  LOG_UPDATED_VALUE(navigation_lowbandwidth_resumption_level_,
+                    kNavigationLowBandwidthResumptionLevelKey,
+                    kLowBandwidthTransportResumptionLevelSection);
+
+  ReadStringValue(&projection_lowbandwidth_resumption_level_,
+                  kDefaultLowBandwidthResumptionLevel,
+                  kLowBandwidthTransportResumptionLevelSection,
+                  kProjectionLowBandwidthResumptionLevelKey);
+
+  LOG_UPDATED_VALUE(projection_lowbandwidth_resumption_level_,
+                    kProjectionLowBandwidthResumptionLevelKey,
+                    kLowBandwidthTransportResumptionLevelSection);
+
+  ReadStringValue(&media_lowbandwidth_resumption_level_,
+                  kDefaultLowBandwidthResumptionLevel,
+                  kLowBandwidthTransportResumptionLevelSection,
+                  kMediaLowBandwidthResumptionLevelKey);
+
+  LOG_UPDATED_VALUE(media_lowbandwidth_resumption_level_,
+                    kMediaLowBandwidthResumptionLevelKey,
+                    kLowBandwidthTransportResumptionLevelSection);
+
   // Read parameters from App Launch section
   ReadUIntValue(&app_launch_wait_time_,
                 kDefaultAppLaunchWaitTime,
@@ -1917,6 +2123,59 @@ void Profile::UpdateValues() {
   LOG_UPDATED_VALUE(app_tranport_change_timer_addition_,
                     kAppTransportChangeTimerAdditionKey,
                     kMainSection);
+
+  ReadBoolValue(&multiple_transports_enabled_,
+                kDefaultMultipleTransportsEnabled,
+                kMultipleTransportsSection,
+                kMultipleTransportsEnabledKey);
+
+  LOG_UPDATED_BOOL_VALUE(multiple_transports_enabled_,
+                         kMultipleTransportsEnabledKey,
+                         kMultipleTransportsSection);
+
+  {  // Secondary Transports and ServicesMap
+    struct KeyPair {
+      std::vector<std::string>* ini_vector;
+      const char* ini_section_name;
+      const char* ini_key_name;
+    } keys[] = {{&secondary_transports_for_bluetooth_,
+                 kMultipleTransportsSection,
+                 kSecondaryTransportForBluetoothKey},
+                {&secondary_transports_for_usb_,
+                 kMultipleTransportsSection,
+                 kSecondaryTransportForUSBKey},
+                {&secondary_transports_for_wifi_,
+                 kMultipleTransportsSection,
+                 kSecondaryTransportForWiFiKey},
+                {&audio_service_transports_,
+                 kServicesMapSection,
+                 kAudioServiceTransportsKey},
+                {&video_service_transports_,
+                 kServicesMapSection,
+                 kVideoServiceTransportsKey},
+                {NULL, NULL, NULL}};
+    struct KeyPair* entry = keys;
+
+    while (entry->ini_vector != NULL) {
+      bool exist = false;
+      std::vector<std::string> profile_entry = ReadStringContainer(
+          entry->ini_section_name, entry->ini_key_name, &exist, true);
+      if (exist) {
+        *entry->ini_vector = profile_entry;
+
+        const std::string list_with_comma = std::accumulate(
+            profile_entry.begin(),
+            profile_entry.end(),
+            std::string(""),
+            [](std::string& first, std::string& second) {
+              return first.empty() ? second : first + ", " + second;
+            });
+        LOG_UPDATED_VALUE(
+            list_with_comma, entry->ini_key_name, entry->ini_section_name);
+      }
+      entry++;
+    }
+  }
 }
 
 bool Profile::ReadValue(bool* value,
@@ -1944,15 +2203,22 @@ bool Profile::ReadValue(std::string* value,
                         const char* const pSection,
                         const char* const pKey) const {
   DCHECK(value);
+  return ReadValueEmpty(value, pSection, pKey) && "\0" != *value;
+}
+
+bool Profile::ReadValueEmpty(std::string* value,
+                             const char* const pSection,
+                             const char* const pKey) const {
+  DCHECK(value);
   bool ret = false;
 
   char buf[INI_LINE_LEN + 1];
   *buf = '\0';
-  if ((0 != ini_read_value(config_file_name_.c_str(), pSection, pKey, buf)) &&
-      ('\0' != *buf)) {
+  if (0 != ini_read_value(config_file_name_.c_str(), pSection, pKey, buf)) {
     *value = buf;
     ret = true;
   }
+
   return ret;
 }
 
@@ -2014,6 +2280,18 @@ namespace {
 int32_t hex_to_int(const std::string& value) {
   return static_cast<int32_t>(strtol(value.c_str(), NULL, 16));
 }
+
+std::string trim_string(const std::string& str) {
+  const char* delims = " \t";
+
+  size_t start = str.find_first_not_of(delims);
+  if (std::string::npos == start) {
+    return std::string();
+  }
+  size_t end = str.find_last_not_of(delims);
+
+  return str.substr(start, end - start + 1);
+}
 }
 
 std::vector<int> Profile::ReadIntContainer(const char* const pSection,
@@ -2031,9 +2309,15 @@ std::vector<int> Profile::ReadIntContainer(const char* const pSection,
 std::vector<std::string> Profile::ReadStringContainer(
     const char* const pSection,
     const char* const pKey,
-    bool* out_result) const {
+    bool* out_result,
+    bool allow_empty) const {
   std::string string;
-  const bool result = ReadValue(&string, pSection, pKey);
+  bool result;
+  if (allow_empty) {
+    result = ReadValueEmpty(&string, pSection, pKey);
+  } else {
+    result = ReadValue(&string, pSection, pKey);
+  }
   if (out_result)
     *out_result = result;
   std::vector<std::string> value_container;
@@ -2043,7 +2327,7 @@ std::vector<std::string> Profile::ReadStringContainer(
     while (iss) {
       if (!getline(iss, temp_str, ','))
         break;
-      value_container.push_back(temp_str);
+      value_container.push_back(trim_string(temp_str));
     }
   }
   return value_container;
diff --git a/src/components/config_profile/test/profile_test.cc b/src/components/config_profile/test/profile_test.cc
index e7d62f4740..64bafdd6bf 100644
--- a/src/components/config_profile/test/profile_test.cc
+++ b/src/components/config_profile/test/profile_test.cc
@@ -690,10 +690,34 @@ TEST_F(ProfileTest, CheckStringContainer) {
   std::vector<std::string>::iterator element_mode = diagmodes_list.begin();
   element_mode++;
   element_mode++;
-  diag_mode = std::find(diagmodes_list.begin(), diagmodes_list.end(), " 0x03");
+  diag_mode = std::find(diagmodes_list.begin(), diagmodes_list.end(), "0x03");
   EXPECT_EQ(diag_mode, element_mode);
 }
 
+TEST_F(ProfileTest, CheckStringContainerEmpty) {
+  // Set new config file
+  profile_.set_config_file_name("smartDeviceLink_test.ini");
+  EXPECT_EQ("smartDeviceLink_test.ini", profile_.config_file_name());
+
+  bool isread = false;
+  std::vector<std::string> output_list =
+      profile_.ReadStringContainer("MAIN", "AppConfigFolder", &isread);
+  EXPECT_FALSE(isread);
+  EXPECT_TRUE(output_list.empty());
+
+  isread = false;
+  std::vector<std::string> output_list2 =
+      profile_.ReadStringContainer("MAIN", "AppConfigFolder", &isread, true);
+  EXPECT_TRUE(isread);
+  EXPECT_TRUE(output_list2.empty());
+
+  isread = false;
+  std::vector<std::string> output_list3 =
+      profile_.ReadStringContainer("MAIN", "DoesNotExistKey", &isread, true);
+  EXPECT_FALSE(isread);
+  EXPECT_TRUE(output_list2.empty());
+}
+
 #ifdef ENABLE_SECURITY
 TEST_F(ProfileTest, CheckIntContainerInSecurityData) {
   // Set new config file