ApplicationManager correctives

	Correctives in application manager component
		after removing LastState, PolicyHandler, MEdiaManager singletons

61 files changed, 1065 insertions, 621 deletions

diff --git a/src/components/application_manager/CMakeLists.txt b/src/components/application_manager/CMakeLists.txt
index fe1ad0afc2..4d627ef359 100644
--- a/src/components/application_manager/CMakeLists.txt
+++ b/src/components/application_manager/CMakeLists.txt
@@ -49,9 +49,9 @@ include_directories (
   ${COMPONENTS_DIR}/rpc_base/include/
   ${COMPONENTS_DIR}/interfaces
   ${CMAKE_BINARY_DIR}/src/components/
-  ${COMPONENTS_DIR}/include/
+#  ${COMPONENTS_DIR}/include/
   ${COMPONENTS_DIR}/policy/src/policy/include/
-  ${COMPONENTS_DIR}/policy/src/policy/policy_table/table_struct/
+#  ${COMPONENTS_DIR}/policy/src/policy/policy_table/table_struct/
   ${COMPONENTS_DIR}/policy/src/policy/usage_statistics/include/
   ${JSONCPP_INCLUDE_DIRECTORY}
   ${ENCRYPTION_INCLUDE_DIRECTORY}
diff --git a/src/components/application_manager/include/application_manager/application_manager.h b/src/components/application_manager/include/application_manager/application_manager.h
index f35577fcab..dba3357d42 100644
--- a/src/components/application_manager/include/application_manager/application_manager.h
+++ b/src/components/application_manager/include/application_manager/application_manager.h
@@ -44,6 +44,15 @@
 #include "utils/data_accessor.h"
 #include "utils/shared_ptr.h"
 #include "telemetry_monitor/telemetry_observable.h"
+#include "application_manager/policies/policy_handler_interface.h"
+
+namespace resumption {
+class LastState;
+}
+
+namespace media_manager {
+class MediaManager;
+}
 
 // Other compomnents class declaration
 namespace hmi_message_handler {
@@ -79,7 +88,8 @@ class ApplicationManager {
   /**
    * Inits application manager
    */
-  virtual bool Init() = 0;
+  virtual bool Init(resumption::LastState& last_state,
+                    media_manager::MediaManager* media_manager) = 0;
 
   /**
    * @brief Stop work.
@@ -94,6 +104,7 @@ class ApplicationManager {
       protocol_handler::ProtocolHandler* handler) = 0;
   virtual void set_connection_handler(
       connection_handler::ConnectionHandler* handler) = 0;
+  virtual connection_handler::ConnectionHandler& connection_handler() const = 0;
 
   virtual DataAccessor<ApplicationSet> applications() const = 0;
 
@@ -220,7 +231,34 @@ class ApplicationManager {
    */
   virtual void OnApplicationRegistered(ApplicationSharedPtr app) = 0;
 
-  virtual connection_handler::ConnectionHandler& connection_handler() const = 0;
+  /**
+   * @brief Checks if application can stream (streaming service is started and
+   * streaming is enabled in application)
+   * @param app_id Application id
+   * @param service_type Service type to check
+   * @return True if streaming is allowed, false in other case
+   */
+  virtual bool CanAppStream(
+      uint32_t app_id, protocol_handler::ServiceType service_type) const = 0;
+
+  /**
+   * @brief ForbidStreaming forbids  the stream over the certain application.
+   * @param app_id the application's id which should stop streaming.
+   */
+  virtual void ForbidStreaming(uint32_t app_id) = 0;
+
+  /*
+   * @brief Creates AudioPassThru data chunk and inserts it
+   * to audio_pass_thru_messages_
+   *
+   * @param session_key Id of application for which
+   * audio pass thru should be sent
+   *
+   * @param binary_data AudioPassThru data chunk
+   */
+  virtual void SendAudioPassThroughNotification(uint32_t session_key,
+                                        std::vector<uint8_t>& binary_data) = 0;
+  virtual policy::PolicyHandlerInterface& GetPolicyHandler() = 0;
 };
 
 }  // namespace application_manager
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 561a8d4f6e..4f176fcc4d 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
@@ -54,11 +54,11 @@
 #include "hmi_message_handler/hmi_message_observer.h"
 #include "hmi_message_handler/hmi_message_sender.h"
 #include "application_manager/policies/policy_handler_observer.h"
-#include "media_manager/media_manager_impl.h"
 #include "connection_handler/connection_handler.h"
 #include "connection_handler/connection_handler_observer.h"
 #include "connection_handler/device.h"
 #include "formatters/CSmartFactory.h"
+#include "policies/policy_handler.h"
 
 #include "interfaces/HMI_API.h"
 #include "interfaces/HMI_API_schema.h"
@@ -218,7 +218,8 @@ class ApplicationManagerImpl
   /**
    * Inits application manager
    */
-  bool Init() OVERRIDE;
+  bool Init(resumption::LastState& last_state,
+            media_manager::MediaManager* media_manager) OVERRIDE;
 
   /**
    * @brief Stop work.
@@ -809,7 +810,7 @@ class ApplicationManagerImpl
   void EndNaviServices(uint32_t app_id);
 
   /**
-   * @brief ForbidStreaming forbid the stream over the certain application.
+   * @brief ForbidStreaming forbids the stream over the certain application.
    * @param app_id the application's id which should stop streaming.
    */
   void ForbidStreaming(uint32_t app_id);
@@ -937,6 +938,9 @@ class ApplicationManagerImpl
   // TODO(AOleynik): Temporary added, to fix build. Should be reworked.
   connection_handler::ConnectionHandler& connection_handler() const OVERRIDE;
 
+  virtual policy::PolicyHandlerInterface& GetPolicyHandler() OVERRIDE {
+      return policy_handler_;
+  }
   /**
    * @brief Checks, if given RPC is allowed at current HMI level for specific
    * application in policy table
@@ -1246,7 +1250,7 @@ class ApplicationManagerImpl
       const protocol_handler::SessionObserver& session_observer =
           connection_handler().get_session_observer();
       if (MessageHelper::CreateHMIApplicationStruct(
-            *it, session_observer, &hmi_application)) {
+              *it, session_observer, GetPolicyHandler(), &hmi_application)) {
         applications[app_count++] = hmi_application;
       } else {
         LOG4CXX_DEBUG(logger_, "Can't CreateHMIApplicationStruct ");
@@ -1438,6 +1442,7 @@ typedef utils::SharedPtr<timer::Timer> TimerSPtr;
 
   hmi_message_handler::HMIMessageHandler* hmi_handler_;
   connection_handler::ConnectionHandler* connection_handler_;
+  policy::PolicyHandler policy_handler_;
   protocol_handler::ProtocolHandler* protocol_handler_;
   request_controller::RequestController request_ctrl_;
 
diff --git a/src/components/application_manager/include/application_manager/commands/hmi/get_system_info_response.h b/src/components/application_manager/include/application_manager/commands/hmi/get_system_info_response.h
index 70983d3ce3..9f57a492ac 100644
--- a/src/components/application_manager/include/application_manager/commands/hmi/get_system_info_response.h
+++ b/src/components/application_manager/include/application_manager/commands/hmi/get_system_info_response.h
@@ -39,6 +39,12 @@ namespace application_manager {
 
 namespace commands {
 
+struct SystemInfo {
+  std::string ccpu_version;
+  std::string wers_country_code;
+  std::string language;
+};
+
 /**
  * @brief GetSystemInfoResponse command class
  **/
@@ -62,6 +68,8 @@ class GetSystemInfoResponse : public ResponseFromHMI {
     virtual void Run();
 
   private:
+    const SystemInfo GetSystemInfo(const hmi_apis::Common_Result::eType code) const;
+
     DISALLOW_COPY_AND_ASSIGN(GetSystemInfoResponse);
 };
 
diff --git a/src/components/application_manager/include/application_manager/commands/mobile/register_app_interface_request.h b/src/components/application_manager/include/application_manager/commands/mobile/register_app_interface_request.h
index f4c581e5d8..2a94a64af3 100644
--- a/src/components/application_manager/include/application_manager/commands/mobile/register_app_interface_request.h
+++ b/src/components/application_manager/include/application_manager/commands/mobile/register_app_interface_request.h
@@ -34,15 +34,17 @@
 #ifndef SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_COMMANDS_MOBILE_REGISTER_APP_INTERFACE_REQUEST_H_
 #define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_COMMANDS_MOBILE_REGISTER_APP_INTERFACE_REQUEST_H_
 
-#include <string.h>
 #include "application_manager/commands/command_request_impl.h"
+#include "application_manager/policies/policy_handler_interface.h"
 #include "utils/macro.h"
 #include "utils/custom_string.h"
 
 namespace policy {
 struct DeviceInfo;
 }
-
+namespace policy {
+class PolicyHandler;
+}
 namespace application_manager {
 
 class Application;
@@ -167,6 +169,7 @@ class RegisterAppInterfaceRequest : public CommandRequestImpl {
   std::string response_info_;
   mobile_apis::Result::eType result_checking_app_hmi_type_;
 
+  policy::PolicyHandlerInterface &GetPolicyHandler();
   DISALLOW_COPY_AND_ASSIGN(RegisterAppInterfaceRequest);
 };
 
diff --git a/src/components/application_manager/include/application_manager/hmi_capabilities.h b/src/components/application_manager/include/application_manager/hmi_capabilities.h
index a58e9478c8..85aaca0f4c 100644
--- a/src/components/application_manager/include/application_manager/hmi_capabilities.h
+++ b/src/components/application_manager/include/application_manager/hmi_capabilities.h
@@ -44,6 +44,9 @@ namespace NsSmartObjects {
 class SmartObject;
 }
 }
+namespace resumption {
+class LastState;
+}
 
 namespace smart_objects = NsSmartDeviceLink::NsSmartObjects;
 
@@ -404,6 +407,8 @@ class HMICapabilities {
    */
   inline const std::string& ccpu_version() const;
 
+  void Init(resumption::LastState* last_state);
+
  protected:
 
   /*
diff --git a/src/components/application_manager/include/application_manager/hmi_language_handler.h b/src/components/application_manager/include/application_manager/hmi_language_handler.h
index aa90da7562..a16a8fdb0b 100644
--- a/src/components/application_manager/include/application_manager/hmi_language_handler.h
+++ b/src/components/application_manager/include/application_manager/hmi_language_handler.h
@@ -35,7 +35,9 @@
 
 #include "application_manager/event_engine/event_observer.h"
 #include "interfaces/HMI_API.h"
-
+namespace resumption {
+class LastState;
+}
 namespace application_manager {
 
 /**
@@ -93,10 +95,10 @@ public:
    * @param vr VR language
    * @param tts TTS language
    */
-  void set_default_capabilities_languages(
-          hmi_apis::Common_Language::eType ui,
-          hmi_apis::Common_Language::eType vr,
-          hmi_apis::Common_Language::eType tts);
+  void set_default_capabilities_languages(hmi_apis::Common_Language::eType ui,
+                                          hmi_apis::Common_Language::eType vr,
+                                          hmi_apis::Common_Language::eType tts);
+  void Init(resumption::LastState* value);
 
 private:
   void SendOnLanguageChangeToMobile(uint32_t connection_key);
@@ -171,6 +173,7 @@ private:
    * @brief Indicates if current TTS language has been received from HMI
    */
   bool is_tts_language_received_;
+  resumption::LastState* last_state_;
 };
 
 } // namespace application_manager
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 0c072184ff..64cd9485cf 100644
--- a/src/components/application_manager/include/application_manager/message_helper.h
+++ b/src/components/application_manager/include/application_manager/message_helper.h
@@ -45,6 +45,7 @@
 #include "application_manager/vehicle_info_data.h"
 #include "policy/policy_types.h"
 #include "protocol_handler/session_observer.h"
+#include "application_manager/policies/policy_handler_interface.h"
 
 namespace NsSmartDeviceLink {
 namespace NsSmartObjects {
@@ -52,6 +53,10 @@ class SmartObject;
 }
 }
 
+namespace policy {
+class PolicyHandlerInterface;
+}
+
 namespace application_manager {
 namespace mobile_api = mobile_apis;
 namespace smart_objects = NsSmartDeviceLink::NsSmartObjects;
@@ -88,18 +93,6 @@ class MessageHelper {
       const uint32_t app_id);
 
   /**
-   * @brief Create OnSystemRequest notification for lock screen icon url
-   */
-  static smart_objects::SmartObject* GetLockScreenIconUrlNotification(
-      const uint32_t connection_key);
-
-  /**
-  * @brief Send the OnSystemRequest notification for lock screen icon url to the
-  * mobile device
-  */
-  static void SendLockScreenIconUrlNotification(const uint32_t connection_key);
-
-  /**
    * @brief Sends to mobile HashUpdateNotification
    */
   static void SendHashUpdateNotification(const uint32_t app_id);
@@ -218,7 +211,8 @@ class MessageHelper {
    *
    */
   static smart_objects::SmartObjectSPtr CreateDeviceListSO(
-      const connection_handler::DeviceMap& devices);
+      const connection_handler::DeviceMap& devices,
+      const policy::PolicyHandlerInterface& policy_handler);
 
   static smart_objects::SmartObjectSPtr CreateModuleInfoSO(
       uint32_t function_id);
@@ -294,9 +288,9 @@ class MessageHelper {
    * @param output smart object to store Common.HMIApplication struct
    * @return true on succes, otherwise return false;
    */
-  static bool CreateHMIApplicationStruct(
-      ApplicationConstSharedPtr app,
+  static bool CreateHMIApplicationStruct(ApplicationConstSharedPtr app,
       const protocol_handler::SessionObserver& session_observer,
+      const policy::PolicyHandlerInterface &policy_handler,
       smart_objects::SmartObject* output);
 
   static void SendAddSubMenuRequestToHMI(ApplicationConstSharedPtr app);
@@ -310,12 +304,14 @@ class MessageHelper {
    * Indicates if connection was unexpectedly lost by TM or HB
    */
   static void SendOnAppUnregNotificationToHMI(
-      ApplicationConstSharedPtr app,
-      const bool is_unexpected_disconnect = false);
+      ApplicationConstSharedPtr app, bool is_unexpected_disconnect = false);
 
-  static smart_objects::SmartObjectSPtr GetBCActivateAppRequestToHMI(ApplicationConstSharedPtr app,
-       const hmi_apis::Common_HMILevel::eType level,
-       const bool send_policy_priority = true);
+  static NsSmartDeviceLink::NsSmartObjects::SmartObjectSPtr
+  GetBCActivateAppRequestToHMI(ApplicationConstSharedPtr app,
+      const protocol_handler::SessionObserver& session_observer,
+      const policy::PolicyHandlerInterface &policy_handler,
+      hmi_apis::Common_HMILevel::eType level,
+      bool send_policy_priority);
 
   static void SendOnResumeAudioSourceToHMI(const uint32_t app_id);
 
@@ -531,17 +527,8 @@ class MessageHelper {
 
   static mobile_apis::Result::eType ProcessSoftButtons(
       smart_objects::SmartObject& message_params,
-      ApplicationConstSharedPtr app);
-
-  /**
-   * @brief checkWithPolicy allows to check soft button's parameters
-   * according to the current policy
-   * @param system_action system action
-   * @param app_mobile_id policy application id
-   * @return
-   */
-  static bool CheckWithPolicy(mobile_apis::SystemAction::eType system_action,
-                              const std::string& app_mobile_id);
+      ApplicationConstSharedPtr app,
+      const policy::PolicyHandlerInterface& policy_handler);
 
   /*
    * @brief subscribe application to softbutton
@@ -575,22 +562,6 @@ class MessageHelper {
       hmi_apis::Common_Language::eType language);
 
     /**
-     * @brief Converts string to common language enum value
-     * @param language language as string
-     * @return Common language enum value
-     */
-    static hmi_apis::Common_Language::eType CommonLanguageFromString(
-       const std::string& language);
-
-    /**
-     * @brief Converts mobile language to string representation
-     * @param language Mobile language
-     * @return Mobile language string representation
-     */
-    static std::string MobileLanguageToString(
-            const mobile_apis::Language::eType language);
-
-    /**
      * @brief Converts string to mobile language enum value
      * @param language language as string
      * @return Mobile language enum value
@@ -650,6 +621,9 @@ class MessageHelper {
      */
     static void SendDecryptCertificateToHMI(const std::string& file_name);
 
+    static hmi_apis::Common_Language::eType CommonLanguageFromString(
+        const std::string& language);
+
   private:
     /**
      * @brief Creates new request object and fill its header
diff --git a/src/components/application_manager/include/application_manager/policies/delegates/statistics_delegate.h b/src/components/application_manager/include/application_manager/policies/delegates/statistics_delegate.h
index 9044a3fd33..526c6aa585 100644
--- a/src/components/application_manager/include/application_manager/policies/delegates/statistics_delegate.h
+++ b/src/components/application_manager/include/application_manager/policies/delegates/statistics_delegate.h
@@ -42,6 +42,8 @@
 
 namespace policy {
 
+class PolicyHandler;
+
   class StatisticsDelegate: public threads::ThreadDelegate {
       enum StatisticType{
         INCREMENT_GLOBAL,
@@ -50,16 +52,19 @@ namespace policy {
         ADD
       };
     public:
-      explicit StatisticsDelegate(usage_statistics::GlobalCounterId type);
+      StatisticsDelegate(PolicyHandler& policy_handler,
+                                  usage_statistics::GlobalCounterId type);
 
-      StatisticsDelegate(const std::string& app_id,
+      StatisticsDelegate(PolicyHandler& policy_handler,
+                         const std::string& app_id,
                         usage_statistics::AppCounterId type);
 
-      StatisticsDelegate(const std::string& app_id,
+      StatisticsDelegate(PolicyHandler &policy_handler, const std::string& app_id,
                         usage_statistics::AppInfoId type,
                         const std::string& value);
 
-      StatisticsDelegate(const std::string& app_id,
+      StatisticsDelegate(PolicyHandler& policy_handler,
+                         const std::string& app_id,
                         usage_statistics::AppStopwatchId type,
                         int32_t timespan_seconds);
 
@@ -76,6 +81,7 @@ namespace policy {
       std::string app_id_;
       std::string value_;
       int32_t timespan_seconds_;
+      PolicyHandler& policy_handler_;
   };
 } // namespace policy
 
diff --git a/src/components/application_manager/include/application_manager/policies/policy_handler.h b/src/components/application_manager/include/application_manager/policies/policy_handler.h
index 74843e0380..32db248965 100644
--- a/src/components/application_manager/include/application_manager/policies/policy_handler.h
+++ b/src/components/application_manager/include/application_manager/policies/policy_handler.h
@@ -37,10 +37,12 @@
 #include <map>
 #include <set>
 #include <vector>
-#include <cstdint>
+#include <stdint.h>
 #include "policy/policy_manager.h"
+#include "application_manager/policies/policy_handler_interface.h"
 #include "application_manager/policies/policy_event_observer.h"
 #include "application_manager/policies/delegates/statistics_delegate.h"
+#include "application_manager/policies/policy_handler_observer.h"
 #include "utils/logger.h"
 #include "utils/singleton.h"
 #include "utils/threads/thread.h"
@@ -48,10 +50,9 @@
 #include "utils/conditional_variable.h"
 #include "utils/rwlock.h"
 #include "utils/custom_string.h"
-#include "usage_statistics/statistics_manager.h"
-#include "application_manager/policies/policy_handler_observer.h"
+#include "policy/usage_statistics/statistics_manager.h"
 #include "utils/threads/async_runner.h"
-#include "application_manager/application_manager_impl.h"
+#include "policy/policy_settings.h"
 
 namespace Json {
 class Value;
@@ -63,58 +64,56 @@ typedef std::vector<uint32_t> DeviceHandles;
 namespace custom_str = utils::custom_string;
 
 class PolicyHandler
-    : public utils::Singleton<PolicyHandler,
-                              utils::deleters::Deleter<PolicyHandler> >,
+    : public PolicyHandlerInterface,
       public PolicyListener,
       public threads::AsyncRunner {
  public:
-  virtual ~PolicyHandler();
-  bool LoadPolicyLibrary();
-  bool PolicyEnabled();
-  bool InitPolicyTable();
-  bool ResetPolicyTable();
-  bool ClearUserConsent();
-  bool SendMessageToSDK(const BinaryMessage& pt_string, const std::string& url);
+  PolicyHandler(const policy::PolicySettings& get_settings);
+  ~PolicyHandler();
+  bool LoadPolicyLibrary() OVERRIDE;
+  bool PolicyEnabled() const OVERRIDE;
+  bool InitPolicyTable() OVERRIDE;
+  bool ResetPolicyTable() OVERRIDE;
+  bool ClearUserConsent() OVERRIDE;
+  bool SendMessageToSDK(const BinaryMessage& pt_string, const std::string& url) OVERRIDE;
   bool ReceiveMessageFromSDK(const std::string& file,
-                             const BinaryMessage& pt_string);
-  bool UnloadPolicyLibrary();
-  virtual void OnPermissionsUpdated(const std::string& policy_app_id,
+                             const BinaryMessage& pt_string) OVERRIDE;
+  bool UnloadPolicyLibrary() OVERRIDE;
+  void OnPermissionsUpdated(const std::string& policy_app_id,
                                     const Permissions& permissions,
-                                    const HMILevel& default_hmi);
+                                    const HMILevel& default_hmi) OVERRIDE;
 
-  virtual void OnPermissionsUpdated(const std::string& policy_app_id,
-                                    const Permissions& permissions);
+  void OnPermissionsUpdated(const std::string& policy_app_id,
+                                    const Permissions& permissions) OVERRIDE;
 
   void OnSnapshotCreated(const BinaryMessage& pt_string) OVERRIDE;
 
-  bool GetPriority(const std::string& policy_app_id, std::string* priority);
+  bool GetPriority(const std::string& policy_app_id, std::string* priority) const OVERRIDE;
   void CheckPermissions(const PTString& app_id,
                         const PTString& hmi_level,
                         const PTString& rpc,
                         const RPCParams& rpc_params,
-                        CheckPermissionResult& result);
+                        CheckPermissionResult& result) OVERRIDE;
 
-  uint32_t GetNotificationsNumber(const std::string& priority);
-  DeviceConsent GetUserConsentForDevice(const std::string& device_id);
+  uint32_t GetNotificationsNumber(const std::string& priority) const OVERRIDE;
+  DeviceConsent GetUserConsentForDevice(const std::string& device_id) const OVERRIDE;
   bool GetDefaultHmi(const std::string& policy_app_id,
-                     std::string* default_hmi);
+                     std::string* default_hmi) const OVERRIDE;
   bool GetInitialAppData(const std::string& application_id,
                          StringArray* nicknames = NULL,
-                         StringArray* app_hmi_types = NULL);
+                         StringArray* app_hmi_types = NULL) OVERRIDE;
   void GetServiceUrls(const std::string& service_type,
-                      EndpointUrls& end_points);
-
-  std::string GetLockScreenIconUrl() const;
-  void ResetRetrySequence();
-  uint32_t NextRetryTimeout();
-  int TimeoutExchange();
-  void OnExceededTimeout();
-  void OnSystemReady();
-  void PTUpdatedAt(Counters counter, int value);
-  void add_listener(PolicyHandlerObserver* listener);
-  void remove_listener(PolicyHandlerObserver* listener);
+                      EndpointUrls& end_points) OVERRIDE;
+  void ResetRetrySequence() OVERRIDE;
+  int NextRetryTimeout() OVERRIDE;
+  int TimeoutExchange() OVERRIDE;
+  void OnExceededTimeout() OVERRIDE;
+  void OnSystemReady() OVERRIDE;
+  void PTUpdatedAt(Counters counter, int value) OVERRIDE;
+  void add_listener(PolicyHandlerObserver* listener) OVERRIDE;
+  void remove_listener(PolicyHandlerObserver* listener) OVERRIDE;
 
-  utils::SharedPtr<usage_statistics::StatisticsManager> GetStatisticManager();
+  utils::SharedPtr<usage_statistics::StatisticsManager> GetStatisticManager() const OVERRIDE;
 
   /**
    * @brief CheckSystemAction allows to check whether certain system
@@ -125,19 +124,19 @@ class PolicyHandler
    * @return true if specified system action is enabled, false otherwise.
    */
   bool CheckSystemAction(mobile_apis::SystemAction::eType system_action,
-                         const std::string& policy_app_id);
+                         const std::string& policy_app_id) const OVERRIDE;
 
   /**
    * Lets client to notify PolicyHandler that more kilometers expired
    * @param kms New value of odometer
    */
-  void KmsChanged(int kms);
+  void KmsChanged(int kms) OVERRIDE;
 
   /**
    * @brief Gather information for application and sends it to HMI
    * @param connection_key Connection key for application
    */
-  void OnActivateApp(uint32_t connection_key, uint32_t correlation_id);
+  void OnActivateApp(uint32_t connection_key, uint32_t correlation_id) OVERRIDE;
 
   /**
    * @brief Process user consent on mobile data connection access
@@ -145,20 +144,20 @@ class PolicyHandler
    * @param User consent from response
    */
   void OnAllowSDLFunctionalityNotification(bool is_allowed,
-                                           const std::string& device_id);
+                                           const std::string& device_id) OVERRIDE;
 
   /**
    * @brief Increment counter for ignition cycles
    */
-  void OnIgnitionCycleOver();
+  void OnIgnitionCycleOver() OVERRIDE;
 
-  void OnPendingPermissionChange(const std::string& policy_app_id);
+  void OnPendingPermissionChange(const std::string& policy_app_id) OVERRIDE;
 
   /**
    * Initializes PT exchange at user request
    * @param correlation_id correlation id of request
    */
-  void PTExchangeAtUserRequest(uint32_t correlation_id);
+  void PTExchangeAtUserRequest(uint32_t correlation_id) OVERRIDE;
 
   /**
    * @brief Add's device to policy table
@@ -166,14 +165,15 @@ class PolicyHandler
    * @param connection_type  Device connection type
    */
   void AddDevice(const std::string& device_id,
-                 const std::string& connection_type);
+                 const std::string& connection_type) OVERRIDE;
 
   /**
    * @brief Save device info for specific device to policy table
    * @param device_id Device mac address
    * @param device_info Device params
    */
-  void SetDeviceInfo(std::string& device_id, const DeviceInfo& device_info);
+  void SetDeviceInfo(const std::string& device_id,
+                     const DeviceInfo& device_info) OVERRIDE;
 
   /**
    * @brief Store user-changed permissions consent to DB
@@ -182,7 +182,7 @@ class PolicyHandler
    * @param permissions User-changed group permissions consent
    */
   void OnAppPermissionConsent(const uint32_t connection_key,
-                              const PermissionConsent& permissions);
+                              const PermissionConsent& permissions) OVERRIDE;
 
   /**
    * @brief Get appropriate message parameters and send them with response
@@ -193,7 +193,7 @@ class PolicyHandler
    */
   void OnGetUserFriendlyMessage(const std::vector<std::string>& message_codes,
                                 const std::string& language,
-                                uint32_t correlation_id);
+                                uint32_t correlation_id) OVERRIDE;
 
   /**
    * @brief Get list of permissions for application/device binded to
@@ -203,32 +203,32 @@ class PolicyHandler
    * @param correlation_id Correlation id from request
    */
   void OnGetListOfPermissions(const uint32_t connection_key,
-                              const uint32_t correlation_id);
+                              const uint32_t correlation_id) OVERRIDE;
 
   /**
    * @brief Get current policy table update state and send response
    * @param correlation_id Correlation id from request
    */
-  void OnGetStatusUpdate(const uint32_t correlation_id);
+  void OnGetStatusUpdate(const uint32_t correlation_id) OVERRIDE;
 
   /**
    * @brief Send notification to HMI with changed policy update status
    * @param status Current policy update state
    */
-  void OnUpdateStatusChanged(const std::string& status);
+  void OnUpdateStatusChanged(const std::string& status) OVERRIDE;
 
   /**
    * @brief Update currently used device id in policies manager for given
    * application
    * @param policy_app_id Application id
    */
-  std::string OnCurrentDeviceIdUpdateRequired(const std::string& policy_app_id);
+  std::string OnCurrentDeviceIdUpdateRequired(const std::string& policy_app_id) OVERRIDE;
 
   /**
    * @brief Set parameters from OnSystemInfoChanged to policy table
    * @param language System language
    */
-  void OnSystemInfoChanged(const std::string& language);
+  void OnSystemInfoChanged(const std::string& language) OVERRIDE;
 
   /**
    * @brief Save data from GetSystemInfo request to policy table
@@ -238,7 +238,7 @@ class PolicyHandler
    */
   void OnGetSystemInfo(const std::string& ccpu_version,
                        const std::string& wers_country_code,
-                       const std::string& language);
+                       const std::string& language) OVERRIDE;
 
   /**
    * @brief Send request to HMI to get update on system parameters
@@ -248,39 +248,39 @@ class PolicyHandler
   /**
    * @brief Sends GetVehicleData request in case when Vechicle info is ready.
    */
-  virtual void OnVIIsReady();
+  void OnVIIsReady() OVERRIDE;
 
   /**
    * @brief Allows to update vechicle data info.
    * @param SmartObject which contains all needed information.
    */
-  virtual void OnVehicleDataUpdated(const smart_objects::SmartObject& message);
+  void OnVehicleDataUpdated(const smart_objects::SmartObject& message) OVERRIDE;
 
   /**
    * Removes device
    * @param device_id id of device
    */
-  void RemoveDevice(const std::string& device_id);
+  void RemoveDevice(const std::string& device_id) OVERRIDE;
 
   /**
    * Adds statistics info
    * @param type type of info
    */
-  void AddStatisticsInfo(int type);
+  void AddStatisticsInfo(int type) OVERRIDE;
 
   /**
    * Handles system error
    * @param code code of error
    */
-  void OnSystemError(int code);
+  void OnSystemError(int code) OVERRIDE;
 
   /**
    * @brief Choose application id to be used for snapshot sending
    * @return Application id or 0, if there are no applications registered
    */
-  uint32_t GetAppIdForSending();
+  uint32_t GetAppIdForSending() const OVERRIDE;
 
-  custom_str::CustomString GetAppName(const std::string& policy_app_id);
+  custom_str::CustomString GetAppName(const std::string& policy_app_id) OVERRIDE;
 
   void OnUpdateHMIAppType(
       std::map<std::string, StringArray> app_hmi_types) OVERRIDE;
@@ -290,9 +290,9 @@ class PolicyHandler
   bool CanUpdate() OVERRIDE;
 
   void OnDeviceConsentChanged(const std::string& device_id,
-                              bool is_allowed) OVERRIDE;
+                                      bool is_allowed) OVERRIDE;
 
-  virtual void OnPTExchangeNeeded();
+  void OnPTExchangeNeeded() OVERRIDE;
 
   void GetAvailableApps(std::queue<std::string>& apps) OVERRIDE;
 
@@ -301,19 +301,19 @@ class PolicyHandler
    * registration process
    * @param application_id The policy aplication id.
    */
-  void AddApplication(const std::string& application_id);
+  void AddApplication(const std::string& application_id) OVERRIDE;
 
   /**
    * Checks whether application is revoked
    * @param app_id id application
    * @return true if application is revoked
    */
-  bool IsApplicationRevoked(const std::string& app_id);
+  bool IsApplicationRevoked(const std::string& app_id) OVERRIDE;
 
   /**
    * @brief Notifies policy manager, that PTS was sent out
    */
-  void OnUpdateRequestSentToMobile();
+  void OnUpdateRequestSentToMobile() OVERRIDE;
 
   /**
    * Returns heart beat timeout
@@ -321,22 +321,22 @@ class PolicyHandler
    * @return if timeout was set then value in milliseconds greater zero
    * otherwise heart beat for specific application isn't set
    */
-  uint32_t HeartBeatTimeout(const std::string& app_id) const;
+  uint32_t HeartBeatTimeout(const std::string& app_id) const OVERRIDE;
 
   /**
    * @brief Returns URL for querying list of remote apps
    */
-  const std::string RemoteAppsUrl() const;
+  const std::string RemoteAppsUrl() const OVERRIDE;
 
   /**
    * @brief Handler on applications search started
    */
-  void OnAppsSearchStarted();
+  void OnAppsSearchStarted() OVERRIDE;
 
   /**
    * @brief Handler on applications search completed
    */
-  void OnAppsSearchCompleted();
+  void OnAppsSearchCompleted() OVERRIDE;
 
   /**
    * @brief Checks if certain request type is allowed for application
@@ -345,7 +345,7 @@ class PolicyHandler
    * @return true, if allowed, otherwise - false
    */
   bool IsRequestTypeAllowed(const std::string& policy_app_id,
-                            mobile_apis::RequestType::eType type) const;
+                            mobile_apis::RequestType::eType type) const OVERRIDE;
 
   /**
    * @brief Gets application request types
@@ -353,44 +353,47 @@ class PolicyHandler
    * @return request types
    */
   const std::vector<std::string> GetAppRequestTypes(
-      const std::string& policy_app_id) const;
+      const std::string& policy_app_id) const OVERRIDE;
 
   /**
    * @brief Gets vehicle information
    * @return Structure with vehicle information
    */
-  const VehicleInfo GetVehicleInfo() const;
+  const VehicleInfo GetVehicleInfo() const OVERRIDE;
 
   /**
-   * @brief OnAppRegisteredOnMobile alows to handle event when application were
+   * @brief OnAppRegisteredOnMobile allows to handle event when application were
    * succesfully registered on mobile device.
    * It will send OnAppPermissionSend notification and will try to start PTU.
    *
    * @param application_id registered application.
    */
-  void OnAppRegisteredOnMobile(const std::string& application_id);
+  void OnAppRegisteredOnMobile(const std::string& application_id) OVERRIDE;
 
   // TODO(AKutsan) REMOVE THIS UGLY HOTFIX
-  virtual void Increment(usage_statistics::GlobalCounterId type);
-  virtual void Increment(const std::string& app_id,
-                         usage_statistics::AppCounterId type);
-  virtual void Set(const std::string& app_id,
+  void Increment(usage_statistics::GlobalCounterId type) OVERRIDE;
+  void Increment(const std::string& app_id,
+                         usage_statistics::AppCounterId type) OVERRIDE;
+  void Set(const std::string& app_id,
                    usage_statistics::AppInfoId type,
-                   const std::string& value);
-  virtual void Add(const std::string& app_id,
+                   const std::string& value) OVERRIDE;
+  void Add(const std::string& app_id,
                    usage_statistics::AppStopwatchId type,
-                   int32_t timespan_seconds);
+                   int32_t timespan_seconds) OVERRIDE;
 
 #ifdef BUILD_TESTS
   void SetPolicyManager(utils::SharedPtr<PolicyManager> pm) {
     policy_manager_ = pm;
   }
 #endif  // BUILD_TESTS
+
 #ifdef ENABLE_SECURITY
-  std::string RetrieveCertificate() const;
+  std::string RetrieveCertificate() const OVERRIDE;
 #endif  // ENABLE_SECURITY
 
- protected:
+  const PolicySettings &get_settings() const OVERRIDE;
+
+  protected:
   /**
    * Starts next retry exchange policy table
    */
@@ -405,7 +408,7 @@ class PolicyHandler
    * policy
    * otherwise true
    */
-  bool CheckKeepContext(const std::string& policy_app_id);
+  bool CheckKeepContext(const std::string& policy_app_id) const;
 
   /**
    * Checks system action of application for permission of steal focus
@@ -415,7 +418,7 @@ class PolicyHandler
    * policy
    * otherwise true
    */
-  bool CheckStealFocus(const std::string& policy_app_id);
+  bool CheckStealFocus(const std::string& policy_app_id) const;
 
   /**
    * @brief OnAppPermissionConsentInternal reacts on permission changing
@@ -425,7 +428,7 @@ class PolicyHandler
    * @param permissions new permissions.
    */
   void OnAppPermissionConsentInternal(const uint32_t connection_key,
-                                      PermissionConsent& permissions);
+                                      PermissionConsent& permissions) OVERRIDE;
 
   /**
    * @brief Sets days after epoch on successful policy update
@@ -434,35 +437,41 @@ class PolicyHandler
 
  private:
   class StatisticManagerImpl : public usage_statistics::StatisticsManager {
+    public:
+
+    StatisticManagerImpl(PolicyHandler* policy_handler)
+        : policy_handler_(policy_handler) {
+      DCHECK(policy_handler_);
+    }
     // TODO(AKutsan) REMOVE THIS UGLY HOTFIX
-    virtual void Increment(usage_statistics::GlobalCounterId type) {
-      PolicyHandler::instance()->AsyncRun(new StatisticsDelegate(type));
+    void Increment(usage_statistics::GlobalCounterId type) {
+      policy_handler_->AsyncRun(new StatisticsDelegate(*policy_handler_, type));
     }
 
-    virtual void Increment(const std::string& app_id,
+    void Increment(const std::string& app_id,
                            usage_statistics::AppCounterId type) {
-      PolicyHandler::instance()->AsyncRun(new StatisticsDelegate(app_id, type));
+      policy_handler_->AsyncRun(
+          new StatisticsDelegate(*policy_handler_, app_id, type));
     }
 
-    virtual void Set(const std::string& app_id,
+    void Set(const std::string& app_id,
                      usage_statistics::AppInfoId type,
                      const std::string& value) {
-      PolicyHandler::instance()->AsyncRun(
-          new StatisticsDelegate(app_id, type, value));
+      policy_handler_->AsyncRun(
+          new StatisticsDelegate(*policy_handler_, app_id, type, value));
     }
 
-    virtual void Add(const std::string& app_id,
+    void Add(const std::string& app_id,
                      usage_statistics::AppStopwatchId type,
                      int32_t timespan_seconds) {
-      PolicyHandler::instance()->AsyncRun(
-          new StatisticsDelegate(app_id, type, timespan_seconds));
+      policy_handler_->AsyncRun(new StatisticsDelegate(
+          *policy_handler_, app_id, type, timespan_seconds));
     }
+  private:
+    PolicyHandler* policy_handler_;
   };
-  // TODO(AKutsan) REMOVE THIS UGLY HOTFIX
 
-  PolicyHandler();
   bool SaveSnapshot(const BinaryMessage& pt_string, std::string& snap_path);
-  static PolicyHandler* instance_;
   static const std::string kLibrary;
   mutable sync_primitives::RWLock policy_manager_lock_;
   utils::SharedPtr<PolicyManager> policy_manager_;
@@ -492,12 +501,10 @@ class PolicyHandler
   sync_primitives::Lock app_to_device_link_lock_;
 
   utils::SharedPtr<StatisticManagerImpl> statistic_manager_impl_;
-
+  const PolicySettings& settings_;
   friend class AppPermissionDelegate;
 
   DISALLOW_COPY_AND_ASSIGN(PolicyHandler);
-  FRIEND_BASE_SINGLETON_CLASS_WITH_DELETER(
-      PolicyHandler, utils::deleters::Deleter<PolicyHandler>);
   FRIEND_DELETER_DESTRUCTOR(PolicyHandler);
 };
 
diff --git a/src/components/application_manager/include/application_manager/policies/policy_handler_interface.h b/src/components/application_manager/include/application_manager/policies/policy_handler_interface.h
deleted file mode 100644
index 503e8ec8ef..0000000000
--- a/src/components/application_manager/include/application_manager/policies/policy_handler_interface.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2015, Ford Motor Company
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * Redistributions of source code must retain the above copyright notice, this
- * list of conditions and the following disclaimer.
- *
- * Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided with the
- * distribution.
- *
- * Neither the name of the Ford Motor Company nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICY_HANDLER_INTERFACE_H_
-#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICY_HANDLER_INTERFACE_H_
-
-#include "policy/policy_types.h"
-
-namespace policy {
-
-// Current interface created just to be able make unit-testing
-// It should be refactored in task pointed below
-// TODO(AByzhynar) : APPLINK-16112 Create PolicyHandler interface
-
-class PolicyHandlerInterface {
- public:
-  virtual ~PolicyHandlerInterface() {}
-  virtual void OnSystemReady() = 0;
-  virtual void PTUpdatedAt(Counters counter, int value) = 0;
-};
-
-}  //  namespace policy
-
-#endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICY_HANDLER_INTERFACE_H_
-
diff --git a/src/components/application_manager/include/application_manager/resumption/resume_ctrl.h b/src/components/application_manager/include/application_manager/resumption/resume_ctrl.h
index 80928ae056..5dda974ac0 100644
--- a/src/components/application_manager/include/application_manager/resumption/resume_ctrl.h
+++ b/src/components/application_manager/include/application_manager/resumption/resume_ctrl.h
@@ -45,7 +45,7 @@
 #include "application_manager/event_engine/event_observer.h"
 #include "smart_objects/smart_object.h"
 #include "application_manager/application.h"
-#include "resumption_data.h"
+#include "application_manager/resumption/resumption_data.h"
 #include "utils/timer.h"
 
 namespace application_manager {
@@ -54,6 +54,8 @@ class Application;
 
 namespace resumption {
 
+class LastState;
+
 /**
  * @brief Contains logic for storage/restore data of applications.
  */
@@ -267,7 +269,7 @@ class ResumeCtrl: public app_mngr::event_engine::EventObserver {
    * @return true if initialization is success otherwise
    * returns false
    */
-  bool Init();
+  bool Init(LastState &last_state);
 
   /**
    * @brief Notify resume controller about new application
diff --git a/src/components/application_manager/include/application_manager/resumption/resumption_data.h b/src/components/application_manager/include/application_manager/resumption/resumption_data.h
index c9dbe8dcab..5c4e5ff256 100644
--- a/src/components/application_manager/include/application_manager/resumption/resumption_data.h
+++ b/src/components/application_manager/include/application_manager/resumption/resumption_data.h
@@ -32,6 +32,7 @@
 
 #ifndef SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_RESUMPTION_RESUMPTION_DATA_H_
 #define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_RESUMPTION_RESUMPTION_DATA_H_
+
 #include "smart_objects/smart_object.h"
 #include "application_manager/application.h"
 
@@ -185,7 +186,7 @@ class ResumptionData {
   /**
    * @brief Init storage
    */
-  virtual bool Init();
+  virtual bool Init() = 0;
 
   /**
    * @brief Drops data related to applicaton data resumption
@@ -196,6 +197,10 @@ class ResumptionData {
   virtual bool DropAppDataResumption(const std::string& device_id,
                                      const std::string& app_id) = 0;
 
+  /**
+   * @brief Persist saves resumption data on file system
+   */
+  virtual void Persist() = 0;
  protected:
   /**
    * @brief Retrieves of commands from application
diff --git a/src/components/application_manager/include/application_manager/resumption/resumption_data_db.h b/src/components/application_manager/include/application_manager/resumption/resumption_data_db.h
index f6de5eec86..18c9369f2e 100644
--- a/src/components/application_manager/include/application_manager/resumption/resumption_data_db.h
+++ b/src/components/application_manager/include/application_manager/resumption/resumption_data_db.h
@@ -200,6 +200,12 @@ class ResumptionDataDB : public ResumptionData {
                               const std::string& device_id,
                               mobile_apis::HMILevel::eType hmi_level);
 
+
+  /**
+   * @brief Write database to file system
+   */
+  void Persist() OVERRIDE;
+
   /**
    * @brief Re-creates and re-init DB
    * @return true if success, otherwise - false
diff --git a/src/components/application_manager/include/application_manager/resumption/resumption_data_json.h b/src/components/application_manager/include/application_manager/resumption/resumption_data_json.h
index f5775ac004..3d6d2a16e2 100644
--- a/src/components/application_manager/include/application_manager/resumption/resumption_data_json.h
+++ b/src/components/application_manager/include/application_manager/resumption/resumption_data_json.h
@@ -35,6 +35,7 @@
 
 #include "application_manager/resumption/resumption_data.h"
 #include "json/json.h"
+#include "resumption/last_state.h"
 
 namespace resumption {
 
@@ -47,7 +48,7 @@ class ResumptionDataJson : public ResumptionData {
   /**
    * @brief Constructor of ResumptionDataJson
    */
-  ResumptionDataJson();
+  ResumptionDataJson(LastState& last_state);
 
   /**
    * @brief allows to destroy ResumptionDataJson object
@@ -182,6 +183,16 @@ class ResumptionDataJson : public ResumptionData {
   bool DropAppDataResumption(const std::string& device_id,
                              const std::string& app_id) OVERRIDE;
 
+
+  /**
+   * @brief Write json resumption info to file system
+   */
+  void Persist() OVERRIDE;
+
+  resumption::LastState& last_state() const {
+      return last_state_;
+  }
+
  private:
   /**
    * @brief GetFromSavedOrAppend allows to get existed record about application
@@ -234,6 +245,7 @@ class ResumptionDataJson : public ResumptionData {
    */
   bool IsResumptionDataValid(uint32_t index) const;
 
+  LastState& last_state_;
   DISALLOW_COPY_AND_ASSIGN(ResumptionDataJson);
 };
 }  // namespace resumption
diff --git a/src/components/application_manager/src/application_impl.cc b/src/components/application_manager/src/application_impl.cc
index 0ef7385314..67221d192d 100644
--- a/src/components/application_manager/src/application_impl.cc
+++ b/src/components/application_manager/src/application_impl.cc
@@ -43,6 +43,7 @@
 #include "utils/gen_hash.h"
 #include "utils/make_shared.h"
 #include "utils/timer_task_impl.h"
+#include "application_manager/policies/policy_handler_interface.h"
 
 namespace {
 
@@ -754,9 +755,11 @@ bool ApplicationImpl::IsCommandLimitsExceeded(
     // In case of policy table values, there is EVEN limitation for number of
     // commands per minute, e.g. 10 command per minute i.e. 1 command per 6 sec
     case POLICY_TABLE: {
-      uint32_t cmd_limit =
-          application_manager::MessageHelper::GetAppCommandLimit(
-              mobile_app_id_);
+      const policy::PolicyHandlerInterface& policy_handler =
+          ApplicationManagerImpl::instance()->GetPolicyHandler();
+      std::string priority;
+      policy_handler.GetPriority(mobile_app_id(), &priority);
+      uint32_t cmd_limit = policy_handler.GetNotificationsNumber(priority);
 
       if (0 == cmd_limit) {
         return true;
@@ -826,8 +829,9 @@ void ApplicationImpl::UpdateHash() {
 }
 
 void ApplicationImpl::CleanupFiles() {
-  std::string directory_name =
-      profile::Profile::instance()->app_storage_folder();
+  profile::Profile* profile =
+          profile::Profile::instance();
+  std::string directory_name = profile->app_storage_folder();
   directory_name += "/" + folder_name();
 
   if (file_system::DirectoryExists(directory_name)) {
diff --git a/src/components/application_manager/src/application_manager_impl.cc b/src/components/application_manager/src/application_manager_impl.cc
index 66e462a96d..752b6c74f4 100644
--- a/src/components/application_manager/src/application_manager_impl.cc
+++ b/src/components/application_manager/src/application_manager_impl.cc
@@ -59,13 +59,36 @@
 #include "smart_objects/enum_schema_item.h"
 #include "interfaces/HMI_API_schema.h"
 #include "application_manager/application_impl.h"
+#include "media_manager/media_manager.h"
 #include "usage_statistics/counter.h"
+#include "utils/custom_string.h"
 #include <time.h>
 
 namespace {
 int get_rand_from_range(uint32_t from = 0, int to = RAND_MAX) {
   return std::rand() % to + from;
 }
+CREATE_LOGGERPTR_LOCAL(logger_, "ApplicationManager")
+
+//void HandleWrongMessageType(smart_objects::SmartObject& output) {
+//  LOG4CXX_AUTO_TRACE(logger_);
+//  switch (output[strings::params][strings::message_type].asInt()) {
+//    case application_manager::MessageType::kNotification: {
+//      LOG4CXX_ERROR(logger_, "Ignore wrong HMI notification");
+//    }
+//    case application_manager::MessageType::kRequest: {
+//      LOG4CXX_ERROR(logger_, "Ignore wrong HMI request");
+//    }
+//    default: {
+//      output.erase(strings::msg_params);
+//      output[strings::params][hmi_response::code] =
+//          hmi_apis::Common_Result::INVALID_DATA;
+//      output[strings::msg_params][strings::info] =
+//          std::string("Received invalid data on HMI response");
+//      LOG4CXX_ERROR(logger_, "Received invalid data on HMI response");
+//    }
+//  }
+//}
 }
 
 namespace application_manager {
@@ -100,6 +123,7 @@ ApplicationManagerImpl::ApplicationManagerImpl()
     , media_manager_(NULL)
     , hmi_handler_(NULL)
     , connection_handler_(NULL)
+    , policy_handler_(*profile::Profile::instance())
     , protocol_handler_(NULL)
     , request_ctrl_()
     , hmi_so_factory_(NULL)
@@ -171,10 +195,8 @@ ApplicationManagerImpl::~ApplicationManagerImpl() {
     mobile_so_factory_ = NULL;
   }
   protocol_handler_ = NULL;
-  media_manager_ = NULL;
   LOG4CXX_DEBUG(logger_, "Destroying Policy Handler");
   RemovePolicyObserver(this);
-  policy::PolicyHandler::destroy();
 
   sync_primitives::AutoLock lock(timer_pool_lock_);
   timer_pool_.clear();
@@ -200,11 +222,11 @@ bool ApplicationManagerImpl::Stop() {
     LOG4CXX_ERROR(logger_,
                   "An error occurred during unregistering applications.");
   }
-
   request_ctrl_.DestroyThreadpool();
+
   // for PASA customer policy backup should happen :AllApp(SUSPEND)
   LOG4CXX_DEBUG(logger_, "Unloading policy library.");
-  policy::PolicyHandler::instance()->UnloadPolicyLibrary();
+  GetPolicyHandler().UnloadPolicyLibrary();
 
   return true;
 }
@@ -232,6 +254,10 @@ ApplicationManagerImpl::connection_handler() const {
   return *connection_handler_;
 }
 
+//policy::PolicyHandlerInterface& ApplicationManagerImpl::policy_handler() const {
+//  return
+//}
+
 ApplicationSharedPtr ApplicationManagerImpl::application_by_policy_id(
     const std::string& policy_app_id) const {
   MobileAppIdPredicate finder(policy_app_id);
@@ -321,7 +347,7 @@ std::vector<ApplicationSharedPtr> ApplicationManagerImpl::IviInfoUpdated(
   // i.e. odometer etc
   switch (vehicle_info) {
     case ODOMETER:
-      policy::PolicyHandler::instance()->KmsChanged(value);
+      GetPolicyHandler().KmsChanged(value);
       break;
     default:
       break;
@@ -418,7 +444,7 @@ ApplicationSharedPtr ApplicationManagerImpl::RegisterApplication(
       message[strings::params][strings::connection_key].asInt();
 
   // app_id is SDL "internal" ID
-  // original app_id can be gotten via ApplicationImpl::policy_app_id()
+  // original app_id can be gotten via ApplicationImpl::mobile_app_id()
   uint32_t app_id = 0;
   std::list<int32_t> sessions_list;
   uint32_t device_id = 0;
@@ -438,7 +464,7 @@ ApplicationSharedPtr ApplicationManagerImpl::RegisterApplication(
   }
 
   LOG4CXX_DEBUG(logger_, "Restarting application list update timer");
-  policy::PolicyHandler::instance()->OnAppsSearchStarted();
+  GetPolicyHandler().OnAppsSearchStarted();
   uint32_t timeout =
       profile::Profile::instance()->application_list_update_timeout();
   application_list_update_timer_.Start(timeout, false);
@@ -478,10 +504,10 @@ ApplicationSharedPtr ApplicationManagerImpl::RegisterApplication(
       policy_app_id,
       device_mac,
       app_name,
-      policy::PolicyHandler::instance()->GetStatisticManager()));
+      GetPolicyHandler().GetStatisticManager()));
   if (!application) {
     usage_statistics::AppCounter count_of_rejections_sync_out_of_memory(
-        policy::PolicyHandler::instance()->GetStatisticManager(),
+        GetPolicyHandler().GetStatisticManager(),
         policy_app_id,
         usage_statistics::REJECTIONS_SYNC_OUT_OF_MEMORY);
     ++count_of_rejections_sync_out_of_memory;
@@ -572,7 +598,7 @@ ApplicationSharedPtr ApplicationManagerImpl::RegisterApplication(
   applications_.insert(application);
   applications_list_lock_.Release();
 
-  policy::PolicyHandler::instance()->AddApplication(
+  GetPolicyHandler().AddApplication(
       application->mobile_app_id());
 
   return application;
@@ -758,12 +784,11 @@ void ApplicationManagerImpl::StartAudioPassThruThread(int32_t session_key,
                                                       int32_t audio_type) {
   LOG4CXX_AUTO_TRACE(logger_);
   LOG4CXX_INFO(logger_, "START MICROPHONE RECORDER");
-  if (NULL != media_manager_) {
-    media_manager_->StartMicrophoneRecording(
-        session_key,
-        profile::Profile::instance()->recording_file_name(),
-        max_duration);
-  }
+  DCHECK_OR_RETURN_VOID(media_manager_);
+  media_manager_->StartMicrophoneRecording(
+      session_key,
+      profile::Profile::instance()->recording_file_name(),
+      max_duration);
 }
 
 void ApplicationManagerImpl::SendAudioPassThroughNotification(
@@ -786,9 +811,8 @@ void ApplicationManagerImpl::SendAudioPassThroughNotification(
 void ApplicationManagerImpl::StopAudioPassThru(int32_t application_key) {
   LOG4CXX_AUTO_TRACE(logger_);
   sync_primitives::AutoLock lock(audio_pass_thru_lock_);
-  if (NULL != media_manager_) {
-    media_manager_->StopMicrophoneRecording(application_key);
-  }
+  DCHECK_OR_RETURN_VOID(media_manager_);
+  media_manager_->StopMicrophoneRecording(application_key);
 }
 
 std::string ApplicationManagerImpl::GetDeviceName(
@@ -926,12 +950,12 @@ void ApplicationManagerImpl::OnDeviceListUpdated(
     policy::DeviceInfo device_info;
     device_info.AdoptDeviceType(dev_params.device_connection_type);
 
-    policy::PolicyHandler::instance()->AddDevice(dev_params.device_mac_address,
+    GetPolicyHandler().AddDevice(dev_params.device_mac_address,
                                                  device_info.connection_type);
   }
 
   smart_objects::SmartObjectSPtr msg_params =
-      MessageHelper::CreateDeviceListSO(device_list);
+      MessageHelper::CreateDeviceListSO(device_list, GetPolicyHandler());
   if (!msg_params) {
     LOG4CXX_WARN(logger_, "Failed to create sub-smart object.");
     return;
@@ -956,7 +980,7 @@ void ApplicationManagerImpl::OnFindNewApplicationsRequest() {
   uint32_t timeout =
       profile::Profile::instance()->application_list_update_timeout();
   application_list_update_timer_.Start(timeout, false);
-  policy::PolicyHandler::instance()->OnAppsSearchStarted();
+  GetPolicyHandler().OnAppsSearchStarted();
 }
 
 void ApplicationManagerImpl::SendUpdateAppList() {
@@ -991,10 +1015,10 @@ mobile_apis::HMILevel::eType ApplicationManagerImpl::GetDefaultHmiLevel(
   LOG4CXX_AUTO_TRACE(logger_);
   HMILevel::eType default_hmi = HMILevel::HMI_NONE;
 
-  if (policy::PolicyHandler::instance()->PolicyEnabled()) {
+  if (policy_handler_.PolicyEnabled()) {
     const std::string policy_app_id = application->mobile_app_id();
     std::string default_hmi_string = "";
-    if (policy::PolicyHandler::instance()->GetDefaultHmi(policy_app_id,
+    if (policy_handler_.GetDefaultHmi(policy_app_id,
                                                          &default_hmi_string)) {
       if ("BACKGROUND" == default_hmi_string) {
         default_hmi = HMILevel::HMI_BACKGROUND;
@@ -1299,7 +1323,7 @@ bool ApplicationManagerImpl::OnHandshakeDone(
 
 void ApplicationManagerImpl::OnCertificateUpdateRequired() {
   LOG4CXX_AUTO_TRACE(logger_);
-  policy::PolicyHandler::instance()->OnPTExchangeNeeded();
+  GetPolicyHandler().OnPTExchangeNeeded();
 }
 
 security_manager::SSLContext::HandshakeContext
@@ -1420,7 +1444,7 @@ void ApplicationManagerImpl::SendMessageToMobile(
               (*message)[strings::msg_params][strings::request_type].asUInt());
       if (mobile_apis::RequestType::PROPRIETARY == request_type ||
           mobile_apis::RequestType::HTTP == request_type) {
-        policy::PolicyHandler::instance()->OnUpdateRequestSentToMobile();
+        GetPolicyHandler().OnUpdateRequestSentToMobile();
       }
     }
   }
@@ -1686,7 +1710,8 @@ bool ApplicationManagerImpl::ManageHMICommand(
   return false;
 }
 
-bool ApplicationManagerImpl::Init() {
+bool ApplicationManagerImpl::Init(resumption::LastState& last_state,
+                                  media_manager::MediaManager* media_manager) {
   LOG4CXX_TRACE(logger_, "Init application manager");
   const std::string app_storage_folder =
       profile::Profile::instance()->app_storage_folder();
@@ -1694,9 +1719,15 @@ bool ApplicationManagerImpl::Init() {
       !IsReadWriteAllowed(app_storage_folder, TYPE_STORAGE)) {
     return false;
   }
-  if (!resume_ctrl_.Init()) {
+  if (!resume_ctrl_.Init(last_state)) {
     LOG4CXX_ERROR(logger_, "Problem with initialization of resume controller");
+  }
+  hmi_capabilities_.Init(&last_state);
 
+  if (!(file_system::IsWritingAllowed(app_storage_folder) &&
+        file_system::IsReadingAllowed(app_storage_folder))) {
+    LOG4CXX_ERROR(logger_,
+                  "Storage directory doesn't have read/write permissions");
     return false;
   }
 
@@ -1714,14 +1745,14 @@ bool ApplicationManagerImpl::Init() {
   // In case there is no R/W permissions for this location, SDL just has to
   // log this and proceed
   IsReadWriteAllowed(app_icons_folder, TYPE_ICONS);
-  if (policy::PolicyHandler::instance()->PolicyEnabled()) {
-    if (!policy::PolicyHandler::instance()->LoadPolicyLibrary()) {
+  if (GetPolicyHandler().PolicyEnabled()) {
+    if (!GetPolicyHandler().LoadPolicyLibrary()) {
       LOG4CXX_ERROR(logger_,
                     "Policy library is not loaded. Check LD_LIBRARY_PATH");
       return false;
     }
     LOG4CXX_INFO(logger_, "Policy library is loaded, now initing PT");
-    if (!policy::PolicyHandler::instance()->InitPolicyTable()) {
+    if (!GetPolicyHandler().InitPolicyTable()) {
       LOG4CXX_ERROR(logger_, "Policy table is not initialized.");
       return false;
     }
@@ -1729,7 +1760,7 @@ bool ApplicationManagerImpl::Init() {
     LOG4CXX_WARN(logger_,
                  "System is configured to work without policy functionality.");
   }
-  media_manager_ = media_manager::MediaManagerImpl::instance();
+  media_manager_ = media_manager;
   return true;
 }
 
@@ -2238,7 +2269,7 @@ void ApplicationManagerImpl::CreateApplications(SmartArray& obj_array,
                             policy_app_id,
                             device_mac,
                             appName,
-                            PolicyHandler::instance()->GetStatisticManager()));
+                            GetPolicyHandler().GetStatisticManager()));
     DCHECK_OR_RETURN_VOID(app);
     app->SetShemaUrl(url_scheme);
     app->SetPackageName(package_name);
@@ -2335,12 +2366,12 @@ void ApplicationManagerImpl::set_application_id(const int32_t correlation_id,
 
 void ApplicationManagerImpl::AddPolicyObserver(
     policy::PolicyHandlerObserver* listener) {
-  policy::PolicyHandler::instance()->add_listener(listener);
+  GetPolicyHandler().add_listener(listener);
 }
 
 void ApplicationManagerImpl::RemovePolicyObserver(
     policy::PolicyHandlerObserver* listener) {
-  policy::PolicyHandler::instance()->remove_listener(listener);
+  GetPolicyHandler().remove_listener(listener);
 }
 
 void ApplicationManagerImpl::SetUnregisterAllApplicationsReason(
@@ -2357,8 +2388,8 @@ void ApplicationManagerImpl::HeadUnitReset(
   switch (reason) {
     case mobile_api::AppInterfaceUnregisteredReason::MASTER_RESET: {
       UnregisterAllApplications();
-      policy::PolicyHandler::instance()->ResetPolicyTable();
-      policy::PolicyHandler::instance()->UnloadPolicyLibrary();
+      GetPolicyHandler().ResetPolicyTable();
+      GetPolicyHandler().UnloadPolicyLibrary();
 
       resume_controller().StopSavePersistentDataTimer();
       file_system::remove_directory_content(
@@ -2366,7 +2397,11 @@ void ApplicationManagerImpl::HeadUnitReset(
       break;
     }
     case mobile_api::AppInterfaceUnregisteredReason::FACTORY_DEFAULTS: {
-      policy::PolicyHandler::instance()->ClearUserConsent();
+      GetPolicyHandler().ClearUserConsent();
+
+      resume_controller().StopSavePersistentDataTimer();
+      file_system::remove_directory_content(
+          profile::Profile::instance()->app_storage_folder());
       break;
     }
     default: {
@@ -2701,7 +2736,7 @@ mobile_apis::Result::eType ApplicationManagerImpl::CheckPolicyPermissions(
   LOG4CXX_AUTO_TRACE(logger_);
   // TODO(AOleynik): Remove check of policy_enable, when this flag will be
   // unused in config file
-  if (!policy::PolicyHandler::instance()->PolicyEnabled()) {
+  if (!GetPolicyHandler().PolicyEnabled()) {
     return mobile_apis::Result::SUCCESS;
   }
 
@@ -2715,7 +2750,7 @@ mobile_apis::Result::eType ApplicationManagerImpl::CheckPolicyPermissions(
                                              << " rpc "
                                              << stringified_functionID);
   policy::CheckPermissionResult result;
-  policy::PolicyHandler::instance()->CheckPermissions(policy_app_id,
+  GetPolicyHandler().CheckPermissions(policy_app_id,
                                                       stringified_hmi_level,
                                                       stringified_functionID,
                                                       rpc_params,
@@ -3193,7 +3228,7 @@ bool ApplicationManagerImpl::IsHMICooperating() const {
 void ApplicationManagerImpl::OnApplicationListUpdateTimer() {
   LOG4CXX_DEBUG(logger_, "Application list update timer finished");
   SendUpdateAppList();
-  policy::PolicyHandler::instance()->OnAppsSearchCompleted();
+  GetPolicyHandler().OnAppsSearchCompleted();
 }
 
 void ApplicationManagerImpl::OnTimerSendTTSGlobalProperties() {
diff --git a/src/components/application_manager/src/commands/hmi/add_statistics_info_notification.cc b/src/components/application_manager/src/commands/hmi/add_statistics_info_notification.cc
index 73c9a49def..024ff86b6e 100644
--- a/src/components/application_manager/src/commands/hmi/add_statistics_info_notification.cc
+++ b/src/components/application_manager/src/commands/hmi/add_statistics_info_notification.cc
@@ -31,7 +31,7 @@
  */
 
 #include "application_manager/commands/hmi/add_statistics_info_notification.h"
-#include "application_manager/policies/policy_handler.h"
+#include "application_manager/application_manager_impl.h"
 #include "interfaces/HMI_API.h"
 
 namespace application_manager {
@@ -52,7 +52,7 @@ void AddStatisticsInfoNotification::Run() {
   int type = (*message_)[strings::msg_params][hmi_notification::statistic_type]
       .asInt();
 
-  policy::PolicyHandler::instance()->AddStatisticsInfo(type);
+  application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler().AddStatisticsInfo(type);
 }
 
 }  // namespace commands
diff --git a/src/components/application_manager/src/commands/hmi/get_system_info_response.cc b/src/components/application_manager/src/commands/hmi/get_system_info_response.cc
index 5b1ec94e9d..83b39b2119 100644
--- a/src/components/application_manager/src/commands/hmi/get_system_info_response.cc
+++ b/src/components/application_manager/src/commands/hmi/get_system_info_response.cc
@@ -31,59 +31,56 @@
  */
 #include "application_manager/commands/hmi/get_system_info_response.h"
 #include "application_manager/application_manager_impl.h"
-#include "application_manager/policies/policy_handler.h"
 #include "application_manager/message_helper.h"
 
 namespace application_manager {
-
 namespace commands {
 
-GetSystemInfoResponse::GetSystemInfoResponse(
-  const MessageSharedPtr& message): ResponseFromHMI(message) {
-}
+GetSystemInfoResponse::GetSystemInfoResponse(const MessageSharedPtr& message)
+    : ResponseFromHMI(message) {}
 
-GetSystemInfoResponse::~GetSystemInfoResponse() {
-}
+GetSystemInfoResponse::~GetSystemInfoResponse() {}
 
 void GetSystemInfoResponse::Run() {
   LOG4CXX_AUTO_TRACE(logger_);
+  application_manager::ApplicationManagerImpl* app_manager_inst =
+      application_manager::ApplicationManagerImpl::instance();
+
   const hmi_apis::Common_Result::eType code =
       static_cast<hmi_apis::Common_Result::eType>(
           (*message_)[strings::params][hmi_response::code].asInt());
 
-  std::string ccpu_version;
-  std::string wers_country_code;
-  std::string language;
+  const SystemInfo& info = GetSystemInfo(code);
+
+  // We have to set preloaded flag as false in policy table on any response
+  // of GetSystemInfo (SDLAQ-CRS-2365)
+  app_manager_inst->GetPolicyHandler().OnGetSystemInfo(
+      info.ccpu_version, info.wers_country_code, info.language);
+}
 
-  if (hmi_apis::Common_Result::SUCCESS == code) {
-    ccpu_version =
-        (*message_)[strings::msg_params]["ccpu_version"].asString();
-    wers_country_code =
-        (*message_)[strings::msg_params]["wersCountryCode"].asString();
-    uint32_t lang_code = (*message_)[strings::msg_params]["language"].asUInt();
-    language = application_manager::MessageHelper::CommonLanguageToString(
-        static_cast<hmi_apis::Common_Language::eType>(lang_code));
+const SystemInfo GetSystemInfoResponse::GetSystemInfo(
+    const hmi_apis::Common_Result::eType code) const {
+  SystemInfo info;
 
-    HMICapabilities& hmi_capabilities =
-      ApplicationManagerImpl::instance()->hmi_capabilities();
-    hmi_capabilities.set_ccpu_version(ccpu_version);
-  } else {
+  if (hmi_apis::Common_Result::SUCCESS != code) {
     LOG4CXX_WARN(logger_, "GetSystemError returns an error code " << code);
-
-    // We have to set preloaded flag as false in policy table on any response
-    // of GetSystemInfo (SDLAQ-CRS-2365)
-    const std::string empty_value;
-    policy::PolicyHandler::instance()->OnGetSystemInfo(empty_value,
-                                                       empty_value,
-                                                       empty_value);
-    return;
+    return info;
   }
+  info.ccpu_version =
+      (*message_)[strings::msg_params]["ccpu_version"].asString();
 
-  // We have to set preloaded flag as false in policy table on any response
-  // of GetSystemInfo (SDLAQ-CRS-2365)
-  policy::PolicyHandler::instance()->OnGetSystemInfo(ccpu_version,
-                                                     wers_country_code,
-                                                     language);
+  info.wers_country_code =
+      (*message_)[strings::msg_params]["wersCountryCode"].asString();
+
+  uint32_t lang_code = (*message_)[strings::msg_params]["language"].asUInt();
+  info.language = application_manager::MessageHelper::CommonLanguageToString(
+      static_cast<hmi_apis::Common_Language::eType>(lang_code));
+
+  application_manager::ApplicationManagerImpl::instance()
+      ->hmi_capabilities()
+      .set_ccpu_version(info.ccpu_version);
+
+  return info;
 }
 
 }  // namespace commands
diff --git a/src/components/application_manager/src/commands/hmi/get_urls.cc b/src/components/application_manager/src/commands/hmi/get_urls.cc
index c8a3471675..831c8118ec 100644
--- a/src/components/application_manager/src/commands/hmi/get_urls.cc
+++ b/src/components/application_manager/src/commands/hmi/get_urls.cc
@@ -33,7 +33,6 @@
 #include "application_manager/commands/hmi/get_urls.h"
 #include "application_manager/message.h"
 #include "application_manager/application_manager_impl.h"
-#include "application_manager/policies/policy_handler.h"
 
 namespace application_manager {
 namespace commands {
@@ -49,12 +48,10 @@ void GetUrls::Run() {
   LOG4CXX_AUTO_TRACE(logger_);
   smart_objects::SmartObject& object = *message_;
   object[strings::params][strings::message_type] = MessageType::kResponse;
-  if (policy::PolicyHandler::instance()->PolicyEnabled()) {
+  if (application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler().PolicyEnabled()) {
     policy::EndpointUrls endpoints;
-    policy::PolicyHandler::instance()->GetServiceUrls(
-        object[strings::msg_params][hmi_request::service].asString(),
-        endpoints);
-
+    application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler().GetServiceUrls(
+        object[strings::msg_params][hmi_request::service].asString(), endpoints);
     if (!endpoints.empty()) {
       object[strings::msg_params].erase(hmi_request::service);
 
diff --git a/src/components/application_manager/src/commands/hmi/on_allow_sdl_functionality_notification.cc b/src/components/application_manager/src/commands/hmi/on_allow_sdl_functionality_notification.cc
index 6bb010ed78..dcc7fdc3d7 100644
--- a/src/components/application_manager/src/commands/hmi/on_allow_sdl_functionality_notification.cc
+++ b/src/components/application_manager/src/commands/hmi/on_allow_sdl_functionality_notification.cc
@@ -31,7 +31,7 @@
  */
 
 #include "application_manager/commands/hmi/on_allow_sdl_functionality_notification.h"
-#include "application_manager/policies/policy_handler.h"
+#include "application_manager/application_manager_impl.h"
 
 namespace application_manager {
 
@@ -49,7 +49,7 @@ void OnAllowSDLFunctionalityNotification::Run() {
   if ((*message_)[strings::msg_params].keyExists("device")) {
     device_id = (*message_)[strings::msg_params]["device"]["id"].asString();
   }
-  policy::PolicyHandler::instance()->OnAllowSDLFunctionalityNotification(
+  application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler().OnAllowSDLFunctionalityNotification(
       (*message_)[strings::msg_params][hmi_response::allowed].asBool(),
       device_id);
 }
diff --git a/src/components/application_manager/src/commands/hmi/on_app_permission_consent_notification.cc b/src/components/application_manager/src/commands/hmi/on_app_permission_consent_notification.cc
index 3e39e2c44e..1503b6c98c 100644
--- a/src/components/application_manager/src/commands/hmi/on_app_permission_consent_notification.cc
+++ b/src/components/application_manager/src/commands/hmi/on_app_permission_consent_notification.cc
@@ -34,7 +34,6 @@
 #include "application_manager/commands/hmi/on_app_permission_consent_notification.h"
 #include "application_manager/application_manager_impl.h"
 #include "application_manager/message_helper.h"
-#include "application_manager/policies/policy_handler.h"
 
 namespace application_manager {
 
@@ -82,8 +81,8 @@ void OnAppPermissionConsentNotification::Run() {
 
     permission_consent.consent_source = msg_params["source"].asString();
 
-    policy::PolicyHandler::instance()->OnAppPermissionConsent(
-        connection_key, permission_consent);
+    application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler().OnAppPermissionConsent(connection_key,
+      permission_consent);
   }
 }
 
diff --git a/src/components/application_manager/src/commands/hmi/on_device_state_changed_notification.cc b/src/components/application_manager/src/commands/hmi/on_device_state_changed_notification.cc
index a1d8d753e7..66e20151d1 100644
--- a/src/components/application_manager/src/commands/hmi/on_device_state_changed_notification.cc
+++ b/src/components/application_manager/src/commands/hmi/on_device_state_changed_notification.cc
@@ -32,7 +32,7 @@
 
 #include <algorithm>
 #include "application_manager/commands/hmi/on_device_state_changed_notification.h"
-#include "application_manager/policies/policy_handler.h"
+#include "application_manager/application_manager_impl.h"
 #include "application_manager/message_helper.h"
 #include "interfaces/HMI_API.h"
 #include "encryption/hashing.h"
@@ -106,7 +106,7 @@ void OnDeviceStateChangedNotification::Run() {
       device_id = encryption::MakeHash(bt_mac);
       LOG4CXX_DEBUG(logger_, "Device_id hashed as BT MAC : " << device_id);
     }
-    policy::PolicyHandler::instance()->RemoveDevice(device_id);
+    application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler().RemoveDevice(device_id);
   }
 }
 
diff --git a/src/components/application_manager/src/commands/hmi/on_ignition_cycle_over_notification.cc b/src/components/application_manager/src/commands/hmi/on_ignition_cycle_over_notification.cc
index 32babf05cc..f02433b76a 100644
--- a/src/components/application_manager/src/commands/hmi/on_ignition_cycle_over_notification.cc
+++ b/src/components/application_manager/src/commands/hmi/on_ignition_cycle_over_notification.cc
@@ -31,7 +31,7 @@
  */
 
 #include "application_manager/commands/hmi/on_ignition_cycle_over_notification.h"
-#include "application_manager/policies/policy_handler.h"
+#include "application_manager/application_manager_impl.h"
 
 namespace application_manager {
 
@@ -47,7 +47,7 @@ OnIgnitionCycleOverNotification::~OnIgnitionCycleOverNotification() {
 
 void OnIgnitionCycleOverNotification::Run() {
   LOG4CXX_AUTO_TRACE(logger_);
-  policy::PolicyHandler::instance()->OnIgnitionCycleOver();
+  application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler().OnIgnitionCycleOver();
 }
 
 }  // namespace commands
diff --git a/src/components/application_manager/src/commands/hmi/on_policy_update.cc b/src/components/application_manager/src/commands/hmi/on_policy_update.cc
index 56c544888a..46812df1ee 100644
--- a/src/components/application_manager/src/commands/hmi/on_policy_update.cc
+++ b/src/components/application_manager/src/commands/hmi/on_policy_update.cc
@@ -31,7 +31,7 @@
  */
 
 #include "application_manager/commands/hmi/on_policy_update.h"
-#include "application_manager/policies/policy_handler.h"
+#include "application_manager/application_manager_impl.h"
 
 namespace application_manager {
 namespace commands {
@@ -45,7 +45,7 @@ OnPolicyUpdate::~OnPolicyUpdate() {
 
 void OnPolicyUpdate::Run() {
   LOG4CXX_AUTO_TRACE(logger_);
-  policy::PolicyHandler::instance()->OnPTExchangeNeeded();
+  application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler().OnPTExchangeNeeded();
 }
 
 }  // namespace commands
diff --git a/src/components/application_manager/src/commands/hmi/on_received_policy_update.cc b/src/components/application_manager/src/commands/hmi/on_received_policy_update.cc
index df620effb0..1cd97c639c 100644
--- a/src/components/application_manager/src/commands/hmi/on_received_policy_update.cc
+++ b/src/components/application_manager/src/commands/hmi/on_received_policy_update.cc
@@ -32,7 +32,7 @@
 
 #include <string>
 #include "application_manager/commands/hmi/on_received_policy_update.h"
-#include "application_manager/policies/policy_handler.h"
+#include "application_manager/application_manager_impl.h"
 #include "utils/file_system.h"
 
 namespace application_manager {
@@ -53,8 +53,7 @@ void OnReceivedPolicyUpdate::Run() {
     LOG4CXX_ERROR(logger_, "Failed to read Update file.");
     return;
   }
-  policy::PolicyHandler::instance()->ReceiveMessageFromSDK(file_path,
-                                                           file_content);
+  application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler().ReceiveMessageFromSDK(file_path, file_content);
 }
 
 }  // namespace commands
diff --git a/src/components/application_manager/src/commands/hmi/on_system_error_notification.cc b/src/components/application_manager/src/commands/hmi/on_system_error_notification.cc
index 09a96cc797..a46b6bb479 100644
--- a/src/components/application_manager/src/commands/hmi/on_system_error_notification.cc
+++ b/src/components/application_manager/src/commands/hmi/on_system_error_notification.cc
@@ -31,7 +31,7 @@
  */
 
 #include "application_manager/commands/hmi/on_system_error_notification.h"
-#include "application_manager/policies/policy_handler.h"
+#include "application_manager/application_manager_impl.h"
 #include "interfaces/HMI_API.h"
 
 namespace application_manager {
@@ -52,7 +52,7 @@ void OnSystemErrorNotification::Run() {
   int code = (*message_)[strings::msg_params][hmi_notification::error]
       .asInt();
 
-  policy::PolicyHandler::instance()->OnSystemError(code);
+  application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler().OnSystemError(code);
 }
 
 }  // namespace commands
diff --git a/src/components/application_manager/src/commands/hmi/on_system_info_changed_notification.cc b/src/components/application_manager/src/commands/hmi/on_system_info_changed_notification.cc
index fb5a9abc43..3f9548a286 100644
--- a/src/components/application_manager/src/commands/hmi/on_system_info_changed_notification.cc
+++ b/src/components/application_manager/src/commands/hmi/on_system_info_changed_notification.cc
@@ -31,7 +31,7 @@
  */
 
 #include "application_manager/commands/hmi/on_system_info_changed_notification.h"
-#include "application_manager/policies/policy_handler.h"
+#include "application_manager/application_manager_impl.h"
 #include "application_manager/message_helper.h"
 
 namespace application_manager {
@@ -54,7 +54,7 @@ void OnSystemInfoChangedNotification::Run() {
       application_manager::MessageHelper::CommonLanguageToString(
         static_cast<hmi_apis::Common_Language::eType>(lang_code));
 
-  policy::PolicyHandler::instance()->OnSystemInfoChanged(language);
+  application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler().OnSystemInfoChanged(language);
 }
 
 }  // namespace commands
diff --git a/src/components/application_manager/src/commands/hmi/on_system_request_notification.cc b/src/components/application_manager/src/commands/hmi/on_system_request_notification.cc
index 2977ed1586..a23bfcae8b 100644
--- a/src/components/application_manager/src/commands/hmi/on_system_request_notification.cc
+++ b/src/components/application_manager/src/commands/hmi/on_system_request_notification.cc
@@ -33,7 +33,7 @@
 #include "application_manager/application_impl.h"
 #include "application_manager/application_manager_impl.h"
 #include "application_manager/commands/hmi/on_system_request_notification.h"
-#include "application_manager/policies/policy_handler.h"
+#include "application_manager/policies/policy_handler_interface.h"
 #include "interfaces/MOBILE_API.h"
 #include "utils/macro.h"
 
@@ -65,8 +65,9 @@ void OnSystemRequestNotification::Run() {
 
   ApplicationSharedPtr app;
   if (strings::default_app_id == app_id) {
-    PolicyHandler* policy_handler = PolicyHandler::instance();
-    uint32_t selected_app_id = policy_handler->GetAppIdForSending();
+    const policy::PolicyHandlerInterface& policy_handler = 
+	application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler();
+    uint32_t selected_app_id = policy_handler.GetAppIdForSending();
     if (0 == selected_app_id) {
       LOG4CXX_WARN(logger_,
                    "Can't select application to forward OnSystemRequestNotification");
diff --git a/src/components/application_manager/src/commands/hmi/sdl_activate_app_request.cc b/src/components/application_manager/src/commands/hmi/sdl_activate_app_request.cc
index c1ee4142c5..88341d9ba3 100644
--- a/src/components/application_manager/src/commands/hmi/sdl_activate_app_request.cc
+++ b/src/components/application_manager/src/commands/hmi/sdl_activate_app_request.cc
@@ -31,8 +31,7 @@
  */
 
 #include "application_manager/commands/hmi/sdl_activate_app_request.h"
-#include "application_manager/policies/policy_handler.h"
-#include "application_manager/message_helper.h"
+#include "application_manager/application_manager_impl.h"
 
 namespace application_manager {
 
@@ -91,8 +90,10 @@ void SDLActivateAppRequest::Run() {
     }
     subscribe_on_event(BasicCommunication_OnAppRegistered);
   } else {
-    policy::PolicyHandler::instance()->OnActivateApp(application_id,
-                                                     correlation_id());
+    const uint32_t application_id = app_id();
+    application_manager::ApplicationManagerImpl::instance()
+	->GetPolicyHandler().OnActivateApp(application_id,
+					   correlation_id());
   }
 }
 
@@ -124,8 +125,8 @@ void SDLActivateAppRequest::on_event(const event_engine::Event& event) {
         logger_, "Application not found by HMI app id: " << hmi_application_id);
     return;
   }
-  policy::PolicyHandler::instance()->OnActivateApp(app->app_id(),
-                                                   correlation_id());
+  application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler()
+      .OnActivateApp(app->app_id(), correlation_id());
 }
 
 uint32_t SDLActivateAppRequest::app_id() const {
diff --git a/src/components/application_manager/src/commands/hmi/sdl_get_list_of_permissions_request.cc b/src/components/application_manager/src/commands/hmi/sdl_get_list_of_permissions_request.cc
index a6649b2579..4575c045c3 100644
--- a/src/components/application_manager/src/commands/hmi/sdl_get_list_of_permissions_request.cc
+++ b/src/components/application_manager/src/commands/hmi/sdl_get_list_of_permissions_request.cc
@@ -31,7 +31,7 @@
  */
 
 #include "application_manager/commands/hmi/sdl_get_list_of_permissions_request.h"
-#include "application_manager/policies/policy_handler.h"
+#include "application_manager/application_manager_impl.h"
 
 namespace application_manager {
 
@@ -51,7 +51,7 @@ void SDLGetListOfPermissionsRequest::Run() {
   if ((*message_)[strings::msg_params].keyExists(strings::app_id)) {
     connection_key = (*message_)[strings::msg_params][strings::app_id].asUInt();
   }
-  policy::PolicyHandler::instance()->OnGetListOfPermissions(
+  application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler().OnGetListOfPermissions(
         connection_key,
         (*message_)[strings::params][strings::correlation_id].asUInt());
 }
diff --git a/src/components/application_manager/src/commands/hmi/sdl_get_status_update_request.cc b/src/components/application_manager/src/commands/hmi/sdl_get_status_update_request.cc
index dd977d99f0..00a1d90928 100644
--- a/src/components/application_manager/src/commands/hmi/sdl_get_status_update_request.cc
+++ b/src/components/application_manager/src/commands/hmi/sdl_get_status_update_request.cc
@@ -31,7 +31,7 @@
  */
 
 #include "application_manager/commands/hmi/sdl_get_status_update_request.h"
-#include "application_manager/policies/policy_handler.h"
+#include "application_manager/application_manager_impl.h"
 
 namespace application_manager {
 
@@ -46,7 +46,7 @@ SDLGetStatusUpdateRequest::~SDLGetStatusUpdateRequest() {
 
 void SDLGetStatusUpdateRequest::Run() {
   LOG4CXX_AUTO_TRACE(logger_);
-  policy::PolicyHandler::instance()->OnGetStatusUpdate(
+  application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler().OnGetStatusUpdate(
         (*message_)[strings::params][strings::correlation_id].asUInt());
 }
 
diff --git a/src/components/application_manager/src/commands/hmi/sdl_get_user_friendly_message_request.cc b/src/components/application_manager/src/commands/hmi/sdl_get_user_friendly_message_request.cc
index cdd5c16ed0..b4905d3d1c 100644
--- a/src/components/application_manager/src/commands/hmi/sdl_get_user_friendly_message_request.cc
+++ b/src/components/application_manager/src/commands/hmi/sdl_get_user_friendly_message_request.cc
@@ -33,7 +33,6 @@
 #include "application_manager/commands/hmi/sdl_get_user_friendly_message_request.h"
 #include "application_manager/application_manager_impl.h"
 #include "application_manager/message_helper.h"
-#include "application_manager/policies/policy_handler.h"
 
 namespace application_manager {
 
@@ -82,7 +81,7 @@ void SDLGetUserFriendlyMessageRequest::Run() {
         application_manager::MessageHelper::CommonLanguageToString(ui_language);
   }
 
-  policy::PolicyHandler::instance()->OnGetUserFriendlyMessage(
+    application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler().OnGetUserFriendlyMessage(
         msg_codes, required_language,
         (*message_)[strings::params][strings::correlation_id].asInt());
 }
diff --git a/src/components/application_manager/src/commands/hmi/update_sdl_request.cc b/src/components/application_manager/src/commands/hmi/update_sdl_request.cc
index b03e595e9c..53df9c0584 100644
--- a/src/components/application_manager/src/commands/hmi/update_sdl_request.cc
+++ b/src/components/application_manager/src/commands/hmi/update_sdl_request.cc
@@ -32,7 +32,7 @@
  */
 
 #include "application_manager/commands/hmi/update_sdl_request.h"
-#include "application_manager/policies/policy_handler.h"
+#include "application_manager/application_manager_impl.h"
 
 namespace application_manager {
 
@@ -48,7 +48,7 @@ UpdateSDLRequest::~UpdateSDLRequest() {
 void UpdateSDLRequest::Run() {
   LOG4CXX_AUTO_TRACE(logger_);
 
-  policy::PolicyHandler::instance()->PTExchangeAtUserRequest(
+  application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler().PTExchangeAtUserRequest(
       (*message_)[strings::params][strings::correlation_id].asInt());
 }
 
diff --git a/src/components/application_manager/src/commands/hmi/vi_get_vehicle_data_response.cc b/src/components/application_manager/src/commands/hmi/vi_get_vehicle_data_response.cc
index 0ed0f7f515..9e6fdffe7d 100644
--- a/src/components/application_manager/src/commands/hmi/vi_get_vehicle_data_response.cc
+++ b/src/components/application_manager/src/commands/hmi/vi_get_vehicle_data_response.cc
@@ -31,7 +31,7 @@
  */
 #include "application_manager/commands/hmi/vi_get_vehicle_data_response.h"
 #include "application_manager/event_engine/event.h"
-#include "application_manager/policies/policy_handler.h"
+#include "application_manager/application_manager_impl.h"
 #include "interfaces/HMI_API.h"
 
 namespace application_manager {
@@ -73,7 +73,7 @@ void VIGetVehicleDataResponse::Run() {
     event.set_smart_object(result);
   } else {
     event.set_smart_object(*message_);
-    policy::PolicyHandler::instance()->OnVehicleDataUpdated(*message_);
+    application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler().OnVehicleDataUpdated(*message_);
   }
 
   event.raise();
diff --git a/src/components/application_manager/src/commands/hmi/vi_is_ready_response.cc b/src/components/application_manager/src/commands/hmi/vi_is_ready_response.cc
index 4a79a6d9b9..54f90f02d6 100644
--- a/src/components/application_manager/src/commands/hmi/vi_is_ready_response.cc
+++ b/src/components/application_manager/src/commands/hmi/vi_is_ready_response.cc
@@ -31,7 +31,6 @@
  */
 #include "application_manager/commands/hmi/vi_is_ready_response.h"
 #include "application_manager/application_manager_impl.h"
-#include "application_manager/policies/policy_handler.h"
 
 namespace application_manager {
 
@@ -57,7 +56,7 @@ void VIIsReadyResponse::Run() {
       ApplicationManagerImpl::instance()->hmi_capabilities();
   hmi_capabilities.set_is_ivi_cooperating(is_available);
 
-  policy::PolicyHandler::instance()->OnVIIsReady();
+  application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler().OnVIIsReady();
 }
 
 }  // namespace commands
diff --git a/src/components/application_manager/src/commands/mobile/alert_maneuver_request.cc b/src/components/application_manager/src/commands/mobile/alert_maneuver_request.cc
index bc63669e22..5cfefd06f5 100644
--- a/src/components/application_manager/src/commands/mobile/alert_maneuver_request.cc
+++ b/src/components/application_manager/src/commands/mobile/alert_maneuver_request.cc
@@ -82,7 +82,8 @@ void AlertManeuverRequest::Run() {
   //ProcessSoftButtons checks strings on the contents incorrect character
 
   mobile_apis::Result::eType processing_result =
-      MessageHelper::ProcessSoftButtons((*message_)[strings::msg_params], app);
+      MessageHelper::ProcessSoftButtons((*message_)[strings::msg_params], app,
+          application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler());
 
   if (mobile_apis::Result::SUCCESS != processing_result) {
     LOG4CXX_ERROR(logger_, "Wrong soft buttons parameters!");
diff --git a/src/components/application_manager/src/commands/mobile/alert_request.cc b/src/components/application_manager/src/commands/mobile/alert_request.cc
index 2c0c798fd1..0ef778a128 100644
--- a/src/components/application_manager/src/commands/mobile/alert_request.cc
+++ b/src/components/application_manager/src/commands/mobile/alert_request.cc
@@ -275,7 +275,8 @@ bool AlertRequest::Validate(uint32_t app_id) {
   //ProcessSoftButtons checks strings on the contents incorrect character
 
   mobile_apis::Result::eType processing_result =
-      MessageHelper::ProcessSoftButtons((*message_)[strings::msg_params], app);
+      MessageHelper::ProcessSoftButtons((*message_)[strings::msg_params], app,
+          application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler());
 
   if (mobile_apis::Result::SUCCESS != processing_result) {
     LOG4CXX_ERROR(logger_, "INVALID_DATA!");
diff --git a/src/components/application_manager/src/commands/mobile/change_registration_request.cc b/src/components/application_manager/src/commands/mobile/change_registration_request.cc
index 0109d3235b..a200bdd628 100644
--- a/src/components/application_manager/src/commands/mobile/change_registration_request.cc
+++ b/src/components/application_manager/src/commands/mobile/change_registration_request.cc
@@ -36,7 +36,6 @@
 #include "application_manager/commands/mobile/change_registration_request.h"
 #include "application_manager/application_manager_impl.h"
 #include "application_manager/application_impl.h"
-#include "application_manager/policies/policy_handler.h"
 #include "interfaces/MOBILE_API.h"
 #include "interfaces/HMI_API.h"
 
@@ -454,8 +453,10 @@ bool ChangeRegistrationRequest::IsNicknameAllowed(
   policy::StringArray app_nicknames;
   policy::StringArray app_hmi_types;
 
-  bool init_result = policy::PolicyHandler::instance()->GetInitialAppData(
-      policy_app_id, &app_nicknames, &app_hmi_types);
+  bool init_result =
+      application_manager::ApplicationManagerImpl::instance()
+          ->GetPolicyHandler()
+          .GetInitialAppData(policy_app_id, &app_nicknames, &app_hmi_types);
 
   if (!init_result) {
     LOG4CXX_ERROR(logger_,
@@ -473,7 +474,9 @@ bool ChangeRegistrationRequest::IsNicknameAllowed(
                    "Application name was not found in nicknames list.");
 
       usage_statistics::AppCounter count_of_rejections_nickname_mismatch(
-          policy::PolicyHandler::instance()->GetStatisticManager(),
+          application_manager::ApplicationManagerImpl::instance()
+              ->GetPolicyHandler()
+              .GetStatisticManager(),
           policy_app_id,
           usage_statistics::REJECTIONS_NICKNAME_MISMATCH);
       ++count_of_rejections_nickname_mismatch;
diff --git a/src/components/application_manager/src/commands/mobile/on_system_request_notification.cc b/src/components/application_manager/src/commands/mobile/on_system_request_notification.cc
index f2c3f42fb7..dd938a44a5 100644
--- a/src/components/application_manager/src/commands/mobile/on_system_request_notification.cc
+++ b/src/components/application_manager/src/commands/mobile/on_system_request_notification.cc
@@ -35,7 +35,7 @@
 #include "interfaces/MOBILE_API.h"
 #include "utils/file_system.h"
 #include "application_manager/application_manager_impl.h"
-#include "application_manager/policies/policy_handler.h"
+#include "application_manager/policies/policy_handler_interface.h"
 
 namespace application_manager {
 
@@ -67,9 +67,10 @@ void OnSystemRequestNotification::Run() {
 
   RequestType::eType request_type = static_cast<RequestType::eType>
       ((*message_)[strings::msg_params][strings::request_type].asInt());
-
-  if (!policy::PolicyHandler::instance()->IsRequestTypeAllowed(
-           app->mobile_app_id(), request_type)) {
+  const policy::PolicyHandlerInterface& policy_handler =
+      application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler();
+  if (!policy_handler.IsRequestTypeAllowed(app->mobile_app_id(),
+                                           request_type)) {
     LOG4CXX_WARN(logger_, "Request type "  << request_type
                  <<" is not allowed by policies");
     return;
diff --git a/src/components/application_manager/src/commands/mobile/put_file_request.cc b/src/components/application_manager/src/commands/mobile/put_file_request.cc
index 624587d0ce..44df989fe7 100644
--- a/src/components/application_manager/src/commands/mobile/put_file_request.cc
+++ b/src/components/application_manager/src/commands/mobile/put_file_request.cc
@@ -115,7 +115,9 @@ void PutFileRequest::Run() {
   // Policy table update in json format is currently to be received via PutFile
   // TODO(PV): after latest discussion has to be changed
   if (mobile_apis::FileType::JSON == file_type_) {
-    policy::PolicyHandler::instance()->ReceiveMessageFromSDK(sync_file_name_, binary_data);
+    application_manager::ApplicationManagerImpl::instance()
+        ->GetPolicyHandler()
+        .ReceiveMessageFromSDK(sync_file_name_, binary_data);
   }
 
   offset_ = 0;
diff --git a/src/components/application_manager/src/commands/mobile/register_app_interface_request.cc b/src/components/application_manager/src/commands/mobile/register_app_interface_request.cc
index 8678ea64c7..46d6123875 100644
--- a/src/components/application_manager/src/commands/mobile/register_app_interface_request.cc
+++ b/src/components/application_manager/src/commands/mobile/register_app_interface_request.cc
@@ -40,13 +40,12 @@
 #include "application_manager/application_manager_impl.h"
 #include "application_manager/application_impl.h"
 #include "application_manager/message_helper.h"
-#include "application_manager/policies/policy_handler.h"
 #include "config_profile/profile.h"
 #include "interfaces/MOBILE_API.h"
+#include "application_manager/policies/policy_handler_interface.h"
 #include "utils/make_shared.h"
 
 namespace {
-
 namespace custom_str = utils::custom_string;
 
 mobile_apis::AppHMIType::eType StringToAppHMIType(const std::string& str) {
@@ -219,7 +218,7 @@ void RegisterAppInterfaceRequest::Run() {
     LOG4CXX_ERROR(logger_, "Coincidence check failed.");
     if (mobile_apis::Result::DUPLICATE_NAME == coincidence_result) {
       usage_statistics::AppCounter count_of_rejections_duplicate_name(
-          policy::PolicyHandler::instance()->GetStatisticManager(),
+          GetPolicyHandler().GetStatisticManager(),
           policy_app_id,
           usage_statistics::REJECTIONS_DUPLICATE_NAME);
       ++count_of_rejections_duplicate_name;
@@ -316,9 +315,7 @@ void RegisterAppInterfaceRequest::Run() {
     FillDeviceInfo(&device_info);
   }
 
-  policy::PolicyHandler::instance()->SetDeviceInfo(
-        dev_params.device_mac_address,
-        device_info);
+  GetPolicyHandler().SetDeviceInfo(device_mac, device_info);
 
   SendRegisterAppInterfaceResponseToMobile();
 }
@@ -504,8 +501,11 @@ void RegisterAppInterfaceRequest::SendRegisterAppInterfaceResponseToMobile() {
       hmi_capabilities.phone_call_supported();
   response_params[strings::sdl_version] =
       profile::Profile::instance()->sdl_version();
-  response_params[strings::system_software_version] =
-      hmi_capabilities.ccpu_version();
+  const std::string ccpu_version = hmi_capabilities.ccpu_version();
+
+  if (!ccpu_version.empty()) {
+    response_params[strings::system_software_version] = ccpu_version;
+  }
 
   bool resumption = (*message_)[strings::msg_params].keyExists(strings::hash_id);
 
@@ -564,7 +564,6 @@ void RegisterAppInterfaceRequest::SendOnAppRegisteredNotificationToHMI(
     bool resumption,
     bool need_restore_vr) {
   using namespace smart_objects;
-
   SmartObjectSPtr notification = utils::MakeShared<SmartObject>(SmartType_Map);
   if (!notification) {
     LOG4CXX_ERROR(logger_, "Failed to create smart object");
@@ -596,8 +595,7 @@ void RegisterAppInterfaceRequest::SendOnAppRegisteredNotificationToHMI(
   }
 
   std::string priority;
-  policy::PolicyHandler::instance()->GetPriority(
-      application_impl.mobile_app_id(), &priority);
+  GetPolicyHandler().GetPriority(application_impl.mobile_app_id(), &priority);
   if (!priority.empty()) {
     msg_params[strings::priority] = MessageHelper::GetPriorityCode(priority);
   }
@@ -627,7 +625,8 @@ void RegisterAppInterfaceRequest::SendOnAppRegisteredNotificationToHMI(
   }
 
   std::vector<std::string> request_types =
-      policy::PolicyHandler::instance()->GetAppRequestTypes(
+
+      GetPolicyHandler().GetAppRequestTypes(
           application_impl.mobile_app_id());
 
   application[strings::request_type] = SmartObject(SmartType_Array);
@@ -662,7 +661,7 @@ void RegisterAppInterfaceRequest::SendOnAppRegisteredNotificationToHMI(
   device_info[strings::id] = mac_address;
 
   const policy::DeviceConsent device_consent =
-      policy::PolicyHandler::instance()->GetUserConsentForDevice(mac_address);
+      GetPolicyHandler().GetUserConsentForDevice(mac_address);
   device_info[strings::isSDLAllowed] =
       policy::DeviceConsent::kDeviceAllowed == device_consent;
 
@@ -725,7 +724,7 @@ mobile_apis::Result::eType RegisterAppInterfaceRequest::CheckWithPolicyData() {
   // TODO(AOleynik): Check is necessary to allow register application in case
   // of disabled policy
   // Remove this check, when HMI will support policy
-  if (!policy::PolicyHandler::instance()->PolicyEnabled()) {
+  if (!GetPolicyHandler().PolicyEnabled()) {
     return mobile_apis::Result::WARNINGS;
   }
 
@@ -735,7 +734,7 @@ mobile_apis::Result::eType RegisterAppInterfaceRequest::CheckWithPolicyData() {
 
   std::string mobile_app_id =
       message[strings::msg_params][strings::app_id].asString();
-  const bool init_result = policy::PolicyHandler::instance()->GetInitialAppData(
+  const bool init_result = GetPolicyHandler().GetInitialAppData(
       mobile_app_id, &app_nicknames, &app_hmi_types);
 
   if (!init_result) {
@@ -754,7 +753,7 @@ mobile_apis::Result::eType RegisterAppInterfaceRequest::CheckWithPolicyData() {
       // App should be unregistered, if its name is not present in nicknames
       // list
       usage_statistics::AppCounter count_of_rejections_nickname_mismatch(
-          policy::PolicyHandler::instance()->GetStatisticManager(),
+          GetPolicyHandler().GetStatisticManager(),
           mobile_app_id,
           usage_statistics::REJECTIONS_NICKNAME_MISMATCH);
       ++count_of_rejections_nickname_mismatch;
@@ -1018,6 +1017,11 @@ void RegisterAppInterfaceRequest::SendSubscribeCustomButtonNotification() {
   CreateHMINotification(FunctionID::Buttons_OnButtonSubscription, msg_params);
 }
 
+policy::PolicyHandlerInterface& RegisterAppInterfaceRequest::GetPolicyHandler() {
+  return application_manager::ApplicationManagerImpl::instance()
+      ->GetPolicyHandler();
+}
+
 }  // namespace commands
 
 }  // namespace application_manager
diff --git a/src/components/application_manager/src/commands/mobile/register_app_interface_response.cc b/src/components/application_manager/src/commands/mobile/register_app_interface_response.cc
index 65b6ff071a..8674a62b15 100644
--- a/src/components/application_manager/src/commands/mobile/register_app_interface_response.cc
+++ b/src/components/application_manager/src/commands/mobile/register_app_interface_response.cc
@@ -33,9 +33,9 @@
 
 #include "application_manager/commands/mobile/register_app_interface_response.h"
 #include "interfaces/MOBILE_API.h"
-#include "application_manager/policies/policy_handler.h"
 #include "application_manager/application_manager_impl.h"
 #include "connection_handler/connection_handler.h"
+#include "application_manager/policies/policy_handler_interface.h"
 
 namespace application_manager {
 
@@ -79,16 +79,17 @@ void RegisterAppInterfaceResponse::Run() {
 
   // Sends OnPermissionChange notification to mobile right after RAI response
   // and HMI level set-up
-  policy::PolicyHandler::instance()->OnAppRegisteredOnMobile(
-        application->mobile_app_id());
+  application_manager::ApplicationManagerImpl::instance()
+      ->GetPolicyHandler().OnAppRegisteredOnMobile(application->mobile_app_id());
 }
 
 void RegisterAppInterfaceResponse::SetHeartBeatTimeout(
     uint32_t connection_key, const std::string& mobile_app_id) {
   LOG4CXX_AUTO_TRACE(logger_);
-  policy::PolicyHandler *policy_handler = policy::PolicyHandler::instance();
-  if (policy_handler->PolicyEnabled()) {
-    const uint32_t timeout = policy_handler->HeartBeatTimeout(mobile_app_id);
+  const policy::PolicyHandlerInterface& policy_handler =
+      application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler();
+  if (policy_handler.PolicyEnabled()) {
+    const uint32_t timeout = policy_handler.HeartBeatTimeout(mobile_app_id);
     if (timeout > 0) {
       application_manager::ApplicationManagerImpl::instance()->
           connection_handler().SetHeartBeatTimeout(connection_key, timeout);
diff --git a/src/components/application_manager/src/commands/mobile/scrollable_message_request.cc b/src/components/application_manager/src/commands/mobile/scrollable_message_request.cc
index 1859261e33..72055add18 100644
--- a/src/components/application_manager/src/commands/mobile/scrollable_message_request.cc
+++ b/src/components/application_manager/src/commands/mobile/scrollable_message_request.cc
@@ -84,7 +84,8 @@ void ScrollableMessageRequest::Run() {
   //ProcessSoftButtons checks strings on the contents incorrect character
 
   mobile_apis::Result::eType processing_result =
-      MessageHelper::ProcessSoftButtons((*message_)[strings::msg_params], app);
+      MessageHelper::ProcessSoftButtons((*message_)[strings::msg_params], app,
+          application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler());
 
   if (mobile_apis::Result::SUCCESS != processing_result) {
     LOG4CXX_ERROR(logger_, "Wrong soft buttons parameters!");
diff --git a/src/components/application_manager/src/commands/mobile/show_constant_tbt_request.cc b/src/components/application_manager/src/commands/mobile/show_constant_tbt_request.cc
index 9a73da49e6..20d58d13a1 100644
--- a/src/components/application_manager/src/commands/mobile/show_constant_tbt_request.cc
+++ b/src/components/application_manager/src/commands/mobile/show_constant_tbt_request.cc
@@ -36,6 +36,7 @@
 #include "application_manager/application_manager_impl.h"
 #include "application_manager/application_impl.h"
 #include "application_manager/message_helper.h"
+#include "application_manager/policies/policy_handler_interface.h"
 #include "interfaces/MOBILE_API.h"
 #include "interfaces/HMI_API.h"
 
@@ -82,7 +83,11 @@ void ShowConstantTBTRequest::Run() {
   //ProcessSoftButtons checks strings on the contents incorrect character
 
   mobile_apis::Result::eType processing_result =
-      MessageHelper::ProcessSoftButtons(msg_params, app);
+      MessageHelper::ProcessSoftButtons(
+          msg_params,
+          app,
+          application_manager::ApplicationManagerImpl::instance()
+              ->GetPolicyHandler());
 
   if (mobile_apis::Result::SUCCESS != processing_result) {
     LOG4CXX_ERROR(logger_, "INVALID_DATA!");
diff --git a/src/components/application_manager/src/commands/mobile/show_request.cc b/src/components/application_manager/src/commands/mobile/show_request.cc
index 2b31cf8f38..8335feeb83 100644
--- a/src/components/application_manager/src/commands/mobile/show_request.cc
+++ b/src/components/application_manager/src/commands/mobile/show_request.cc
@@ -79,9 +79,11 @@ void ShowRequest::Run() {
   mobile_apis::Result::eType processing_result = mobile_apis::Result::SUCCESS;
   if(((*message_)[strings::msg_params].keyExists(strings::soft_buttons)) &&
       ((*message_)[strings::msg_params][strings::soft_buttons].length() > 0)) {
-    processing_result =
-        MessageHelper::ProcessSoftButtons((*message_)[strings::msg_params],
-        app);
+    processing_result = MessageHelper::ProcessSoftButtons(
+        (*message_)[strings::msg_params],
+        app,
+        application_manager::ApplicationManagerImpl::instance()
+            ->GetPolicyHandler());
   }
 
   if (mobile_apis::Result::SUCCESS != processing_result) {
diff --git a/src/components/application_manager/src/commands/mobile/system_request.cc b/src/components/application_manager/src/commands/mobile/system_request.cc
index c4c81a837e..3720b98c02 100644
--- a/src/components/application_manager/src/commands/mobile/system_request.cc
+++ b/src/components/application_manager/src/commands/mobile/system_request.cc
@@ -37,7 +37,7 @@ Copyright (c) 2013, Ford Motor Company
 #include "application_manager/commands/mobile/system_request.h"
 #include "application_manager/application_manager_impl.h"
 #include "application_manager/application_impl.h"
-#include "application_manager/policies/policy_handler.h"
+#include "application_manager/policies/policy_handler_interface.h"
 #include "interfaces/MOBILE_API.h"
 #include "config_profile/profile.h"
 #include "utils/file_system.h"
@@ -75,8 +75,10 @@ void SystemRequest::Run() {
       static_cast<mobile_apis::RequestType::eType>(
           (*message_)[strings::msg_params][strings::request_type].asInt());
 
-  if (!policy::PolicyHandler::instance()->IsRequestTypeAllowed(
-          application->mobile_app_id(), request_type)) {
+  const policy::PolicyHandlerInterface& policy_handler =
+      application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler();
+  if (!policy_handler.IsRequestTypeAllowed(
+           application->mobile_app_id(), request_type)) {
     SendResponse(false, mobile_apis::Result::DISALLOWED);
     return;
   }
diff --git a/src/components/application_manager/src/commands/mobile/update_turn_list_request.cc b/src/components/application_manager/src/commands/mobile/update_turn_list_request.cc
index 482e9d7b42..8ed5886e01 100644
--- a/src/components/application_manager/src/commands/mobile/update_turn_list_request.cc
+++ b/src/components/application_manager/src/commands/mobile/update_turn_list_request.cc
@@ -73,7 +73,8 @@ void UpdateTurnListRequest::Run() {
   // ProcessSoftButtons checks strings on the contents incorrect character
 
   mobile_apis::Result::eType processing_result =
-      MessageHelper::ProcessSoftButtons((*message_)[strings::msg_params], app);
+      MessageHelper::ProcessSoftButtons((*message_)[strings::msg_params], app,
+          application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler());
 
   if (mobile_apis::Result::SUCCESS != processing_result) {
     LOG4CXX_ERROR(logger_, "INVALID_DATA!");
diff --git a/src/components/application_manager/src/hmi_capabilities.cc b/src/components/application_manager/src/hmi_capabilities.cc
index 96d4a39aeb..858c07641d 100644
--- a/src/components/application_manager/src/hmi_capabilities.cc
+++ b/src/components/application_manager/src/hmi_capabilities.cc
@@ -232,11 +232,6 @@ HMICapabilities::HMICapabilities(ApplicationManagerImpl* const app_mngr)
     , is_navigation_supported_(false)
     , is_phone_call_supported_(false)
     , app_mngr_(app_mngr) {
-  if (false == load_capabilities_from_file()) {
-    LOG4CXX_ERROR(logger_, "file hmi_capabilities.json was not loaded");
-  } else {
-    LOG4CXX_INFO(logger_, "file hmi_capabilities.json was loaded");
-  }
   if (false == profile::Profile::instance()->launch_hmi()) {
     is_vr_ready_response_recieved_ = true;
     is_tts_ready_response_recieved_ = true;
@@ -250,9 +245,6 @@ HMICapabilities::HMICapabilities(ApplicationManagerImpl* const app_mngr)
     is_navi_cooperating_ = true;
     is_ivi_cooperating_ = true;
   }
-
-  hmi_language_handler_.set_default_capabilities_languages(
-        ui_language_, vr_language_, tts_language_);
 }
 
 HMICapabilities::~HMICapabilities() {
@@ -572,7 +564,18 @@ void HMICapabilities::set_navigation_supported(bool supported) {
 }
 
 void HMICapabilities::set_phone_call_supported(bool supported) {
-  is_phone_call_supported_ = supported;
+    is_phone_call_supported_ = supported;
+}
+
+void HMICapabilities::Init(resumption::LastState *last_state) {    
+  hmi_language_handler_.Init(last_state);
+  if (false == load_capabilities_from_file()) {
+    LOG4CXX_ERROR(logger_, "file hmi_capabilities.json was not loaded");
+  } else {
+    LOG4CXX_INFO(logger_, "file hmi_capabilities.json was loaded");
+  }
+  hmi_language_handler_.set_default_capabilities_languages(
+        ui_language_, vr_language_, tts_language_);
 }
 
 bool HMICapabilities::load_capabilities_from_file() {
diff --git a/src/components/application_manager/src/hmi_language_handler.cc b/src/components/application_manager/src/hmi_language_handler.cc
index 8ef9bf9479..e6a58889a7 100644
--- a/src/components/application_manager/src/hmi_language_handler.cc
+++ b/src/components/application_manager/src/hmi_language_handler.cc
@@ -46,18 +46,13 @@ CREATE_LOGGERPTR_GLOBAL(logger_, "ApplicationManager")
 
 namespace application_manager {
 
-HMILanguageHandler::HMILanguageHandler()  :
-    capabilities_ui_language_(hmi_apis::Common_Language::INVALID_ENUM),
-    capabilities_vr_language_(hmi_apis::Common_Language::INVALID_ENUM),
-    capabilities_tts_language_(hmi_apis::Common_Language::INVALID_ENUM),
-    is_ui_language_received_(false),
-    is_vr_language_received_(false),
-    is_tts_language_received_(false) {
-
-  persisted_ui_language_ = get_language_for(INTERFACE_UI);
-  persisted_vr_language_ = get_language_for(INTERFACE_VR);
-  persisted_tts_language_ = get_language_for(INTERFACE_TTS);
-
+HMILanguageHandler::HMILanguageHandler()
+    : capabilities_ui_language_(hmi_apis::Common_Language::INVALID_ENUM)
+    , capabilities_vr_language_(hmi_apis::Common_Language::INVALID_ENUM)
+    , capabilities_tts_language_(hmi_apis::Common_Language::INVALID_ENUM)
+    , is_ui_language_received_(false)
+    , is_vr_language_received_(false)
+    , is_tts_language_received_(false) {
   subscribe_on_event(hmi_apis::FunctionID::BasicCommunication_OnAppRegistered);
 }
 
@@ -79,10 +74,11 @@ void HMILanguageHandler::set_language_for(
     default:
       LOG4CXX_WARN(logger_, "Unknown interface has been passed " << interface);
       return;
-    }
-  LOG4CXX_DEBUG(logger_, "Setting language " << language
-               << " for interface " << interface);
-  resumption::LastState::instance()->dictionary[LanguagesKey][key] = language;
+  }
+  LOG4CXX_DEBUG(logger_,
+                "Setting language " << language << " for interface "
+                                    << interface);
+  last_state_->dictionary[LanguagesKey][key] = language;
   return;
 }
 
@@ -107,11 +103,10 @@ hmi_apis::Common_Language::eType HMILanguageHandler::get_language_for(
       return Common_Language::INVALID_ENUM;
   }
 
-  if (LastState::instance()->dictionary.isMember(LanguagesKey)) {
-    if (LastState::instance()->dictionary[LanguagesKey].isMember(key)) {
-      Common_Language::eType language =
-          static_cast<Common_Language::eType>(
-          LastState::instance()->dictionary[LanguagesKey][key].asInt());
+  if (last_state_->dictionary.isMember(LanguagesKey)) {
+    if (last_state_->dictionary[LanguagesKey].isMember(key)) {
+      Common_Language::eType language = static_cast<Common_Language::eType>(
+          last_state_->dictionary[LanguagesKey][key].asInt());
       return language;
     }
   }
@@ -321,4 +316,12 @@ void HMILanguageHandler::CheckApplication(const Apps::value_type app) {
   }
 }
 
-} // namespace application_manager
+void HMILanguageHandler::Init(resumption::LastState* value) {
+  last_state_ = value;
+  persisted_ui_language_ = get_language_for(INTERFACE_UI);
+  persisted_vr_language_ = get_language_for(INTERFACE_VR);
+  persisted_tts_language_ = get_language_for(INTERFACE_TTS);
+
+}
+
+}  // namespace application_manager
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 809947dea1..ead390ec77 100644
--- a/src/components/application_manager/src/message_helper/message_helper.cc
+++ b/src/components/application_manager/src/message_helper/message_helper.cc
@@ -45,7 +45,8 @@
 #include "application_manager/application.h"
 #include "application_manager/application_manager_impl.h"
 #include "application_manager/commands/command_impl.h"
-#include "application_manager/policies/policy_handler.h"
+#include "application_manager/message_helper.h"
+#include "application_manager/policies/policy_handler_interface.h"
 #include "config_profile/profile.h"
 #include "connection_handler/connection_handler_impl.h"
 #include "interfaces/MOBILE_API.h"
@@ -218,12 +219,6 @@ hmi_apis::Common_Language::eType MessageHelper::CommonLanguageFromString(
   return hmi_apis::Common_Language::INVALID_ENUM;
 }
 
-uint32_t MessageHelper::GetAppCommandLimit(const std::string& policy_app_id) {
-  std::string priority;
-  policy::PolicyHandler::instance()->GetPriority(policy_app_id, &priority);
-  return policy::PolicyHandler::instance()->GetNotificationsNumber(priority);
-}
-
 smart_objects::SmartObjectSPtr MessageHelper::CreateRequestObject() {
   using namespace smart_objects;
 
@@ -262,58 +257,6 @@ smart_objects::SmartObjectSPtr MessageHelper::GetHashUpdateNotification(
   return message;
 }
 
-smart_objects::SmartObject* MessageHelper::GetLockScreenIconUrlNotification(
-    const uint32_t connection_key) {
-  ApplicationSharedPtr app =
-      ApplicationManagerImpl::instance()->application(connection_key);
-  DCHECK(app.get());
-
-  smart_objects::SmartObject* message =
-      new smart_objects::SmartObject(smart_objects::SmartType_Map);
-  (*message)[strings::params][strings::function_id] =
-      mobile_apis::FunctionID::OnSystemRequestID;
-  (*message)[strings::params][strings::connection_key] = connection_key;
-  (*message)[strings::params][strings::message_type] =
-      mobile_apis::messageType::notification;
-  (*message)[strings::params][strings::protocol_type] =
-      commands::CommandImpl::mobile_protocol_type_;
-  (*message)[strings::params][strings::protocol_version] =
-      commands::CommandImpl::protocol_version_;
-
-  (*message)[strings::msg_params][strings::request_type] =
-      mobile_apis::RequestType::LOCK_SCREEN_ICON_URL;
-
-  (*message)[strings::msg_params][strings::url] =
-      policy::PolicyHandler::instance()->GetLockScreenIconUrl();
-
-  return message;
-}
-void MessageHelper::SendLockScreenIconUrlNotification(
-    const uint32_t connection_key) {
-  LOG4CXX_AUTO_TRACE(logger_);
-
-  smart_objects::SmartObject* so =
-      GetLockScreenIconUrlNotification(connection_key);
-  PrintSmartObject(*so);
-  DCHECK(ApplicationManagerImpl::instance()->ManageMobileCommand(so));
-}
-
-void MessageHelper::SendHashUpdateNotification(const uint32_t app_id) {
-  LOG4CXX_AUTO_TRACE(logger_);
-
-  smart_objects::SmartObjectSPtr so = GetHashUpdateNotification(app_id);
-  if (so) {
-    PrintSmartObject(*so);
-    if (!ApplicationManagerImpl::instance()->ManageMobileCommand(so)) {
-      LOG4CXX_ERROR(logger_, "Failed to send HashUpdate notification.");
-    } else {
-      ApplicationManagerImpl::instance()
-          ->resume_controller()
-          .ApplicationsDataUpdated();
-    }
-  }
-}
-
 void MessageHelper::SendOnAppInterfaceUnregisteredNotificationToMobile(
     int32_t connection_key,
     mobile_api::AppInterfaceUnregisteredReason::eType reason) {
@@ -582,7 +525,8 @@ smart_objects::SmartObjectSPtr MessageHelper::CreateBlockedByPoliciesResponse(
 }
 
 smart_objects::SmartObjectSPtr MessageHelper::CreateDeviceListSO(
-    const connection_handler::DeviceMap& devices) {
+    const connection_handler::DeviceMap& devices,
+    const policy::PolicyHandlerInterface& policy_handler) {
   LOG4CXX_AUTO_TRACE(logger_);
   smart_objects::SmartObjectSPtr device_list_so =
       new smart_objects::SmartObject(smart_objects::SmartType_Map);
@@ -601,8 +545,7 @@ smart_objects::SmartObjectSPtr MessageHelper::CreateDeviceListSO(
     list_so[index][strings::id] = it->second.mac_address();
 
     const policy::DeviceConsent device_consent =
-        policy::PolicyHandler::instance()->GetUserConsentForDevice(
-            it->second.mac_address());
+        policy_handler.GetUserConsentForDevice(it->second.mac_address());
     list_so[index][strings::isSDLAllowed] =
         policy::DeviceConsent::kDeviceAllowed == device_consent;
     list_so[index][strings::transport_type] =
@@ -1247,13 +1190,12 @@ smart_objects::SmartObjectSPtr MessageHelper::CreateAddVRCommandToHMI(
 }
 
 bool MessageHelper::CreateHMIApplicationStruct(
-      ApplicationConstSharedPtr app,
-      const protocol_handler::SessionObserver& session_observer,
-      NsSmartDeviceLink::NsSmartObjects::SmartObject* output) {
-  LOG4CXX_AUTO_TRACE(logger_);
-  using smart_objects::SmartObject;
-
-  DCHECK(output);
+    ApplicationConstSharedPtr app,
+    const protocol_handler::SessionObserver& session_observer,
+    const policy::PolicyHandlerInterface& policy_handler,
+    NsSmartDeviceLink::NsSmartObjects::SmartObject* output) {
+  using NsSmartDeviceLink::NsSmartObjects::SmartObject;
+  DCHECK_OR_RETURN(output, false);
   SmartObject& message = *output;
   if (!app) {
     LOG4CXX_WARN(logger_, "Application is not valid");
@@ -1306,7 +1248,7 @@ bool MessageHelper::CreateHMIApplicationStruct(
   message[strings::device_info][strings::name] = device_name;
   message[strings::device_info][strings::id] = mac_address;
   const policy::DeviceConsent device_consent =
-      policy::PolicyHandler::instance()->GetUserConsentForDevice(mac_address);
+      policy_handler.GetUserConsentForDevice(mac_address);
   message[strings::device_info][strings::isSDLAllowed] =
       policy::DeviceConsent::kDeviceAllowed == device_consent;
 
@@ -1383,11 +1325,11 @@ void MessageHelper::SendOnAppUnregNotificationToHMI(
   ApplicationManagerImpl::instance()->ManageHMICommand(notification);
 }
 
-smart_objects::SmartObjectSPtr
-MessageHelper::GetBCActivateAppRequestToHMI(
-      ApplicationConstSharedPtr app,
-     const hmi_apis::Common_HMILevel::eType level,
-     const bool send_policy_priority) {
+smart_objects::SmartObjectSPtr MessageHelper::GetBCActivateAppRequestToHMI(ApplicationConstSharedPtr app,
+    const protocol_handler::SessionObserver& session_observer,
+    const policy::PolicyHandlerInterface &policy_handler,
+    hmi_apis::Common_HMILevel::eType level,
+    bool send_policy_priority) {
   DCHECK_OR_RETURN(app, smart_objects::SmartObjectSPtr());
 
   const uint32_t correlation_id =
@@ -1405,15 +1347,14 @@ MessageHelper::GetBCActivateAppRequestToHMI(
     std::string priority;
     // TODO(KKolodiy): need remove method policy_manager
 
-    policy::PolicyHandler::instance()->GetPriority(app->mobile_app_id(),
+    policy_handler.GetPriority(app->mobile_app_id(),
                                                    &priority);
     // According SDLAQ-CRS-2794
     // SDL have to send ActivateApp without "proirity" parameter to HMI.
     // in case of unconsented device
     const std::string& mac_adress = app->mac_address();
 
-    policy::DeviceConsent consent =
-        policy::PolicyHandler::instance()->GetUserConsentForDevice(mac_adress);
+    policy::DeviceConsent consent = policy_handler.GetUserConsentForDevice(mac_adress);
     if (!priority.empty() &&
         (policy::DeviceConsent::kDeviceAllowed == consent)) {
       (*message)[strings::msg_params][strings::priority] =
@@ -1892,21 +1833,22 @@ void application_manager::MessageHelper::SendQueryApps(
   using namespace mobile_apis;
   using namespace smart_objects;
 
-  policy::PolicyHandler* policy_handler = policy::PolicyHandler::instance();
+  policy::PolicyHandlerInterface& policy_handler =
+      ApplicationManagerImpl::instance()->GetPolicyHandler();
 
   SmartObject* content = new SmartObject(SmartType_Map);
   (*content)[strings::msg_params][strings::request_type] =
       RequestType::QUERY_APPS;
   (*content)[strings::msg_params][strings::url] =
-      policy_handler->RemoteAppsUrl();
+      policy_handler.RemoteAppsUrl();
   (*content)[strings::msg_params][strings::timeout] =
-      policy_handler->TimeoutExchange();
+      policy_handler.TimeoutExchange();
 
   Json::Value http;
   Json::Value& http_header =
       http[http_request::httpRequest][http_request::headers];
 
-  const int timeout = policy_handler->TimeoutExchange();
+  const int timeout = policy_handler.TimeoutExchange();
 
   http_header[http_request::content_type] = "application/json";
   http_header[http_request::connect_timeout] = timeout;
@@ -1928,6 +1870,40 @@ void application_manager::MessageHelper::SendQueryApps(
   SendSystemRequestNotification(connection_key, content);
 }
 
+smart_objects::SmartObjectSPtr MessageHelper::CreateHashUpdateNotification(
+    const uint32_t app_id) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  smart_objects::SmartObjectSPtr message =
+      utils::MakeShared<smart_objects::SmartObject>(
+          smart_objects::SmartType_Map);
+  (*message)[strings::params][strings::function_id] =
+      mobile_apis::FunctionID::OnHashChangeID;
+  (*message)[strings::params][strings::connection_key] = app_id;
+  (*message)[strings::params][strings::message_type] =
+      static_cast<int32_t>(kNotification);
+  return message;
+}
+
+void MessageHelper::SendHashUpdateNotification(const uint32_t app_id) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  ApplicationSharedPtr app =
+      ApplicationManagerImpl::instance()->application(app_id);
+  if (!app) {
+    LOG4CXX_ERROR(logger_, "Application not found by appID");
+    return;
+  }
+  smart_objects::SmartObjectSPtr so = CreateHashUpdateNotification(app_id);
+  PrintSmartObject(*so);
+  if (!ApplicationManagerImpl::instance()->ManageMobileCommand(
+          so, commands::Command::ORIGIN_SDL)) {
+    LOG4CXX_ERROR(logger_, "Failed to send HashUpdate notification.");
+  } else {
+    ApplicationManagerImpl::instance()
+        ->resume_controller()
+        .ApplicationsDataUpdated();
+  }
+}
+
 void MessageHelper::SendOnPermissionsChangeNotification(
     uint32_t connection_key, const policy::Permissions& permissions) {
   utils::SharedPtr<smart_objects::SmartObject> notification =
@@ -2302,21 +2278,20 @@ bool MessageHelper::VerifySoftButtonString(const std::string& str) {
   return true;
 }
 
-bool MessageHelper::CheckWithPolicy(
-    mobile_api::SystemAction::eType system_action,
-    const std::string& app_mobile_id) {
+bool CheckWithPolicy(mobile_api::SystemAction::eType system_action,
+                     const std::string& app_mobile_id,
+                     const policy::PolicyHandlerInterface& policy_handler) {
   using namespace mobile_apis;
   bool result = true;
-  policy::PolicyHandler* policy_handler = policy::PolicyHandler::instance();
-  if (NULL != policy_handler && policy_handler->PolicyEnabled()) {
-    result = policy_handler->CheckSystemAction(system_action, app_mobile_id);
+  if (policy_handler.PolicyEnabled()) {
+    result = policy_handler.CheckSystemAction(system_action, app_mobile_id);
   }
-
   return result;
 }
 
-mobile_apis::Result::eType MessageHelper::ProcessSoftButtons(
-    smart_objects::SmartObject& message_params, ApplicationConstSharedPtr app) {
+mobile_apis::Result::eType MessageHelper::ProcessSoftButtons(smart_objects::SmartObject& message_params,
+    ApplicationConstSharedPtr app,
+    const policy::PolicyHandlerInterface &policy_handler) {
   using namespace mobile_apis;
   using namespace smart_objects;
 
@@ -2340,7 +2315,7 @@ mobile_apis::Result::eType MessageHelper::ProcessSoftButtons(
         request_soft_buttons[i][strings::system_action].asInt();
 
     if (!CheckWithPolicy(static_cast<SystemAction::eType>(system_action),
-                         app->mobile_app_id())) {
+                         app->mobile_app_id(),  policy_handler)) {
       return Result::DISALLOWED;
     }
 
diff --git a/src/components/application_manager/src/policies/delegates/app_permission_delegate.cc b/src/components/application_manager/src/policies/delegates/app_permission_delegate.cc
index 497558d8d2..27052db51e 100644
--- a/src/components/application_manager/src/policies/delegates/app_permission_delegate.cc
+++ b/src/components/application_manager/src/policies/delegates/app_permission_delegate.cc
@@ -31,7 +31,8 @@
  */
 
 #include "application_manager/policies/delegates/app_permission_delegate.h"
-#include "application_manager/policies/policy_handler.h"
+#include "application_manager/application_manager_impl.h"
+#include "application_manager/policies/policy_handler_interface.h"
 
 namespace policy {
   CREATE_LOGGERPTR_GLOBAL(logger_, "PolicyHandler")
@@ -44,7 +45,9 @@ namespace policy {
 
   void AppPermissionDelegate::threadMain() {
   LOG4CXX_AUTO_TRACE(logger_);
-  PolicyHandler::instance()->OnAppPermissionConsentInternal(connection_key_,
+  policy::PolicyHandlerInterface& policy_handler =
+      application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler();
+  policy_handler.OnAppPermissionConsentInternal(connection_key_,
                                                             permissions_);
 }
 
@@ -52,4 +55,4 @@ void AppPermissionDelegate::exitThreadMain() {
   // Do nothing
 }
 
-} // namespace policy
+}  // namespace policy
diff --git a/src/components/application_manager/src/policies/delegates/statistics_delegate.cc b/src/components/application_manager/src/policies/delegates/statistics_delegate.cc
index 26a1df2e3c..4fe765688f 100644
--- a/src/components/application_manager/src/policies/delegates/statistics_delegate.cc
+++ b/src/components/application_manager/src/policies/delegates/statistics_delegate.cc
@@ -35,61 +35,61 @@
 
 CREATE_LOGGERPTR_GLOBAL(logger_, "PolicyHandler")
 namespace policy {
-  StatisticsDelegate::StatisticsDelegate(usage_statistics::GlobalCounterId type)
-    : type_(INCREMENT_GLOBAL),
-      global_counter_(type),
-      app_id_(""),
-      value_(""),
-      timespan_seconds_(0) {
-
-  }
-
-  StatisticsDelegate::StatisticsDelegate(const std::string& app_id,
+StatisticsDelegate::StatisticsDelegate(PolicyHandler& policy_handler,
+                                       usage_statistics::GlobalCounterId type)
+    : type_(INCREMENT_GLOBAL)
+    , global_counter_(type)
+    , app_id_("")
+    , value_("")
+    , timespan_seconds_(0)
+    , policy_handler_(policy_handler) {}
+
+StatisticsDelegate::StatisticsDelegate(PolicyHandler& policy_handler,
+                                       const std::string& app_id,
                                        usage_statistics::AppCounterId type)
-    : type_(INCREMENT_APP),
-      app_counter_(type),
-      app_id_(app_id),
-      value_(""),
-      timespan_seconds_(0) {
-
-  }
-
-  StatisticsDelegate::StatisticsDelegate(const std::string& app_id,
+    : type_(INCREMENT_APP)
+    , app_counter_(type)
+    , app_id_(app_id)
+    , value_("")
+    , timespan_seconds_(0)
+    , policy_handler_(policy_handler) {}
+
+StatisticsDelegate::StatisticsDelegate(PolicyHandler& policy_handler,
+                                       const std::string& app_id,
                                        usage_statistics::AppInfoId type,
                                        const std::string& value)
-    : type_(SET),
-      app_info_(type),
-      app_id_(app_id),
-      value_(value),
-      timespan_seconds_(0) {
-
-  }
-
-  StatisticsDelegate::StatisticsDelegate(const std::string& app_id,
+    : type_(SET)
+    , app_info_(type)
+    , app_id_(app_id)
+    , value_(value)
+    , timespan_seconds_(0)
+    , policy_handler_(policy_handler) {}
+
+StatisticsDelegate::StatisticsDelegate(PolicyHandler& policy_handler,
+                                       const std::string& app_id,
                                        usage_statistics::AppStopwatchId type,
                                        int32_t timespan_seconds)
-    : type_(ADD),
-      stop_watch_(type),
-      app_id_(app_id),
-      value_(""),
-      timespan_seconds_(timespan_seconds) {
-
-  }
+    : type_(ADD)
+    , stop_watch_(type)
+    , app_id_(app_id)
+    , value_("")
+    , timespan_seconds_(timespan_seconds)
+    , policy_handler_(policy_handler) {}
 
   void StatisticsDelegate::threadMain() {
     LOG4CXX_AUTO_TRACE(logger_);
     switch (type_) {
       case INCREMENT_GLOBAL:
-        PolicyHandler::instance()->Increment(global_counter_);
+        policy_handler_.Increment(global_counter_);
         break;
       case INCREMENT_APP:
-        PolicyHandler::instance()->Increment(app_id_, app_counter_);
+        policy_handler_.Increment(app_id_, app_counter_);
         break;
       case SET:
-        PolicyHandler::instance()->Set(app_id_, app_info_, value_);
+        policy_handler_.Set(app_id_, app_info_, value_);
         break;
       case ADD:
-        PolicyHandler::instance()->Add(app_id_, stop_watch_, timespan_seconds_);
+        policy_handler_.Add(app_id_, stop_watch_, timespan_seconds_);
         break;
       default:
         LOG4CXX_ERROR(logger_,"Unknown statistics operator");
diff --git a/src/components/application_manager/src/policies/policy_handler.cc b/src/components/application_manager/src/policies/policy_handler.cc
index 60a90f545e..098f0cfeec 100644
--- a/src/components/application_manager/src/policies/policy_handler.cc
+++ b/src/components/application_manager/src/policies/policy_handler.cc
@@ -49,7 +49,6 @@
 #include "utils/date_time.h"
 #include "json/value.h"
 #include "json/writer.h"
-#include "config_profile/profile.h"
 #include "application_manager/usage_statistics.h"
 #include "policy/policy_types.h"
 #include "interfaces/MOBILE_API.h"
@@ -276,16 +275,15 @@ struct PermissionsConsolidator {
   std::vector<policy::FunctionalGroupPermission> consolidated_permissions_;
 };
 
-PolicyHandler* PolicyHandler::instance_ = NULL;
 const std::string PolicyHandler::kLibrary = "libPolicy.so";
 
-PolicyHandler::PolicyHandler()
-
+PolicyHandler::PolicyHandler(const PolicySettings& settings)
     : AsyncRunner("PolicyHandler async runner thread")
     , dl_handle_(0)
     , last_activated_app_id_(0)
     , app_to_device_link_lock_(true)
-    , statistic_manager_impl_(utils::MakeShared<StatisticManagerImpl>()) {}
+    , statistic_manager_impl_(utils::MakeShared<StatisticManagerImpl>(this))
+    , settings_(settings) {}
 
 PolicyHandler::~PolicyHandler() {}
 
@@ -314,8 +312,8 @@ bool PolicyHandler::LoadPolicyLibrary() {
   return policy_manager_.valid();
 }
 
-bool PolicyHandler::PolicyEnabled() {
-  return profile::Profile::instance()->enable_policy();
+bool PolicyHandler::PolicyEnabled() const{
+  return get_settings().enable_policy();
 }
 
 bool PolicyHandler::CreateManager() {
@@ -331,17 +329,20 @@ bool PolicyHandler::CreateManager() {
   return policy_manager_.valid();
 }
 
+const PolicySettings& PolicyHandler::get_settings() const {
+  return settings_;
+}
+
 bool PolicyHandler::InitPolicyTable() {
-  LOG4CXX_AUTO_TRACE(logger_);
-  POLICY_LIB_CHECK(false);
+    LOG4CXX_AUTO_TRACE(logger_);
+    POLICY_LIB_CHECK(false);
   // Subscribing to notification for system readiness to be able to get system
   // info necessary for policy table
   event_observer_->subscribe_on_event(
       hmi_apis::FunctionID::BasicCommunication_OnReady);
-  std::string preloaded_file =
-      profile::Profile::instance()->preloaded_pt_file();
+  const std::string& preloaded_file = get_settings().preloaded_pt_file();
   if (file_system::FileExists(preloaded_file)) {
-    return policy_manager_->InitPT(preloaded_file);
+    return policy_manager_->InitPT(preloaded_file, &get_settings());
   }
   LOG4CXX_FATAL(logger_, "The file which contains preloaded PT is not exist");
   return false;
@@ -350,8 +351,7 @@ bool PolicyHandler::InitPolicyTable() {
 bool PolicyHandler::ResetPolicyTable() {
   LOG4CXX_TRACE(logger_, "Reset policy table.");
   POLICY_LIB_CHECK(false);
-  std::string preloaded_file =
-      profile::Profile::instance()->preloaded_pt_file();
+  const std::string& preloaded_file =get_settings().preloaded_pt_file();
   if (file_system::FileExists(preloaded_file)) {
     return policy_manager_->ResetPT(preloaded_file);
   }
@@ -365,7 +365,8 @@ bool PolicyHandler::ClearUserConsent() {
   return policy_manager_->ResetUserConsent();
 }
 
-uint32_t PolicyHandler::GetAppIdForSending() {
+uint32_t PolicyHandler::GetAppIdForSending() const {
+  POLICY_LIB_CHECK(0);
   ApplicationManagerImpl::ApplicationListAccessor accessor;
   HmiLevelOrderedApplicationList app_list(accessor.begin(), accessor.end());
 
@@ -460,7 +461,7 @@ void PolicyHandler::AddDevice(const std::string& device_id,
   policy_manager_->AddDevice(device_id, connection_type);
 }
 
-void PolicyHandler::SetDeviceInfo(std::string& device_id,
+void PolicyHandler::SetDeviceInfo(const std::string& device_id,
                                   const DeviceInfo& device_info) {
   LOG4CXX_AUTO_TRACE(logger_);
   POLICY_LIB_CHECK_VOID();
@@ -1062,12 +1063,8 @@ void PolicyHandler::OnPermissionsUpdated(const std::string& policy_app_id,
 
 bool PolicyHandler::SaveSnapshot(const BinaryMessage& pt_string,
                                  std::string& snap_path) {
-  using namespace profile;
-
-  const std::string& policy_snapshot_file_name =
-      Profile::instance()->policies_snapshot_file_name();
-  const std::string& system_files_path =
-      Profile::instance()->system_files_path();
+  const std::string& policy_snapshot_file_name = get_settings().policies_snapshot_file_name();
+  const std::string& system_files_path = get_settings().system_files_path();
   snap_path = system_files_path + '/' + policy_snapshot_file_name;
 
   bool result = false;
@@ -1094,7 +1091,7 @@ void PolicyHandler::OnSnapshotCreated(const BinaryMessage& pt_string) {
 }
 
 bool PolicyHandler::GetPriority(const std::string& policy_app_id,
-                                std::string* priority) {
+                                std::string* priority) const {
   POLICY_LIB_CHECK(false);
   return policy_manager_->GetPriority(policy_app_id, priority);
 }
@@ -1108,19 +1105,19 @@ void PolicyHandler::CheckPermissions(const PTString& app_id,
   policy_manager_->CheckPermissions(app_id, hmi_level, rpc, rpc_params, result);
 }
 
-uint32_t PolicyHandler::GetNotificationsNumber(const std::string& priority) {
+uint32_t PolicyHandler::GetNotificationsNumber(const std::string& priority) const {
   POLICY_LIB_CHECK(0);
   return policy_manager_->GetNotificationsNumber(priority);
 }
 
 DeviceConsent PolicyHandler::GetUserConsentForDevice(
-    const std::string& device_id) {
+    const std::string& device_id) const {
   POLICY_LIB_CHECK(kDeviceDisallowed);
   return policy_manager_->GetUserConsentForDevice(device_id);
 }
 
 bool PolicyHandler::GetDefaultHmi(const std::string& policy_app_id,
-                                  std::string* default_hmi) {
+                                  std::string* default_hmi) const {
   POLICY_LIB_CHECK(false);
   return policy_manager_->GetDefaultHmi(policy_app_id, default_hmi);
 }
@@ -1130,7 +1127,7 @@ bool PolicyHandler::GetInitialAppData(const std::string& application_id,
                                       StringArray* app_hmi_types) {
   POLICY_LIB_CHECK(false);
   return policy_manager_->GetInitialAppData(
-      application_id, nicknames, app_hmi_types);
+        application_id, nicknames, app_hmi_types);
 }
 
 void PolicyHandler::GetServiceUrls(const std::string& service_type,
@@ -1139,17 +1136,12 @@ void PolicyHandler::GetServiceUrls(const std::string& service_type,
   policy_manager_->GetServiceUrls(service_type, end_points);
 }
 
-std::string PolicyHandler::GetLockScreenIconUrl() const {
-  POLICY_LIB_CHECK(std::string(""));
-  return policy_manager_->GetLockScreenIconUrl();
-}
-
 void PolicyHandler::ResetRetrySequence() {
   POLICY_LIB_CHECK_VOID();
   policy_manager_->ResetRetrySequence();
 }
 
-uint32_t PolicyHandler::NextRetryTimeout() {
+int PolicyHandler::NextRetryTimeout() {
   POLICY_LIB_CHECK(0);
   return policy_manager_->NextRetryTimeout();
 }
@@ -1191,7 +1183,7 @@ void PolicyHandler::remove_listener(PolicyHandlerObserver* listener) {
 }
 
 utils::SharedPtr<usage_statistics::StatisticsManager>
-PolicyHandler::GetStatisticManager() {
+PolicyHandler::GetStatisticManager() const {
   return statistic_manager_impl_;
 }
 
@@ -1284,19 +1276,19 @@ void PolicyHandler::OnUpdateRequestSentToMobile() {
   policy_manager_->OnUpdateStarted();
 }
 
-bool PolicyHandler::CheckKeepContext(const std::string& policy_app_id) {
+bool PolicyHandler::CheckKeepContext(const std::string& policy_app_id) const {
   POLICY_LIB_CHECK(false);
   return policy_manager_->CanAppKeepContext(policy_app_id);
 }
 
-bool PolicyHandler::CheckStealFocus(const std::string& policy_app_id) {
+bool PolicyHandler::CheckStealFocus(const std::string& policy_app_id) const {
   POLICY_LIB_CHECK(false);
   return policy_manager_->CanAppStealFocus(policy_app_id);
 }
 
 bool PolicyHandler::CheckSystemAction(
     mobile_apis::SystemAction::eType system_action,
-    const std::string& policy_app_id) {
+    const std::string& policy_app_id) const {
   using namespace mobile_apis;
   LOG4CXX_AUTO_TRACE(logger_);
   switch (system_action) {
diff --git a/src/components/application_manager/src/resumption/resume_ctrl.cc b/src/components/application_manager/src/resumption/resume_ctrl.cc
index 7bec944d44..84dd9a13e8 100644
--- a/src/components/application_manager/src/resumption/resume_ctrl.cc
+++ b/src/components/application_manager/src/resumption/resume_ctrl.cc
@@ -42,7 +42,6 @@
 #include "application_manager/message_helper.h"
 #include "connection_handler/connection.h"
 #include "application_manager/commands/command_impl.h"
-#include "resumption/last_state.h"
 #include "policy/policy_manager_impl.h"
 #include "application_manager/policies/policy_handler.h"
 #include "utils/helpers.h"
@@ -68,7 +67,7 @@ ResumeCtrl::ResumeCtrl()
       is_data_saved_(false),
       launch_time_(time(NULL)) {}
 
-bool ResumeCtrl::Init() {
+bool ResumeCtrl::Init(resumption::LastState& last_state) {
   using namespace profile;
   bool use_db = Profile::instance()->use_db_for_resumption();
   if (use_db) {
@@ -96,7 +95,11 @@ bool ResumeCtrl::Init() {
       db->UpdateDBVersion();
     }
   } else {
-    resumption_storage_.reset(new ResumptionDataJson());
+    resumption_storage_.reset(new ResumptionDataJson(last_state));
+    if (!resumption_storage_->Init()) {
+        LOG4CXX_DEBUG(logger_, "Resumption storage initialisation failed");
+        return false;
+    }
   }
   LoadResumeData();
   save_persistent_data_timer_.Start(
@@ -210,8 +213,9 @@ bool ResumeCtrl::SetAppHMIState(ApplicationSharedPtr application,
                    << check_policy);
   const std::string& device_mac = application->mac_address();
   if (check_policy &&
-      policy::PolicyHandler::instance()->GetUserConsentForDevice(device_mac) !=
-          policy::DeviceConsent::kDeviceAllowed) {
+      ApplicationManagerImpl::instance()->
+          GetPolicyHandler().GetUserConsentForDevice(device_mac) !=
+              policy::DeviceConsent::kDeviceAllowed) {
     LOG4CXX_ERROR(logger_, "Resumption abort. Data consent wasn't allowed");
     SetupDefaultHMILevel(application);
     return false;
@@ -253,7 +257,8 @@ void ResumeCtrl::OnSuspend() {
   LOG4CXX_AUTO_TRACE(logger_);
   StopSavePersistentDataTimer();
   SaveAllApplications();
-  return resumption_storage_->OnSuspend();
+  resumption_storage_->OnSuspend();
+  resumption_storage_->Persist();
 }
 
 void ResumeCtrl::OnAwake() {
@@ -418,7 +423,7 @@ void ResumeCtrl::SaveDataOnTimer() {
     SaveAllApplications();
     is_data_saved_ = true;
     if (!(profile::Profile::instance()->use_db_for_resumption())) {
-      resumption::LastState::instance()->SaveToFileSystem();
+      resumption_storage_->Persist();
     }
   }
 }
diff --git a/src/components/application_manager/src/resumption/resumption_data.cc b/src/components/application_manager/src/resumption/resumption_data.cc
index dfa19550c2..d068945d6b 100644
--- a/src/components/application_manager/src/resumption/resumption_data.cc
+++ b/src/components/application_manager/src/resumption/resumption_data.cc
@@ -43,11 +43,6 @@ ResumptionData::ResumptionData():
   resumption_lock_(true) {
 }
 
-bool ResumptionData::Init() {
-  LOG4CXX_AUTO_TRACE(logger_);
-  return true;
-}
-
 smart_objects::SmartObject ResumptionData::GetApplicationCommands(
     app_mngr::ApplicationConstSharedPtr application) const {
   using namespace app_mngr;
diff --git a/src/components/application_manager/src/resumption/resumption_data_db.cc b/src/components/application_manager/src/resumption/resumption_data_db.cc
index 5f11dca2a0..21c9eed3b4 100644
--- a/src/components/application_manager/src/resumption/resumption_data_db.cc
+++ b/src/components/application_manager/src/resumption/resumption_data_db.cc
@@ -270,7 +270,6 @@ void ResumptionDataDB::OnSuspend() {
       LOG4CXX_INFO(logger_, "Data last_ign_off_time was updated");
     }
   }
-  WriteDb();
 }
 
 bool ResumptionDataDB::DeleteAppWithIgnCount(const int application_lifes) {
@@ -650,6 +649,10 @@ void ResumptionDataDB::UpdateHmiLevel(const std::string& policy_app_id,
   }
 }
 
+void ResumptionDataDB::Persist() {
+    WriteDb();
+}
+
 bool ResumptionDataDB::RefreshDB() const {
   utils::dbms::SQLQuery query(db());
   if (!query.Exec(resumption::kDropSchema)) {
diff --git a/src/components/application_manager/src/resumption/resumption_data_json.cc b/src/components/application_manager/src/resumption/resumption_data_json.cc
index 919f7c051c..62297eb2de 100644
--- a/src/components/application_manager/src/resumption/resumption_data_json.cc
+++ b/src/components/application_manager/src/resumption/resumption_data_json.cc
@@ -36,7 +36,6 @@
 #include "formatters/CFormatterJsonBase.h"
 #include "application_manager/message_helper.h"
 #include "application_manager/smart_object_keys.h"
-#include "resumption/last_state.h"
 #include "config_profile/profile.h"
 
 namespace resumption {
@@ -45,7 +44,8 @@ namespace Formatters = NsSmartDeviceLink::NsJSONHandler::Formatters;
 
 CREATE_LOGGERPTR_GLOBAL(logger_, "Resumption")
 
-ResumptionDataJson::ResumptionDataJson() : ResumptionData() {}
+ResumptionDataJson::ResumptionDataJson(LastState& last_state)
+    : ResumptionData(), last_state_(last_state) {}
 
 void ResumptionDataJson::SaveApplication(
     app_mngr::ApplicationSharedPtr application) {
@@ -207,7 +207,6 @@ void ResumptionDataJson::OnSuspend() {
   SetSavedApplication(to_save);
   SetLastIgnOffTime(time(NULL));
   LOG4CXX_DEBUG(logger_, GetResumptionData().toStyledString());
-  ::resumption::LastState::instance()->SaveToFileSystem();
 }
 
 void ResumptionDataJson::OnAwake() {
@@ -411,12 +410,12 @@ Json::Value& ResumptionDataJson::GetResumptionData() const {
   using namespace app_mngr;
   LOG4CXX_AUTO_TRACE(logger_);
   sync_primitives::AutoLock autolock(resumption_lock_);
-  Json::Value& last_state = ::resumption::LastState::instance()->dictionary;
-  if (!last_state.isMember(strings::resumption)) {
-    last_state[strings::resumption] = Json::Value(Json::objectValue);
+  Json::Value& dictionary = last_state().dictionary;
+  if (!dictionary.isMember(strings::resumption)) {
+    last_state().dictionary[strings::resumption] = Json::Value(Json::objectValue);
     LOG4CXX_WARN(logger_, "resumption section is missed");
   }
-  Json::Value& resumption = last_state[strings::resumption];
+  Json::Value& resumption = dictionary[strings::resumption];
   if (!resumption.isObject()) {
     LOG4CXX_ERROR(logger_, "resumption type INVALID rewrite");
     resumption = Json::Value(Json::objectValue);
@@ -515,5 +514,9 @@ bool ResumptionDataJson::DropAppDataResumption(const std::string& device_id,
   return true;
 }
 
+void ResumptionDataJson::Persist() {
+    last_state().SaveToFileSystem();
+}
+
 
-} // resumption
+}  // resumption
diff --git a/src/components/application_manager/src/state_controller.cc b/src/components/application_manager/src/state_controller.cc
index 6d921db864..800ce285e8 100644
--- a/src/components/application_manager/src/state_controller.cc
+++ b/src/components/application_manager/src/state_controller.cc
@@ -34,6 +34,7 @@
 #include "application_manager/usage_statistics.h"
 #include "utils/helpers.h"
 #include "utils/make_shared.h"
+#include "connection_handler/connection_handler.h"
 
 namespace application_manager {
 
@@ -551,9 +552,13 @@ int64_t StateController::SendBCActivateApp(
     hmi_apis::Common_HMILevel::eType level,
     bool send_policy_priority) {
   LOG4CXX_AUTO_TRACE(logger_);
+  connection_handler::ConnectionHandler& conn_handler =
+      app_mngr_->connection_handler();
   smart_objects::SmartObjectSPtr bc_activate_app_request =
       MessageHelper::GetBCActivateAppRequestToHMI(
           app,
+          conn_handler.get_session_observer(),
+          app_mngr_->GetPolicyHandler(),
           level,
           send_policy_priority);
   if (!bc_activate_app_request) {
diff --git a/src/components/application_manager/src/usage_statistics.cc b/src/components/application_manager/src/usage_statistics.cc
index 12ae4df909..9483703f37 100644
--- a/src/components/application_manager/src/usage_statistics.cc
+++ b/src/components/application_manager/src/usage_statistics.cc
@@ -33,7 +33,7 @@
 #include "application_manager/usage_statistics.h"
 #include "smart_objects/smart_object.h"
 #include "smart_objects/enum_schema_item.h"
-#include "usage_statistics/statistics_manager.h"
+#include "policy/usage_statistics/statistics_manager.h"
 #include "utils/macro.h"
 #include "utils/make_shared.h"
 
diff --git a/src/components/include/application_manager/policies/policy_handler_interface.h b/src/components/include/application_manager/policies/policy_handler_interface.h
new file mode 100644
index 0000000000..1298350718
--- /dev/null
+++ b/src/components/include/application_manager/policies/policy_handler_interface.h
@@ -0,0 +1,382 @@
+/*
+ * Copyright (c) 2015, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICY_HANDLER_INTERFACE_H_
+#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICY_HANDLER_INTERFACE_H_
+
+#include <string>
+#include <map>
+#include <set>
+#include <vector>
+#include <queue>
+#include "interfaces/MOBILE_API.h"
+#include "policy/policy_types.h"
+#include "application_manager/policies/policy_handler_observer.h"
+#include "policy/usage_statistics/statistics_manager.h"
+#include "utils/custom_string.h"
+#include "policy/policy_settings.h"
+#include "smart_objects/smart_object.h"
+
+namespace policy {
+namespace smart_objects = NsSmartDeviceLink::NsSmartObjects;
+class PolicyHandlerInterface {
+ public:
+  virtual ~PolicyHandlerInterface() {}
+
+  virtual bool LoadPolicyLibrary() = 0;
+  virtual bool PolicyEnabled() const = 0;
+  virtual bool InitPolicyTable() = 0;
+  virtual bool ResetPolicyTable() = 0;
+  virtual bool ClearUserConsent() = 0;
+  virtual bool SendMessageToSDK(const BinaryMessage& pt_string,
+                                const std::string& url) = 0;
+  virtual bool ReceiveMessageFromSDK(const std::string& file,
+                                     const BinaryMessage& pt_string) = 0;
+  virtual bool UnloadPolicyLibrary() = 0;
+  virtual void OnPermissionsUpdated(const std::string& policy_app_id,
+                                    const Permissions& permissions,
+                                    const HMILevel& default_hmi) = 0;
+
+  virtual void OnPermissionsUpdated(const std::string& policy_app_id,
+                                    const Permissions& permissions) = 0;
+
+  virtual bool GetPriority(const std::string& policy_app_id,
+                           std::string* priority) const = 0;
+  virtual void CheckPermissions(const PTString& app_id,
+                                const PTString& hmi_level, const PTString& rpc,
+                                const RPCParams& rpc_params,
+                                CheckPermissionResult& result) = 0;
+
+  virtual uint32_t GetNotificationsNumber(
+      const std::string& priority) const = 0;
+  virtual DeviceConsent GetUserConsentForDevice(
+      const std::string& device_id) const = 0;
+  virtual bool GetDefaultHmi(const std::string& policy_app_id,
+                             std::string* default_hmi) const = 0;
+  virtual bool GetInitialAppData(const std::string& application_id,
+                                 StringArray* nicknames = NULL,
+                                 StringArray* app_hmi_types = NULL) = 0;
+  virtual void GetServiceUrls(const std::string& service_type,
+                              EndpointUrls& end_points) = 0;
+  virtual void ResetRetrySequence() = 0;
+  virtual int NextRetryTimeout() = 0;
+  virtual int TimeoutExchange() = 0;
+  virtual void OnExceededTimeout() = 0;
+  virtual void OnSystemReady() = 0;
+  virtual void PTUpdatedAt(Counters counter, int value) = 0;
+  virtual void add_listener(PolicyHandlerObserver* listener) = 0;
+  virtual void remove_listener(PolicyHandlerObserver* listener) = 0;
+
+  virtual utils::SharedPtr<usage_statistics::StatisticsManager>
+  GetStatisticManager() const = 0;
+
+  /**
+   * @brief CheckSystemAction allows to check whether certain system
+   * action is enabled.
+   *
+   * @param system_action system action to check.
+   *
+   * @return true if specified system action is enabled, false otherwise.
+   */
+  virtual bool CheckSystemAction(mobile_apis::SystemAction::eType system_action,
+                                 const std::string& policy_app_id) const = 0;
+
+  /**
+   * Lets client to notify PolicyHandler that more kilometers expired
+   * @param kms New value of odometer
+   */
+  virtual void KmsChanged(int kms) = 0;
+
+  /**
+   * @brief Gather information for application and sends it to HMI
+   * @param connection_key Connection key for application
+   */
+  virtual void OnActivateApp(uint32_t connection_key,
+                             uint32_t correlation_id) = 0;
+
+  /**
+   * @brief Process user consent on mobile data connection access
+   * @param Device id or empty string, if concern to all SDL functionality
+   * @param User consent from response
+   */
+  virtual void OnAllowSDLFunctionalityNotification(
+      bool is_allowed, const std::string& device_id) = 0;
+
+  /**
+   * @brief Increment counter for ignition cycles
+   */
+  virtual void OnIgnitionCycleOver() = 0;
+
+  virtual void OnPendingPermissionChange(const std::string& policy_app_id) = 0;
+
+  /**
+   * Initializes PT exchange at user request
+   * @param correlation_id correlation id of request
+   */
+  virtual void PTExchangeAtUserRequest(uint32_t correlation_id) = 0;
+
+  /**
+   * @brief Add's device to policy table
+   * @param device_id        Device mac address
+   * @param connection_type  Device connection type
+   */
+  virtual void AddDevice(const std::string& device_id,
+                         const std::string& connection_type) = 0;
+
+  /**
+   * @brief Save device info for specific device to policy table
+   * @param device_id Device mac address
+   * @param device_info Device params
+   */
+  virtual void SetDeviceInfo(const std::string& device_id,
+                             const DeviceInfo& device_info) = 0;
+
+  /**
+   * @brief Store user-changed permissions consent to DB
+   * @param connection_key Connection key of application or 0, if permissions
+   * should be applied to all applications
+   * @param permissions User-changed group permissions consent
+   */
+  virtual void OnAppPermissionConsent(const uint32_t connection_key,
+                                      const PermissionConsent& permissions) = 0;
+
+  /**
+   * @brief Get appropriate message parameters and send them with response
+   * to HMI
+   * @param message_codes RPC message codes
+   * @param language Language
+   * @param correlation_id correlation id of request
+   */
+  virtual void OnGetUserFriendlyMessage(
+      const std::vector<std::string>& message_codes,
+      const std::string& language, uint32_t correlation_id) = 0;
+
+  /**
+   * @brief Get list of permissions for application/device binded to
+   * connection key from request and send response
+   * @param connection_key Connection key for specific application or 0 for all
+   * currently registered applications
+   * @param correlation_id Correlation id from request
+   */
+  virtual void OnGetListOfPermissions(const uint32_t connection_key,
+                                      const uint32_t correlation_id) = 0;
+
+  /**
+   * @brief Get current policy table update state and send response
+   * @param correlation_id Correlation id from request
+   */
+  virtual void OnGetStatusUpdate(const uint32_t correlation_id) = 0;
+
+  /**
+   * @brief Send notification to HMI with changed policy update status
+   * @param status Current policy update state
+   */
+  virtual void OnUpdateStatusChanged(const std::string& status) = 0;
+
+  /**
+   * @brief Update currently used device id in policies manager for given
+   * application
+   * @param policy_app_id Application id
+   */
+  virtual std::string OnCurrentDeviceIdUpdateRequired(
+      const std::string& policy_app_id) = 0;
+
+  /**
+   * @brief Set parameters from OnSystemInfoChanged to policy table
+   * @param language System language
+   */
+  virtual void OnSystemInfoChanged(const std::string& language) = 0;
+
+  /**
+   * @brief Save data from GetSystemInfo request to policy table
+   * @param ccpu_version CCPU version
+   * @param wers_country_code WERS country code
+   * @param language System language
+   */
+  virtual void OnGetSystemInfo(const std::string& ccpu_version,
+                               const std::string& wers_country_code,
+                               const std::string& language) = 0;
+
+  /**
+   * @brief Send request to HMI to get update on system parameters
+   */
+  virtual void OnSystemInfoUpdateRequired() = 0;
+
+  /**
+   * @brief Sends GetVehicleData request in case when Vechicle info is ready.
+   */
+  virtual void OnVIIsReady() = 0;
+
+  /**
+   * @brief Allows to update vechicle data info.
+   * @param SmartObject which contains all needed information.
+   */
+  virtual void OnVehicleDataUpdated(
+      const smart_objects::SmartObject& message) = 0;
+
+  /**
+   * Removes device
+   * @param device_id id of device
+   */
+  virtual void RemoveDevice(const std::string& device_id) = 0;
+
+  /**
+   * Adds statistics info
+   * @param type type of info
+   */
+  virtual void AddStatisticsInfo(int type) = 0;
+
+  /**
+   * Handles system error
+   * @param code code of error
+   */
+  virtual void OnSystemError(int code) = 0;
+
+  /**
+   * @brief Choose application id to be used for snapshot sending
+   * @return Application id or 0, if there are no applications registered
+   */
+  virtual uint32_t GetAppIdForSending() const = 0;
+
+  virtual utils::custom_string::CustomString GetAppName(
+      const std::string& policy_app_id) = 0;
+
+  virtual void OnUpdateHMIAppType(
+      std::map<std::string, StringArray> app_hmi_types) = 0;
+
+  virtual void OnCertificateUpdated(const std::string& certificate_data) = 0;
+
+  virtual bool CanUpdate() = 0;
+
+  virtual void OnDeviceConsentChanged(const std::string& device_id,
+                                      bool is_allowed) = 0;
+
+  virtual void OnPTExchangeNeeded() = 0;
+
+  virtual void GetAvailableApps(std::queue<std::string>& apps) = 0;
+
+  /**
+   * @brief Allows to add new or update existed application during
+   * registration process
+   * @param application_id The policy aplication id.
+   */
+  virtual void AddApplication(const std::string& application_id) = 0;
+
+  /**
+   * Checks whether application is revoked
+   * @param app_id id application
+   * @return true if application is revoked
+   */
+  virtual bool IsApplicationRevoked(const std::string& app_id) = 0;
+
+  /**
+   * @brief Notifies policy manager, that PTS was sent out
+   */
+  virtual void OnUpdateRequestSentToMobile() = 0;
+
+  /**
+   * Returns heart beat timeout
+   * @param app_id application id
+   * @return if timeout was set then value in milliseconds greater zero
+   * otherwise heart beat for specific application isn't set
+   */
+  virtual uint32_t HeartBeatTimeout(const std::string& app_id) const = 0;
+
+  /**
+   * @brief Handler on applications search started
+   */
+  virtual void OnAppsSearchStarted() = 0;
+
+  /**
+   * @brief Handler on applications search completed
+   */
+  virtual void OnAppsSearchCompleted() = 0;
+
+  /**
+   * @brief OnAppRegisteredOnMobile allows to handle event when application were
+   * succesfully registered on mobile device.
+   * It will send OnAppPermissionSend notification and will try to start PTU.
+   *
+   * @param application_id registered application.
+   */
+  virtual void OnAppRegisteredOnMobile(const std::string& application_id) = 0;
+
+  /**
+   * @brief Checks if certain request type is allowed for application
+   * @param policy_app_id Unique applicaion id
+   * @param type Request type
+   * @return true, if allowed, otherwise - false
+   */
+  virtual bool IsRequestTypeAllowed(
+      const std::string& policy_app_id,
+      mobile_apis::RequestType::eType type) const = 0;
+
+  /**
+   * @brief Gets application request types
+   * @param policy_app_id Unique application id
+   * @return request types
+   */
+  virtual const std::vector<std::string> GetAppRequestTypes(
+      const std::string& policy_app_id) const = 0;
+
+  /**
+   * @brief Gets vehicle information
+   * @return Structure with vehicle information
+   */
+  virtual const VehicleInfo GetVehicleInfo() const = 0;
+
+  virtual void Increment(usage_statistics::GlobalCounterId type) = 0;
+  virtual void Increment(const std::string& app_id,
+                         usage_statistics::AppCounterId type) = 0;
+  virtual void Set(const std::string& app_id, usage_statistics::AppInfoId type,
+                   const std::string& value) = 0;
+  virtual void Add(const std::string& app_id,
+                   usage_statistics::AppStopwatchId type,
+                   int32_t timespan_seconds) = 0;
+
+#ifdef ENABLE_SECURITY
+  virtual std::string RetrieveCertificate() const = 0;
+#endif  // ENABLE_SECURITY
+
+  virtual const PolicySettings& get_settings() const = 0;
+  virtual const std::string RemoteAppsUrl() const = 0;
+
+ private:
+   virtual void OnAppPermissionConsentInternal(const uint32_t connection_key,
+                                        PermissionConsent& permissions) =0;
+
+      friend class AppPermissionDelegate;
+};
+
+}  //  namespace policy
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICY_HANDLER_INTERFACE_H_