1 files changed, 165 insertions, 0 deletions
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_pending_resumption_handler.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_pending_resumption_handler.h
new file mode 100644
index 0000000000..944d47b052
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_pending_resumption_handler.h
@@ -0,0 +1,165 @@
+#pragma once
+
+#include <map>
+#include <queue>
+#include "application_manager/event_engine/event_observer.h"
+#include "application_manager/resumption/pending_resumption_handler.h"
+#include "application_manager/resumption/resumption_data_processor.h"
+#include "application_manager/rpc_service.h"
+#include "rc_rpc_plugin/interior_data_cache.h"
+#include "rc_rpc_plugin/rc_app_extension.h"
+
+namespace rc_rpc_plugin {
+
+/**
+ * @brief The RCPendingResumptionHandler class
+ * responsibility to avoid duplication of subscription requests to HMI
+ * if multiple applications are registering
+ */
+class RCPendingResumptionHandler : public resumption::PendingResumptionHandler {
+ public:
+  RCPendingResumptionHandler(
+      application_manager::ApplicationManager& application_manager,
+      rc_rpc_plugin::InteriorDataCache& interior_data_cache);
+
+  void on_event(const application_manager::event_engine::Event& event) override;
+
+  void HandleResumptionSubscriptionRequest(
+      application_manager::AppExtension& extension,
+      application_manager::Application& app) override;
+
+  void OnResumptionRevert() override;
+
+  /**
+   * @brief Creates GetInteriorVehicleData subscription request
+   * @param module unique identifier of module (moduleType + moduleID) used to
+   * create the request
+   * @param correlation_id - unique ID
+   * @return subscription request in smart object representation
+   */
+  static smart_objects::SmartObjectSPtr CreateSubscriptionRequest(
+      const ModuleUid& module, const uint32_t correlation_id);
+
+  /**
+   * @brief Retrieves function id from subscription request
+   * @param subscription_request a subscription request that contains the
+   * function id
+   * @return function id
+   */
+  static hmi_apis::FunctionID::eType GetFunctionId(
+      const smart_objects::SmartObject& subscription_request);
+
+  /**
+   * @brief Retrieves module uid from subscription request
+   * @param subscription_request a subscription request that contains a unique
+   * module identifier
+   * @return unique module identifier
+   */
+  static ModuleUid GetModuleUid(
+      const smart_objects::SmartObject& subscription_request);
+
+ private:
+  /**
+   * @brief The PendingRequest struct contains fields, needed during
+   * processing events, related to responses from HMI to each resumption request
+   */
+  struct PendingRequest {
+    uint32_t app_id;
+    smart_objects::SmartObject message;
+    uint32_t correlation_id() const {
+      namespace am_strings = app_mngr::strings;
+      return message[am_strings::params][am_strings::correlation_id].asInt();
+    }
+  };
+
+  /**
+   * @brief Handles a successful response from HMI
+   * @param event contains response from HMI
+   * @param module_uid a unique identifier for module
+   */
+  void HandleSuccessfulResponse(
+      const application_manager::event_engine::Event& event,
+      const ModuleUid& module_uid);
+
+  /**
+   * @brief Creates next GetInteriorVehicleData subscription request if a
+   * previous resumption of subscriptions is not successful
+   * @param module a unique identifier for module
+   */
+  void ProcessNextPausedResumption(const ModuleUid& module);
+
+  /**
+   * @brief Notifies subscriber about resumption status
+   * @param subscription_response response from HMI
+   * @param correlation_id unique message ID
+   */
+  void RaiseEventForResponse(
+      const smart_objects::SmartObject& subscription_response,
+      const uint32_t correlation_id) const;
+
+  /**
+   * @brief Checks if SDL is still waiting on a subscription response for the
+   * specified module
+   * @param module the unique identifier for the module to be checked against
+   */
+  bool IsPendingForResponse(const ModuleUid& module) const;
+
+  /**
+   * @brief Checks if any app except passed is subscribed to a given module
+   * @param module module to check
+   * @param app_id app to ignore subscription
+   * @return true if any app except passed is subscribed to module, otherwise
+   * false
+   */
+  bool IsOtherAppsSubscribed(const uint32_t app_id,
+                             const ModuleUid& module) const;
+
+  /**
+   * @brief Returns pending request, which corresponds to correlation ID
+   * @param corr_id unique message ID
+   * @return optional object, which contains subscription request, or empty
+   * optional, if such request wasn't found
+   */
+  utils::Optional<smart_objects::SmartObject> GetPendingRequest(
+      const uint32_t corr_id);
+
+  /**
+   * @brief Returns ID of application, related to pending request, which
+   * corresponds to correlation ID
+   * @param corr_id unique message ID
+   * @return optional object, which contains ID of application, or empty
+   * optional, if such request wasn't found
+   */
+  utils::Optional<uint32_t> GetPendingApp(const uint32_t corr_id);
+
+  /**
+   * @brief Removes pending request, which corresponds to
+   * correlation ID
+   * @param corr_id unique ID
+   */
+  void RemovePendingRequest(const uint32_t corr_id);
+
+  /**
+   * @brief Adds pending request, related to
+   * application ID
+   * @param request_so pending request message
+   */
+  void AddPendingRequest(const uint32_t app_id,
+                         const smart_objects::SmartObject request_so);
+
+  /**
+   * @brief PendingRequestQueue contains subscription request,
+   * which will be sent to the HMI in the case that a previous resumption
+   * attempt for the same module was not successful
+   */
+  using PendingRequestQueue = std::queue<PendingRequest>;
+  std::map<ModuleUid, PendingRequestQueue> paused_resumptions_;
+
+  sync_primitives::Lock pending_resumption_lock_;
+  std::vector<PendingRequest> pending_requests_;
+
+  application_manager::rpc_service::RPCService& rpc_service_;
+  rc_rpc_plugin::InteriorDataCache& interior_data_cache_;
+};
+
+}  // namespace rc_rpc_plugin