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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
#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 "rc_rpc_plugin/resource_allocation_manager.h"
#include "application_manager/application_impl.h"
#include "rc_rpc_plugin/rc_app_extension.h"
#include "utils/macro.h"
#include "utils/lock.h"
namespace rc_rpc_plugin {
typedef std::vector<application_manager::ApplicationSharedPtr> Apps;
class ResourceAllocationManagerImpl : public ResourceAllocationManager {
public:
ResourceAllocationManagerImpl(
application_manager::ApplicationManager& app_mngr,
application_manager::rpc_service::RPCService& rpc_service);
~ResourceAllocationManagerImpl();
AcquireResult::eType AcquireResource(const std::string& module_type,
const uint32_t app_id) OVERRIDE FINAL;
void ForceAcquireResource(const std::string& module_type,
const uint32_t app_id) 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 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(
application_manager::plugin_manager::ApplicationEvent event,
application_manager::ApplicationSharedPtr application) FINAL;
/**
* @brief OnPolicyEvent Processes policy related events
* @param event Policy event
*/
void OnPolicyEvent(
application_manager::plugin_manager::PolicyEvent event) FINAL;
void ResetAllAllocations() FINAL;
/**
* @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) FINAL;
private:
/**
* @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 RemoveAppsSubscriptions Removes subscriptions for interior data for
* applications in the list
* @param apps Application list
*/
void RemoveAppsSubscriptions(const Apps& apps);
/**
* @brief SetResourceAquired mark resourse as aquired and process logic of
* changing state of aquired resources
* @param module_type resource name
* @param app applicastion that aquire resource
*/
void SetResourceAquired(const std::string& module_type,
const uint32_t app_id);
/**
* @brief SetResourceFree mark resourse as free and process logic of
* changing state of aquired resources
* @param module_type resource name
* @param app applicastion that aquire resource
*/
void SetResourceFree(const std::string& module_type, const uint32_t app_id);
std::vector<std::string> all_supported_modules();
/**
* @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_;
application_manager::ApplicationManager& app_mngr_;
application_manager::rpc_service::RPCService& rpc_service_;
};
} // rc_rpc_plugin
#endif // SRC_COMPONENTS_REMOTE_CONTROL_INCLUDE_REMOTE_CONTROL_RESOURCE_ALLOCATION_IMPL_H
|
