Policies and Resumption correctives after removing all singletons

15 files changed, 379 insertions, 292 deletions

diff --git a/src/components/application_manager/include/application_manager/policies/delegates/app_permission_delegate.h b/src/components/application_manager/include/application_manager/policies/delegates/app_permission_delegate.h
index 55a4f146c2..ecd3d0e707 100644
--- a/src/components/application_manager/include/application_manager/policies/delegates/app_permission_delegate.h
+++ b/src/components/application_manager/include/application_manager/policies/delegates/app_permission_delegate.h
@@ -39,9 +39,10 @@
 #include "utils/conditional_variable.h"
 
 #include "policy/policy_types.h"
+#include "application_manager/policies/policy_handler_interface.h"
 
 namespace policy {
-
+class PolicyHandler;
   /**
  * @brief The AppPermissionDelegate class allows to call OnAppPermissionConsent
  * in async way.
@@ -56,8 +57,9 @@ class AppPermissionDelegate: public threads::ThreadDelegate {
      *
      * @param permissions new permissions
      */
-    AppPermissionDelegate(const uint32_t connection_key,
-                          const PermissionConsent &permissions);
+   AppPermissionDelegate(const uint32_t connection_key,
+                         const PermissionConsent& permissions,
+                         policy::PolicyHandlerInterface& policy_handler);
 
     /**
      * @brief threadMain run the needed function.
@@ -74,6 +76,7 @@ class AppPermissionDelegate: public threads::ThreadDelegate {
   private:
     uint32_t connection_key_;
     PermissionConsent permissions_;
+    policy::PolicyHandlerInterface& policy_handler_;
 };
 
 } // namespace policy
diff --git a/src/components/application_manager/include/application_manager/policies/policy_event_observer.h b/src/components/application_manager/include/application_manager/policies/policy_event_observer.h
index e251170fec..3c2aa5125c 100644
--- a/src/components/application_manager/include/application_manager/policies/policy_event_observer.h
+++ b/src/components/application_manager/include/application_manager/policies/policy_event_observer.h
@@ -34,24 +34,27 @@
 #define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICY_EVENT_OBSERVER_H_
 
 #include "application_manager/event_engine/event_observer.h"
+#include "utils/lock.h"
 
 namespace policy {
 namespace smart_objects = NsSmartDeviceLink::NsSmartObjects;
 
-class PolicyHandler;
+class PolicyHandlerInterface;
 
 class PolicyEventObserver :
     public application_manager::event_engine::EventObserver {
  public:
-  explicit PolicyEventObserver(policy::PolicyHandler* const policy_handler);
-  void set_policy_handler(policy::PolicyHandler* const policy_handler);
+  PolicyEventObserver(
+      policy::PolicyHandlerInterface* const policy_handler,
+      application_manager::event_engine::EventDispatcher& event_dispatcher);
+  void set_policy_handler(policy::PolicyHandlerInterface* const policy_handler);
   void on_event(const application_manager::event_engine::Event& event);
   void subscribe_on_event(
       const application_manager::event_engine::Event::EventID& event_id,
       int32_t hmi_correlation_id = 0);
  private:
   sync_primitives::Lock policy_handler_lock_;
-  PolicyHandler* policy_handler_;
+  PolicyHandlerInterface* policy_handler_;
   void ProcessOdometerEvent(const smart_objects::SmartObject& message);
 };
 
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 32db248965..1ec3e47081 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,14 +37,13 @@
 #include <map>
 #include <set>
 #include <vector>
-#include <stdint.h>
+#include <list>
 #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"
 #include "utils/threads/thread_delegate.h"
 #include "utils/conditional_variable.h"
@@ -58,6 +57,10 @@ namespace Json {
 class Value;
 }
 
+namespace application_manager {
+class ApplicationManager;
+}
+
 namespace policy {
 typedef std::vector<uint32_t> AppIds;
 typedef std::vector<uint32_t> DeviceHandles;
@@ -68,8 +71,9 @@ class PolicyHandler
       public PolicyListener,
       public threads::AsyncRunner {
  public:
-  PolicyHandler(const policy::PolicySettings& get_settings);
-  ~PolicyHandler();
+  PolicyHandler(const policy::PolicySettings& get_settings,
+                application_manager::ApplicationManager& application_manager);
+  virtual ~PolicyHandler();
   bool LoadPolicyLibrary() OVERRIDE;
   bool PolicyEnabled() const OVERRIDE;
   bool InitPolicyTable() OVERRIDE;
@@ -79,16 +83,16 @@ class PolicyHandler
   bool ReceiveMessageFromSDK(const std::string& file,
                              const BinaryMessage& pt_string) OVERRIDE;
   bool UnloadPolicyLibrary() OVERRIDE;
-  void OnPermissionsUpdated(const std::string& policy_app_id,
+  virtual void OnPermissionsUpdated(const std::string& policy_app_id,
                                     const Permissions& permissions,
                                     const HMILevel& default_hmi) OVERRIDE;
 
-  void OnPermissionsUpdated(const std::string& policy_app_id,
+  virtual void OnPermissionsUpdated(const std::string& policy_app_id,
                                     const Permissions& permissions) OVERRIDE;
 
-  void OnSnapshotCreated(const BinaryMessage& pt_string) OVERRIDE;
+  virtual void OnSnapshotCreated(const BinaryMessage& pt_string) OVERRIDE;
 
-  bool GetPriority(const std::string& policy_app_id, std::string* priority) const OVERRIDE;
+  virtual 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,
@@ -96,7 +100,7 @@ class PolicyHandler
                         CheckPermissionResult& result) OVERRIDE;
 
   uint32_t GetNotificationsNumber(const std::string& priority) const OVERRIDE;
-  DeviceConsent GetUserConsentForDevice(const std::string& device_id) const OVERRIDE;
+  virtual DeviceConsent GetUserConsentForDevice(const std::string& device_id) const OVERRIDE;
   bool GetDefaultHmi(const std::string& policy_app_id,
                      std::string* default_hmi) const OVERRIDE;
   bool GetInitialAppData(const std::string& application_id,
@@ -243,18 +247,18 @@ class PolicyHandler
   /**
    * @brief Send request to HMI to get update on system parameters
    */
-  void OnSystemInfoUpdateRequired() OVERRIDE;
+  virtual void OnSystemInfoUpdateRequired() OVERRIDE;
 
   /**
    * @brief Sends GetVehicleData request in case when Vechicle info is ready.
    */
-  void OnVIIsReady() OVERRIDE;
+  virtual void OnVIIsReady() OVERRIDE;
 
   /**
    * @brief Allows to update vechicle data info.
    * @param SmartObject which contains all needed information.
    */
-  void OnVehicleDataUpdated(const smart_objects::SmartObject& message) OVERRIDE;
+  virtual void OnVehicleDataUpdated(const smart_objects::SmartObject& message) OVERRIDE;
 
   /**
    * Removes device
@@ -282,19 +286,23 @@ class PolicyHandler
 
   custom_str::CustomString GetAppName(const std::string& policy_app_id) OVERRIDE;
 
-  void OnUpdateHMIAppType(
+  virtual void OnUpdateHMIAppType(
       std::map<std::string, StringArray> app_hmi_types) OVERRIDE;
 
-  void OnCertificateUpdated(const std::string& certificate_data) OVERRIDE;
+  virtual void OnCertificateUpdated(const std::string& certificate_data) OVERRIDE;
 
-  bool CanUpdate() OVERRIDE;
+  virtual bool CanUpdate() OVERRIDE;
 
-  void OnDeviceConsentChanged(const std::string& device_id,
+  virtual void OnDeviceConsentChanged(const std::string& device_id,
                                       bool is_allowed) OVERRIDE;
 
-  void OnPTExchangeNeeded() OVERRIDE;
+  virtual void SendOnAppPermissionsChanged(
+      const AppPermissions& permissions,
+      const std::string& policy_app_id) const OVERRIDE;
+
+  virtual void OnPTExchangeNeeded() OVERRIDE;
 
-  void GetAvailableApps(std::queue<std::string>& apps) OVERRIDE;
+  virtual void GetAvailableApps(std::queue<std::string>& apps) OVERRIDE;
 
   /**
    * @brief Allows to add new or update existed application during
@@ -371,13 +379,13 @@ class PolicyHandler
   void OnAppRegisteredOnMobile(const std::string& application_id) OVERRIDE;
 
   // TODO(AKutsan) REMOVE THIS UGLY HOTFIX
-  void Increment(usage_statistics::GlobalCounterId type) OVERRIDE;
-  void Increment(const std::string& app_id,
+  virtual void Increment(usage_statistics::GlobalCounterId type) OVERRIDE;
+  virtual void Increment(const std::string& app_id,
                          usage_statistics::AppCounterId type) OVERRIDE;
-  void Set(const std::string& app_id,
+  virtual void Set(const std::string& app_id,
                    usage_statistics::AppInfoId type,
                    const std::string& value) OVERRIDE;
-  void Add(const std::string& app_id,
+  virtual void Add(const std::string& app_id,
                    usage_statistics::AppStopwatchId type,
                    int32_t timespan_seconds) OVERRIDE;
 
@@ -444,7 +452,7 @@ class PolicyHandler
       DCHECK(policy_handler_);
     }
     // TODO(AKutsan) REMOVE THIS UGLY HOTFIX
-    void Increment(usage_statistics::GlobalCounterId type) {
+    virtual void Increment(usage_statistics::GlobalCounterId type) {
       policy_handler_->AsyncRun(new StatisticsDelegate(*policy_handler_, type));
     }
 
@@ -502,10 +510,10 @@ class PolicyHandler
 
   utils::SharedPtr<StatisticManagerImpl> statistic_manager_impl_;
   const PolicySettings& settings_;
+  application_manager::ApplicationManager& application_manager_;
   friend class AppPermissionDelegate;
 
   DISALLOW_COPY_AND_ASSIGN(PolicyHandler);
-  FRIEND_DELETER_DESTRUCTOR(PolicyHandler);
 };
 
 }  //  namespace policy
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 a2896a43e8..50cf784485 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
@@ -49,6 +49,7 @@
 #include "utils/timer.h"
 
 namespace application_manager {
+class ApplicationManager;
 class Application;
 }
 
@@ -67,7 +68,7 @@ class ResumeCtrl: public app_mngr::event_engine::EventObserver {
   /**
    * @brief allows to create ResumeCtrl object
    */
-  ResumeCtrl();
+  ResumeCtrl(application_manager::ApplicationManager& application_manager);
 
   /**
    * @brief allows to destroy ResumeCtrl object
@@ -159,6 +160,11 @@ class ResumeCtrl: public app_mngr::event_engine::EventObserver {
   void StopSavePersistentDataTimer();
 
   /**
+   * @brief Method stops restore_hmi_level_timer_ "RsmCtrlRstore" in OnSuspend()
+   */
+  void StopRestoreHmiLevelTimer();
+
+  /**
    * @brief Start timer for resumption applications
    *        Restore D1-D5 data
    * @param application that is need to be restored
@@ -173,8 +179,7 @@ class ResumeCtrl: public app_mngr::event_engine::EventObserver {
    * @param application that is need to be restored
    * @return true if it was saved, otherwise return false
    */
-  bool StartResumptionOnlyHMILevel(
-      app_mngr::ApplicationSharedPtr application);
+  bool StartResumptionOnlyHMILevel(app_mngr::ApplicationSharedPtr application);
 
   /**
    * @brief Check if there are all files need for resumption
@@ -217,7 +222,7 @@ class ResumeCtrl: public app_mngr::event_engine::EventObserver {
    * @return HMI app ID
    */
   uint32_t GetHMIApplicationID(const std::string& policy_app_id,
-                               const std::string& device_mac) const;
+                               const std::string& device_id) const;
   /**
    * @brief SaveDataOnTimer :
    *  Timer callback for persisting ResumptionData each N seconds
@@ -277,15 +282,17 @@ class ResumeCtrl: public app_mngr::event_engine::EventObserver {
    * @param device_id - id of device where application is run
    */
   void OnAppRegistrationStart(const std::string& policy_app_id,
-                                const std::string& device_id);
+                              const std::string& device_id);
 
   /**
    * @brief Notify resume controller about delete new application
    */
   void OnAppRegistrationEnd();
 
+#ifdef BUILD_TESTS
+  void set_resumption_storage(utils::SharedPtr<ResumptionData> mock_storage);
+#endif  // BUILD_TESTS
  private:
-
   /**
    * @brief restores saved data of application
    * @param application contains application for which restores data
@@ -356,7 +363,8 @@ class ResumeCtrl: public app_mngr::event_engine::EventObserver {
 
   bool CheckIgnCycleRestrictions(const smart_objects::SmartObject& saved_app);
 
-  bool DisconnectedJustBeforeIgnOff(const smart_objects::SmartObject& saved_app);
+  bool DisconnectedJustBeforeIgnOff(
+      const smart_objects::SmartObject& saved_app);
 
   bool CheckAppRestrictions(app_mngr::ApplicationConstSharedPtr application,
                             const smart_objects::SmartObject& saved_app);
@@ -379,20 +387,20 @@ class ResumeCtrl: public app_mngr::event_engine::EventObserver {
 
   typedef std::pair<uint32_t, uint32_t> application_timestamp;
 
-  //    std::set<ApplicationSharedPtr> retrieve_application();
+  std::set<app_mngr::ApplicationSharedPtr> retrieve_application();
 
   /**
    * @brief This struct need to map
    * timestamp and application from correlationID
    */
   struct ResumingApp {
-    uint32_t old_session_key; // session key is the same as app_id
+    uint32_t old_session_key;  // session key is the same as app_id
     app_mngr::ApplicationSharedPtr app;
   };
 
   struct TimeStampComparator {
-    bool operator() (const application_timestamp& lhs,
-                     const application_timestamp& rhs) const{
+    bool operator()(const application_timestamp& lhs,
+                    const application_timestamp& rhs) const {
       return lhs.second < rhs.second;
     }
   };
@@ -442,7 +450,7 @@ class ResumeCtrl: public app_mngr::event_engine::EventObserver {
 
   void InsertToTimerQueue(uint32_t app_id, uint32_t time_stamp);
 
-  void AddToResumptionTimerQueue(uint32_t app_id);
+  void AddToResumptionTimerQueue(const uint32_t app_id);
 
   void LoadResumeData();
 
@@ -453,6 +461,21 @@ class ResumeCtrl: public app_mngr::event_engine::EventObserver {
    */
   bool IsAppDataResumptionExpired(
           const smart_objects::SmartObject& application) const;
+  /**
+   * @brief Checks from resume data, if application has been disconnected
+   * unexpectedly
+   * @param app Application section from resume data
+   * @return true, if it has been unexpectedly disconnected, otherwise - false
+   */
+  bool IsUnexpectedlyDisconnected(const smart_objects::SmartObject& app) const;
+
+  /**
+   * @brief Checks, if application can be resumed
+   * @param application Application
+   * @return true, if no restrictions currently, otherwise - false
+   */
+  bool IsResumeAllowed(
+          const application_manager::ApplicationSharedPtr application) const;
 
   /**
    *@brief Mapping applications to time_stamps
@@ -468,6 +491,7 @@ class ResumeCtrl: public app_mngr::event_engine::EventObserver {
   bool                            is_data_saved_;
   time_t                          launch_time_;
   utils::SharedPtr<ResumptionData>    resumption_storage_;
+  application_manager::ApplicationManager& application_manager_;
 };
 
 }  // namespace resumption
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 5c4e5ff256..f75e2c443a 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
@@ -35,6 +35,11 @@
 
 #include "smart_objects/smart_object.h"
 #include "application_manager/application.h"
+#include "application_manager/application_manager.h"
+
+namespace application_manager {
+    class ApplicationManagerSettings;
+}
 
 namespace resumption {
 
@@ -52,7 +57,8 @@ class ResumptionData {
   /**
    * @brief Constructor of ResumptionData
    */
-  ResumptionData();
+  ResumptionData(
+      const application_manager::ApplicationManager& application_manager);
 
   /**
    * @brief Destructor of ResumptionData
@@ -63,7 +69,8 @@ class ResumptionData {
    * @brief Save application persistent info for future resuming
    * @param application is application witch need to be saved
    */
-  virtual void SaveApplication(app_mngr::ApplicationSharedPtr application) = 0;
+  virtual void SaveApplication(
+      app_mngr::ApplicationSharedPtr application) = 0;
 
   /**
    * @brief Returns HMI level of application from saved data
@@ -202,6 +209,7 @@ class ResumptionData {
    */
   virtual void Persist() = 0;
  protected:
+
   /**
    * @brief Retrieves of commands from application
    * @param application contains application of which selection commands
@@ -279,8 +287,8 @@ class ResumptionData {
       ++first;
     }
   }
-
-  mutable sync_primitives::Lock resumption_lock_;
+  mutable sync_primitives::Lock           resumption_lock_;
+  const application_manager::ApplicationManager& application_manager_;
 };
 }  // namespace resumption
 
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 18c9369f2e..962b164134 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
@@ -42,7 +42,10 @@ namespace resumption {
 /**
  * @brief Points what structure contains vr commands
  */
-enum AccessoryVRCommand { kVRCommandFromChoice = 0, kVRCommandFromCommand };
+enum AccessoryVRCommand {
+  kVRCommandFromChoice = 0,
+  kVRCommandFromCommand
+};
 
 struct ApplicationParams {
   ApplicationParams(const smart_objects::SmartObject& application);
@@ -65,8 +68,10 @@ class ResumptionDataDB : public ResumptionData {
  public:
   /**
    * @brief Constructor of ResumptionDataDB
+   * @param db_storage show database should be saved in a disk file or in memory
    */
-  ResumptionDataDB();
+  ResumptionDataDB(
+      const application_manager::ApplicationManager& application_manager);
 
   /**
    * @brief allows to destroy ResumptionDataDB object
@@ -84,7 +89,8 @@ class ResumptionDataDB : public ResumptionData {
    * @brief Save application persistent info for future resuming to db
    * @param application is application which need to be saved
    */
-  virtual void SaveApplication(app_mngr::ApplicationSharedPtr application);
+  void SaveApplication(
+      app_mngr::ApplicationSharedPtr application) OVERRIDE;
   /**
    * @brief Returns HMI level of application from saved data
    * @param policy_app_id contains policy id of application
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 3d6d2a16e2..092ac25ea3 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
@@ -48,7 +48,8 @@ class ResumptionDataJson : public ResumptionData {
   /**
    * @brief Constructor of ResumptionDataJson
    */
-  ResumptionDataJson(LastState& last_state);
+  ResumptionDataJson(LastState& last_state,
+                     const application_manager::ApplicationManager& application_manager);
 
   /**
    * @brief allows to destroy ResumptionDataJson object
@@ -59,7 +60,8 @@ class ResumptionDataJson : public ResumptionData {
    * @brief Save application persistent info for future resuming on json format
    * @param application is application witch need to be saved
    */
-  virtual void SaveApplication(app_mngr::ApplicationSharedPtr application);
+  virtual void SaveApplication(
+      app_mngr::ApplicationSharedPtr application) OVERRIDE;
 
   /**
    * @brief Returns HMI level of application from saved data
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 27052db51e..ceff36c00a 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,23 +31,23 @@
  */
 
 #include "application_manager/policies/delegates/app_permission_delegate.h"
-#include "application_manager/application_manager_impl.h"
+#include "application_manager/application_manager.h"
 #include "application_manager/policies/policy_handler_interface.h"
 
 namespace policy {
   CREATE_LOGGERPTR_GLOBAL(logger_, "PolicyHandler")
 
   AppPermissionDelegate::AppPermissionDelegate(
-      const uint32_t connection_key, const PermissionConsent& permissions)
-    : connection_key_(connection_key),
-      permissions_(permissions) {
-  }
+      const uint32_t connection_key,
+      const PermissionConsent& permissions,
+      policy::PolicyHandlerInterface& policy_handler)
+      : connection_key_(connection_key)
+      , permissions_(permissions)
+      , policy_handler_(policy_handler) {}
 
   void AppPermissionDelegate::threadMain() {
   LOG4CXX_AUTO_TRACE(logger_);
-  policy::PolicyHandlerInterface& policy_handler =
-      application_manager::ApplicationManagerImpl::instance()->GetPolicyHandler();
-  policy_handler.OnAppPermissionConsentInternal(connection_key_,
+  policy_handler_.OnAppPermissionConsentInternal(connection_key_,
                                                             permissions_);
 }
 
diff --git a/src/components/application_manager/src/policies/policy_event_observer.cc b/src/components/application_manager/src/policies/policy_event_observer.cc
index 184f091bf5..819d99e065 100644
--- a/src/components/application_manager/src/policies/policy_event_observer.cc
+++ b/src/components/application_manager/src/policies/policy_event_observer.cc
@@ -43,11 +43,12 @@ class PolicyHandler;
 
 CREATE_LOGGERPTR_GLOBAL(logger_, "PolicyHandler")
 
-PolicyEventObserver::PolicyEventObserver(PolicyHandler* const policy_handler)
-  : policy_handler_(policy_handler) {
-}
+PolicyEventObserver::PolicyEventObserver(
+    policy::PolicyHandlerInterface* const policy_handler,
+    application_manager::event_engine::EventDispatcher& event_dispatcher)
+    : EventObserver(event_dispatcher), policy_handler_(policy_handler) {}
 
-void PolicyEventObserver::set_policy_handler(policy::PolicyHandler* const policy_handler) {
+void PolicyEventObserver::set_policy_handler(PolicyHandlerInterface* const policy_handler) {
   LOG4CXX_AUTO_TRACE(logger_);
   sync_primitives::AutoLock auto_lock(policy_handler_lock_);
   LOG4CXX_DEBUG(logger_, "Set policy handler " << policy_handler);
diff --git a/src/components/application_manager/src/policies/policy_handler.cc b/src/components/application_manager/src/policies/policy_handler.cc
index 098f0cfeec..adfbd2aa53 100644
--- a/src/components/application_manager/src/policies/policy_handler.cc
+++ b/src/components/application_manager/src/policies/policy_handler.cc
@@ -29,9 +29,7 @@
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  POSSIBILITY OF SUCH DAMAGE.
  */
-
 #include "application_manager/policies/policy_handler.h"
-
 #include <unistd.h>
 #include <dlfcn.h>
 #include <algorithm>
@@ -40,10 +38,10 @@
 
 #include "application_manager/policies/delegates/app_permission_delegate.h"
 
-#include "application_manager/application_manager_impl.h"
+#include "application_manager/application_manager.h"
+#include "application_manager/state_controller.h"
 #include "application_manager/message_helper.h"
 #include "policy/policy_manager_impl.h"
-#include "./types.h"
 #include "connection_handler/connection_handler.h"
 #include "utils/macro.h"
 #include "utils/date_time.h"
@@ -115,6 +113,7 @@ const policy::DeviceParams GetDeviceParams(
   return device_params;
 }
 }
+
 #define POLICY_LIB_CHECK(return_value)                                      \
   {                                                                         \
     sync_primitives::AutoReadLock lock(policy_manager_lock_);               \
@@ -133,6 +132,8 @@ const policy::DeviceParams GetDeviceParams(
     }                                                                       \
   }
 
+static const std::string kCerficateFileName = "certificate";
+
 struct ApplicationListHmiLevelSorter {
   bool operator()(const application_manager::ApplicationSharedPtr& lhs,
                   const application_manager::ApplicationSharedPtr& rhs) {
@@ -154,26 +155,32 @@ typedef std::set<application_manager::ApplicationSharedPtr,
 
 struct DeactivateApplication {
   explicit DeactivateApplication(
-      const connection_handler::DeviceHandle& device_id)
-      : device_id_(device_id) {}
+      const connection_handler::DeviceHandle& device_id,
+            StateController& state_ctrl)
+      : device_id_(device_id), state_ctrl_(state_ctrl) {}
 
   void operator()(const ApplicationSharedPtr& app) {
     if (device_id_ == app->device()) {
-      ApplicationManagerImpl::instance()->SetState<true>(
-          app->app_id(),
+      state_ctrl_.SetRegularState(
+          app,
           mobile_apis::HMILevel::HMI_NONE,
-          mobile_apis::AudioStreamingState::NOT_AUDIBLE);
+          mobile_apis::AudioStreamingState::NOT_AUDIBLE,
+                  true);
     }
   }
 
  private:
   connection_handler::DeviceHandle device_id_;
+  StateController& state_ctrl_;
 };
 
 struct SDLAlowedNotification {
   SDLAlowedNotification(const connection_handler::DeviceHandle& device_id,
-                        PolicyManager* policy_manager)
-      : device_id_(device_id), policy_manager_(policy_manager) {}
+                        PolicyManager* policy_manager,
+                        StateController& state_controller)
+      : device_id_(device_id)
+      , policy_manager_(policy_manager)
+      , state_controller_(state_controller) {}
 
   void operator()(const ApplicationSharedPtr& app) {
     if (!policy_manager_) {
@@ -182,7 +189,7 @@ struct SDLAlowedNotification {
     if (device_id_ == app->device()) {
       std::string hmi_level;
       mobile_apis::HMILevel::eType default_mobile_hmi;
-      policy_manager_->GetDefaultHmi(app->mobile_app_id(), &hmi_level);
+      policy_manager_->GetDefaultHmi(app->policy_app_id(), &hmi_level);
       if ("BACKGROUND" == hmi_level) {
         default_mobile_hmi = mobile_apis::HMILevel::HMI_BACKGROUND;
       } else if ("FULL" == hmi_level) {
@@ -194,20 +201,22 @@ struct SDLAlowedNotification {
       } else {
         return;
       }
-      ApplicationManagerImpl::instance()->SetState<true>(app->app_id(),
-                                                         default_mobile_hmi);
+      state_controller_.SetRegularState(app, default_mobile_hmi, true);
     }
   }
 
  private:
   connection_handler::DeviceHandle device_id_;
   PolicyManager* policy_manager_;
+  StateController& state_controller_;
 };
 
 struct LinkAppToDevice {
   explicit LinkAppToDevice(
-      std::map<std::string, std::string>& app_to_device_link)
-      : app_to_device_link_(app_to_device_link) {
+      std::map<std::string, std::string>& app_to_device_link,
+            const ApplicationManager& application_manager)
+      : app_to_device_link_(app_to_device_link),
+       application_manager_(application_manager) {
     app_to_device_link_.clear();
   }
 
@@ -220,10 +229,9 @@ struct LinkAppToDevice {
     }
     DeviceParams device_params =
         GetDeviceParams(app->device(),
-                        ApplicationManagerImpl::instance()
-                            ->connection_handler()
-                              .get_session_observer());
-    const std::string app_id = app->mobile_app_id();
+                        application_manager_.connection_handler()
+                            .get_session_observer());
+    const std::string app_id = app->policy_app_id();
     if (device_params.device_mac_address.empty()) {
       LOG4CXX_WARN(logger_,
                    "Couldn't find device, which hosts application " << app_id);
@@ -234,6 +242,7 @@ struct LinkAppToDevice {
 
  private:
   std::map<std::string, std::string>& app_to_device_link_;
+  const ApplicationManager& application_manager_;
 };
 
 struct PermissionsConsolidator {
@@ -277,13 +286,15 @@ struct PermissionsConsolidator {
 
 const std::string PolicyHandler::kLibrary = "libPolicy.so";
 
-PolicyHandler::PolicyHandler(const PolicySettings& settings)
+PolicyHandler::PolicyHandler(const PolicySettings& settings,
+                             ApplicationManager& application_manager)
     : 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>(this))
-    , settings_(settings) {}
+    , settings_(settings)
+    , application_manager_(application_manager) {}
 
 PolicyHandler::~PolicyHandler() {}
 
@@ -303,7 +314,9 @@ bool PolicyHandler::LoadPolicyLibrary() {
   if (!error) {
     if (CreateManager()) {
       policy_manager_->set_listener(this);
-      event_observer_ = utils::MakeShared<PolicyEventObserver>(this);
+      event_observer_ = utils::SharedPtr<PolicyEventObserver>(
+            new PolicyEventObserver(this,
+                                    application_manager_.event_dispatcher()));
     }
   } else {
     LOG4CXX_ERROR(logger_, error);
@@ -318,11 +331,14 @@ bool PolicyHandler::PolicyEnabled() const{
 
 bool PolicyHandler::CreateManager() {
   typedef PolicyManager* (*CreateManager)();
+  typedef void (*DeleteManager)(PolicyManager* );
   CreateManager create_manager =
       reinterpret_cast<CreateManager>(dlsym(dl_handle_, "CreateManager"));
+  DeleteManager delete_manager =
+          reinterpret_cast<DeleteManager>(dlsym(dl_handle_, "DeleteManager"));
   char* error_string = dlerror();
   if (NULL == error_string) {
-    policy_manager_ = create_manager();
+    policy_manager_ = utils::SharedPtr<PolicyManager>(create_manager(), delete_manager);
   } else {
     LOG4CXX_WARN(logger_, error_string);
   }
@@ -367,7 +383,7 @@ bool PolicyHandler::ClearUserConsent() {
 
 uint32_t PolicyHandler::GetAppIdForSending() const {
   POLICY_LIB_CHECK(0);
-  ApplicationManagerImpl::ApplicationListAccessor accessor;
+  const ApplicationSet& accessor = application_manager_.applications().GetData();
   HmiLevelOrderedApplicationList app_list(accessor.begin(), accessor.end());
 
   LOG4CXX_INFO(logger_, "Apps size: " << app_list.size());
@@ -376,12 +392,11 @@ uint32_t PolicyHandler::GetAppIdForSending() const {
        first != app_list.end();
        ++first) {
     if ((*first)->IsRegistered()) {
-      const uint32_t app_id = (*first)->app_id();
-      DeviceParams device_params =
-          GetDeviceParams((*first)->device(),
-                          ApplicationManagerImpl::instance()
-                              ->connection_handler()
-                              .get_session_observer());
+    const uint32_t app_id = (*first)->app_id();
+    DeviceParams device_params =
+        GetDeviceParams((*first)->device(),
+                        application_manager_.connection_handler()
+                            .get_session_observer());
 
       if (kDeviceAllowed ==
           policy_manager_->GetUserConsentForDevice(
@@ -390,33 +405,32 @@ uint32_t PolicyHandler::GetAppIdForSending() const {
       }
     }
   }
-
   return 0;
 }
 
 void PolicyHandler::OnAppPermissionConsent(
     const uint32_t connection_key, const PermissionConsent& permissions) {
   LOG4CXX_AUTO_TRACE(logger_);
-  AsyncRun(new AppPermissionDelegate(connection_key, permissions));
+  AsyncRun(new AppPermissionDelegate(connection_key, permissions, *this));
 }
 
 void PolicyHandler::OnDeviceConsentChanged(const std::string& device_id,
                                            bool is_allowed) {
   POLICY_LIB_CHECK_VOID();
   connection_handler::DeviceHandle device_handle;
-  ApplicationManagerImpl::instance()->connection_handler().GetDeviceID(
+  application_manager_.connection_handler().GetDeviceID(
       device_id, &device_handle);
   // In case of changed consent for device, related applications will be
   // limited to pre_DataConsent permissions, if device disallowed, or switch
   // back to their own permissions, if device allowed again, and must be
   // notified about these changes
 
-  ApplicationManagerImpl::ApplicationListAccessor accessor;
+  const ApplicationSet& accessor = application_manager_.applications().GetData();
   ApplicationSetConstIt it_app_list = accessor.begin();
   ApplicationSetConstIt it_app_list_end = accessor.end();
   for (; it_app_list != it_app_list_end; ++it_app_list) {
     if (device_handle == (*it_app_list).get()->device()) {
-      const std::string policy_app_id = (*it_app_list)->mobile_app_id();
+      const std::string policy_app_id = (*it_app_list)->policy_app_id();
 
       // If app has predata policy, which is assigned without device consent or
       // with negative data consent, there no necessity to change smth and send
@@ -432,20 +446,36 @@ void PolicyHandler::OnDeviceConsentChanged(const std::string& device_id,
   }
 }
 
+void PolicyHandler::SendOnAppPermissionsChanged(
+    const AppPermissions& permissions, const std::string& policy_app_id) const {
+  LOG4CXX_AUTO_TRACE(logger_);
+  LOG4CXX_DEBUG(logger_,
+                "PolicyHandler::SendOnAppPermissionsChanged for "
+                    << policy_app_id);
+  ApplicationSharedPtr app =
+      application_manager_.application_by_policy_id(
+          policy_app_id);
+  if (!app.valid()) {
+    LOG4CXX_WARN(logger_, "No app found for policy app id = " << policy_app_id);
+    return;
+  }
+  MessageHelper::SendOnAppPermissionsChangedNotification(app->app_id(),
+                                                         permissions, application_manager_);
+}
+
 void PolicyHandler::OnPTExchangeNeeded() {
   POLICY_LIB_CHECK_VOID();
-  MessageHelper::SendOnStatusUpdate(policy_manager_->ForcePTExchange());
+  MessageHelper::SendOnStatusUpdate(policy_manager_->ForcePTExchange(), application_manager_);
 }
 
 void PolicyHandler::GetAvailableApps(std::queue<std::string>& apps) {
   LOG4CXX_INFO(logger_, "GetAvailable apps");
-  ApplicationManagerImpl::ApplicationListAccessor accessor;
-  const ApplicationSet app_list = accessor.applications();
+  const ApplicationSet& app_list = application_manager_.applications().GetData();
   ApplicationSetConstIt iter = app_list.begin();
 
   for (; app_list.end() != iter; ++iter) {
     LOG4CXX_INFO(logger_, "one more app");
-    apps.push((*iter)->mobile_app_id());
+    apps.push((*iter)->policy_app_id());
   }
 }
 
@@ -474,15 +504,14 @@ void PolicyHandler::OnAppPermissionConsentInternal(
   POLICY_LIB_CHECK_VOID();
   if (connection_key) {
     ApplicationSharedPtr app =
-        ApplicationManagerImpl::instance()->application(connection_key);
+        application_manager_.application(connection_key);
 
     if (app.valid()) {
-      permissions.policy_app_id = app->mobile_app_id();
+      permissions.policy_app_id = app->policy_app_id();
       DeviceParams device_params =
           GetDeviceParams(app->device(),
-                          ApplicationManagerImpl::instance()
-                              ->connection_handler()
-                                  .get_session_observer());
+                          application_manager_.connection_handler()
+                              .get_session_observer());
 
       permissions.device_id = device_params.device_mac_address;
     }
@@ -508,7 +537,7 @@ void PolicyHandler::OnAppPermissionConsentInternal(
       app_to_device_link_.end();
   for (; it != it_end; ++it) {
     ApplicationSharedPtr app =
-        ApplicationManagerImpl::instance()->application_by_policy_id(it->first);
+        application_manager_.application_by_policy_id(it->first);
 
     // If list of apps sent to HMI for user consents is not the same as current,
     // permissions should be set only for coincident to registered apps
@@ -518,11 +547,12 @@ void PolicyHandler::OnAppPermissionConsentInternal(
                    "Permissions setting skipped.");
       continue;
     }
+
     DeviceParams device_params =
         GetDeviceParams(app->device(),
-                        ApplicationManagerImpl::instance()
-                            ->connection_handler()
-                              .get_session_observer());
+                        application_manager_.connection_handler()
+                            .get_session_observer());
+
     if (device_params.device_mac_address != it->second) {
       LOG4CXX_WARN(logger_,
                    "Device_id of application is changed."
@@ -560,7 +590,7 @@ void PolicyHandler::OnGetUserFriendlyMessage(
   std::vector<UserFriendlyMessage> result =
       policy_manager_->GetUserFriendlyMessages(message_codes, language);
   // Send response to HMI with gathered data
-  MessageHelper::SendGetUserFriendlyMessageResponse(result, correlation_id);
+  MessageHelper::SendGetUserFriendlyMessageResponse(result, correlation_id, application_manager_);
 }
 
 void PolicyHandler::OnGetListOfPermissions(const uint32_t connection_key,
@@ -571,8 +601,8 @@ void PolicyHandler::OnGetListOfPermissions(const uint32_t connection_key,
   // applications
   if (!connection_key) {
     sync_primitives::AutoLock lock(app_to_device_link_lock_);
-    LinkAppToDevice linker(app_to_device_link_);
-    ApplicationManagerImpl::ApplicationListAccessor accessor;
+    LinkAppToDevice linker(app_to_device_link_, application_manager_);
+    const ApplicationSet& accessor = application_manager_.applications().GetData();
     ApplicationSetConstIt it_app = accessor.begin();
     ApplicationSetConstIt it_app_end = accessor.end();
 
@@ -590,14 +620,13 @@ void PolicyHandler::OnGetListOfPermissions(const uint32_t connection_key,
     }
 
     MessageHelper::SendGetListOfPermissionsResponse(
-        consolidator.GetConsolidatedPermissions(), correlation_id);
+        consolidator.GetConsolidatedPermissions(), correlation_id, application_manager_);
 
     return;
   }
 
   // Single app only
-  ApplicationSharedPtr app =
-      ApplicationManagerImpl::instance()->application(connection_key);
+  ApplicationSharedPtr app = application_manager_.application(connection_key);
 
   if (!app.valid()) {
     LOG4CXX_WARN(logger_,
@@ -607,11 +636,12 @@ void PolicyHandler::OnGetListOfPermissions(const uint32_t connection_key,
                         "not found within registered applications.");
     return;
   }
+
   DeviceParams device_params =
       GetDeviceParams(app->device(),
-                      ApplicationManagerImpl::instance()
-                          ->connection_handler()
-                            .get_session_observer());
+                      application_manager_.connection_handler()
+                          .get_session_observer());
+
   std::vector<FunctionalGroupPermission> group_permissions;
   if (device_params.device_mac_address.empty()) {
     LOG4CXX_WARN(logger_, "Couldn't find device, which hosts application.");
@@ -619,11 +649,11 @@ void PolicyHandler::OnGetListOfPermissions(const uint32_t connection_key,
     LOG4CXX_WARN(logger_, "Couldn't find application to get permissions.");
   } else {
     policy_manager_->GetUserConsentForApp(device_params.device_mac_address,
-                                          app->mobile_app_id(),
+                                          app->policy_app_id(),
                                           group_permissions);
 
     MessageHelper::SendGetListOfPermissionsResponse(group_permissions,
-                                                    correlation_id);
+                                                    correlation_id, application_manager_);
   }
 }
 
@@ -631,19 +661,19 @@ void PolicyHandler::OnGetStatusUpdate(const uint32_t correlation_id) {
   LOG4CXX_AUTO_TRACE(logger_);
   POLICY_LIB_CHECK_VOID();
   MessageHelper::SendGetStatusUpdateResponse(
-      policy_manager_->GetPolicyTableStatus(), correlation_id);
+      policy_manager_->GetPolicyTableStatus(), correlation_id, application_manager_);
 }
 
 void PolicyHandler::OnUpdateStatusChanged(const std::string& status) {
   LOG4CXX_AUTO_TRACE(logger_);
-  MessageHelper::SendOnStatusUpdate(status);
+  MessageHelper::SendOnStatusUpdate(status, application_manager_);
 }
 
 std::string PolicyHandler::OnCurrentDeviceIdUpdateRequired(
     const std::string& policy_app_id) {
   LOG4CXX_AUTO_TRACE(logger_);
   ApplicationSharedPtr app =
-      ApplicationManagerImpl::instance()->application_by_policy_id(
+      application_manager_.application_by_policy_id(
           policy_app_id);
 
   if (!app.valid()) {
@@ -656,9 +686,9 @@ std::string PolicyHandler::OnCurrentDeviceIdUpdateRequired(
   }
   DeviceParams device_params =
       GetDeviceParams(app->device(),
-                      ApplicationManagerImpl::instance()
-                          ->connection_handler()
-                            .get_session_observer());
+                      application_manager_.connection_handler()
+                          .get_session_observer());
+
   return device_params.device_mac_address;
 }
 
@@ -679,17 +709,17 @@ void PolicyHandler::OnGetSystemInfo(const std::string& ccpu_version,
 void PolicyHandler::OnSystemInfoUpdateRequired() {
   LOG4CXX_AUTO_TRACE(logger_);
   POLICY_LIB_CHECK_VOID();
-  MessageHelper::SendGetSystemInfoRequest();
+  MessageHelper::SendGetSystemInfoRequest(application_manager_);
 }
 
 void PolicyHandler::OnVIIsReady() {
-  const uint32_t correlation_id =
-      ApplicationManagerImpl::instance()->GetNextHMICorrelationID();
+  LOG4CXX_AUTO_TRACE(logger_);
+  const uint32_t correlation_id = application_manager_.GetNextHMICorrelationID();
 
   std::vector<std::string> params;
   params.push_back(strings::vin);
 
-  MessageHelper::CreateGetVehicleDataRequest(correlation_id, params);
+  MessageHelper::CreateGetVehicleDataRequest(correlation_id, params, application_manager_);
 }
 
 void PolicyHandler::OnVehicleDataUpdated(
@@ -703,8 +733,7 @@ void PolicyHandler::OnPendingPermissionChange(
                 "PolicyHandler::OnPendingPermissionChange for "
                     << policy_app_id);
   POLICY_LIB_CHECK_VOID();
-  ApplicationSharedPtr app =
-      ApplicationManagerImpl::instance()->application_by_policy_id(
+  ApplicationSharedPtr app = application_manager_.application_by_policy_id(
           policy_app_id);
   if (!app.valid()) {
     LOG4CXX_WARN(logger_,
@@ -719,11 +748,12 @@ void PolicyHandler::OnPendingPermissionChange(
 
   if (permissions.appRevoked) {
     application_manager::MessageHelper::SendOnAppPermissionsChangedNotification(
-        app_id, permissions);
-    ApplicationManagerImpl::instance()->SetState<true>(
-        app->app_id(),
+        app_id, permissions, application_manager_);
+    application_manager_.state_controller().SetRegularState(
+        app,
         mobile_apis::HMILevel::HMI_NONE,
-        mobile_apis::AudioStreamingState::NOT_AUDIBLE);
+        mobile_apis::AudioStreamingState::NOT_AUDIBLE,
+        true);
     policy_manager_->RemovePendingPermissionChanges(policy_app_id);
     return;
   }
@@ -735,7 +765,7 @@ void PolicyHandler::OnPendingPermissionChange(
     case mobile_apis::HMILevel::eType::HMI_LIMITED: {
       if (permissions.appPermissionsConsentNeeded) {
         MessageHelper::SendOnAppPermissionsChangedNotification(app->app_id(),
-                                                               permissions);
+                                                               permissions, application_manager_);
 
         policy_manager_->RemovePendingPermissionChanges(policy_app_id);
         // "Break" statement has to be here to continue processing in case of
@@ -746,7 +776,7 @@ void PolicyHandler::OnPendingPermissionChange(
     case mobile_apis::HMILevel::eType::HMI_BACKGROUND: {
       if (permissions.isAppPermissionsRevoked) {
         MessageHelper::SendOnAppPermissionsChangedNotification(app->app_id(),
-                                                               permissions);
+                                                               permissions, application_manager_);
 
         policy_manager_->RemovePendingPermissionChanges(policy_app_id);
       }
@@ -760,19 +790,20 @@ void PolicyHandler::OnPendingPermissionChange(
     if (mobile_apis::HMILevel::HMI_FULL == app_hmi_level ||
         mobile_apis::HMILevel::HMI_LIMITED == app_hmi_level) {
       MessageHelper::SendOnAppPermissionsChangedNotification(app->app_id(),
-                                                             permissions);
+                                                             permissions, application_manager_);
     }
-    MessageHelper::SendOnAppInterfaceUnregisteredNotificationToMobile(
+    application_manager_.ManageMobileCommand(MessageHelper::GetOnAppInterfaceUnregisteredNotificationToMobile(
         app->app_id(),
-        mobile_api::AppInterfaceUnregisteredReason::APP_UNAUTHORIZED);
+        mobile_api::AppInterfaceUnregisteredReason::APP_UNAUTHORIZED), commands::Command::ORIGIN_SDL);
 
-    ApplicationManagerImpl::instance()->OnAppUnauthorized(app->app_id());
+    application_manager_.OnAppUnauthorized(app->app_id());
 
     policy_manager_->RemovePendingPermissionChanges(policy_app_id);
   }
+
   if (permissions.requestTypeChanged) {
     MessageHelper::SendOnAppPermissionsChangedNotification(app->app_id(),
-                                                           permissions);
+                                                           permissions, application_manager_);
     policy_manager_->RemovePendingPermissionChanges(policy_app_id);
   }
 }
@@ -782,38 +813,36 @@ bool PolicyHandler::SendMessageToSDK(const BinaryMessage& pt_string,
   LOG4CXX_AUTO_TRACE(logger_);
   POLICY_LIB_CHECK(false);
 
-  uint32_t app_id = GetAppIdForSending(); /*last_used_app_ids_.back();*/
+  if (last_used_app_ids_.empty()) {
+    LOG4CXX_WARN(logger_, "last_used_app_ids_ is empty");
+    return false;
+  }
+  uint32_t app_id = last_used_app_ids_.back();
 
-  ApplicationSharedPtr app =
-      ApplicationManagerImpl::instance()->application(app_id);
+  ApplicationSharedPtr app = application_manager_.application(app_id);
 
   if (!app.valid()) {
     LOG4CXX_WARN(logger_,
                  "There is no registered application with "
                  "connection key '"
-                     << app_id
-                     << "'");
+                     << app_id << "'");
     return false;
   }
 
-  const std::string& mobile_app_id = app->mobile_app_id();
+  const std::string& mobile_app_id = app->policy_app_id();
   if (mobile_app_id.empty()) {
     LOG4CXX_WARN(logger_,
                  "Application with connection key '"
-                     << app_id
-                     << "'"
-                        " has no application id.");
+                     << app_id << "'"
+                                  " has no application id.");
     return false;
   }
 
-  LOG4CXX_DEBUG(
-      logger_,
-      "Update url is "
-          << url
-          << " for application "
-          << ApplicationManagerImpl::instance()->application(app_id)->name().c_str());
+  LOG4CXX_DEBUG(logger_,
+                "Update url is " << url << " for application "
+                                           "with connection key " << app_id);
 
-  MessageHelper::SendPolicySnapshotNotification(app_id, pt_string, url);
+  MessageHelper::SendPolicySnapshotNotification(app_id, pt_string, url, application_manager_);
 
   return true;
 }
@@ -827,8 +856,7 @@ bool PolicyHandler::ReceiveMessageFromSDK(const std::string& file,
   if (ret) {
     LOG4CXX_INFO(logger_, "PTU was successful.");
     policy_manager_->CleanupUnpairedDevices();
-    int32_t correlation_id =
-        ApplicationManagerImpl::instance()->GetNextHMICorrelationID();
+    int32_t correlation_id = application_manager_.GetNextHMICorrelationID();
 
     SetDaysAfterEpoch();
 
@@ -842,7 +870,7 @@ bool PolicyHandler::ReceiveMessageFromSDK(const std::string& file,
     std::vector<std::string> vehicle_data_args;
     vehicle_data_args.push_back(strings::odometer);
     MessageHelper::CreateGetVehicleDataRequest(correlation_id,
-                                               vehicle_data_args);
+                                               vehicle_data_args , application_manager_);
   } else {
     LOG4CXX_WARN(logger_, "Exchange wasn't successful, trying another one.");
     OnPTExchangeNeeded();
@@ -871,15 +899,15 @@ void PolicyHandler::OnAllowSDLFunctionalityNotification(
     bool is_allowed, const std::string& device_mac) {
   LOG4CXX_AUTO_TRACE(logger_);
   POLICY_LIB_CHECK_VOID();
+  using namespace mobile_apis;
   // Device ids, need to be changed
   std::vector<std::string> device_macs;
   const bool device_specific = !device_mac.empty();
   // Common devices consents change
-    connection_handler::ConnectionHandler& connection_handler =
-        application_manager::ApplicationManagerImpl::instance()
-            ->connection_handler();
+  connection_handler::ConnectionHandler& connection_handler =
+      application_manager_.connection_handler();
   if (!device_specific) {
-      connection_handler.GetConnectedDevicesMAC(device_macs);
+    connection_handler.GetConnectedDevicesMAC(device_macs);
   } else {
     device_macs.push_back(device_mac);
   }
@@ -910,7 +938,7 @@ void PolicyHandler::OnAllowSDLFunctionalityNotification(
     }
     DeviceHandles::iterator it = std::find(pending_device_handles_.begin(),
                                            pending_device_handles_.end(),
-                                             device_handle);
+                                           device_handle);
     // If consent done from HMI menu
     if (it == pending_device_handles_.end()) {
       return;
@@ -929,14 +957,13 @@ void PolicyHandler::OnIgnitionCycleOver() {
 void PolicyHandler::OnActivateApp(uint32_t connection_key,
                                   uint32_t correlation_id) {
   LOG4CXX_AUTO_TRACE(logger_);
-
-  ApplicationSharedPtr app =
-      ApplicationManagerImpl::instance()->application(connection_key);
+  POLICY_LIB_CHECK_VOID();
+  ApplicationSharedPtr app = application_manager_.application(connection_key);
   if (!app.valid()) {
     LOG4CXX_WARN(logger_, "Activated App failed: no app found.");
     return;
   }
-  std::string policy_app_id = app->mobile_app_id();
+  std::string policy_app_id = app->policy_app_id();
 
   AppPermissions permissions(policy_app_id);
 
@@ -956,14 +983,14 @@ void PolicyHandler::OnActivateApp(uint32_t connection_key,
   // In this case we need to activate application
   if (false == permissions.appRevoked && true == permissions.isSDLAllowed) {
     LOG4CXX_INFO(logger_, "Application will be activated");
-    if (ApplicationManagerImpl::instance()->ActivateApplication(app)) {
+    if (application_manager_.ActivateApplication(app)) {
       last_activated_app_id_ = 0;
     }
   } else {
     LOG4CXX_WARN(logger_, "Application should not be activated");
   }
 
-  MessageHelper::SendSDLActivateAppResponse(permissions, correlation_id);
+  MessageHelper::SendSDLActivateAppResponse(permissions, correlation_id, application_manager_);
 }
 
 void PolicyHandler::KmsChanged(int kilometers) {
@@ -977,7 +1004,7 @@ void PolicyHandler::PTExchangeAtUserRequest(uint32_t correlation_id) {
   LOG4CXX_TRACE(logger_, "PT exchange at user request");
   POLICY_LIB_CHECK_VOID();
   std::string update_status = policy_manager_->ForcePTExchange();
-  MessageHelper::SendUpdateSDLResponse(update_status, correlation_id);
+  MessageHelper::SendUpdateSDLResponse(update_status, correlation_id, application_manager_);
 }
 
 void PolicyHandler::OnPermissionsUpdated(const std::string& policy_app_id,
@@ -986,8 +1013,7 @@ void PolicyHandler::OnPermissionsUpdated(const std::string& policy_app_id,
   LOG4CXX_AUTO_TRACE(logger_);
   OnPermissionsUpdated(policy_app_id, permissions);
 
-  ApplicationSharedPtr app =
-      ApplicationManagerImpl::instance()->application_by_policy_id(
+  ApplicationSharedPtr app = application_manager_.application_by_policy_id(
           policy_app_id);
   if (!app.valid()) {
     LOG4CXX_WARN(
@@ -1016,16 +1042,17 @@ void PolicyHandler::OnPermissionsUpdated(const std::string& policy_app_id,
     case mobile_apis::HMILevel::HMI_NONE: {
       LOG4CXX_INFO(logger_,
                    "Changing hmi level of application "
-                       << policy_app_id
-                       << " to default hmi level "
+                       << policy_app_id << " to default hmi level "
                        << default_hmi);
 
       if (hmi_level == mobile_apis::HMILevel::HMI_FULL) {
-        ApplicationManagerImpl::instance()->SetState<true>(app->app_id(),
-                                                           hmi_level);
+        application_manager_.state_controller().SetRegularState(app,
+                                                                hmi_level,
+                                                                true);
       } else {
-        ApplicationManagerImpl::instance()->SetState<false>(app->app_id(),
-                                                            hmi_level);
+        application_manager_.state_controller().SetRegularState(app,
+                                                                hmi_level,
+                                                                false);
       }
       break;
     }
@@ -1041,8 +1068,7 @@ void PolicyHandler::OnPermissionsUpdated(const std::string& policy_app_id,
 void PolicyHandler::OnPermissionsUpdated(const std::string& policy_app_id,
                                          const Permissions& permissions) {
   LOG4CXX_AUTO_TRACE(logger_);
-  ApplicationSharedPtr app =
-      ApplicationManagerImpl::instance()->application_by_policy_id(
+  ApplicationSharedPtr app = application_manager_.application_by_policy_id(
           policy_app_id);
   if (!app.valid()) {
     LOG4CXX_WARN(
@@ -1052,13 +1078,12 @@ void PolicyHandler::OnPermissionsUpdated(const std::string& policy_app_id,
   }
 
   MessageHelper::SendOnPermissionsChangeNotification(app->app_id(),
-                                                     permissions);
+                                                     permissions ,application_manager_);
 
-  LOG4CXX_DEBUG(
-      logger_,
-      "Notification sent for application_id:" << policy_app_id
-                                              << " and connection_key "
-                                              << app->app_id());
+  LOG4CXX_DEBUG(logger_,
+                "Notification sent for application_id:"
+                    << policy_app_id << " and connection_key "
+                    << app->app_id());
 }
 
 bool PolicyHandler::SaveSnapshot(const BinaryMessage& pt_string,
@@ -1219,9 +1244,9 @@ void PolicyHandler::OnSystemError(int code) {
   }
 }
 
-custom_str::CustomString PolicyHandler::GetAppName(const std::string& policy_app_id) {
-  ApplicationSharedPtr app =
-      ApplicationManagerImpl::instance()->application_by_policy_id(
+custom_str::CustomString PolicyHandler::GetAppName(
+    const std::string& policy_app_id) {
+  ApplicationSharedPtr app = application_manager_.application_by_policy_id(
           policy_app_id);
 
   if (!app.valid()) {
@@ -1248,7 +1273,8 @@ void PolicyHandler::OnCertificateUpdated(const std::string& certificate_data) {
   sync_primitives::AutoLock lock(listeners_lock_);
   HandlersCollection::const_iterator it = listeners_.begin();
   for (; it != listeners_.end(); ++it) {
-    (*it)->OnCertificateUpdated(certificate_data);
+    PolicyHandlerObserver* observer = *it;
+    observer->OnCertificateUpdated(certificate_data);
   }
 }
 
@@ -1327,7 +1353,7 @@ void policy::PolicyHandler::OnAppsSearchStarted() {
   policy_manager_->OnAppsSearchStarted();
 }
 
-void policy::PolicyHandler::OnAppsSearchCompleted() {
+void PolicyHandler::OnAppsSearchCompleted() {
   POLICY_LIB_CHECK();
   policy_manager_->OnAppsSearchCompleted();
 }
diff --git a/src/components/application_manager/src/policies/pt_exchange_handler_ext.cc b/src/components/application_manager/src/policies/pt_exchange_handler_ext.cc
index eba808f406..df1761ef66 100644
--- a/src/components/application_manager/src/policies/pt_exchange_handler_ext.cc
+++ b/src/components/application_manager/src/policies/pt_exchange_handler_ext.cc
@@ -61,9 +61,9 @@ void PTExchangeHandlerExt::Start() {
   LOG4CXX_TRACE(logger_, "Start exchange PT");
 
   const string policy_snapshot_file_name =
-      Profile::instance()->policies_snapshot_file_name();
+      policy_handler_->get_settings().policies_snapshot_file_name();
   const std::string system_files_path =
-      Profile::instance()->system_files_path();
+      policy_handler_->get_settings().system_files_path();
   const std::string policy_snapshot_full_path = system_files_path + '/' +
       policy_snapshot_file_name;
   BinaryMessageSptr pt_snapshot = policy_handler_->RequestPTUpdate();
diff --git a/src/components/application_manager/src/resumption/resume_ctrl.cc b/src/components/application_manager/src/resumption/resume_ctrl.cc
index 333a3b7f01..02440b13a6 100644
--- a/src/components/application_manager/src/resumption/resume_ctrl.cc
+++ b/src/components/application_manager/src/resumption/resume_ctrl.cc
@@ -34,9 +34,8 @@
 #include <fstream>
 #include <algorithm>
 
-#include "application_manager/application_manager_impl.h"
+#include "application_manager/application_manager.h"
 
-#include "config_profile/profile.h"
 #include "utils/file_system.h"
 #include "connection_handler/connection_handler_impl.h"
 #include "application_manager/message_helper.h"
@@ -44,6 +43,7 @@
 #include "application_manager/commands/command_impl.h"
 #include "policy/policy_manager_impl.h"
 #include "application_manager/policies/policy_handler.h"
+#include "application_manager/state_controller.h"
 #include "utils/helpers.h"
 #include "application_manager/resumption/resumption_data_db.h"
 #include "application_manager/resumption/resumption_data_json.h"
@@ -55,23 +55,31 @@ using namespace application_manager;
 
 CREATE_LOGGERPTR_GLOBAL(logger_, "Resumption")
 
-ResumeCtrl::ResumeCtrl()
-    : queue_lock_(false),
-      restore_hmi_level_timer_(
-          "RsmCtrlRstore", new timer::TimerTaskImpl<ResumeCtrl>(
-                               this, &ResumeCtrl::ApplicationResumptiOnTimer)),
-      save_persistent_data_timer_(
-          "RsmCtrlPercist",
-          new timer::TimerTaskImpl<ResumeCtrl>(this, &ResumeCtrl::SaveDataOnTimer)),
-      is_resumption_active_(false),
-      is_data_saved_(false),
-      launch_time_(time(NULL)) {}
+ResumeCtrl::ResumeCtrl(ApplicationManager& application_manager)
+    : event_engine::EventObserver(application_manager.event_dispatcher()),
+      queue_lock_(false)
+    , restore_hmi_level_timer_(
+          "RsmCtrlRstore",
+          new timer::TimerTaskImpl<ResumeCtrl>(
+              this, &ResumeCtrl::ApplicationResumptiOnTimer))
+    , save_persistent_data_timer_("RsmCtrlPercist",
+                                  new timer::TimerTaskImpl<ResumeCtrl>(
+                                      this, &ResumeCtrl::SaveDataOnTimer))
+    , is_resumption_active_(false)
+    , is_data_saved_(false)
+    , launch_time_(time(NULL))
+    , application_manager_(application_manager) {}
+#ifdef BUILD_TESTS
+void ResumeCtrl::set_resumption_storage(
+    utils::SharedPtr<ResumptionData> mock_storage) {
+  resumption_storage_ = mock_storage;
+}
+#endif  // BUILD_TESTS
 
 bool ResumeCtrl::Init(resumption::LastState& last_state) {
-  using namespace profile;
-  bool use_db = Profile::instance()->use_db_for_resumption();
+  bool use_db = application_manager_.get_settings().use_db_for_resumption();
   if (use_db) {
-    resumption_storage_.reset(new ResumptionDataDB());
+    resumption_storage_.reset(new ResumptionDataDB(application_manager_));
     if (!resumption_storage_->Init()) {
       return false;
     }
@@ -95,7 +103,8 @@ bool ResumeCtrl::Init(resumption::LastState& last_state) {
       db->UpdateDBVersion();
     }
   } else {
-    resumption_storage_.reset(new ResumptionDataJson(last_state));
+    resumption_storage_.reset(new ResumptionDataJson(last_state,
+                                                     application_manager_));
     if (!resumption_storage_->Init()) {
         LOG4CXX_DEBUG(logger_, "Resumption storage initialisation failed");
         return false;
@@ -103,16 +112,15 @@ bool ResumeCtrl::Init(resumption::LastState& last_state) {
   }
   LoadResumeData();
   save_persistent_data_timer_.Start(
-      profile::Profile::instance()
-          ->app_resumption_save_persistent_data_timeout(),
-      false);
+      application_manager_.get_settings().app_resumption_save_persistent_data_timeout(),
+      true);
   return true;
 }
 
 ResumeCtrl::~ResumeCtrl() {}
 
 void ResumeCtrl::SaveAllApplications() {
-  ApplicationManagerImpl::ApplicationListAccessor accessor;
+  DataAccessor<ApplicationSet> accessor(application_manager_.applications());
   std::for_each(accessor.GetData().begin(),
                 accessor.GetData().end(),
                 std::bind1st(std::mem_fun(&ResumeCtrl::SaveApplication), this));
@@ -137,11 +145,11 @@ bool ResumeCtrl::RestoreAppHMIState(ApplicationSharedPtr application) {
   DCHECK_OR_RETURN(application, false);
   LOG4CXX_DEBUG(logger_,
                 "app_id : " << application->app_id() << "; policy_app_id : "
-                            << application->mobile_app_id());
+                            << application->policy_app_id());
   const std::string& device_mac = application->mac_address();
   smart_objects::SmartObject saved_app(smart_objects::SmartType_Map);
   bool result = resumption_storage_->GetSavedApplication(
-      application->mobile_app_id(), device_mac, saved_app);
+      application->policy_app_id(), device_mac, saved_app);
   if (result) {
     DCHECK_OR_RETURN(application, false);
     if (saved_app.keyExists(strings::hmi_level)) {
@@ -164,7 +172,7 @@ bool ResumeCtrl::SetupDefaultHMILevel(ApplicationSharedPtr application) {
   LOG4CXX_AUTO_TRACE(logger_);
   DCHECK_OR_RETURN(application, false);
   mobile_apis::HMILevel::eType default_hmi =
-      ApplicationManagerImpl::instance()->GetDefaultHmiLevel(application);
+      application_manager_.GetDefaultHmiLevel(application);
   return SetAppHMIState(application, default_hmi, false);
 }
 
@@ -174,8 +182,7 @@ void ResumeCtrl::ApplicationResumptiOnTimer() {
   WaitingForTimerList::iterator it = waiting_for_timer_.begin();
 
   for (; it != waiting_for_timer_.end(); ++it) {
-    ApplicationSharedPtr app =
-        ApplicationManagerImpl::instance()->application(*it);
+    ApplicationSharedPtr app = application_manager_.application(*it);
     if (!app) {
       LOG4CXX_ERROR(logger_, "Invalid app_id = " << *it);
       continue;
@@ -213,18 +220,17 @@ bool ResumeCtrl::SetAppHMIState(ApplicationSharedPtr application,
                    << check_policy);
   const std::string& device_mac = application->mac_address();
   if (check_policy &&
-      ApplicationManagerImpl::instance()->
-          GetPolicyHandler().GetUserConsentForDevice(device_mac) !=
-              policy::DeviceConsent::kDeviceAllowed) {
-    LOG4CXX_ERROR(logger_, "Resumption abort. Data consent wasn't allowed");
+          application_manager_.GetUserConsentForDevice(device_mac) !=
+          policy::DeviceConsent::kDeviceAllowed) {
+    LOG4CXX_ERROR(logger_, "Resumption abort. Data consent wasn't allowed.");
     SetupDefaultHMILevel(application);
     return false;
   }
   application->set_is_resuming(true);
-  ApplicationManagerImpl::instance()->SetHmiState(application->app_id(),
-                                                  hmi_level);
+  application_manager_.state_controller().SetRegularState(application,
+                                                          hmi_level);
   LOG4CXX_INFO(logger_,
-               "Application with policy id " << application->mobile_app_id()
+               "Application with policy id " << application->policy_app_id()
                                              << " got HMI level "
                                              << hmi_level);
   return true;
@@ -248,9 +254,9 @@ uint32_t ResumeCtrl::GetHMIApplicationID(const std::string& policy_app_id,
 
 bool ResumeCtrl::RemoveApplicationFromSaved(
     ApplicationConstSharedPtr application) {
-  const std::string device_mac = application->mac_address();
+  const std::string& device_mac = application->mac_address();
   return resumption_storage_->RemoveApplicationFromSaved(
-      application->mobile_app_id(), device_mac);
+      application->policy_app_id(), device_mac);
 }
 
 void ResumeCtrl::OnSuspend() {
@@ -271,9 +277,7 @@ void ResumeCtrl::StartSavePersistentDataTimer() {
   LOG4CXX_AUTO_TRACE(logger_);
   if (!save_persistent_data_timer_.is_running()) {
     save_persistent_data_timer_.Start(
-        profile::Profile::instance()
-            ->app_resumption_save_persistent_data_timeout(),
-        false);
+        application_manager_.get_settings().app_resumption_save_persistent_data_timeout(), true);
   }
 }
 
@@ -292,14 +296,14 @@ bool ResumeCtrl::StartResumption(ApplicationSharedPtr application,
                 " Resume app_id = " << application->app_id() << " hmi_app_id = "
                                     << application->hmi_app_id()
                                     << " policy_id = "
-                                    << application->mobile_app_id()
+                                    << application->policy_app_id()
                                     << " received hash = "
                                     << hash);
   SetupDefaultHMILevel(application);
   smart_objects::SmartObject saved_app;
   const std::string& device_mac = application->mac_address();
   bool result = resumption_storage_->GetSavedApplication(
-      application->mobile_app_id(),
+      application->policy_app_id(),
       device_mac,
       saved_app);
   if (result) {
@@ -324,12 +328,12 @@ bool ResumeCtrl::StartResumptionOnlyHMILevel(ApplicationSharedPtr application) {
                     << "with hmi_app_id "
                     << application->hmi_app_id()
                     << ", policy_app_id "
-                    << application->mobile_app_id());
+                    << application->policy_app_id());
   SetupDefaultHMILevel(application);
   const std::string& device_mac = application->mac_address();
   smart_objects::SmartObject saved_app;
   bool result = resumption_storage_->GetSavedApplication(
-      application->mobile_app_id(),
+      application->policy_app_id(),
       device_mac,
       saved_app);
   if (result) {
@@ -341,14 +345,13 @@ bool ResumeCtrl::StartResumptionOnlyHMILevel(ApplicationSharedPtr application) {
 }
 
 void ResumeCtrl::StartAppHmiStateResumption(ApplicationSharedPtr application) {
-  using namespace profile;
   using namespace date_time;
   LOG4CXX_AUTO_TRACE(logger_);
   DCHECK_OR_RETURN_VOID(application);
   smart_objects::SmartObject saved_app;
   const std::string& device_mac = application->mac_address();
   bool result = resumption_storage_->GetSavedApplication(
-      application->mobile_app_id(),
+      application->policy_app_id(),
       device_mac,
       saved_app);
   DCHECK_OR_RETURN_VOID(result);
@@ -359,17 +362,18 @@ void ResumeCtrl::StartAppHmiStateResumption(ApplicationSharedPtr application) {
       ((0 == ign_off_count) || CheckIgnCycleRestrictions(saved_app));
   if (restore_data_allowed) {
     LOG4CXX_INFO(logger_,
-                 "Resume application " << application->mobile_app_id());
+                 "Resume application " << application->policy_app_id());
     RestoreAppHMIState(application);
     RemoveApplicationFromSaved(application);
   } else {
     LOG4CXX_INFO(logger_,
                  "Do not need to resume application "
-                     << application->mobile_app_id());
+                     << application->policy_app_id());
   }
 }
 
 void ResumeCtrl::ResetLaunchTime() {
+  LOG4CXX_AUTO_TRACE(logger_);
   launch_time_ = time(NULL);
 }
 
@@ -379,11 +383,11 @@ bool ResumeCtrl::CheckPersistenceFilesForResumption(
   DCHECK_OR_RETURN(application, false);
   LOG4CXX_DEBUG(logger_,
                 " Resume app_id = " << application->app_id() << " policy_id = "
-                                    << application->mobile_app_id());
+                                    << application->policy_app_id());
   smart_objects::SmartObject saved_app;
   const std::string& device_mac = application->mac_address();
   bool result = resumption_storage_->GetSavedApplication(
-      application->mobile_app_id(),
+      application->policy_app_id(),
       device_mac,
       saved_app);
   if (result) {
@@ -406,7 +410,7 @@ bool ResumeCtrl::CheckApplicationHash(ApplicationSharedPtr application,
   smart_objects::SmartObject saved_app;
   const std::string& device_mac = application->mac_address();
   bool result = resumption_storage_->GetSavedApplication(
-      application->mobile_app_id(),
+      application->policy_app_id(),
       device_mac,
       saved_app);
   return result ? saved_app[strings::hash_id].asString() == hash : false;
@@ -422,7 +426,7 @@ void ResumeCtrl::SaveDataOnTimer() {
   if (false == is_data_saved_) {
     SaveAllApplications();
     is_data_saved_ = true;
-    if (!(profile::Profile::instance()->use_db_for_resumption())) {
+    if (!application_manager_.get_settings().use_db_for_resumption()) {
       resumption_storage_->Persist();
     }
   }
@@ -430,6 +434,7 @@ void ResumeCtrl::SaveDataOnTimer() {
 
 bool ResumeCtrl::IsDeviceMacAddressEqual(ApplicationSharedPtr application,
                                          const std::string& saved_device_mac) {
+  LOG4CXX_AUTO_TRACE(logger_);
   const std::string device_mac = application->mac_address();
   return device_mac == saved_device_mac;
 }
@@ -442,7 +447,7 @@ bool ResumeCtrl::RestoreApplicationData(ApplicationSharedPtr application) {
   smart_objects::SmartObject saved_app(smart_objects::SmartType_Map);
   const std::string& device_mac = application->mac_address();
   bool result = resumption_storage_->GetSavedApplication(
-      application->mobile_app_id(),
+      application->policy_app_id(),
       device_mac,
       saved_app);
   if (result) {
@@ -508,7 +513,7 @@ void ResumeCtrl::AddSubmenues(ApplicationSharedPtr application,
       application->AddSubMenu(submenu[strings::menu_id].asUInt(), submenu);
     }
     ProcessHMIRequests(
-        MessageHelper::CreateAddSubMenuRequestToHMI(application));
+        MessageHelper::CreateAddSubMenuRequestToHMI(application, application_manager_.GetNextHMICorrelationID()));
   } else {
     LOG4CXX_FATAL(logger_, "application_submenus section is not exists");
   }
@@ -527,7 +532,7 @@ void ResumeCtrl::AddCommands(ApplicationSharedPtr application,
       application->AddCommand(command[strings::cmd_id].asUInt(), command);
     }
     ProcessHMIRequests(
-        MessageHelper::CreateAddCommandRequestToHMI(application));
+        MessageHelper::CreateAddCommandRequestToHMI(application, application_manager_));
   } else {
     LOG4CXX_FATAL(logger_, "application_commands section is not exists");
   }
@@ -547,7 +552,7 @@ void ResumeCtrl::AddChoicesets(ApplicationSharedPtr application,
       application->AddChoiceSet(choice_set_id, choice_set);
     }
     ProcessHMIRequests(
-        MessageHelper::CreateAddVRCommandRequestFromChoiceToHMI(application));
+        MessageHelper::CreateAddVRCommandRequestFromChoiceToHMI(application, application_manager_));
   } else {
     LOG4CXX_FATAL(logger_, "There is no any choicesets");
   }
@@ -562,7 +567,7 @@ void ResumeCtrl::SetGlobalProperties(
     const smart_objects::SmartObject& properties_so =
         saved_app[strings::application_global_properties];
     application->load_global_properties(properties_so);
-    MessageHelper::SendGlobalPropertiesToHMI(application);
+    MessageHelper::SendGlobalPropertiesToHMI(application, application_manager_);
   }
 }
 
@@ -574,8 +579,7 @@ void ResumeCtrl::AddWayPointsSubscription(app_mngr::ApplicationSharedPtr applica
     const smart_objects::SmartObject& subscribed_for_way_points_so =
         saved_app[strings::subscribed_for_way_points];
     if (true == subscribed_for_way_points_so.asBool()) {
-      application_manager::ApplicationManagerImpl::instance()->
-          SubscribeAppForWayPoints(application->app_id());
+      application_manager_.SubscribeAppForWayPoints(application->app_id());
     }
   }
 }
@@ -597,7 +601,7 @@ void ResumeCtrl::AddSubscriptions(ApplicationSharedPtr application,
         application->SubscribeToButton(btn);
       }
     }
-    MessageHelper::SendAllOnButtonSubscriptionNotificationsForApp(application);
+    MessageHelper::SendAllOnButtonSubscriptionNotificationsForApp(application, application_manager_);
 
     if (subscribtions.keyExists(strings::application_vehicle_info)) {
       const smart_objects::SmartObject& subscribtions_ivi =
@@ -607,8 +611,9 @@ void ResumeCtrl::AddSubscriptions(ApplicationSharedPtr application,
         ivi = static_cast<VehicleDataType>((subscribtions_ivi[i]).asInt());
         application->SubscribeToIVI(ivi);
       }
+      ProcessHMIRequests(
+          MessageHelper::GetIVISubscriptionRequests(application, application_manager_));
     }
-    ProcessHMIRequests(MessageHelper::GetIVISubscriptionRequests(application));
   }
 }
 
@@ -632,7 +637,6 @@ bool ResumeCtrl::CheckIgnCycleRestrictions(
 bool ResumeCtrl::DisconnectedJustBeforeIgnOff(
     const smart_objects::SmartObject& saved_app) {
   using namespace date_time;
-  using namespace profile;
   LOG4CXX_AUTO_TRACE(logger_);
   DCHECK_OR_RETURN(saved_app.keyExists(strings::time_stamp), false);
 
@@ -647,9 +651,9 @@ bool ResumeCtrl::DisconnectedJustBeforeIgnOff(
                       << "; sec_spent_before_ign "
                       << sec_spent_before_ign
                       << "; resumption_delay_before_ign "
-                      << Profile::instance()->resumption_delay_before_ign());
+                      << application_manager_.get_settings().resumption_delay_before_ign());
   return sec_spent_before_ign <=
-         Profile::instance()->resumption_delay_before_ign();
+         application_manager_.get_settings().resumption_delay_before_ign();
 }
 
 bool ResumeCtrl::CheckAppRestrictions(
@@ -679,18 +683,17 @@ bool ResumeCtrl::CheckIcons(ApplicationSharedPtr application,
   using namespace smart_objects;
   LOG4CXX_AUTO_TRACE(logger_);
   const mobile_apis::Result::eType verify_images =
-      MessageHelper::VerifyImageFiles(obj, application);
+      MessageHelper::VerifyImageFiles(obj, application, application_manager_);
   return mobile_apis::Result::INVALID_DATA != verify_images;
 }
 
 bool ResumeCtrl::CheckDelayAfterIgnOn() {
   using namespace date_time;
-  using namespace profile;
   LOG4CXX_AUTO_TRACE(logger_);
   const time_t curr_time = time(NULL);
   const time_t sdl_launch_time = launch_time();
   const uint32_t seconds_from_sdl_start = labs(curr_time - sdl_launch_time);
-  const uint32_t wait_time = Profile::instance()->resumption_delay_after_ign();
+  const uint32_t wait_time = application_manager_.get_settings().resumption_delay_after_ign();
   LOG4CXX_DEBUG(logger_,
                 "curr_time " << curr_time << "; sdl_launch_time "
                              << sdl_launch_time
@@ -721,7 +724,7 @@ bool ResumeCtrl::ProcessHMIRequest(smart_objects::SmartObjectSPtr request,
         (*request)[strings::correlation_id].asInt();
     subscribe_on_event(function_id, hmi_correlation_id);
   }
-  if (!ApplicationManagerImpl::instance()->ManageHMICommand(request)) {
+  if (!application_manager_.ManageHMICommand(request)) {
     LOG4CXX_ERROR(logger_, "Unable to send request");
     return false;
   }
@@ -738,15 +741,18 @@ void ResumeCtrl::ProcessHMIRequests(
   }
 }
 
-void ResumeCtrl::AddToResumptionTimerQueue(uint32_t app_id) {
+void ResumeCtrl::AddToResumptionTimerQueue(const uint32_t app_id) {
   LOG4CXX_AUTO_TRACE(logger_);
   queue_lock_.Acquire();
   waiting_for_timer_.push_back(app_id);
   queue_lock_.Release();
+  LOG4CXX_DEBUG(logger_,
+                "Application ID " << app_id << " have been added"
+                                               " to resumption queue.");
   if (!is_resumption_active_) {
     is_resumption_active_ = true;
     restore_hmi_level_timer_.Start(
-        profile::Profile::instance()->app_resuming_timeout(), true);
+        application_manager_.get_settings().app_resuming_timeout(), false);
   }
 }
 
diff --git a/src/components/application_manager/src/resumption/resumption_data.cc b/src/components/application_manager/src/resumption/resumption_data.cc
index d068945d6b..f7332a796d 100644
--- a/src/components/application_manager/src/resumption/resumption_data.cc
+++ b/src/components/application_manager/src/resumption/resumption_data.cc
@@ -34,14 +34,14 @@
 #include "utils/logger.h"
 #include "application_manager/smart_object_keys.h"
 #include "application_manager/vehicle_info_data.h"
+#include "application_manager/application_manager_settings.h"
 
 namespace resumption {
 
 CREATE_LOGGERPTR_GLOBAL(logger_, "Resumption")
 
-ResumptionData::ResumptionData():
-  resumption_lock_(true) {
-}
+ResumptionData::ResumptionData(const application_manager::ApplicationManager& application_manager)
+    : resumption_lock_(true), application_manager_(application_manager) {}
 
 smart_objects::SmartObject ResumptionData::GetApplicationCommands(
     app_mngr::ApplicationConstSharedPtr application) const {
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 6765bf8eff..19d26dc249 100644
--- a/src/components/application_manager/src/resumption/resumption_data_db.cc
+++ b/src/components/application_manager/src/resumption/resumption_data_db.cc
@@ -36,11 +36,11 @@
 #include "application_manager/resumption/resumption_data_db.h"
 #include "application_manager/resumption/resumption_sql_queries.h"
 #include "application_manager/smart_object_keys.h"
-#include "config_profile/profile.h"
 #include "application_manager/message_helper.h"
 #include "utils/helpers.h"
 #include "utils/gen_hash.h"
 #include "utils/scope_guard.h"
+#include "application_manager/application_manager_settings.h"
 
 namespace {
 const std::string kDatabaseName = "resumption";
@@ -49,10 +49,11 @@ const std::string kDatabaseName = "resumption";
 namespace resumption {
 CREATE_LOGGERPTR_GLOBAL(logger_, "Resumption")
 
-ResumptionDataDB::ResumptionDataDB()
-    : db_(new utils::dbms::SQLDatabase(kDatabaseName)) {
+ResumptionDataDB::ResumptionDataDB(const application_manager::ApplicationManager& application_manager)
+    : ResumptionData(application_manager),
+      db_(new utils::dbms::SQLDatabase(kDatabaseName)) {
 #ifndef __QNX__
-  std::string path = profile::Profile::instance()->app_storage_folder();
+  std::string path = application_manager_.get_settings().app_storage_folder();
   if (!path.empty()) {
     db_->set_path(path + "/");
   }
@@ -70,12 +71,10 @@ bool ResumptionDataDB::Init() {
   if (!db_->Open()) {
     LOG4CXX_ERROR(logger_, "Failed opening database.");
     LOG4CXX_INFO(logger_, "Starting opening retries.");
-    const uint16_t attempts =
-        profile::Profile::instance()->attempts_to_open_resumption_db();
+    const uint16_t attempts = application_manager_.get_settings().attempts_to_open_resumption_db();
     LOG4CXX_DEBUG(logger_, "Total attempts number is: " << attempts);
     bool is_opened = false;
-    const uint16_t open_attempt_timeout_ms =
-        profile::Profile::instance()->open_attempt_timeout_ms_resumption_db();
+    const uint16_t open_attempt_timeout_ms = application_manager_.get_settings().open_attempt_timeout_ms_resumption_db();
     const useconds_t sleep_interval_mcsec = open_attempt_timeout_ms * 1000;
     LOG4CXX_DEBUG(logger_,
                   "Open attempt timeout(ms) is: " << open_attempt_timeout_ms);
@@ -140,7 +139,7 @@ void ResumptionDataDB::SaveApplication(
   LOG4CXX_AUTO_TRACE(logger_);
   DCHECK_OR_RETURN_VOID(application);
   bool application_exist = false;
-  const std::string& policy_app_id = application->mobile_app_id();
+  const std::string& policy_app_id = application->policy_app_id();
   const std::string& device_mac = application->mac_address();
   LOG4CXX_INFO(logger_,
                "app_id : " << application->app_id() << " policy_app_id : "
@@ -234,6 +233,7 @@ bool ResumptionDataDB::CheckSavedApplication(const std::string& policy_app_id,
 uint32_t ResumptionDataDB::GetHMIApplicationID(
     const std::string& policy_app_id, const std::string& device_id) const {
   LOG4CXX_AUTO_TRACE(logger_);
+
   uint32_t hmi_app_id = 0;
   SelectHMIId(policy_app_id, device_id, hmi_app_id);
   return hmi_app_id;
@@ -687,9 +687,11 @@ bool ResumptionDataDB::GetAllData(smart_objects::SmartObject& data) const {
   data = smart_objects::SmartObject(smart_objects::SmartType_Array);
 
   uint32_t index = 0;
+  std::string app_id;
+  std::string device_id;
   while (query.Next()) {
-    const std::string app_id = query.GetString(0);
-    const std::string device_id = query.GetString(1);
+    app_id = query.GetString(0);
+    device_id = query.GetString(1);
     if (GetSavedApplication(app_id, device_id, data[index])) {
       ++index;
     }
@@ -2614,8 +2616,7 @@ bool ResumptionDataDB::InsertApplicationData(
   const mobile_apis::HMILevel::eType hmi_level = application.m_hmi_level;
   bool is_media_application = application.m_is_media_application;
   bool is_subscribed_for_way_points =
-      app_mngr::ApplicationManagerImpl::instance()->IsAppSubscribedForWayPoints(
-          connection_key);
+      application_manager_.IsAppSubscribedForWayPoints(connection_key);
 
   if (!query.Prepare(kInsertApplication)) {
     LOG4CXX_WARN(logger_,
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 becc9c19ce..46fb21729e 100644
--- a/src/components/application_manager/src/resumption/resumption_data_json.cc
+++ b/src/components/application_manager/src/resumption/resumption_data_json.cc
@@ -37,7 +37,7 @@
 #include "formatters/CFormatterJsonBase.h"
 #include "application_manager/message_helper.h"
 #include "application_manager/smart_object_keys.h"
-#include "config_profile/profile.h"
+#include "application_manager/application_manager_settings.h"
 
 namespace resumption {
 
@@ -45,8 +45,9 @@ namespace Formatters = NsSmartDeviceLink::NsJSONHandler::Formatters;
 
 CREATE_LOGGERPTR_GLOBAL(logger_, "Resumption")
 
-ResumptionDataJson::ResumptionDataJson(LastState& last_state)
-    : ResumptionData(), last_state_(last_state) {}
+ResumptionDataJson::ResumptionDataJson(LastState& last_state,
+    const application_manager::ApplicationManager& application_manager)
+    : ResumptionData(application_manager), last_state_(last_state) {}
 
 void ResumptionDataJson::SaveApplication(
     app_mngr::ApplicationSharedPtr application) {
@@ -54,7 +55,7 @@ void ResumptionDataJson::SaveApplication(
   LOG4CXX_AUTO_TRACE(logger_);
   DCHECK_OR_RETURN_VOID(application);
 
-  const std::string& policy_app_id = application->mobile_app_id();
+  const std::string& policy_app_id = application->policy_app_id();
   LOG4CXX_DEBUG(logger_,
                 "app_id : " << application->app_id() << " policy_app_id : "
                             << policy_app_id);
@@ -63,8 +64,7 @@ void ResumptionDataJson::SaveApplication(
   const uint32_t time_stamp = (uint32_t)time(NULL);
   const std::string device_mac = application->mac_address();
   const mobile_apis::HMILevel::eType hmi_level = application->hmi_level();
-  const bool is_subscribed_for_way_points =
-      app_mngr::ApplicationManagerImpl::instance()->
+  const bool is_subscribed_for_way_points = application_manager_.
       IsAppSubscribedForWayPoints(application->app_id());
 
   sync_primitives::AutoLock autolock(resumption_lock_);
@@ -185,7 +185,6 @@ uint32_t ResumptionDataJson::GetHMIApplicationID(
 
 void ResumptionDataJson::OnSuspend() {
   using namespace app_mngr;
-  using namespace profile;
   LOG4CXX_AUTO_TRACE(logger_);
   sync_primitives::AutoLock autolock(resumption_lock_);
   Json::Value to_save;