1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
#ifndef SRC_COMPONENTS_REMOTE_CONTROL_INCLUDE_REMOTE_CONTROL_RESOURCE_ALLOCATION_IMPL_H
#define SRC_COMPONENTS_REMOTE_CONTROL_INCLUDE_REMOTE_CONTROL_RESOURCE_ALLOCATION_IMPL_H
#include "remote_control/resource_allocation_manager.h"
#include "remote_control/remote_plugin_interface.h"
#include "utils/macro.h"
#include "utils/lock.h"
namespace remote_control {
typedef rc_event_engine::EventDispatcher<application_manager::MessagePtr,
std::string> RCEventDispatcher;
class ResourceAllocationManagerImpl : public ResourceAllocationManager {
public:
ResourceAllocationManagerImpl(RemotePluginInterface& rc_plugin);
~ResourceAllocationManagerImpl();
AcquireResult::eType AcquireResource(const std::string& module_type,
const uint32_t app_id) OVERRIDE FINAL;
void SetResourceState(const std::string& module_type,
const uint32_t app_id,
const ResourceState::eType state) FINAL;
bool IsResourceFree(const std::string& module_type) const FINAL;
void SetAccessMode(
const hmi_apis::Common_RCAccessMode::eType access_mode) FINAL;
hmi_apis::Common_RCAccessMode::eType GetAccessMode() const FINAL;
void ForceAcquireResource(const std::string& module_type,
const uint32_t app_id) FINAL;
void OnDriverDisallowed(const std::string& module_type,
const uint32_t app_id) FINAL;
/**
* @brief OnApplicationEvent Notifies modules on certain application events
* @param event Event
* @param application Pointer to application struct
*/
void OnApplicationEvent(
functional_modules::ApplicationEvent event,
application_manager::ApplicationSharedPtr application) FINAL;
/**
* @brief OnPolicyEvent Processes policy related events
* @param event Policy event
*/
void OnPolicyEvent(functional_modules::PolicyEvent event) FINAL;
void ResetAllAllocations() FINAL;
private:
typedef std::vector<application_manager::ApplicationSharedPtr> Apps;
/**
* @brief IsModuleTypeRejected check if current resource was rejected by
* driver for current application
* @param module_type resource to check
* @param app_id application id
* @return true if current resource was rejected by driver for current
* application, otherwise - false
*/
bool IsModuleTypeRejected(const std::string& module_type,
const uint32_t app_id);
/**
* @brief ReleaseResource Releases resource acquired by application
* @param module_type Module name
* @param application_id Application id
*/
void ReleaseResource(const std::string& module_type,
const uint32_t application_id);
/**
* @brief GetAcquiredResources Provides resources acquired by particular
* application currently
* @param application_id Application id
* @return List of acquired resources by specific application
*/
Resources GetAcquiredResources(const uint32_t application_id) const;
/**
* @brief ProcessApplicationPolicyUpdate Checks if allowed modules list is
* changed for registered RC applications and releases in case some modules
* now out of the list
*/
void ProcessApplicationPolicyUpdate();
/**
* @brief GetApplicationExtention Provides access to application RC extention
* @param application Application
* @return Pointer to RC extention of application or NULL if not available
*/
RCAppExtensionPtr GetApplicationExtention(
application_manager::ApplicationSharedPtr application);
/**
* @brief RemoveAppsSubscriptions Removes subscriptions for interior data for
* applications in the list
* @param apps Application list
*/
void RemoveAppsSubscriptions(const Apps& apps);
/**
* @brief AllocatedResources contains link between resource and application
* owning that resource
*/
typedef std::map<std::string, uint32_t> AllocatedResources;
AllocatedResources allocated_resources_;
mutable sync_primitives::Lock allocated_resources_lock_;
/**
* @brief ResourcesState contains states of ALLOCATED resources
*/
typedef std::map<std::string, ResourceState::eType> ResourcesState;
ResourcesState resources_state_;
mutable sync_primitives::Lock resources_state_lock_;
/**
* @brief RejectedResources type for connecting list of resources rejected by
* driver for application
* application_id : [vector of rejected resources]
*/
typedef std::map<uint32_t, std::vector<std::string> > RejectedResources;
RejectedResources rejected_resources_for_application_;
mutable sync_primitives::Lock rejected_resources_for_application_lock_;
hmi_apis::Common_RCAccessMode::eType current_access_mode_;
RemotePluginInterface& rc_plugin_;
};
} // remote_control
#endif // SRC_COMPONENTS_REMOTE_CONTROL_INCLUDE_REMOTE_CONTROL_RESOURCE_ALLOCATION_IMPL_H
|
