Add using device id for proprietary mode.

2 files changed, 116 insertions, 18 deletions

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(