1 files changed, 69 insertions, 4 deletions

diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/resource_allocation_manager.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/resource_allocation_manager.h
index 67598b667b..ee0bd11885 100644
--- a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/resource_allocation_manager.h
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/resource_allocation_manager.h
@@ -35,8 +35,8 @@
 #include <string>
 #include "utils/macro.h"
 
-#include "interfaces/HMI_API.h"
 #include "application_manager/plugin_manager/rpc_plugin.h"
+#include "interfaces/HMI_API.h"
 #include "rc_rpc_plugin/rc_app_extension.h"
 
 namespace rc_rpc_plugin {
@@ -66,58 +66,87 @@ namespace NotificationTrigger {
  * MODULE_ALLOCATION module allocation/deallocation event
  */
 enum eType { APP_REGISTRATION = 0, MODULE_ALLOCATION, RC_STATE_CHANGING };
-}
+}  // namespace NotificationTrigger
+
+/**
+ * Defines result of releasing specified module type resource.
+ */
+namespace ResourceReleasedState {
+/**
+ * NOT_ALLOCATED Module's resource is not allocated
+ * IS_ALLOCATED Module's resource is already allocated by
+ * different application
+ * IS_RELEASED Module's resource is released.
+ */
+enum eType { NOT_ALLOCATED = 0, IS_ALLOCATED, IS_RELEASED };
+}  // namespace ResourceReleasedState
+
+/**
+ * @brief ModuleUid uniquely identify a module
+ * moduleType + moduleID
+ */
+typedef std::pair<std::string, std::string> ModuleUid;
 
 /**
  * @brief Resources defines list of resources
  */
-typedef std::vector<std::string> Resources;
+typedef std::vector<ModuleUid> Resources;
 
 class ResourceAllocationManager {
  public:
   /**
    * @brief AcquireResource acquires resource by application
    * @param module_type resource to acquire
+   * @param module_id uuid of a resource
    * @param app_id application that acquire resource
    * @return ALLOWED if resource acquired \
    *         IN_USE  if resource already acquired
    *         ASK_DRIVER if driver confirmation is required
    */
   virtual AcquireResult::eType AcquireResource(const std::string& module_type,
+                                               const std::string& module_id,
                                                const uint32_t app_id) = 0;
 
   /**
    * @brief SetResourceState changes resource state. Resource must be acquired
    * beforehand.
    * @param module_type Resource to change its state
+   * @param module_id uuid of a resource
    * @param app_id Application aquired resource before
    * @param state State to set for resource
    */
   virtual void SetResourceState(const std::string& module_type,
+                                const std::string& module_id,
                                 const uint32_t app_id,
                                 const ResourceState::eType state) = 0;
 
   /**
    * @brief IsResourceFree check resource state
    * @param module_type Resource name
+   * @param module_id uuid of a resource
    * @return True if free, otherwise - false
    */
-  virtual bool IsResourceFree(const std::string& module_type) const = 0;
+  virtual bool IsResourceFree(const std::string& module_type,
+                              const std::string& module_id) const = 0;
 
   /**
    * @brief AcquireResource forces acquiring resource by application
    * @param module_type resource to acquire
+   * @param module_id uuid of a resource
    * @param app_id application that acquire resource
    */
   virtual void ForceAcquireResource(const std::string& module_type,
+                                    const std::string& module_id,
                                     const uint32_t app_id) = 0;
 
   /**
    * @brief OnDriverDisallowed callback for rejecting acquiring resource
    * @param module_type resource type
+   * @param module_id uuid of a resource
    * @param app_id application id
    */
   virtual void OnDriverDisallowed(const std::string& module_type,
+                                  const std::string& module_id,
                                   const uint32_t app_id) = 0;
 
   /**
@@ -171,6 +200,42 @@ class ResourceAllocationManager {
 
   virtual void set_rc_enabled(const bool value) = 0;
 
+  /**
+   * @brief ReleaseResource Releases resource acquired by application
+   * @param module_type Module name
+   * @param module_id uuid of a module
+   * @param application_id Application id
+   */
+  virtual ResourceReleasedState::eType ReleaseResource(
+      const std::string& module_type,
+      const std::string& module_id,
+      const uint32_t application_id) = 0;
+
+  /**
+   * @brief SetResourceAquired mark resourse as aquired and process logic of
+   * changing state of aquired resources
+   * @param module_type resource name
+   * @param module_id uuid of a resource
+   * @param app applicastion that aquire resource
+   */
+  virtual void SetResourceAcquired(const std::string& module_type,
+                                   const std::string& module_id,
+                                   const uint32_t app_id) = 0;
+
+  /**
+   * @brief Checks if specific resource is already aquired by specific
+   * application
+   * @param moduleUid Module resurce (module type + module ID)
+   * @param app_id Application ID which try to aquire resource
+   * @return true In case when resource is already aquired by specific
+   * application
+   * @return false In case when isn't aquired by specific
+   * application
+   */
+  virtual bool IsResourceAlreadyAcquiredByApp(
+      const rc_rpc_plugin::ModuleUid& moduleUid,
+      const uint32_t app_id) const = 0;
+
   virtual ~ResourceAllocationManager() {}
 };