Adjustment of proprietary policy component for multiple devices.

8 files changed, 253 insertions, 21 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 917f8be559..65030ad7bc 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
@@ -87,11 +87,14 @@ class PolicyHandler : public PolicyHandlerInterface,
   bool ReceiveMessageFromSDK(const std::string& file,
                              const BinaryMessage& pt_string) OVERRIDE;
   bool UnloadPolicyLibrary() OVERRIDE;
-  virtual void OnPermissionsUpdated(const std::string& policy_app_id,
+
+  virtual void OnPermissionsUpdated(const std::string& device_id,
+                                    const std::string& policy_app_id,
                                     const Permissions& permissions,
                                     const HMILevel& default_hmi) OVERRIDE;
 
-  virtual void OnPermissionsUpdated(const std::string& policy_app_id,
+  virtual void OnPermissionsUpdated(const std::string& device_id,
+                                    const std::string& policy_app_id,
                                     const Permissions& permissions) OVERRIDE;
 
 #ifdef EXTERNAL_PROPRIETARY_MODE
@@ -556,13 +559,26 @@ class PolicyHandler : public PolicyHandlerInterface,
   void OnAppsSearchCompleted(const bool trigger_ptu) OVERRIDE;
 
   /**
+   * DEPRECATED
    * @brief OnAppRegisteredOnMobile allows to handle event when application were
    * succesfully registered on mobile device.
    * It will send OnAppPermissionSend notification and will try to start PTU.
    *
    * @param application_id registered application.
    */
-  void OnAppRegisteredOnMobile(const std::string& application_id) OVERRIDE;
+  DEPRECATED void OnAppRegisteredOnMobile(
+      const std::string& application_id) OVERRIDE;
+
+  /**
+   * @brief OnAppRegisteredOnMobile allows to handle event when application were
+   * succesfully registered on mobile device.
+   * It will send OnAppPermissionSend notification and will try to start PTU.
+   *
+   * @param device_id device identifier
+   * @param application_id registered application.
+   */
+  void OnAppRegisteredOnMobile(const std::string& device_id,
+                               const std::string& application_id) OVERRIDE;
 
   /**
    * @brief Checks if certain request type is allowed for application
@@ -673,6 +689,13 @@ class PolicyHandler : public PolicyHandlerInterface,
   void StartNextRetry();
 
  private:
+  void OnPermissionsUpdated(const std::string& policy_app_id,
+                            const Permissions& permissions,
+                            const HMILevel& default_hmi) OVERRIDE;
+
+  void OnPermissionsUpdated(const std::string& policy_app_id,
+                            const Permissions& permissions) OVERRIDE;
+
   /**
    * Checks system action of application for permission of keep context
    * @param system_action system action (see mobile api)
diff --git a/src/components/application_manager/src/policies/policy_handler.cc b/src/components/application_manager/src/policies/policy_handler.cc
index cac09bd5f3..e71d49f4f0 100644
--- a/src/components/application_manager/src/policies/policy_handler.cc
+++ b/src/components/application_manager/src/policies/policy_handler.cc
@@ -472,7 +472,8 @@ void PolicyHandler::OnDeviceConsentChanged(const std::string& device_id,
 
       policy_manager_->ReactOnUserDevConsentForApp(policy_app_id, is_allowed);
 
-      policy_manager_->SendNotificationOnPermissionsUpdated(policy_app_id);
+      policy_manager_->SendNotificationOnPermissionsUpdated(device_id,
+                                                            policy_app_id);
     }
   }
 }
@@ -1383,6 +1384,62 @@ void PolicyHandler::OnPermissionsUpdated(const std::string& policy_app_id,
   }
 }
 
+void PolicyHandler::OnPermissionsUpdated(const std::string& device_id,
+                                         const std::string& policy_app_id,
+                                         const Permissions& permissions,
+                                         const HMILevel& default_hmi) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  OnPermissionsUpdated(device_id, policy_app_id, permissions);
+
+  ApplicationSharedPtr app =
+      application_manager_.application(device_id, policy_app_id);
+  if (app.use_count() == 0) {
+    LOG4CXX_WARN(
+        logger_,
+        "Connection_key not found for application_id:" << policy_app_id);
+    return;
+  }
+
+  // The application currently not running (i.e. in NONE) should change HMI
+  // level to default
+  mobile_apis::HMILevel::eType current_hmi_level = app->hmi_level();
+  mobile_apis::HMILevel::eType hmi_level =
+      MessageHelper::StringToHMILevel(default_hmi);
+
+  if (mobile_apis::HMILevel::INVALID_ENUM == hmi_level) {
+    LOG4CXX_WARN(
+        logger_,
+        "Couldn't convert default hmi level " << default_hmi << " to enum.");
+    return;
+  }
+  if (current_hmi_level == hmi_level) {
+    LOG4CXX_DEBUG(logger_, "Application already in default hmi state.");
+    return;
+  }
+  switch (current_hmi_level) {
+    case mobile_apis::HMILevel::HMI_NONE: {
+      LOG4CXX_INFO(logger_,
+                   "Changing hmi level of application "
+                       << policy_app_id << " to default hmi level "
+                       << default_hmi);
+
+      const bool is_full_hmi_level =
+          mobile_apis::HMILevel::HMI_FULL == hmi_level;
+
+      application_manager_.state_controller().SetRegularState(
+          app, hmi_level, is_full_hmi_level);
+
+      break;
+    }
+    default:
+      LOG4CXX_WARN(logger_,
+                   "Application " << policy_app_id
+                                  << " is running."
+                                     "HMI level won't be changed.");
+      break;
+  }
+}
+
 void PolicyHandler::OnPermissionsUpdated(const std::string& policy_app_id,
                                          const Permissions& permissions) {
   LOG4CXX_AUTO_TRACE(logger_);
@@ -1404,6 +1461,28 @@ void PolicyHandler::OnPermissionsUpdated(const std::string& policy_app_id,
                     << app->app_id());
 }
 
+void PolicyHandler::OnPermissionsUpdated(const std::string& device_id,
+                                         const std::string& policy_app_id,
+                                         const Permissions& permissions) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  ApplicationSharedPtr app =
+      application_manager_.application(device_id, policy_app_id);
+  if (app.use_count() == 0) {
+    LOG4CXX_WARN(
+        logger_,
+        "Connection_key not found for application_id:" << policy_app_id);
+    return;
+  }
+
+  MessageHelper::SendOnPermissionsChangeNotification(
+      app->app_id(), permissions, application_manager_);
+
+  LOG4CXX_DEBUG(logger_,
+                "Notification sent for application_id:"
+                    << policy_app_id << " and connection_key "
+                    << app->app_id());
+}
+
 bool PolicyHandler::SaveSnapshot(const BinaryMessage& pt_string,
                                  std::string& snap_path) {
   const std::string& policy_snapshot_file_name =
@@ -2080,7 +2159,18 @@ void PolicyHandler::OnAppsSearchCompleted(const bool trigger_ptu) {
 
 void PolicyHandler::OnAppRegisteredOnMobile(const std::string& application_id) {
   POLICY_LIB_CHECK_VOID();
-  policy_manager_->OnAppRegisteredOnMobile(application_id);
+  const auto app =
+      application_manager_.application_by_policy_id(application_id);
+  if (app.use_count()) {
+    policy_manager_->OnAppRegisteredOnMobile(app->mac_address(),
+                                             application_id);
+  }
+}
+
+void PolicyHandler::OnAppRegisteredOnMobile(const std::string& device_id,
+                                            const std::string& application_id) {
+  POLICY_LIB_CHECK_VOID();
+  policy_manager_->OnAppRegisteredOnMobile(device_id, application_id);
 }
 
 RequestType::State PolicyHandler::GetAppRequestTypeState(
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 835ddedd28..8d63450062 100644
--- a/src/components/include/application_manager/policies/policy_handler_interface.h
+++ b/src/components/include/application_manager/policies/policy_handler_interface.h
@@ -71,11 +71,17 @@ class PolicyHandlerInterface {
   virtual bool ReceiveMessageFromSDK(const std::string& file,
                                      const BinaryMessage& pt_string) = 0;
   virtual bool UnloadPolicyLibrary() = 0;
-  virtual void OnPermissionsUpdated(const std::string& policy_app_id,
+  DEPRECATED virtual void OnPermissionsUpdated(const std::string& policy_app_id,
+                                               const Permissions& permissions,
+                                               const HMILevel& default_hmi) = 0;
+  virtual void OnPermissionsUpdated(const std::string& device_id,
+                                    const std::string& policy_app_id,
                                     const Permissions& permissions,
                                     const HMILevel& default_hmi) = 0;
-
-  virtual void OnPermissionsUpdated(const std::string& policy_app_id,
+  DEPRECATED virtual void OnPermissionsUpdated(
+      const std::string& policy_app_id, const Permissions& permissions) = 0;
+  virtual void OnPermissionsUpdated(const std::string& device_id,
+                                    const std::string& policy_app_id,
                                     const Permissions& permissions) = 0;
 
 #ifdef EXTERNAL_PROPRIETARY_MODE
@@ -380,13 +386,26 @@ class PolicyHandlerInterface {
   virtual void OnAppsSearchCompleted(const bool trigger_ptu) = 0;
 
   /**
+   * DEPRECATED
+   * @brief OnAppRegisteredOnMobile allows to handle event when application were
+   * succesfully registered on mobile device.
+   * It will send OnAppPermissionSend notification and will try to start PTU.
+   *
+   * @param application_id registered application.
+   */
+  DEPRECATED virtual void OnAppRegisteredOnMobile(
+      const std::string& application_id) = 0;
+
+  /**
    * @brief OnAppRegisteredOnMobile allows to handle event when application were
    * succesfully registered on mobile device.
    * It will send OnAppPermissionSend notification and will try to start PTU.
    *
+   * @param device_id device identifier
    * @param application_id registered application.
    */
-  virtual void OnAppRegisteredOnMobile(const std::string& application_id) = 0;
+  virtual void OnAppRegisteredOnMobile(const std::string& device_id,
+                                       const std::string& application_id) = 0;
 
   /**
    * @brief Checks if certain request type is allowed for application
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 f12bb2e85f..46d015d44b 100644
--- a/src/components/include/policy/policy_regular/policy/policy_listener.h
+++ b/src/components/include/policy/policy_regular/policy/policy_listener.h
@@ -45,10 +45,18 @@ namespace custom_str = utils::custom_string;
 class PolicyListener {
  public:
   virtual ~PolicyListener() {}
-  virtual void OnPermissionsUpdated(const std::string& policy_app_id,
+  DEPRECATED virtual void OnPermissionsUpdated(
+      const std::string& policy_app_id,
+      const Permissions& permissions,
+      const policy::HMILevel& default_hmi) = 0;
+  virtual void OnPermissionsUpdated(const std::string& device_id,
+                                    const std::string& policy_app_id,
                                     const Permissions& permissions,
                                     const policy::HMILevel& default_hmi) = 0;
-  virtual void OnPermissionsUpdated(const std::string& policy_app_id,
+  DEPRECATED virtual void OnPermissionsUpdated(
+      const std::string& policy_app_id, const Permissions& permissions) = 0;
+  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;
   virtual void OnUpdateStatusChanged(const std::string&) = 0;
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 713f71dcdb..f8b88d3cbb 100644
--- a/src/components/include/policy/policy_regular/policy/policy_manager.h
+++ b/src/components/include/policy/policy_regular/policy/policy_manager.h
@@ -396,13 +396,22 @@ class PolicyManager : public usage_statistics::StatisticsManager {
                              const std::string& language) = 0;
 
   /**
+   * DEPRECATED
    * @brief Send OnPermissionsUpdated for choosen application
    * @param application_id Unique application id
    */
-  virtual void SendNotificationOnPermissionsUpdated(
+  DEPRECATED virtual void SendNotificationOnPermissionsUpdated(
       const std::string& application_id) = 0;
 
   /**
+   * @brief Send OnPermissionsUpdated for choosen application
+   * @param device_id device identifier
+   * @param application_id Unique application id
+   */
+  virtual void SendNotificationOnPermissionsUpdated(
+      const std::string& device_id, const std::string& application_id) = 0;
+
+  /**
    * @brief Marks device as upaired
    * @param device_id id device
    */
@@ -634,12 +643,26 @@ class PolicyManager : public usage_statistics::StatisticsManager {
       const std::string& policy_app_id) const = 0;
 
   /**
+   * DEPRECATED
+   * @brief OnAppRegisteredOnMobile allows to handle event when application were
+   * succesfully registered on mobile device.
+   * It will send OnAppPermissionSend notification and will try to start PTU.
+   *
+   * @param application_id registered application.
+   */
+  DEPRECATED virtual void OnAppRegisteredOnMobile(
+      const std::string& application_id) = 0;
+
+  /**
    * @brief OnAppRegisteredOnMobile allows to handle event when application were
    * succesfully registered on mobile device.
-   * It will send OnAppPermissionSend notification and will try to start PTU. *
+   * It will send OnAppPermissionSend notification and will try to start PTU.
+   *
+   * @param device_id device identifier
    * @param application_id registered application.
    */
-  virtual void OnAppRegisteredOnMobile(const std::string& application_id) = 0;
+  virtual void OnAppRegisteredOnMobile(const std::string& device_id,
+                                       const std::string& application_id) = 0;
 
   virtual void OnDeviceSwitching(const std::string& device_id_from,
                                  const std::string& device_id_to) = 0;
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 13d19e1a41..76a7ccadee 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
@@ -417,10 +417,11 @@ class PolicyManagerImpl : public PolicyManager {
 
   /**
    * @brief Send OnPermissionsUpdated for choosen application
+   * @param device_id device identifier
    * @param application_id Unique application id
    */
   void SendNotificationOnPermissionsUpdated(
-      const std::string& application_id) OVERRIDE;
+      const std::string& device_id, const std::string& application_id) OVERRIDE;
 
   /**
    * @brief Removes unpaired device records and related records from DB
@@ -682,12 +683,26 @@ class PolicyManagerImpl : public PolicyManager {
       const std::string& policy_app_id) const OVERRIDE;
 
   /**
+   * DEPRECATED
    * @brief OnAppRegisteredOnMobile allows to handle event when application were
    * succesfully registered on mobile device.
-   * It will send OnAppPermissionSend notification and will try to start PTU. *
+   * It will send OnAppPermissionSend notification and will try to start PTU.
+   *
    * @param application_id registered application.
    */
-  void OnAppRegisteredOnMobile(const std::string& application_id) OVERRIDE;
+  DEPRECATED void OnAppRegisteredOnMobile(
+      const std::string& application_id) OVERRIDE;
+
+  /**
+   * @brief OnAppRegisteredOnMobile allows to handle event when application were
+   * succesfully registered on mobile device.
+   * It will send OnAppPermissionSend notification and will try to start PTU.
+   *
+   * @param device_id device identifier
+   * @param application_id registered application.
+   */
+  void OnAppRegisteredOnMobile(const std::string& device_id,
+                               const std::string& application_id) OVERRIDE;
 
   void OnDeviceSwitching(const std::string& device_id_from,
                          const std::string& device_id_to) OVERRIDE;
@@ -807,6 +822,14 @@ class PolicyManagerImpl : public PolicyManager {
 
  private:
   /**
+   * DEPRECATED
+   * @brief Send OnPermissionsUpdated for choosen application
+   * @param application_id Unique application id
+   */
+  void SendNotificationOnPermissionsUpdated(
+      const std::string& application_id) OVERRIDE;
+
+  /**
    * @brief Checks if PT update should be started and schedules it if needed
    */
   void CheckTriggers();
diff --git a/src/components/policy/policy_regular/src/policy_helper.cc b/src/components/policy/policy_regular/src/policy_helper.cc
index 5fa0b314b3..a186b9714b 100644
--- a/src/components/policy/policy_regular/src/policy_helper.cc
+++ b/src/components/policy/policy_regular/src/policy_helper.cc
@@ -286,7 +286,8 @@ void CheckAppPolicy::SendPermissionsToApp(
   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(app_id, notification_data, 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 00a3d33379..c19eb8fee5 100644
--- a/src/components/policy/policy_regular/src/policy_manager_impl.cc
+++ b/src/components/policy/policy_regular/src/policy_manager_impl.cc
@@ -531,6 +531,12 @@ void PolicyManagerImpl::OnAppRegisteredOnMobile(
   SendNotificationOnPermissionsUpdated(application_id);
 }
 
+void PolicyManagerImpl::OnAppRegisteredOnMobile(
+    const std::string& device_id, const std::string& application_id) {
+  StartPTExchange();
+  SendNotificationOnPermissionsUpdated(device_id, application_id);
+}
+
 void PolicyManagerImpl::OnDeviceSwitching(const std::string& device_id_from,
                                           const std::string& device_id_to) {
   LOG4CXX_AUTO_TRACE(logger_);
@@ -721,12 +727,50 @@ void PolicyManagerImpl::SendNotificationOnPermissionsUpdated(
 
   const ApplicationOnDevice who = {device_id, application_id};
   if (access_remote_->IsAppRemoteControl(who)) {
-    listener()->OnPermissionsUpdated(application_id, notification_data);
+    listener()->OnPermissionsUpdated(
+        device_id, application_id, notification_data);
+    return;
+  }
+
+  listener()->OnPermissionsUpdated(
+      device_id, application_id, notification_data, default_hmi);
+}
+
+void PolicyManagerImpl::SendNotificationOnPermissionsUpdated(
+    const std::string& device_id, const std::string& application_id) {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  std::vector<FunctionalGroupPermission> app_group_permissions;
+  GetPermissionsForApp(device_id, application_id, app_group_permissions);
+
+  policy_table::FunctionalGroupings functional_groupings;
+  cache_->GetFunctionalGroupings(functional_groupings);
+
+  policy_table::Strings app_groups;
+  for (const auto& group_permission : app_group_permissions) {
+    app_groups.push_back(group_permission.group_name);
+  }
+
+  Permissions notification_data;
+  PrepareNotificationData(functional_groupings,
+                          app_groups,
+                          app_group_permissions,
+                          notification_data);
+
+  LOG4CXX_INFO(logger_,
+               "Send notification for application_id: " << application_id);
+
+  std::string default_hmi = "NONE";
+
+  const ApplicationOnDevice who = {device_id, application_id};
+  if (access_remote_->IsAppRemoteControl(who)) {
+    listener()->OnPermissionsUpdated(
+        device_id, application_id, notification_data);
     return;
   }
 
   listener()->OnPermissionsUpdated(
-      application_id, notification_data, default_hmi);
+      device_id, application_id, notification_data, default_hmi);
 }
 
 bool PolicyManagerImpl::CleanupUnpairedDevices() {
@@ -1515,7 +1559,8 @@ void PolicyManagerImpl::SendAppPermissionsChanged(
     const std::string& device_id, const std::string& application_id) {
   Permissions notification_data;
   GetPermissions(device_id, application_id, &notification_data);
-  listener()->OnPermissionsUpdated(application_id, notification_data);
+  listener()->OnPermissionsUpdated(
+      device_id, application_id, notification_data);
 }
 
 void PolicyManagerImpl::SendAuthTokenUpdated(const std::string policy_app_id) {