Add using device id for external proprietary mode.

11 files changed, 883 insertions, 129 deletions

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 65030ad7bc..275dd84ac7 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
@@ -117,11 +117,23 @@ class PolicyHandler : public PolicyHandlerInterface,
       const std::string& device_id) const OVERRIDE;
 
   /**
+   * DEPRECATED
+   * @brief Sets HMI default type for specified application
+   * @param application_id ID application
+   * @param app_types list of HMI types
+   */
+  DEPRECATED void SetDefaultHmiTypes(
+      const std::string& application_id,
+      const smart_objects::SmartObject* app_types) OVERRIDE;
+
+  /**
    * @brief Sets HMI default type for specified application
+   * @param device_handle device identifier
    * @param application_id ID application
    * @param app_types list of HMI types
    */
-  void SetDefaultHmiTypes(const std::string& application_id,
+  void SetDefaultHmiTypes(const transport_manager::DeviceHandle& device_handle,
+                          const std::string& application_id,
                           const smart_objects::SmartObject* app_types) OVERRIDE;
 
   /**
@@ -180,7 +192,10 @@ class PolicyHandler : public PolicyHandlerInterface,
   bool GetModuleTypes(const std::string& policy_app_id,
                       std::vector<std::string>* modules) const OVERRIDE;
 
-  bool GetDefaultHmi(const std::string& policy_app_id,
+  DEPRECATED bool GetDefaultHmi(const std::string& policy_app_id,
+                                std::string* default_hmi) const OVERRIDE;
+  bool GetDefaultHmi(const std::string& device_id,
+                     const std::string& policy_app_id,
                      std::string* default_hmi) const OVERRIDE;
   bool GetInitialAppData(const std::string& application_id,
                          StringArray* nicknames = NULL,
@@ -253,7 +268,8 @@ class PolicyHandler : public PolicyHandlerInterface,
    */
   void OnIgnitionCycleOver() OVERRIDE;
 
-  void OnPendingPermissionChange(const std::string& policy_app_id) OVERRIDE;
+  void OnPendingPermissionChange(const std::string& device_id,
+                                 const std::string& policy_app_id) OVERRIDE;
 
   /**
    * Initializes PT exchange at user request
@@ -340,9 +356,11 @@ class PolicyHandler : public PolicyHandlerInterface,
   /**
    * @brief Update currently used device id in policies manager for given
    * application
+   * @param device_handle device identifier
    * @param policy_app_id Application id
    */
   std::string OnCurrentDeviceIdUpdateRequired(
+      const transport_manager::DeviceHandle& device_handle,
       const std::string& policy_app_id) OVERRIDE;
 
   /**
@@ -506,6 +524,7 @@ class PolicyHandler : public PolicyHandlerInterface,
 
   virtual void SendOnAppPermissionsChanged(
       const AppPermissions& permissions,
+      const std::string& device_id,
       const std::string& policy_app_id) const OVERRIDE;
 
   virtual void OnPTExchangeNeeded() OVERRIDE;
@@ -513,13 +532,27 @@ class PolicyHandler : public PolicyHandlerInterface,
   virtual void GetAvailableApps(std::queue<std::string>& apps) OVERRIDE;
 
   /**
+   * DEPRECATED
+   * @brief Allows to add new or update existed application during
+   * registration process
+   * @param application_id The policy aplication id.
+   * @param hmi_types list of hmi types
+   * @return function that will notify update manager about new application
+   */
+  DEPRECATED StatusNotifier AddApplication(
+      const std::string& application_id,
+      const rpc::policy_table_interface_base::AppHmiTypes& hmi_types) OVERRIDE;
+
+  /**
    * @brief Allows to add new or update existed application during
    * registration process
+   * @param device_id device identifier
    * @param application_id The policy aplication id.
    * @param hmi_types list of hmi types
    * @return function that will notify update manager about new application
    */
   StatusNotifier AddApplication(
+      const std::string& device_id,
       const std::string& application_id,
       const rpc::policy_table_interface_base::AppHmiTypes& hmi_types) OVERRIDE;
 
@@ -581,12 +614,25 @@ class PolicyHandler : public PolicyHandlerInterface,
                                const std::string& application_id) OVERRIDE;
 
   /**
+   * DEPRECATED
+   * @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
+   */
+  DEPRECATED bool IsRequestTypeAllowed(
+      const std::string& policy_app_id,
+      mobile_apis::RequestType::eType type) const OVERRIDE;
+
+  /**
    * @brief Checks if certain request type is allowed for application
+   * @param device_handle device identifier
    * @param policy_app_id Unique applicaion id
    * @param type Request type
    * @return true, if allowed, otherwise - false
    */
   bool IsRequestTypeAllowed(
+      const transport_manager::DeviceHandle& device_handle,
       const std::string& policy_app_id,
       mobile_apis::RequestType::eType type) const OVERRIDE;
 
@@ -617,11 +663,22 @@ class PolicyHandler : public PolicyHandlerInterface,
       const std::string& policy_app_id) const OVERRIDE;
 
   /**
+   * DEPRECATED
+   * @brief Gets application request types
+   * @param policy_app_id Unique application id
+   * @return request types
+   */
+  DEPRECATED const std::vector<std::string> GetAppRequestTypes(
+      const std::string& policy_app_id) const OVERRIDE;
+
+  /**
    * @brief Gets application request types
+   * @param device_id device identifier
    * @param policy_app_id Unique application id
    * @return request types
    */
   const std::vector<std::string> GetAppRequestTypes(
+      const transport_manager::DeviceHandle& device_id,
       const std::string& policy_app_id) const OVERRIDE;
 
   /**
@@ -689,6 +746,21 @@ class PolicyHandler : public PolicyHandlerInterface,
   void StartNextRetry();
 
  private:
+  /**
+   * DEPRECATED
+   * @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) OVERRIDE;
+
+  void OnPendingPermissionChange(const std::string& policy_app_id) OVERRIDE;
+
+  void SendOnAppPermissionsChanged(
+      const AppPermissions& permissions,
+      const std::string& policy_app_id) const OVERRIDE;
+
   void OnPermissionsUpdated(const std::string& policy_app_id,
                             const Permissions& permissions,
                             const HMILevel& default_hmi) OVERRIDE;
@@ -748,7 +820,7 @@ class PolicyHandler : public PolicyHandlerInterface,
   void UpdateHMILevel(application_manager::ApplicationSharedPtr app,
                       mobile_apis::HMILevel::eType level);
   std::vector<std::string> GetDevicesIds(
-      const std::string& policy_app_id) OVERRIDE;
+      const std::string& policy_app_id) const OVERRIDE;
 
   /**
    * @brief Sets days after epoch on successful policy update
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/on_system_request_notification.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/on_system_request_notification.cc
index a85dec10bb..fc99bb323c 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/on_system_request_notification.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/on_system_request_notification.cc
@@ -86,8 +86,8 @@ void OnSystemRequestNotification::Run() {
           static_cast<rpc::policy_table_interface_base::RequestType>(
               request_type));
 
-  if (!policy_handler.IsRequestTypeAllowed(app->policy_app_id(),
-                                           request_type)) {
+  if (!policy_handler.IsRequestTypeAllowed(
+          app->device(), app->policy_app_id(), request_type)) {
     LOG4CXX_WARN(logger_,
                  "Request type " << stringified_request_type
                                  << " is not allowed by policies");
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/register_app_interface_request.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/register_app_interface_request.cc
index 15db8ba70c..b5d6cc5cfc 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/register_app_interface_request.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/register_app_interface_request.cc
@@ -841,14 +841,15 @@ void RegisterAppInterfaceRequest::SendRegisterAppInterfaceResponseToMobile(
     }
   }
   policy::StatusNotifier notify_upd_manager = GetPolicyHandler().AddApplication(
-      application->policy_app_id(), hmi_types);
+      application->mac_address(), application->policy_app_id(), hmi_types);
 
   response_params[strings::icon_resumed] =
       file_system::FileExists(application->app_icon_path());
 
   SendResponse(true, result_code, add_info.c_str(), &response_params);
   if (msg_params.keyExists(strings::app_hmi_type)) {
-    GetPolicyHandler().SetDefaultHmiTypes(application->policy_app_id(),
+    GetPolicyHandler().SetDefaultHmiTypes(application->device(),
+                                          application->policy_app_id(),
                                           &(msg_params[strings::app_hmi_type]));
   }
 
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/system_request.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/system_request.cc
index e70433f29b..9be5a270f5 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/system_request.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/system_request.cc
@@ -470,8 +470,8 @@ void SystemRequest::Run() {
           static_cast<rpc::policy_table_interface_base::RequestType>(
               request_type));
 
-  if (!policy_handler.IsRequestTypeAllowed(application->policy_app_id(),
-                                           request_type)) {
+  if (!policy_handler.IsRequestTypeAllowed(
+          application->device(), application->policy_app_id(), request_type)) {
     LOG4CXX_ERROR(logger_,
                   "RequestType " << stringified_request_type
                                  << " is DISALLOWED by policies");
diff --git a/src/components/application_manager/src/application_manager_impl.cc b/src/components/application_manager/src/application_manager_impl.cc
index bf59b03bb3..412b8533ba 100644
--- a/src/components/application_manager/src/application_manager_impl.cc
+++ b/src/components/application_manager/src/application_manager_impl.cc
@@ -1654,7 +1654,8 @@ mobile_apis::HMILevel::eType ApplicationManagerImpl::GetDefaultHmiLevel(
   if (GetPolicyHandler().PolicyEnabled()) {
     const std::string policy_app_id = application->policy_app_id();
     std::string default_hmi_string = "";
-    if (GetPolicyHandler().GetDefaultHmi(policy_app_id, &default_hmi_string)) {
+    if (GetPolicyHandler().GetDefaultHmi(
+            application->mac_address(), policy_app_id, &default_hmi_string)) {
       if ("BACKGROUND" == default_hmi_string) {
         default_hmi = HMILevel::HMI_BACKGROUND;
       } else if ("FULL" == default_hmi_string) {
@@ -2513,8 +2514,24 @@ void ApplicationManagerImpl::CreateApplications(SmartArray& obj_array,
     }
 
     const std::string policy_app_id(app_data[json::appId].asString());
-    ApplicationSharedPtr registered_app =
-        application_by_policy_id(policy_app_id);
+
+    connection_handler::DeviceHandle device_handle;
+    if (-1 == connection_handler().get_session_observer().GetDataOnSessionKey(
+                  connection_key, nullptr, nullptr, &device_handle)) {
+      LOG4CXX_ERROR(logger_,
+                    "Failed to create application: no connection info.");
+      continue;
+    }
+
+    std::string device_id;
+    if (-1 == connection_handler().get_session_observer().GetDataOnDeviceID(
+                  device_handle, nullptr, nullptr, &device_id)) {
+      LOG4CXX_ERROR(logger_,
+                    "Failed to create application: no connection info.");
+      continue;
+    }
+
+    ApplicationSharedPtr registered_app = application(device_id, policy_app_id);
     if (registered_app) {
       LOG4CXX_DEBUG(logger_,
                     "Application with the same id: "
@@ -2553,22 +2570,9 @@ void ApplicationManagerImpl::CreateApplications(SmartArray& obj_array,
     const std::string app_icon_dir(settings_.app_icons_folder());
     const std::string full_icon_path(app_icon_dir + "/" + policy_app_id);
 
-    connection_handler::DeviceHandle device_id = 0;
-
-    if (-1 == connection_handler().get_session_observer().GetDataOnSessionKey(
-                  connection_key, nullptr, nullptr, &device_id)) {
-      LOG4CXX_ERROR(logger_,
-                    "Failed to create application: no connection info.");
-      continue;
-    }
-
-    std::string device_mac;
-    connection_handler().get_session_observer().GetDataOnDeviceID(
-        device_id, nullptr, nullptr, &device_mac, nullptr);
-
     const uint32_t hmi_app_id =
-        resume_controller().IsApplicationSaved(policy_app_id, device_mac)
-            ? resume_controller().GetHMIApplicationID(policy_app_id, device_mac)
+        resume_controller().IsApplicationSaved(policy_app_id, device_id)
+            ? resume_controller().GetHMIApplicationID(policy_app_id, device_id)
             : GenerateNewHMIAppID();
 
     // AppId = 0 because this is query_app(provided by hmi for download, but not
@@ -2576,8 +2580,8 @@ void ApplicationManagerImpl::CreateApplications(SmartArray& obj_array,
     ApplicationSharedPtr app(
         new ApplicationImpl(0,
                             policy_app_id,
-                            device_mac,
                             device_id,
+                            device_handle,
                             appName,
                             GetPolicyHandler().GetStatisticManager(),
                             *this));
diff --git a/src/components/application_manager/src/policies/policy_handler.cc b/src/components/application_manager/src/policies/policy_handler.cc
index 422d180d8c..bf5c5f9419 100644
--- a/src/components/application_manager/src/policies/policy_handler.cc
+++ b/src/components/application_manager/src/policies/policy_handler.cc
@@ -470,7 +470,8 @@ void PolicyHandler::OnDeviceConsentChanged(const std::string& device_id,
         continue;
       }
 
-      policy_manager_->ReactOnUserDevConsentForApp(policy_app_id, is_allowed);
+      policy_manager_->ReactOnUserDevConsentForApp(
+          device_handle, policy_app_id, is_allowed);
 
       policy_manager_->SendNotificationOnPermissionsUpdated(device_id,
                                                             policy_app_id);
@@ -494,6 +495,24 @@ void PolicyHandler::SendOnAppPermissionsChanged(
       app->app_id(), permissions, application_manager_);
 }
 
+void PolicyHandler::SendOnAppPermissionsChanged(
+    const AppPermissions& permissions,
+    const std::string& device_id,
+    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(device_id, policy_app_id);
+  if (app.use_count() == 0) {
+    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() {
   LOG4CXX_AUTO_TRACE(logger_);
   POLICY_LIB_CHECK_VOID();
@@ -519,10 +538,11 @@ struct SmartObjectToInt {
 };
 
 StatusNotifier PolicyHandler::AddApplication(
+    const std::string& device_id,
     const std::string& application_id,
     const rpc::policy_table_interface_base::AppHmiTypes& hmi_types) {
   POLICY_LIB_CHECK(std::make_shared<utils::CallNothing>());
-  return policy_manager_->AddApplication(application_id, hmi_types);
+  return policy_manager_->AddApplication(device_id, application_id, hmi_types);
 }
 
 void PolicyHandler::AddDevice(const std::string& device_id,
@@ -579,7 +599,7 @@ void PolicyHandler::OnAppPermissionConsentInternal(
         app_to_device_link_.begin();
     for (; app_to_device_link_.end() != it; ++it) {
       ApplicationSharedPtr app =
-          application_manager_.application_by_policy_id(it->second);
+          application_manager_.application(it->first, it->second);
 
       // If list of apps sent to HMI for user consents is not the same as
       // current,
@@ -853,10 +873,15 @@ void PolicyHandler::OnUpdateStatusChanged(const std::string& status) {
 }
 
 std::string PolicyHandler::OnCurrentDeviceIdUpdateRequired(
+    const transport_manager::DeviceHandle& device_handle,
     const std::string& policy_app_id) {
   LOG4CXX_AUTO_TRACE(logger_);
-  ApplicationSharedPtr app =
-      application_manager_.application_by_policy_id(policy_app_id);
+  DeviceParams device_params = GetDeviceParams(
+      device_handle,
+      application_manager_.connection_handler().get_session_observer());
+
+  ApplicationSharedPtr app = application_manager_.application(
+      device_params.device_mac_address, policy_app_id);
 
   if (app.use_count() == 0) {
     LOG4CXX_WARN(logger_,
@@ -864,11 +889,8 @@ std::string PolicyHandler::OnCurrentDeviceIdUpdateRequired(
                      << policy_app_id
                      << "' "
                         "not found within registered applications.");
-    return "";
+    return std::string();
   }
-  DeviceParams device_params = GetDeviceParams(
-      app->device(),
-      application_manager_.connection_handler().get_session_observer());
 
   return device_params.device_mac_address;
 }
@@ -926,14 +948,14 @@ void PolicyHandler::OnVehicleDataUpdated(
 }
 
 void PolicyHandler::OnPendingPermissionChange(
-    const std::string& policy_app_id) {
+    const std::string& device_id, const std::string& policy_app_id) {
   LOG4CXX_AUTO_TRACE(logger_);
   LOG4CXX_DEBUG(
       logger_,
       "PolicyHandler::OnPendingPermissionChange for " << policy_app_id);
   POLICY_LIB_CHECK_VOID();
   ApplicationSharedPtr app =
-      application_manager_.application_by_policy_id(policy_app_id);
+      application_manager_.application(device_id, policy_app_id);
   if (app.use_count() == 0) {
     LOG4CXX_WARN(logger_,
                  "No app found for " << policy_app_id << " policy app id.");
@@ -941,7 +963,7 @@ void PolicyHandler::OnPendingPermissionChange(
   }
 
   AppPermissions permissions =
-      policy_manager_->GetAppPermissionsChanges(policy_app_id);
+      policy_manager_->GetAppPermissionsChanges(device_id, policy_app_id);
 
   const uint32_t app_id = app->app_id();
 
@@ -1100,7 +1122,8 @@ struct SDLAlowedNotification {
     if (app->device() == device_id_) {
       std::string hmi_level;
       mobile_apis::HMILevel::eType default_mobile_hmi;
-      policy_manager_->GetDefaultHmi(app->policy_app_id(), &hmi_level);
+      policy_manager_->GetDefaultHmi(
+          app->mac_address(), app->policy_app_id(), &hmi_level);
       if ("BACKGROUND" == hmi_level) {
         default_mobile_hmi = mobile_apis::HMILevel::HMI_BACKGROUND;
       } else if ("FULL" == hmi_level) {
@@ -1257,7 +1280,8 @@ void PolicyHandler::OnActivateApp(uint32_t connection_key,
       permissions.isSDLAllowed = true;
     }
   } else {
-    permissions = policy_manager_->GetAppPermissionsChanges(policy_app_id);
+    permissions = policy_manager_->GetAppPermissionsChanges(app->mac_address(),
+                                                            policy_app_id);
 #ifdef EXTERNAL_PROPRIETARY_MODE
     UsageStatistics& usage = app->usage_report();
 
@@ -1339,7 +1363,7 @@ void PolicyHandler::OnPermissionsUpdated(const std::string& policy_app_id,
   if (app.use_count() == 0) {
     LOG4CXX_WARN(
         logger_,
-        "Connection_key not found for application_id:" << policy_app_id);
+        "Connection_key not found for application_id: " << policy_app_id);
     return;
   }
 
@@ -1396,7 +1420,7 @@ void PolicyHandler::OnPermissionsUpdated(const std::string& device_id,
   if (app.use_count() == 0) {
     LOG4CXX_WARN(
         logger_,
-        "Connection_key not found for application_id:" << policy_app_id);
+        "Connection_key not found for application_id: " << policy_app_id);
     return;
   }
 
@@ -1448,7 +1472,7 @@ void PolicyHandler::OnPermissionsUpdated(const std::string& policy_app_id,
   if (app.use_count() == 0) {
     LOG4CXX_WARN(
         logger_,
-        "Connection_key not found for application_id:" << policy_app_id);
+        "Connection_key not found for application_id: " << policy_app_id);
     return;
   }
 
@@ -1456,7 +1480,7 @@ void PolicyHandler::OnPermissionsUpdated(const std::string& policy_app_id,
       app->app_id(), permissions, application_manager_);
 
   LOG4CXX_DEBUG(logger_,
-                "Notification sent for application_id:"
+                "Notification sent for application_id: "
                     << policy_app_id << " and connection_key "
                     << app->app_id());
 }
@@ -1470,7 +1494,7 @@ void PolicyHandler::OnPermissionsUpdated(const std::string& device_id,
   if (app.use_count() == 0) {
     LOG4CXX_WARN(
         logger_,
-        "Connection_key not found for application_id:" << policy_app_id);
+        "Connection_key not found for application_id: " << policy_app_id);
     return;
   }
 
@@ -1478,7 +1502,7 @@ void PolicyHandler::OnPermissionsUpdated(const std::string& device_id,
       app->app_id(), permissions, application_manager_);
 
   LOG4CXX_DEBUG(logger_,
-                "Notification sent for application_id:"
+                "Notification sent for application_id: "
                     << policy_app_id << " and connection_key "
                     << app->app_id());
 }
@@ -1580,13 +1604,9 @@ void PolicyHandler::CheckPermissions(
                "Checking permissions for  " << app->policy_app_id() << " in "
                                             << hmi_level << " on device "
                                             << device_id << " rpc " << rpc);
-#ifdef EXTERNAL_PROPRIETARY_MODE
-  policy_manager_->CheckPermissions(
-      app->policy_app_id(), hmi_level, rpc, rpc_params, result);
-#else   // EXTERNAL_PROPRIETARY_MODE
+
   policy_manager_->CheckPermissions(
       device_id, app->policy_app_id(), hmi_level, rpc, rpc_params, result);
-#endif  // EXTERNAL_PROPRIETARY_MODE
 }
 
 uint32_t PolicyHandler::GetNotificationsNumber(
@@ -1601,10 +1621,11 @@ DeviceConsent PolicyHandler::GetUserConsentForDevice(
   return policy_manager_->GetUserConsentForDevice(device_id);
 }
 
-bool PolicyHandler::GetDefaultHmi(const std::string& policy_app_id,
+bool PolicyHandler::GetDefaultHmi(const std::string& device_id,
+                                  const std::string& policy_app_id,
                                   std::string* default_hmi) const {
   POLICY_LIB_CHECK(false);
-  return policy_manager_->GetDefaultHmi(policy_app_id, default_hmi);
+  return policy_manager_->GetDefaultHmi(device_id, policy_app_id, default_hmi);
 }
 
 bool PolicyHandler::GetInitialAppData(const std::string& application_id,
@@ -1741,7 +1762,7 @@ custom_str::CustomString PolicyHandler::GetAppName(
   if (app.use_count() == 0) {
     LOG4CXX_WARN(
         logger_,
-        "Connection_key not found for application_id:" << policy_app_id);
+        "Connection_key not found for application_id: " << policy_app_id);
     return custom_str::CustomString("");
   }
   return app->name();
@@ -2186,12 +2207,13 @@ RequestSubType::State PolicyHandler::GetAppRequestSubTypeState(
 }
 
 bool PolicyHandler::IsRequestTypeAllowed(
+    const transport_manager::DeviceHandle& device_id,
     const std::string& policy_app_id,
     mobile_apis::RequestType::eType type) const {
   POLICY_LIB_CHECK(false);
   using namespace mobile_apis;
 
-  std::string stringified_type = RequestTypeToString(type);
+  const std::string stringified_type = RequestTypeToString(type);
   if (stringified_type.empty()) {
     LOG4CXX_ERROR(logger_, "Unknown request type.");
     return false;
@@ -2264,6 +2286,7 @@ bool PolicyHandler::IsRequestSubTypeAllowed(
 }
 
 const std::vector<std::string> PolicyHandler::GetAppRequestTypes(
+    const transport_manager::DeviceHandle& device_handle,
     const std::string& policy_app_id) const {
   POLICY_LIB_CHECK(std::vector<std::string>());
 #ifdef EXTERNAL_PROPRIETARY_MODE
@@ -2320,18 +2343,32 @@ bool PolicyHandler::IsUrlAppIdValid(const uint32_t app_idx,
                                     const EndpointUrls& urls) const {
   const EndpointData& app_data = urls[app_idx];
   const std::vector<std::string> app_urls = app_data.url;
-  const ApplicationSharedPtr app =
-      application_manager_.application_by_policy_id(app_data.app_id);
 
-  const bool is_registered = (app && (app->IsRegistered()));
-  const bool is_default = (app_data.app_id == policy::kDefaultId);
-  const bool is_empty_urls = app_urls.empty();
+  if (policy::kDefaultId == app_data.app_id) {
+    return true;
+  }
+
+  if (app_urls.empty()) {
+    return false;
+  }
 
-  return ((is_registered && !is_empty_urls) || is_default);
+  const auto devices_ids = GetDevicesIds(app_data.app_id);
+  LOG4CXX_TRACE(logger_,
+                "Count devices: " << devices_ids.size()
+                                  << " for app_id: " << app_data.app_id);
+  for (const auto& device_id : devices_ids) {
+    ApplicationSharedPtr app =
+        application_manager_.application(device_id, app_data.app_id);
+    if (app && (app->IsRegistered())) {
+      return true;
+    }
+  }
+
+  return false;
 }
 
 std::vector<std::string> PolicyHandler::GetDevicesIds(
-    const std::string& policy_app_id) {
+    const std::string& policy_app_id) const {
   return application_manager_.devices(policy_app_id);
 }
 
@@ -2405,6 +2442,7 @@ bool PolicyHandler::GetModuleTypes(const std::string& policy_app_id,
 }
 
 void PolicyHandler::SetDefaultHmiTypes(
+    const transport_manager::DeviceHandle& device_handle,
     const std::string& application_id,
     const smart_objects::SmartObject* app_types) {
   LOG4CXX_AUTO_TRACE(logger_);
@@ -2417,7 +2455,7 @@ void PolicyHandler::SetDefaultHmiTypes(
                    std::back_inserter(hmi_types),
                    SmartObjectToInt());
   }
-  policy_manager_->SetDefaultHmiTypes(application_id, hmi_types);
+  policy_manager_->SetDefaultHmiTypes(device_handle, application_id, hmi_types);
 }
 
 bool PolicyHandler::CheckHMIType(const std::string& application_id,
diff --git a/src/components/include/application_manager/policies/policy_handler_interface.h b/src/components/include/application_manager/policies/policy_handler_interface.h
index 8d63450062..c4c1a6a8f9 100644
--- a/src/components/include/application_manager/policies/policy_handler_interface.h
+++ b/src/components/include/application_manager/policies/policy_handler_interface.h
@@ -104,7 +104,10 @@ class PolicyHandlerInterface {
       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,
+  DEPRECATED virtual bool GetDefaultHmi(const std::string& policy_app_id,
+                                        std::string* default_hmi) const = 0;
+  virtual bool GetDefaultHmi(const std::string& device_id,
+                             const std::string& policy_app_id,
                              std::string* default_hmi) const = 0;
   virtual bool GetInitialAppData(const std::string& application_id,
                                  StringArray* nicknames = NULL,
@@ -141,8 +144,13 @@ class PolicyHandlerInterface {
   virtual std::shared_ptr<usage_statistics::StatisticsManager>
   GetStatisticManager() const = 0;
 
+  DEPRECATED virtual void SendOnAppPermissionsChanged(
+      const AppPermissions& permissions,
+      const std::string& policy_app_id) const = 0;
+
   virtual void SendOnAppPermissionsChanged(
       const AppPermissions& permissions,
+      const std::string& device_id,
       const std::string& policy_app_id) const = 0;
 
   /**
@@ -182,7 +190,11 @@ class PolicyHandlerInterface {
    */
   virtual void OnIgnitionCycleOver() = 0;
 
-  virtual void OnPendingPermissionChange(const std::string& policy_app_id) = 0;
+  DEPRECATED virtual void OnPendingPermissionChange(
+      const std::string& policy_app_id) = 0;
+
+  virtual void OnPendingPermissionChange(const std::string& device_id,
+                                         const std::string& policy_app_id) = 0;
 
   /**
    * Initializes PT exchange at user request
@@ -259,11 +271,22 @@ class PolicyHandlerInterface {
   virtual void OnUpdateStatusChanged(const std::string& status) = 0;
 
   /**
+   * DEPRECATED
+   * @brief Update currently used device id in policies manager for given
+   * application
+   * @param policy_app_id Application id
+   */
+  DEPRECATED virtual std::string OnCurrentDeviceIdUpdateRequired(
+      const std::string& policy_app_id) = 0;
+
+  /**
    * @brief Update currently used device id in policies manager for given
    * application
+   * @param device_handle device identifier
    * @param policy_app_id Application id
    */
   virtual std::string OnCurrentDeviceIdUpdateRequired(
+      const transport_manager::DeviceHandle& device_handle,
       const std::string& policy_app_id) = 0;
 
   /**
@@ -346,12 +369,25 @@ class PolicyHandlerInterface {
   virtual void GetAvailableApps(std::queue<std::string>& apps) = 0;
 
   /**
+   * DEPRECATED
+   * @brief Allows to add new or update existed application during
+   * registration process
+   * @param application_id The policy aplication id.
+   * @return function that will notify update manager about new application
+   */
+  DEPRECATED virtual StatusNotifier AddApplication(
+      const std::string& application_id,
+      const rpc::policy_table_interface_base::AppHmiTypes& hmi_types) = 0;
+
+  /**
    * @brief Allows to add new or update existed application during
    * registration process
+   * @param device_id device identifier
    * @param application_id The policy aplication id.
    * @return function that will notify update manager about new application
    */
   virtual StatusNotifier AddApplication(
+      const std::string& device_id,
       const std::string& application_id,
       const rpc::policy_table_interface_base::AppHmiTypes& hmi_types) = 0;
 
@@ -408,12 +444,25 @@ class PolicyHandlerInterface {
                                        const std::string& application_id) = 0;
 
   /**
+   * DEPRECATED
+   * @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
+   */
+  DEPRECATED virtual bool IsRequestTypeAllowed(
+      const std::string& policy_app_id,
+      mobile_apis::RequestType::eType type) const = 0;
+
+  /**
    * @brief Checks if certain request type is allowed for application
+   * @param device_handle device identifier
    * @param policy_app_id Unique applicaion id
    * @param type Request type
    * @return true, if allowed, otherwise - false
    */
   virtual bool IsRequestTypeAllowed(
+      const transport_manager::DeviceHandle& device_handle,
       const std::string& policy_app_id,
       mobile_apis::RequestType::eType type) const = 0;
 
@@ -444,11 +493,22 @@ class PolicyHandlerInterface {
       const std::string& policy_app_id) const = 0;
 
   /**
+   * DEPRECATED
    * @brief Gets application request types
    * @param policy_app_id Unique application id
    * @return request types
    */
+  DEPRECATED virtual const std::vector<std::string> GetAppRequestTypes(
+      const std::string& policy_app_id) const = 0;
+
+  /**
+   * @brief Gets application request types
+   * @param device_handle device identifier
+   * @param policy_app_id Unique application id
+   * @return request types
+   */
   virtual const std::vector<std::string> GetAppRequestTypes(
+      const transport_manager::DeviceHandle& device_handle,
       const std::string& policy_app_id) const = 0;
 
   /**
@@ -583,11 +643,23 @@ class PolicyHandlerInterface {
                                  const std::string& device_id_to) = 0;
 
   /**
+   * DEPERECATED
+   * @brief Sets HMI default type for specified application
+   * @param application_id ID application
+   * @param app_types list of HMI types
+   */
+  DEPRECATED virtual void SetDefaultHmiTypes(
+      const std::string& application_id,
+      const smart_objects::SmartObject* app_types) = 0;
+
+  /**
    * @brief Sets HMI default type for specified application
+   * @param device_handle device identifier
    * @param application_id ID application
    * @param app_types list of HMI types
    */
   virtual void SetDefaultHmiTypes(
+      const transport_manager::DeviceHandle& device_handle,
       const std::string& application_id,
       const smart_objects::SmartObject* app_types) = 0;
 
diff --git a/src/components/include/policy/policy_external/policy/policy_listener.h b/src/components/include/policy/policy_external/policy/policy_listener.h
index fc1af920d5..69a459745b 100644
--- a/src/components/include/policy/policy_external/policy/policy_listener.h
+++ b/src/components/include/policy/policy_external/policy/policy_listener.h
@@ -58,9 +58,15 @@ class PolicyListener {
   virtual void OnPermissionsUpdated(const std::string& device_id,
                                     const std::string& policy_app_id,
                                     const Permissions& permissions) = 0;
-  virtual void OnPendingPermissionChange(const std::string& policy_app_id) = 0;
+  DEPRECATED virtual void OnPendingPermissionChange(
+      const std::string& policy_app_id) = 0;
+  virtual void OnPendingPermissionChange(const std::string& device_id,
+                                         const std::string& policy_app_id) = 0;
   virtual void OnUpdateStatusChanged(const std::string&) = 0;
+  DEPRECATED virtual std::string OnCurrentDeviceIdUpdateRequired(
+      const std::string& policy_app_id) = 0;
   virtual std::string OnCurrentDeviceIdUpdateRequired(
+      const transport_manager::DeviceHandle& device_handle,
       const std::string& policy_app_id) = 0;
   virtual void OnSystemInfoUpdateRequired() = 0;
   virtual custom_str::CustomString GetAppName(
@@ -101,12 +107,24 @@ class PolicyListener {
                                       bool is_allowed) = 0;
 
   /**
+   * DEPRECATED
+   * @brief Sends OnAppPermissionsChanged notification to HMI
+   * @param permissions contains parameter for OnAppPermisionChanged
+   * @param policy_app_id contains policy application id
+   */
+  DEPRECATED virtual void SendOnAppPermissionsChanged(
+      const AppPermissions& permissions,
+      const std::string& policy_app_id) const = 0;
+
+  /**
    * @brief Sends OnAppPermissionsChanged notification to HMI
    * @param permissions contains parameter for OnAppPermisionChanged
+   * @param device_id device identifier
    * @param policy_app_id contains policy application id
    */
   virtual void SendOnAppPermissionsChanged(
       const AppPermissions& permissions,
+      const std::string& device_id,
       const std::string& policy_app_id) const = 0;
 
   /**
@@ -154,7 +172,7 @@ class PolicyListener {
    * @return list devices ids
    */
   virtual std::vector<std::string> GetDevicesIds(
-      const std::string& policy_app_id) = 0;
+      const std::string& policy_app_id) const = 0;
 
   /**
    * Notifies about changing HMI level
diff --git a/src/components/include/policy/policy_external/policy/policy_manager.h b/src/components/include/policy/policy_external/policy/policy_manager.h
index d399e2ef8e..a53ade33aa 100644
--- a/src/components/include/policy/policy_external/policy/policy_manager.h
+++ b/src/components/include/policy/policy_external/policy/policy_manager.h
@@ -130,9 +130,28 @@ class PolicyManager : public usage_statistics::StatisticsManager {
   virtual void RequestPTUpdate() = 0;
 
   /**
+   * DEPRECATED
+   * @brief Check if specified RPC for specified application
+   * has permission to be executed in specified HMI Level
+   * and also its permitted params.
+   * @param app_id Id of application provided during registration
+   * @param hmi_level Current HMI Level of application
+   * @param rpc Name of RPC
+   * @param rpc_params List of RPC params
+   * @param CheckPermissionResult containing flag if HMI Level is allowed
+   * and list of allowed params.
+   */
+  DEPRECATED virtual void CheckPermissions(const PTString& app_id,
+                                           const PTString& hmi_level,
+                                           const PTString& rpc,
+                                           const RPCParams& rpc_params,
+                                           CheckPermissionResult& result) = 0;
+
+  /**
    * @brief Check if specified RPC for specified application
    * has permission to be executed in specified HMI Level
    * and also its permitted params.
+   * @param device_id device identifier
    * @param app_id Id of application provided during registration
    * @param hmi_level Current HMI Level of application
    * @param rpc Name of RPC
@@ -140,7 +159,8 @@ class PolicyManager : public usage_statistics::StatisticsManager {
    * @param CheckPermissionResult containing flag if HMI Level is allowed
    * and list of allowed params.
    */
-  virtual void CheckPermissions(const PTString& app_id,
+  virtual void CheckPermissions(const PTString& device_id,
+                                const PTString& app_id,
                                 const PTString& hmi_level,
                                 const PTString& rpc,
                                 const RPCParams& rpc_params,
@@ -263,14 +283,28 @@ class PolicyManager : public usage_statistics::StatisticsManager {
                                        const bool is_allowed) = 0;
 
   /**
+   * DEPRECATED
+   * @brief Update Application Policies as reaction
+   * on User allowing/disallowing device this app is running on.
+   * @param app_id Unique application id
+   * @param is_device_allowed true if user allowing device otherwise false
+   * @return true if operation was successful
+   */
+  DEPRECATED virtual bool ReactOnUserDevConsentForApp(
+      const std::string& app_id, const bool is_device_allowed) = 0;
+
+  /**
    * @brief Update Application Policies as reaction
    * on User allowing/disallowing device this app is running on.
+   * @param device_handle device identifier
    * @param app_id Unique application id
    * @param is_device_allowed true if user allowing device otherwise false
    * @return true if operation was successful
    */
-  virtual bool ReactOnUserDevConsentForApp(const std::string& app_id,
-                                           const bool is_device_allowed) = 0;
+  virtual bool ReactOnUserDevConsentForApp(
+      const transport_manager::DeviceHandle& device_handle,
+      const std::string& app_id,
+      const bool is_device_allowed) = 0;
 
   /**
    * @brief Sets counter value that passed for receiving PT UPdate.
@@ -317,13 +351,26 @@ class PolicyManager : public usage_statistics::StatisticsManager {
                                     const NotificationMode mode) = 0;
 
   /**
+   * DEPRECATED
+   * @brief Get default HMI level for application
+   * @param policy_app_id Unique application id
+   * @param default_hmi Default HMI level for application or empty, if value
+   * was not set
+   * @return true, if succedeed, otherwise - false
+   */
+  DEPRECATED virtual bool GetDefaultHmi(const std::string& policy_app_id,
+                                        std::string* default_hmi) const = 0;
+
+  /**
    * @brief Get default HMI level for application
+   * @param device_id device identifier
    * @param policy_app_id Unique application id
    * @param default_hmi Default HMI level for application or empty, if value
    * was not set
    * @return true, if succedeed, otherwise - false
    */
-  virtual bool GetDefaultHmi(const std::string& policy_app_id,
+  virtual bool GetDefaultHmi(const std::string& device_id,
+                             const std::string& policy_app_id,
                              std::string* default_hmi) const = 0;
 
   /**
@@ -367,25 +414,46 @@ class PolicyManager : public usage_statistics::StatisticsManager {
       std::vector<FunctionalGroupPermission>& permissions) = 0;
 
   /**
+   * DEPRECATED
    * @brief Gets specific application permissions changes since last policy
    * table update
    * @param policy_app_id Unique application id
    * @return Permissions changes
    */
-  virtual AppPermissions GetAppPermissionsChanges(
+  DEPRECATED virtual AppPermissions GetAppPermissionsChanges(
       const std::string& policy_app_id) = 0;
 
   /**
+   * @brief Gets specific application permissions changes since last policy
+   * table update
+   * @param device_id device identifier
+   * @param policy_app_id Unique application id
+   * @return Permissions changes
+   */
+  virtual AppPermissions GetAppPermissionsChanges(
+      const std::string& device_id, const std::string& policy_app_id) = 0;
+
+  /**
    * @brief Removes specific application permissions changes
    * @param app_id Unique application id
    */
   virtual void RemovePendingPermissionChanges(const std::string& app_id) = 0;
 
   /**
+   * DEPRECATED
+   * @brief Return device id, which hosts specific application
+   * @param policy_app_id Application id, which is required to update device id
+   */
+  DEPRECATED virtual std::string& GetCurrentDeviceId(
+      const std::string& policy_app_id) const = 0;
+
+  /**
    * @brief Return device id, which hosts specific application
+   * @param device_handle device identifier
    * @param policy_app_id Application id, which is required to update device id
    */
   virtual std::string& GetCurrentDeviceId(
+      const transport_manager::DeviceHandle& device_handle,
       const std::string& policy_app_id) const = 0;
 
   /**
@@ -427,13 +495,27 @@ class PolicyManager : public usage_statistics::StatisticsManager {
   virtual void MarkUnpairedDevice(const std::string& device_id) = 0;
 
   /**
+   * DEPRECATED
+   * @brief Adds, application to the db or update existed one
+   * run PTU if policy update is necessary for application.
+   * @param application_id Unique application id
+   * @param hmi_types application HMI types
+   * @return function that will notify update manager about new application
+   */
+  DEPRECATED virtual StatusNotifier AddApplication(
+      const std::string& application_id,
+      const rpc::policy_table_interface_base::AppHmiTypes& hmi_types) = 0;
+
+  /**
    * @brief Adds, application to the db or update existed one
    * run PTU if policy update is necessary for application.
+   * @param device_id device identifier
    * @param application_id Unique application id
    * @param hmi_types application HMI types
    * @return function that will notify update manager about new application
    */
   virtual StatusNotifier AddApplication(
+      const std::string& device_id,
       const std::string& application_id,
       const rpc::policy_table_interface_base::AppHmiTypes& hmi_types) = 0;
 
@@ -552,11 +634,22 @@ class PolicyManager : public usage_statistics::StatisticsManager {
       const std::string& policy_app_id) const = 0;
 
   /**
+   * DEPRECATED
+   * @brief Gets request types for application
+   * @param policy_app_id Unique application id
+   * @return request types of application
+   */
+  DEPRECATED virtual const std::vector<std::string> GetAppRequestTypes(
+      const std::string policy_app_id) const = 0;
+
+  /**
    * @brief Gets request types for application
+   * @param device_handle device identifier
    * @param policy_app_id Unique application id
    * @return request types of application
    */
   virtual const std::vector<std::string> GetAppRequestTypes(
+      const transport_manager::DeviceHandle& device_handle,
       const std::string policy_app_id) const = 0;
 
   /**
@@ -716,12 +809,24 @@ class PolicyManager : public usage_statistics::StatisticsManager {
   virtual AppIdURL GetNextUpdateUrl(const EndpointUrls& urls) = 0;
 
   /**
+   * DEPRECATED
+   * @brief Assigns new HMI types for specified application
+   * @param application_id Unique application id
+   * @param hmi_types new HMI types list
+   */
+  DEPRECATED virtual void SetDefaultHmiTypes(
+      const std::string& application_id, const std::vector<int>& hmi_types) = 0;
+
+  /**
    * @brief Assigns new HMI types for specified application
+   * @param device_handle device identifier
    * @param application_id Unique application id
    * @param hmi_types new HMI types list
    */
-  virtual void SetDefaultHmiTypes(const std::string& application_id,
-                                  const std::vector<int>& hmi_types) = 0;
+  virtual void SetDefaultHmiTypes(
+      const transport_manager::DeviceHandle& device_handle,
+      const std::string& application_id,
+      const std::vector<int>& hmi_types) = 0;
   /**
    * @brief Gets HMI types
    * @param application_id ID application
diff --git a/src/components/policy/policy_external/include/policy/policy_manager_impl.h b/src/components/policy/policy_external/include/policy/policy_manager_impl.h
index c7d9c8478f..2ee7edf472 100644
--- a/src/components/policy/policy_external/include/policy/policy_manager_impl.h
+++ b/src/components/policy/policy_external/include/policy/policy_manager_impl.h
@@ -119,9 +119,28 @@ class PolicyManagerImpl : public PolicyManager {
   void RequestPTUpdate() OVERRIDE;
 
   /**
+   * DEPRECATED
+   * @brief Check if specified RPC for specified application
+   * has permission to be executed in specified HMI Level
+   * and also its permitted params.
+   * @param app_id Id of application provided during registration
+   * @param hmi_level Current HMI Level of application
+   * @param rpc Name of RPC
+   * @param rpc_params List of RPC params
+   * @param result containing flag if HMI Level is allowed
+   * and list of allowed params.
+   */
+  DEPRECATED void CheckPermissions(const PTString& app_id,
+                                   const PTString& hmi_level,
+                                   const PTString& rpc,
+                                   const RPCParams& rpc_params,
+                                   CheckPermissionResult& result) OVERRIDE;
+
+  /**
    * @brief Check if specified RPC for specified application
    * has permission to be executed in specified HMI Level
    * and also its permitted params.
+   * @param device_id device identifier
    * @param app_id Id of application provided during registration
    * @param hmi_level Current HMI Level of application
    * @param rpc Name of RPC
@@ -129,7 +148,8 @@ class PolicyManagerImpl : public PolicyManager {
    * @param result containing flag if HMI Level is allowed
    * and list of allowed params.
    */
-  void CheckPermissions(const PTString& app_id,
+  void CheckPermissions(const PTString& device_id,
+                        const PTString& app_id,
                         const PTString& hmi_level,
                         const PTString& rpc,
                         const RPCParams& rpc_params,
@@ -265,14 +285,28 @@ class PolicyManagerImpl : public PolicyManager {
                                const bool is_allowed) OVERRIDE;
 
   /**
+   * DEPRECATED
+   * @brief Update Application Policies as reaction
+   * on User allowing/disallowing device this app is running on.
+   * @param app_id Unique application id
+   * @param is_device_allowed true if user allowing device otherwise false
+   * @return true if operation was successful
+   */
+  DEPRECATED bool ReactOnUserDevConsentForApp(
+      const std::string& app_id, const bool is_device_allowed) OVERRIDE;
+
+  /**
    * @brief Update Application Policies as reaction
    * on User allowing/disallowing device this app is running on.
+   * @param device_handle device identifier
    * @param app_id Unique application id
    * @param is_device_allowed true if user allowing device otherwise false
    * @return true if operation was successful
    */
-  bool ReactOnUserDevConsentForApp(const std::string& app_id,
-                                   const bool is_device_allowed) OVERRIDE;
+  bool ReactOnUserDevConsentForApp(
+      const transport_manager::DeviceHandle& device_handle,
+      const std::string& app_id,
+      const bool is_device_allowed) OVERRIDE;
 
   /**
    * @brief Retrieves data from app_policies about app on its registration:
@@ -314,13 +348,26 @@ class PolicyManagerImpl : public PolicyManager {
                             const NotificationMode mode) OVERRIDE;
 
   /**
+   * DEPRECATED
    * @brief Get default HMI level for application
    * @param policy_app_id Unique application id
    * @param default_hmi Default HMI level for application or empty, if value
    * was not set
    * @return true, if succedeed, otherwise - false
    */
-  bool GetDefaultHmi(const std::string& policy_app_id,
+  DEPRECATED bool GetDefaultHmi(const std::string& policy_app_id,
+                                std::string* default_hmi) const OVERRIDE;
+
+  /**
+   * @brief Get default HMI level for application
+   * @param device_id device identifier
+   * @param policy_app_id Unique application id
+   * @param default_hmi Default HMI level for application or empty, if value
+   * was not set
+   * @return true, if succedeed, otherwise - false
+   */
+  bool GetDefaultHmi(const std::string& device_id,
+                     const std::string& policy_app_id,
                      std::string* default_hmi) const OVERRIDE;
 
   /**
@@ -365,9 +412,11 @@ class PolicyManagerImpl : public PolicyManager {
 
   /**
    * @brief Return device id, which hosts specific application
+   * @param device_id device identifier
    * @param policy_app_id Application id, which is required to update device id
    */
   std::string& GetCurrentDeviceId(
+      const transport_manager::DeviceHandle& device_id,
       const std::string& policy_app_id) const OVERRIDE;
 
   /**
@@ -407,13 +456,24 @@ class PolicyManagerImpl : public PolicyManager {
   void SetVINValue(const std::string& value) OVERRIDE;
 
   /**
+   * DEPRECATED
    * @brief Gets specific application permissions changes since last policy
    * table update
    * @param policy_app_id Unique application id
    * @return Permissions changes
    */
+  DEPRECATED AppPermissions
+  GetAppPermissionsChanges(const std::string& policy_app_id) OVERRIDE;
+
+  /**
+   * @brief Gets specific application permissions changes since last policy
+   * table update
+   * @param device_id device identifier
+   * @param policy_app_id Unique application id
+   * @return Permissions changes
+   */
   AppPermissions GetAppPermissionsChanges(
-      const std::string& policy_app_id) OVERRIDE;
+      const std::string& device_id, const std::string& policy_app_id) OVERRIDE;
 
   /**
    * @brief Removes specific application permissions changes
@@ -456,22 +516,48 @@ class PolicyManagerImpl : public PolicyManager {
   void MarkUnpairedDevice(const std::string& device_id) OVERRIDE;
 
   /**
+   * DEPRECATED
+   * @brief Adds, application to the db or update existed one
+   * run PTU if policy update is necessary for application.
+   * @param application_id Unique application id
+   * @param hmi_types application HMI types
+   * @return function that will notify update manager about new application
+   */
+  DEPRECATED StatusNotifier AddApplication(
+      const std::string& application_id,
+      const rpc::policy_table_interface_base::AppHmiTypes& hmi_types) OVERRIDE;
+
+  /**
    * @brief Adds, application to the db or update existed one
    * run PTU if policy update is necessary for application.
+   * @param device_id device identifier
    * @param application_id Unique application id
    * @param hmi_types application HMI types
    * @return function that will notify update manager about new application
    */
   StatusNotifier AddApplication(
+      const std::string& device_id,
       const std::string& application_id,
       const rpc::policy_table_interface_base::AppHmiTypes& hmi_types) OVERRIDE;
 
   /**
+   * DEPRECATED
    * @brief Assigns new HMI types for specified application
    * @param application_id Unique application id
    * @param hmi_types new HMI types list
    */
-  void SetDefaultHmiTypes(const std::string& application_id,
+  DEPRECATED void SetDefaultHmiTypes(
+      const std::string& application_id,
+      const std::vector<int>& hmi_types) OVERRIDE;
+
+  /**
+   * @brief Assigns new HMI types for specified application
+   * @param device_handle device identifier
+   * @param application_id Unique application id
+   * @param hmi_types new HMI types list
+   */
+  void SetDefaultHmiTypes(const transport_manager::DeviceHandle& device_handle,
+                          const std::string& application_id,
                           const std::vector<int>& hmi_types) OVERRIDE;
 
   /**
@@ -565,10 +651,12 @@ class PolicyManagerImpl : public PolicyManager {
 
   /**
    * @brief Gets request types for application
+   * @param device_handle device identifier
    * @param policy_app_id Unique application id
    * @return request types of application
    */
   const std::vector<std::string> GetAppRequestTypes(
+      const transport_manager::DeviceHandle& device_handle,
       const std::string policy_app_id) const OVERRIDE;
 
   /**
@@ -854,6 +942,23 @@ class PolicyManagerImpl : public PolicyManager {
  private:
   /**
    * DEPRECATED
+   * @brief Gets request types for application
+   * @param policy_app_id Unique application id
+   * @return request types of application
+   */
+  const std::vector<std::string> GetAppRequestTypes(
+      const std::string policy_app_id) const OVERRIDE;
+
+  /**
+   * DEPRECATED
+   * @brief Return device id, which hosts specific application
+   * @param policy_app_id Application id, which is required to update device id
+   */
+  std::string& GetCurrentDeviceId(
+      const std::string& policy_app_id) const OVERRIDE;
+
+  /**
+   * DEPRECATED
    * @brief Send OnPermissionsUpdated for choosen application
    * @param application_id Unique application id
    */
@@ -941,19 +1046,23 @@ class PolicyManagerImpl : public PolicyManager {
   /**
    * @brief Allows to process case when added application is not present in
    * policy db.
+   * @param device_id device identifier
    * @param policy application id.
    * @param cuuren consent for application's device.
    */
-  void AddNewApplication(const std::string& application_id,
+  void AddNewApplication(const std::string& device_id,
+                         const std::string& application_id,
                          DeviceConsent device_consent);
 
   /**
    * @brief Allows to process case when added application is already
    * in policy db.
+   * @param device_id device identifier
    * @param policy application id.
    * @param cuuren consent for application's device.
    */
-  void PromoteExistedApplication(const std::string& application_id,
+  void PromoteExistedApplication(const std::string& device_id,
+                                 const std::string& application_id,
                                  DeviceConsent device_consent);
 
   /**
@@ -971,9 +1080,12 @@ class PolicyManagerImpl : public PolicyManager {
 
   /**
    * @brief Checks whether need ask the permission of users
+   * @param device_id device identifier
+   * @param appid policy application id
    * @return true if user consent is needed
    */
-  virtual bool IsConsentNeeded(const std::string& app_id);
+  virtual bool IsConsentNeeded(const std::string& device_id,
+                               const std::string& app_id);
 
   /**
    * @brief Changes isConsentNeeded for app pending permissions, in case
@@ -1090,11 +1202,13 @@ class PolicyManagerImpl : public PolicyManager {
    * user consents (if any) and ExternalConsent consents (if any) will be
    * updated
    * appropiately to current ExternalConsent status stored by policy table
+   * @param device_id device identifier
    * @param application_id Application id
    * @param processing_policy Defines whether consents timestamps must be
    * considered or external consents take over
    */
   void ProcessExternalConsentStatusForApp(
+      const std::string& device_id,
       const std::string& application_id,
       const ConsentProcessingPolicy processing_policy);
   /**
@@ -1122,16 +1236,20 @@ class PolicyManagerImpl : public PolicyManager {
 
   /**
    * @brief Notifies system by sending OnAppPermissionChanged notification
+   * @param device_id device identifier
    * @param app_policy Reference to application policy
    */
-  void NotifySystem(const AppPoliciesValueType& app_policy) const;
+  void NotifySystem(const std::string& device_id,
+                    const AppPoliciesValueType& app_policy) const;
 
   /**
    * @brief Sends OnPermissionChange notification to application if its
    * currently registered
+   * @param device_id device identifier
    * @param app_policy Reference to application policy
    */
-  void SendPermissionsToApp(const AppPoliciesValueType& app_policy);
+  void SendPermissionsToApp(const std::string& device_id,
+                            const AppPoliciesValueType& app_policy);
 
   /**
    * @brief Gets groups names from collection of groups permissions
diff --git a/src/components/policy/policy_external/src/policy_manager_impl.cc b/src/components/policy/policy_external/src/policy_manager_impl.cc
index bc2e54800f..09a2ca342c 100644
--- a/src/components/policy/policy_external/src/policy_manager_impl.cc
+++ b/src/components/policy/policy_external/src/policy_manager_impl.cc
@@ -565,33 +565,35 @@ void PolicyManagerImpl::ProcessAppPolicyCheckResults(
 void PolicyManagerImpl::ProcessActionsForAppPolicies(
     const ApplicationsPoliciesActions& actions,
     const policy_table::ApplicationPolicies& app_policies) {
-  ApplicationsPoliciesActions::const_iterator it_actions = actions.begin();
-  for (; it_actions != actions.end(); ++it_actions) {
-    policy_table::ApplicationPolicies::const_iterator app_policy =
-        app_policies.find(it_actions->first);
+  for (const auto& action : actions) {
+    const auto& app_policy = app_policies.find(action.first);
     if (app_policies.end() == app_policy) {
       continue;
     }
 
-    if (it_actions->second.is_consent_needed) {
-      // Post-check after ExternalConsent consent changes
-      const std::string& policy_app_id = app_policy->first;
-      if (!IsConsentNeeded(policy_app_id)) {
-        sync_primitives::AutoLock lock(app_permissions_diff_lock_);
+    const auto devices_ids = listener()->GetDevicesIds(app_policy->first);
+    for (const auto& device_id : devices_ids) {
+      if (action.second.is_consent_needed) {
+        // Post-check after ExternalConsent consent changes
+        const auto& policy_app_id = app_policy->first;
+        if (!IsConsentNeeded(device_id, policy_app_id)) {
+          sync_primitives::AutoLock lock(app_permissions_diff_lock_);
 
-        PendingPermissions::iterator app_id_diff =
-            app_permissions_diff_.find(policy_app_id);
+          const auto& app_id_diff = app_permissions_diff_.find(policy_app_id);
 
-        if (app_permissions_diff_.end() != app_id_diff) {
-          app_id_diff->second.appPermissionsConsentNeeded = false;
+          if (app_permissions_diff_.end() != app_id_diff) {
+            app_id_diff->second.appPermissionsConsentNeeded = false;
+          }
         }
       }
-    }
-    if (it_actions->second.is_notify_system) {
-      NotifySystem(*app_policy);
-    }
-    if (it_actions->second.is_send_permissions_to_app) {
-      SendPermissionsToApp(*app_policy);
+
+      if (action.second.is_notify_system) {
+        NotifySystem(device_id, *app_policy);
+      }
+
+      if (action.second.is_send_permissions_to_app) {
+        SendPermissionsToApp(device_id, *app_policy);
+      }
     }
   }
 }
@@ -726,6 +728,19 @@ const std::vector<std::string> PolicyManagerImpl::GetAppRequestTypes(
   return request_types;
 }
 
+const std::vector<std::string> PolicyManagerImpl::GetAppRequestTypes(
+    const transport_manager::DeviceHandle& device_handle,
+    const std::string policy_app_id) const {
+  std::vector<std::string> request_types;
+  if (kDeviceAllowed != cache_->GetDeviceConsent(
+                            GetCurrentDeviceId(device_handle, policy_app_id))) {
+    cache_->GetAppRequestTypes(kPreDataConsentId, request_types);
+  } else {
+    cache_->GetAppRequestTypes(policy_app_id, request_types);
+  }
+  return request_types;
+}
+
 RequestType::State PolicyManagerImpl::GetAppRequestTypesState(
     const std::string& policy_app_id) const {
   LOG4CXX_AUTO_TRACE(logger_);
@@ -983,6 +998,170 @@ void PolicyManagerImpl::CheckPermissions(const PTString& app_id,
   }
 }
 
+void PolicyManagerImpl::CheckPermissions(const PTString& device_id,
+                                         const PTString& app_id,
+                                         const PTString& hmi_level,
+                                         const PTString& rpc,
+                                         const RPCParams& rpc_params,
+                                         CheckPermissionResult& result) {
+  LOG4CXX_INFO(logger_,
+               "CheckPermissions for " << app_id << " and rpc " << rpc
+                                       << " for " << hmi_level << " level.");
+
+  Permissions rpc_permissions;
+
+  // Check, if there are calculated permission present in cache
+  if (!cache_->IsPermissionsCalculated(device_id, app_id, rpc_permissions)) {
+    LOG4CXX_DEBUG(logger_,
+                  "IsPermissionsCalculated for device: "
+                      << device_id << " and app: " << app_id
+                      << " returns false");
+    // Get actual application group permission according to user consents
+    std::vector<FunctionalGroupPermission> app_group_permissions;
+    GetPermissionsForApp(device_id, app_id, app_group_permissions);
+
+    // Fill struct with known groups RPCs
+    policy_table::FunctionalGroupings functional_groupings;
+    cache_->GetFunctionalGroupings(functional_groupings);
+
+    policy_table::Strings app_groups = GetGroupsNames(app_group_permissions);
+
+    // Undefined groups (without user consent) disallowed by default, since
+    // OnPermissionsChange notification has no "undefined" section
+    // For RPC permission checking undefinded group will be treated as separate
+    // type
+    ProcessFunctionalGroup processor(functional_groupings,
+                                     app_group_permissions,
+                                     rpc_permissions,
+                                     GroupConsent::kGroupUndefined);
+    std::for_each(app_groups.begin(), app_groups.end(), processor);
+
+    cache_->AddCalculatedPermissions(device_id, app_id, rpc_permissions);
+  } else {
+    LOG4CXX_DEBUG(logger_,
+                  "IsPermissionsCalculated for device: "
+                      << device_id << " and app: " << app_id
+                      << " returns true");
+  }
+
+  if (cache_->IsApplicationRevoked(app_id)) {
+    // SDL must be able to notify mobile side with its status after app has
+    // been revoked by backend
+    if ("OnHMIStatus" == rpc && "NONE" == hmi_level) {
+      result.hmi_level_permitted = kRpcAllowed;
+    } else {
+      result.hmi_level_permitted = kRpcDisallowed;
+    }
+    return;
+  }
+
+  const bool known_rpc = rpc_permissions.end() != rpc_permissions.find(rpc);
+  LOG4CXX_DEBUG(logger_, "Is known rpc " << (known_rpc ? "true" : "false"));
+  if (!known_rpc) {
+    // RPC not found in list == disallowed by backend
+    result.hmi_level_permitted = kRpcDisallowed;
+    return;
+  }
+
+  // Check HMI level
+  if (rpc_permissions[rpc].hmi_permissions[kAllowedKey].end() !=
+      rpc_permissions[rpc].hmi_permissions[kAllowedKey].find(hmi_level)) {
+    // RPC found in allowed == allowed by backend and user
+    result.hmi_level_permitted = kRpcAllowed;
+  } else if (rpc_permissions[rpc].hmi_permissions[kUndefinedKey].end() !=
+             rpc_permissions[rpc].hmi_permissions[kUndefinedKey].find(
+                 hmi_level)) {
+    // RPC found in undefined == allowed by backend, but not consented yet by
+    // user
+    result.hmi_level_permitted = kRpcDisallowed;
+  } else if (rpc_permissions[rpc].hmi_permissions[kUserDisallowedKey].end() !=
+             rpc_permissions[rpc].hmi_permissions[kUserDisallowedKey].find(
+                 hmi_level)) {
+    // RPC found in allowed == allowed by backend, but disallowed by user
+    LOG4CXX_DEBUG(
+        logger_,
+        "RPC found in allowed == allowed by backend, but disallowed by user");
+    result.hmi_level_permitted = kRpcUserDisallowed;
+  } else {
+    LOG4CXX_DEBUG(logger_,
+                  "HMI level " << hmi_level << " wasn't found "
+                               << " for rpc " << rpc << " and appID "
+                               << app_id);
+    return;
+  }
+
+  if (kRpcAllowed != result.hmi_level_permitted) {
+    LOG4CXX_DEBUG(logger_, "RPC is not allowed. Stop parameters processing.");
+    result.list_of_allowed_params =
+        rpc_permissions[rpc].parameter_permissions[kAllowedKey];
+
+    result.list_of_disallowed_params =
+        rpc_permissions[rpc].parameter_permissions[kUserDisallowedKey];
+
+    result.list_of_undefined_params =
+        rpc_permissions[rpc].parameter_permissions[kUndefinedKey];
+    return;
+  }
+
+  // Considered that items disallowed by user take priority over system (policy)
+  // permissions, so that flag is processed first
+  if (rpc_permissions[rpc]
+          .parameter_permissions.any_parameter_disallowed_by_user) {
+    LOG4CXX_DEBUG(logger_, "All parameters are disallowed by user.");
+    result.list_of_disallowed_params = rpc_params;
+    result.hmi_level_permitted = kRpcUserDisallowed;
+    return;
+  }
+
+  if (rpc_permissions[rpc]
+          .parameter_permissions.any_parameter_disallowed_by_policy) {
+    LOG4CXX_DEBUG(logger_, "All parameters are disallowed by policy.");
+    result.list_of_undefined_params = rpc_params;
+    result.hmi_level_permitted = kRpcDisallowed;
+    return;
+  }
+
+  if (rpc_permissions[rpc].parameter_permissions.any_parameter_allowed) {
+    LOG4CXX_DEBUG(logger_, "All parameters are allowed.");
+    result.list_of_allowed_params = rpc_params;
+    return;
+  }
+
+  result.list_of_allowed_params =
+      rpc_permissions[rpc].parameter_permissions[kAllowedKey];
+
+  result.list_of_disallowed_params =
+      rpc_permissions[rpc].parameter_permissions[kUserDisallowedKey];
+
+  result.list_of_undefined_params =
+      rpc_permissions[rpc].parameter_permissions[kUndefinedKey];
+
+  // In case of some parameters of RPC are missing in current policy table
+  // they will be considered as disallowed by policy itself, not by user.
+  // Undefined parameters contain parameters present in policy table, but which
+  // have not been allowed or disallowed explicitly by user, so missing params
+  // are being added to undefined.
+  RPCParams::const_iterator parameter = rpc_params.begin();
+  RPCParams::const_iterator end = rpc_params.end();
+  for (; end != parameter; ++parameter) {
+    if (!result.HasParameter(*parameter)) {
+      LOG4CXX_DEBUG(logger_,
+                    "Parameter " << *parameter
+                                 << " is unknown."
+                                    " Adding to undefined list.");
+      result.list_of_undefined_params.insert(*parameter);
+    }
+  }
+
+  if (result.DisallowedInclude(rpc_params)) {
+    LOG4CXX_DEBUG(logger_, "All parameters are disallowed.");
+    result.hmi_level_permitted = kRpcUserDisallowed;
+  } else if (!result.IsAnyAllowed(rpc_params)) {
+    LOG4CXX_DEBUG(logger_, "There are no parameters allowed.");
+    result.hmi_level_permitted = kRpcDisallowed;
+  }
+}
+
 bool PolicyManagerImpl::ResetUserConsent() {
   return cache_->ResetUserConsent();
 }
@@ -1034,7 +1213,7 @@ void PolicyManagerImpl::SendNotificationOnPermissionsUpdated(
   }
 
   std::string default_hmi;
-  GetDefaultHmi(application_id, &default_hmi);
+  GetDefaultHmi(device_id, application_id, &default_hmi);
 
   listener()->OnPermissionsUpdated(
       device_id, application_id, notification_data, default_hmi);
@@ -1076,7 +1255,7 @@ void PolicyManagerImpl::SendNotificationOnPermissionsUpdated(
   }
 
   std::string default_hmi;
-  GetDefaultHmi(application_id, &default_hmi);
+  GetDefaultHmi(device_id, application_id, &default_hmi);
 
   listener()->OnPermissionsUpdated(
       device_id, application_id, notification_data, default_hmi);
@@ -1144,7 +1323,55 @@ bool PolicyManagerImpl::ReactOnUserDevConsentForApp(
   }
 
   if (permissions.requestTypeChanged || (!permissions.priority.empty())) {
-    listener_->SendOnAppPermissionsChanged(permissions, app_id);
+    const auto devices_ids = listener()->GetDevicesIds(app_id);
+    if (devices_ids.size() == 0) {
+      LOG4CXX_WARN(logger_,
+                   "Could not find device info for app_id: " << app_id);
+      return false;
+    }
+    listener_->SendOnAppPermissionsChanged(
+        permissions, devices_ids.back(), app_id);
+  }
+  return result;
+}
+
+bool PolicyManagerImpl::ReactOnUserDevConsentForApp(
+    const transport_manager::DeviceHandle& device_handle,
+    const std::string& app_id,
+    const bool is_device_allowed) {
+  auto current_request_types = GetAppRequestTypes(device_handle, app_id);
+  std::string current_priority, new_priority;
+  GetPriority(app_id, &current_priority);
+
+  bool result = cache_->ReactOnUserDevConsentForApp(app_id, is_device_allowed);
+
+  auto new_request_types = GetAppRequestTypes(device_handle, app_id);
+  GetPriority(app_id, &new_priority);
+  std::sort(current_request_types.begin(), current_request_types.end());
+  std::sort(new_request_types.begin(), new_request_types.end());
+
+  std::vector<std::string> diff;
+  std::set_symmetric_difference(current_request_types.begin(),
+                                current_request_types.end(),
+                                new_request_types.begin(),
+                                new_request_types.end(),
+                                std::back_inserter(diff));
+
+  AppPermissions permissions(app_id);
+
+  if (!diff.empty()) {
+    permissions.requestType = new_request_types;
+    permissions.requestTypeChanged = true;
+  }
+
+  if ((!current_priority.empty()) && (!new_priority.empty()) &&
+      (current_priority != new_priority)) {
+    permissions.priority = new_priority;
+  }
+
+  if (permissions.requestTypeChanged || (!permissions.priority.empty())) {
+    const auto& device_id = GetCurrentDeviceId(device_handle, app_id);
+    listener_->SendOnAppPermissionsChanged(permissions, device_id, app_id);
   }
   return result;
 }
@@ -1333,6 +1560,17 @@ bool PolicyManagerImpl::GetDefaultHmi(const std::string& policy_app_id,
   return cache_->GetDefaultHMI(app_id, *default_hmi);
 }
 
+bool PolicyManagerImpl::GetDefaultHmi(const std::string& device_id,
+                                      const std::string& policy_app_id,
+                                      std::string* default_hmi) const {
+  LOG4CXX_AUTO_TRACE(logger_);
+  DeviceConsent device_consent = GetUserConsentForDevice(device_id);
+  const std::string app_id = policy::kDeviceAllowed != device_consent
+                                 ? kPreDataConsentId
+                                 : policy_app_id;
+  return cache_->GetDefaultHMI(app_id, *default_hmi);
+}
+
 bool PolicyManagerImpl::GetPriority(const std::string& policy_app_id,
                                     std::string* priority) const {
   LOG4CXX_AUTO_TRACE(logger_);
@@ -1430,11 +1668,13 @@ void PolicyManagerImpl::GetPermissionsForApp(
   }
 
   bool allowed_by_default = false;
-  if (cache_->IsDefaultPolicy(policy_app_id)) {
+  const auto device_consent = GetUserConsentForDevice(device_id);
+  if ((policy::kDeviceAllowed == device_consent) &&
+      cache_->IsDefaultPolicy(policy_app_id)) {
     app_id_to_check = kDefaultId;
     allowed_by_default = true;
   } else if (cache_->IsPredataPolicy(policy_app_id) ||
-             policy::kDeviceDisallowed == GetUserConsentForDevice(device_id)) {
+             policy::kDeviceAllowed != device_consent) {
     app_id_to_check = kPreDataConsentId;
     allowed_by_default = true;
   }
@@ -1520,7 +1760,22 @@ void PolicyManagerImpl::GetPermissionsForApp(
 std::string& PolicyManagerImpl::GetCurrentDeviceId(
     const std::string& policy_app_id) const {
   LOG4CXX_INFO(logger_, "GetDeviceInfo");
-  last_device_id_ = listener()->OnCurrentDeviceIdUpdateRequired(policy_app_id);
+  const auto devices_ids = listener()->GetDevicesIds(policy_app_id);
+  if (devices_ids.size() == 0) {
+    LOG4CXX_WARN(logger_,
+                 "Could not find device info for app_id: " << policy_app_id);
+    return last_device_id_;
+  }
+  last_device_id_ = devices_ids.back();
+  return last_device_id_;
+}
+
+std::string& PolicyManagerImpl::GetCurrentDeviceId(
+    const transport_manager::DeviceHandle& device_handle,
+    const std::string& policy_app_id) const {
+  LOG4CXX_INFO(logger_, "GetDeviceInfo");
+  last_device_id_ =
+      listener()->OnCurrentDeviceIdUpdateRequired(device_handle, policy_app_id);
   return last_device_id_;
 }
 
@@ -1624,15 +1879,16 @@ void PolicyManagerImpl::UpdateAppConsentWithExternalConsent(
 }
 
 void PolicyManagerImpl::NotifySystem(
+    const std::string& device_id,
     const PolicyManagerImpl::AppPoliciesValueType& app_policy) const {
-  listener()->OnPendingPermissionChange(app_policy.first);
+  listener()->OnPendingPermissionChange(device_id, app_policy.first);
 }
 
 void PolicyManagerImpl::SendPermissionsToApp(
+    const std::string& device_id,
     const PolicyManagerImpl::AppPoliciesValueType& app_policy) {
   const std::string app_id = app_policy.first;
 
-  const std::string device_id = GetCurrentDeviceId(app_id);
   if (device_id.empty()) {
     LOG4CXX_WARN(logger_,
                  "Couldn't find device info for application id: " << app_id);
@@ -1916,10 +2172,10 @@ bool PolicyManagerImpl::IsApplicationRevoked(const std::string& app_id) const {
   return cache_->IsApplicationRevoked(app_id);
 }
 
-bool PolicyManagerImpl::IsConsentNeeded(const std::string& app_id) {
+bool PolicyManagerImpl::IsConsentNeeded(const std::string& device_id,
+                                        const std::string& app_id) {
   LOG4CXX_AUTO_TRACE(logger_);
-  const std::string device_id = GetCurrentDeviceId(app_id);
-  int count = cache_->CountUnconsentedGroups(app_id, device_id);
+  const int count = cache_->CountUnconsentedGroups(app_id, device_id);
   LOG4CXX_DEBUG(logger_, "There are: " << count << " unconsented groups.");
   return count != 0;
 }
@@ -1938,7 +2194,29 @@ AppPermissions PolicyManagerImpl::GetAppPermissionsChanges(
   if (app_permissions_diff_.end() != app_id_diff) {
     permissions = app_id_diff->second;
   } else {
-    permissions.appPermissionsConsentNeeded = IsConsentNeeded(policy_app_id);
+    const auto devices_ids = listener()->GetDevicesIds(policy_app_id);
+    const auto device_id =
+        devices_ids.size() ? devices_ids.back() : last_device_id_;
+    permissions.appPermissionsConsentNeeded =
+        IsConsentNeeded(device_id, policy_app_id);
+    permissions.appRevoked = IsApplicationRevoked(policy_app_id);
+    GetPriority(permissions.application_id, &permissions.priority);
+  }
+  return permissions;
+}
+
+AppPermissions PolicyManagerImpl::GetAppPermissionsChanges(
+    const std::string& device_id, const std::string& policy_app_id) {
+  PendingPermissions::iterator app_id_diff =
+      app_permissions_diff_.find(policy_app_id);
+
+  AppPermissions permissions(policy_app_id);
+
+  if (app_permissions_diff_.end() != app_id_diff) {
+    permissions = app_id_diff->second;
+  } else {
+    permissions.appPermissionsConsentNeeded =
+        IsConsentNeeded(device_id, policy_app_id);
     permissions.appRevoked = IsApplicationRevoked(policy_app_id);
     GetPriority(permissions.application_id, &permissions.priority);
   }
@@ -2067,17 +2345,41 @@ StatusNotifier PolicyManagerImpl::AddApplication(
     const std::string& application_id,
     const rpc::policy_table_interface_base::AppHmiTypes& hmi_types) {
   LOG4CXX_AUTO_TRACE(logger_);
-  const std::string device_id = GetCurrentDeviceId(application_id);
+  const auto devices_ids = listener()->GetDevicesIds(application_id);
+  const auto device_id =
+      devices_ids.size() ? devices_ids.back() : last_device_id_;
   DeviceConsent device_consent = GetUserConsentForDevice(device_id);
   sync_primitives::AutoLock lock(apps_registration_lock_);
   if (IsNewApplication(application_id)) {
     LOG4CXX_DEBUG(logger_, "Adding new application");
-    AddNewApplication(application_id, device_consent);
+    AddNewApplication(device_id, application_id, device_consent);
+    return std::make_shared<CallStatusChange>(update_status_manager_,
+                                              device_consent);
+  }
+  LOG4CXX_DEBUG(logger_, "Promote existed application");
+  PromoteExistedApplication(device_id, application_id, device_consent);
+  update_status_manager_.OnExistedApplicationAdded(cache_->UpdateRequired());
+  return std::make_shared<utils::CallNothing>();
+}
+
+StatusNotifier PolicyManagerImpl::AddApplication(
+    const std::string& device_id,
+    const std::string& application_id,
+    const rpc::policy_table_interface_base::AppHmiTypes& hmi_types) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  auto device_consent = GetUserConsentForDevice(device_id);
+  LOG4CXX_DEBUG(logger_,
+                "check_device_id: " << device_id << " check_device_consent: "
+                                    << device_consent);
+  sync_primitives::AutoLock lock(apps_registration_lock_);
+  if (IsNewApplication(application_id)) {
+    LOG4CXX_DEBUG(logger_, "Adding new application");
+    AddNewApplication(device_id, application_id, device_consent);
     return std::make_shared<CallStatusChange>(update_status_manager_,
                                               device_consent);
   }
   LOG4CXX_DEBUG(logger_, "Promote existed application");
-  PromoteExistedApplication(application_id, device_consent);
+  PromoteExistedApplication(device_id, application_id, device_consent);
   update_status_manager_.OnExistedApplicationAdded(cache_->UpdateRequired());
   return std::make_shared<utils::CallNothing>();
 }
@@ -2094,6 +2396,7 @@ bool PolicyManagerImpl::IsPredataPolicy(
 }
 
 void PolicyManagerImpl::ProcessExternalConsentStatusForApp(
+    const std::string& device_id,
     const std::string& application_id,
     const ConsentProcessingPolicy processing_policy) {
   ExternalConsentStatus status = cache_->GetExternalConsentStatus();
@@ -2105,7 +2408,7 @@ void PolicyManagerImpl::ProcessExternalConsentStatusForApp(
   CalculateGroupsConsentFromExternalConsent(
       groups_by_status, allowed_groups, disallowed_groups);
 
-  const std::string device_id = GetCurrentDeviceId(application_id);
+  LOG4CXX_DEBUG(logger_, "check device_id: " << device_id);
   UpdateAppConsentWithExternalConsent(device_id,
                                       application_id,
                                       allowed_groups,
@@ -2113,7 +2416,8 @@ void PolicyManagerImpl::ProcessExternalConsentStatusForApp(
                                       processing_policy);
 }
 
-void PolicyManagerImpl::AddNewApplication(const std::string& application_id,
+void PolicyManagerImpl::AddNewApplication(const std::string& device_id,
+                                          const std::string& application_id,
                                           DeviceConsent device_consent) {
   LOG4CXX_AUTO_TRACE(logger_);
 
@@ -2133,19 +2437,31 @@ void PolicyManagerImpl::AddNewApplication(const std::string& application_id,
   }
 
   ProcessExternalConsentStatusForApp(
-      application_id, ConsentProcessingPolicy::kExternalConsentBased);
+      device_id,
+      application_id,
+      ConsentProcessingPolicy::kExternalConsentBased);
 }
 
 void PolicyManagerImpl::PromoteExistedApplication(
-    const std::string& application_id, DeviceConsent device_consent) {
+    const std::string& device_id,
+    const std::string& application_id,
+    DeviceConsent device_consent) {
   // If device consent changed to allowed during application being
   // disconnected, app permissions should be changed also
+  LOG4CXX_DEBUG(logger_,
+                "kDeviceAllowed == device_consent: "
+                    << (kDeviceAllowed == device_consent)
+                    << " device_consent: " << device_consent);
   if (kDeviceAllowed == device_consent &&
       cache_->IsPredataPolicy(application_id)) {
+    LOG4CXX_INFO(logger_,
+                 "Setting "
+                     << policy::kDefaultId
+                     << " permissions for application id: " << application_id);
     cache_->SetDefaultPolicy(application_id);
   }
-  ProcessExternalConsentStatusForApp(application_id,
-                                     ConsentProcessingPolicy::kTimestampBased);
+  ProcessExternalConsentStatusForApp(
+      device_id, application_id, ConsentProcessingPolicy::kTimestampBased);
 }
 
 bool PolicyManagerImpl::IsNewApplication(
@@ -2233,6 +2549,16 @@ void PolicyManagerImpl::SetDefaultHmiTypes(const std::string& application_id,
   access_remote_->SetDefaultHmiTypes(who, hmi_types);
 }
 
+void PolicyManagerImpl::SetDefaultHmiTypes(
+    const transport_manager::DeviceHandle& device_handle,
+    const std::string& application_id,
+    const std::vector<int>& hmi_types) {
+  LOG4CXX_INFO(logger_, "SetDefaultHmiTypes");
+  const auto device_id = GetCurrentDeviceId(device_handle, application_id);
+  ApplicationOnDevice who = {device_id, application_id};
+  access_remote_->SetDefaultHmiTypes(who, hmi_types);
+}
+
 struct HMITypeToInt {
   int operator()(const policy_table::AppHMITypes::value_type item) {
     return policy_table::AppHMIType(item);
@@ -2266,7 +2592,7 @@ bool PolicyManagerImpl::CheckModule(const PTString& app_id,
 
 void PolicyManagerImpl::SendHMILevelChanged(const ApplicationOnDevice& who) {
   std::string default_hmi("NONE");
-  if (GetDefaultHmi(who.app_id, &default_hmi)) {
+  if (GetDefaultHmi(who.dev_id, who.app_id, &default_hmi)) {
     listener()->OnUpdateHMIStatus(who.dev_id, who.app_id, default_hmi);
   } else {
     LOG4CXX_WARN(