Add using device id for proprietary mode.

7 files changed, 316 insertions, 32 deletions

diff --git a/src/components/application_manager/src/message_helper/message_helper.cc b/src/components/application_manager/src/message_helper/message_helper.cc
index 28f8fd88bb..bae4802e56 100644
--- a/src/components/application_manager/src/message_helper/message_helper.cc
+++ b/src/components/application_manager/src/message_helper/message_helper.cc
@@ -1648,7 +1648,8 @@ bool MessageHelper::CreateHMIApplicationStruct(
   const policy::RequestType::State app_request_types_state =
       policy_handler.GetAppRequestTypeState(policy_app_id);
   if (policy::RequestType::State::AVAILABLE == app_request_types_state) {
-    const auto request_types = policy_handler.GetAppRequestTypes(policy_app_id);
+    const auto request_types =
+        policy_handler.GetAppRequestTypes(app->device(), policy_app_id);
     message[strings::request_type] =
         SmartObject(smart_objects::SmartType_Array);
     smart_objects::SmartObject& request_types_array =
diff --git a/src/components/application_manager/src/policies/policy_handler.cc b/src/components/application_manager/src/policies/policy_handler.cc
index e71d49f4f0..422d180d8c 100644
--- a/src/components/application_manager/src/policies/policy_handler.cc
+++ b/src/components/application_manager/src/policies/policy_handler.cc
@@ -2214,7 +2214,11 @@ bool PolicyHandler::IsRequestTypeAllowed(
     case RequestType::State::AVAILABLE: {
       // If any of request types is available for current application - get them
       const auto request_types =
+#ifdef EXTERNAL_PROPRIETARY_MODE
+          policy_manager_->GetAppRequestTypes(device_id, policy_app_id);
+#else
           policy_manager_->GetAppRequestTypes(policy_app_id);
+#endif
       return helpers::in_range(request_types, stringified_type);
     }
     default:
@@ -2262,7 +2266,11 @@ bool PolicyHandler::IsRequestSubTypeAllowed(
 const std::vector<std::string> PolicyHandler::GetAppRequestTypes(
     const std::string& policy_app_id) const {
   POLICY_LIB_CHECK(std::vector<std::string>());
+#ifdef EXTERNAL_PROPRIETARY_MODE
+  return policy_manager_->GetAppRequestTypes(device_handle, policy_app_id);
+#else
   return policy_manager_->GetAppRequestTypes(policy_app_id);
+#endif
 }
 
 const std::vector<std::string> PolicyHandler::GetAppRequestSubTypes(
diff --git a/src/components/include/policy/policy_regular/policy/policy_listener.h b/src/components/include/policy/policy_regular/policy/policy_listener.h
index 46d015d44b..25e09343f5 100644
--- a/src/components/include/policy/policy_regular/policy/policy_listener.h
+++ b/src/components/include/policy/policy_regular/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(
@@ -99,12 +105,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;
 
   /**
@@ -136,7 +154,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_regular/policy/policy_manager.h b/src/components/include/policy/policy_regular/policy/policy_manager.h
index f8b88d3cbb..cf256f41d6 100644
--- a/src/components/include/policy/policy_regular/policy/policy_manager.h
+++ b/src/components/include/policy/policy_regular/policy/policy_manager.h
@@ -258,14 +258,28 @@ class PolicyManager : public usage_statistics::StatisticsManager {
                                        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
    */
-  virtual bool ReactOnUserDevConsentForApp(const std::string app_id,
-                                           bool is_device_allowed) = 0;
+  DEPRECATED virtual bool ReactOnUserDevConsentForApp(
+      const std::string app_id, 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 transport_manager::DeviceHandle& device_handle,
+      const std::string app_id,
+      bool is_device_allowed) = 0;
 
   /**
    * @brief Sets counter value that passed for receiving PT UPdate.
@@ -310,13 +324,26 @@ class PolicyManager : public usage_statistics::StatisticsManager {
   virtual void SetUserConsentForApp(const PermissionConsent& permissions) = 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
    */
-  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;
+
+  /**
+   * @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& device_id,
+                             const std::string& policy_app_id,
                              std::string* default_hmi) const = 0;
 
   /**
@@ -358,25 +385,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;
 
   /**
@@ -418,13 +466,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;
 
@@ -696,12 +758,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
diff --git a/src/components/policy/policy_regular/include/policy/policy_manager_impl.h b/src/components/policy/policy_regular/include/policy/policy_manager_impl.h
index 76a7ccadee..8f2afb6174 100644
--- a/src/components/policy/policy_regular/include/policy/policy_manager_impl.h
+++ b/src/components/policy/policy_regular/include/policy/policy_manager_impl.h
@@ -263,14 +263,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:
@@ -310,13 +324,26 @@ class PolicyManagerImpl : public PolicyManager {
   void SetUserConsentForApp(const PermissionConsent& permissions) 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
+   */
+  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& policy_app_id,
+  bool GetDefaultHmi(const std::string& device_id,
+                     const std::string& policy_app_id,
                      std::string* default_hmi) const OVERRIDE;
 
   /**
@@ -359,9 +386,11 @@ class PolicyManagerImpl : public PolicyManager {
 
   /**
    * @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
    */
   std::string& GetCurrentDeviceId(
+      const transport_manager::DeviceHandle& device_handle,
       const std::string& policy_app_id) const OVERRIDE;
 
   /**
@@ -401,13 +430,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
@@ -450,22 +490,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
+   */
+  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 std::string& application_id,
+  void SetDefaultHmiTypes(const transport_manager::DeviceHandle& device_handle,
+                          const std::string& application_id,
                           const std::vector<int>& hmi_types) OVERRIDE;
 
   /**
@@ -823,6 +889,14 @@ class PolicyManagerImpl : public PolicyManager {
  private:
   /**
    * 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
    */
@@ -913,12 +987,23 @@ class PolicyManagerImpl : public PolicyManager {
   bool CheckAppStorageFolder() const;
 
   /**
+   * DEPRECATED
    * @brief Checks whether need ask the permission of users
+   * @param app_id policy application id
    * @return true if user consent is needed
    */
   virtual bool IsConsentNeeded(const std::string& app_id);
 
   /**
+   * @brief Checks whether need ask the permission of users
+   * @param device_id device identifier
+   * @param app_id policy application id
+   * @return true if user consent is needed
+   */
+  virtual bool IsConsentNeeded(const std::string& device_id,
+                               const std::string& app_id);
+
+  /**
    * @brief Changes isConsentNeeded for app pending permissions, in case
    * user set permissions before app activation.
    * @param Unique app id
diff --git a/src/components/policy/policy_regular/src/policy_helper.cc b/src/components/policy/policy_regular/src/policy_helper.cc
index a186b9714b..26e4984e6d 100644
--- a/src/components/policy/policy_regular/src/policy_helper.cc
+++ b/src/components/policy/policy_regular/src/policy_helper.cc
@@ -263,31 +263,45 @@ bool CheckAppPolicy::IsKnownAppication(
 
 void policy::CheckAppPolicy::NotifySystem(
     const policy::AppPoliciesValueType& app_policy) const {
-  pm_->listener()->OnPendingPermissionChange(app_policy.first);
+  auto& listener = *pm_->listener();
+  const auto devices_ids = listener.GetDevicesIds(app_policy.first);
+  if (devices_ids.empty()) {
+    LOG4CXX_WARN(
+        logger_,
+        "Couldn't find device info for application id: " << app_policy.first);
+    return;
+  }
+
+  for (const auto& device_id : devices_ids) {
+    listener.OnPendingPermissionChange(device_id, app_policy.first);
+  }
 }
 
 void CheckAppPolicy::SendPermissionsToApp(
     const std::string& app_id, const policy_table::Strings& groups) const {
-  const std::string device_id = pm_->GetCurrentDeviceId(app_id);
-  if (device_id.empty()) {
+  const auto devices_ids = pm_->listener()->GetDevicesIds(app_id);
+  if (devices_ids.empty()) {
     LOG4CXX_WARN(logger_,
                  "Couldn't find device info for application id: " << app_id);
     return;
   }
-  std::vector<FunctionalGroupPermission> group_permissons;
-  pm_->GetPermissionsForApp(device_id, app_id, group_permissons);
 
-  Permissions notification_data;
-  pm_->PrepareNotificationData(update_->policy_table.functional_groupings,
-                               groups,
-                               group_permissons,
-                               notification_data);
+  for (const auto& device_id : devices_ids) {
+    std::vector<FunctionalGroupPermission> group_permissons;
+    pm_->GetPermissionsForApp(device_id, app_id, group_permissons);
+
+    Permissions notification_data;
+    pm_->PrepareNotificationData(update_->policy_table.functional_groupings,
+                                 groups,
+                                 group_permissons,
+                                 notification_data);
 
-  LOG4CXX_INFO(logger_, "Send notification for application_id: " << app_id);
-  // Default_hmi is Ford-specific and should not be used with basic policy
-  const std::string default_hmi;
-  pm_->listener()->OnPermissionsUpdated(
-      device_id, app_id, notification_data, default_hmi);
+    LOG4CXX_INFO(logger_, "Send notification for application_id: " << app_id);
+    // Default_hmi is Ford-specific and should not be used with basic policy
+    const std::string default_hmi;
+    pm_->listener()->OnPermissionsUpdated(
+        device_id, app_id, notification_data, default_hmi);
+  }
 }
 
 bool CheckAppPolicy::IsAppRevoked(
diff --git a/src/components/policy/policy_regular/src/policy_manager_impl.cc b/src/components/policy/policy_regular/src/policy_manager_impl.cc
index c19eb8fee5..15d895583a 100644
--- a/src/components/policy/policy_regular/src/policy_manager_impl.cc
+++ b/src/components/policy/policy_regular/src/policy_manager_impl.cc
@@ -802,6 +802,19 @@ void PolicyManagerImpl::SetUserConsentForDevice(const std::string& device_id,
 
 bool PolicyManagerImpl::ReactOnUserDevConsentForApp(const std::string app_id,
                                                     bool is_device_allowed) {
+  UNUSED(app_id);
+  UNUSED(is_device_allowed);
+
+  return true;
+}
+
+bool PolicyManagerImpl::ReactOnUserDevConsentForApp(
+    const transport_manager::DeviceHandle& device_handle,
+    const std::string app_id,
+    bool is_device_allowed) {
+  UNUSED(device_handle);
+  UNUSED(app_id);
+  UNUSED(is_device_allowed);
   return true;
 }
 
@@ -923,6 +936,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_);
+  const 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_);
@@ -999,7 +1023,7 @@ void PolicyManagerImpl::GetPermissionsForApp(
     app_id_to_check = kDefaultId;
     allowed_by_default = true;
   } else if (cache_->IsPredataPolicy(policy_app_id) ||
-             policy::kDeviceDisallowed == GetUserConsentForDevice(device_id)) {
+             policy::kDeviceAllowed != GetUserConsentForDevice(device_id)) {
     app_id_to_check = kPreDataConsentId;
     allowed_by_default = true;
   }
@@ -1056,7 +1080,17 @@ void PolicyManagerImpl::GetPermissionsForApp(
 std::string& PolicyManagerImpl::GetCurrentDeviceId(
     const std::string& policy_app_id) const {
   LOG4CXX_AUTO_TRACE(logger_);
-  last_device_id_ = listener()->OnCurrentDeviceIdUpdateRequired(policy_app_id);
+  const auto devices_ids = listener()->GetDevicesIds(policy_app_id);
+  last_device_id_ = devices_ids.size() ? devices_ids.back() : last_device_id_;
+  return last_device_id_;
+}
+
+std::string& PolicyManagerImpl::GetCurrentDeviceId(
+    const transport_manager::DeviceHandle& device_handle,
+    const std::string& policy_app_id) const {
+  LOG4CXX_AUTO_TRACE(logger_);
+  last_device_id_ =
+      listener()->OnCurrentDeviceIdUpdateRequired(device_handle, policy_app_id);
   return last_device_id_;
 }
 
@@ -1251,6 +1285,12 @@ bool PolicyManagerImpl::IsConsentNeeded(const std::string& app_id) {
   return false;
 }
 
+bool PolicyManagerImpl::IsConsentNeeded(const std::string& device_id,
+                                        const std::string& app_id) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  return false;
+}
+
 void PolicyManagerImpl::SetVINValue(const std::string& value) {}
 
 AppPermissions PolicyManagerImpl::GetAppPermissionsChanges(
@@ -1268,6 +1308,22 @@ AppPermissions PolicyManagerImpl::GetAppPermissionsChanges(
   return permissions;
 }
 
+AppPermissions PolicyManagerImpl::GetAppPermissionsChanges(
+    const std::string& device_id, const std::string& policy_app_id) {
+  typedef std::map<std::string, AppPermissions>::iterator PermissionsIt;
+  PermissionsIt 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);
+  }
+  return permissions;
+}
+
 void PolicyManagerImpl::RemovePendingPermissionChanges(
     const std::string& app_id) {
   app_permissions_diff_.erase(app_id);
@@ -1365,6 +1421,23 @@ StatusNotifier PolicyManagerImpl::AddApplication(
   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);
+  sync_primitives::AutoLock lock(apps_registration_lock_);
+  if (IsNewApplication(application_id)) {
+    AddNewApplication(application_id, device_consent);
+    return std::make_shared<CallStatusChange>(update_status_manager_,
+                                              device_consent);
+  }
+  PromoteExistedApplication(application_id, device_consent);
+  update_status_manager_.OnExistedApplicationAdded(cache_->UpdateRequired());
+  return std::make_shared<utils::CallNothing>();
+}
+
 void PolicyManagerImpl::RemoveAppConsentForGroup(
     const std::string& app_id, const std::string& group_name) {
   cache_->RemoveAppConsentForGroup(app_id, group_name);
@@ -1489,6 +1562,17 @@ 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 std::string 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);
@@ -1522,7 +1606,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(