1 #ifndef ANDROID_HARDWARE_AUTOMOTIVE_AUDIOCONTROL_H
2 #define ANDROID_HARDWARE_AUTOMOTIVE_AUDIOCONTROL_H
3 
4 #include <array>
5 #include <map>
6 #include <optional>
7 #include <string>
8 #include <vector>
9 #include <sstream>
10 
11 #if __has_include(<libxml/parser.h>)
12 #include <libxml/parser.h>
13 #include <libxml/xinclude.h>
14 #else
15 #error Require libxml2 library. Please add libxml2 to shared_libs or static_libs
16 #endif
17 
18 #include "android_hardware_automotive_audiocontrol_enums.h"
19 
20 namespace android {
21     namespace hardware {
22         namespace automotive {
23             namespace audiocontrol {
24                 class CarAudioConfigurationType;
25                 class ZonesType;
26                 class ActivationVolumeConfigsType;
27                 class OemContextsType;
28                 class DeviceConfigurationsType;
29                 class ZoneType;
30                 class ZoneConfigsType;
31                 class ZoneConfigType;
32                 class ApplyFadeConfigsType;
33                 class ApplyFadeConfigType;
34                 class AudioAttributeUsagesType;
35                 class VolumeGroupsType;
36                 class VolumeGroupType;
37                 class DeviceRoutesType;
38                 class ContextNameType;
39                 class OemContextType;
40                 class AudioAttributesUsagesType;
41                 class AttributesType;
42                 class DeviceConfigurationType;
43                 class ContentType;
44                 class UsageType;
45                 class ActivationVolumeConfigType;
46                 class ActivationVolumeConfigEntryType;
47                 class MirroringDevicesType;
48                 class MirroringDevice;
49                 class InputDevicesType;
50                 class InputDeviceType;
51                 std::optional<CarAudioConfigurationType> read(const char* configFile);
52 
53                 std::optional<CarAudioConfigurationType> parse(const char* xml);
54 
55                 class CarAudioConfigurationType {
56                     private:
57                     const std::vector<MirroringDevicesType> mirroringDevices_;
58                     const std::vector<DeviceConfigurationsType> deviceConfigurations_;
59                     const std::vector<OemContextsType> oemContexts_;
60                     const std::vector<ActivationVolumeConfigsType> activationVolumeConfigs_;
61                     const std::vector<ZonesType> zones_;
62                     const std::string version_;
63                     public:
64                     CarAudioConfigurationType(std::vector<MirroringDevicesType> mirroringDevices, std::vector<DeviceConfigurationsType> deviceConfigurations, std::vector<OemContextsType> oemContexts, std::vector<ActivationVolumeConfigsType> activationVolumeConfigs, std::vector<ZonesType> zones, std::string version);
65                     const std::vector<MirroringDevicesType>& getMirroringDevices() const;
66                     bool hasMirroringDevices() const;
67                     const MirroringDevicesType* getFirstMirroringDevices() const;
68                     const std::vector<DeviceConfigurationsType>& getDeviceConfigurations() const;
69                     bool hasDeviceConfigurations() const;
70                     const DeviceConfigurationsType* getFirstDeviceConfigurations() const;
71                     const std::vector<OemContextsType>& getOemContexts() const;
72                     bool hasOemContexts() const;
73                     const OemContextsType* getFirstOemContexts() const;
74                     const std::vector<ActivationVolumeConfigsType>& getActivationVolumeConfigs() const;
75                     bool hasActivationVolumeConfigs() const;
76                     const ActivationVolumeConfigsType* getFirstActivationVolumeConfigs() const;
77                     const std::vector<ZonesType>& getZones() const;
78                     bool hasZones() const;
79                     const ZonesType* getFirstZones() const;
80                     const std::string& getVersion() const;
81                     bool hasVersion() const;
82                     static CarAudioConfigurationType read(xmlNode *root);
83                 };
84 
85                 class ZonesType {
86                     private:
87                     const std::vector<ZoneType> zone_;
88                     public:
89                     explicit ZonesType(std::vector<ZoneType> zone);
90                     const std::vector<ZoneType>& getZone() const;
91                     bool hasZone() const;
92                     const ZoneType* getFirstZone() const;
93                     static ZonesType read(xmlNode *root);
94                 };
95 
96                 class ActivationVolumeConfigsType {
97                     private:
98                     const std::vector<ActivationVolumeConfigType> activationVolumeConfig_;
99                     public:
100                     explicit ActivationVolumeConfigsType(std::vector<ActivationVolumeConfigType> activationVolumeConfig);
101                     const std::vector<ActivationVolumeConfigType>& getActivationVolumeConfig() const;
102                     bool hasActivationVolumeConfig() const;
103                     const ActivationVolumeConfigType* getFirstActivationVolumeConfig() const;
104                     static ActivationVolumeConfigsType read(xmlNode *root);
105                 };
106 
107                 class OemContextsType {
108                     private:
109                     const std::vector<OemContextType> oemContext_;
110                     public:
111                     explicit OemContextsType(std::vector<OemContextType> oemContext);
112                     const std::vector<OemContextType>& getOemContext() const;
113                     bool hasOemContext() const;
114                     const OemContextType* getFirstOemContext() const;
115                     static OemContextsType read(xmlNode *root);
116                 };
117 
118                 class DeviceConfigurationsType {
119                     private:
120                     const std::vector<DeviceConfigurationType> deviceConfiguration_;
121                     public:
122                     explicit DeviceConfigurationsType(std::vector<DeviceConfigurationType> deviceConfiguration);
123                     const std::vector<DeviceConfigurationType>& getDeviceConfiguration() const;
124                     bool hasDeviceConfiguration() const;
125                     const DeviceConfigurationType* getFirstDeviceConfiguration() const;
126                     static DeviceConfigurationsType read(xmlNode *root);
127                 };
128 
129                 class ZoneType {
130                     private:
131                     const std::vector<InputDevicesType> inputDevices_;
132                     const std::vector<ZoneConfigsType> zoneConfigs_;
133                     const std::optional<std::string> name_;
134                     const std::string audioZoneId_;
135                     const std::optional<bool> isPrimary_;
136                     const std::optional<std::string> occupantZoneId_;
137                     public:
138                     ZoneType(std::vector<InputDevicesType> inputDevices, std::vector<ZoneConfigsType> zoneConfigs, std::optional<std::string> name, std::string audioZoneId, std::optional<bool> isPrimary, std::optional<std::string> occupantZoneId);
139                     const std::vector<InputDevicesType>& getInputDevices() const;
140                     bool hasInputDevices() const;
141                     const InputDevicesType* getFirstInputDevices() const;
142                     const std::vector<ZoneConfigsType>& getZoneConfigs() const;
143                     bool hasZoneConfigs() const;
144                     const ZoneConfigsType* getFirstZoneConfigs() const;
145                     const std::string& getName() const;
146                     bool hasName() const;
147                     const std::string& getAudioZoneId() const;
148                     bool hasAudioZoneId() const;
149                     const bool& getIsPrimary() const;
150                     bool hasIsPrimary() const;
151                     const std::string& getOccupantZoneId() const;
152                     bool hasOccupantZoneId() const;
153                     static ZoneType read(xmlNode *root);
154                 };
155 
156                 class ZoneConfigsType {
157                     private:
158                     const std::vector<ZoneConfigType> zoneConfig_;
159                     public:
160                     explicit ZoneConfigsType(std::vector<ZoneConfigType> zoneConfig);
161                     const std::vector<ZoneConfigType>& getZoneConfig() const;
162                     bool hasZoneConfig() const;
163                     const ZoneConfigType* getFirstZoneConfig() const;
164                     static ZoneConfigsType read(xmlNode *root);
165                 };
166 
167                 class ZoneConfigType {
168                     private:
169                     const std::vector<VolumeGroupsType> volumeGroups_;
170                     const std::vector<ApplyFadeConfigsType> applyFadeConfigs_;
171                     const std::optional<std::string> name_;
172                     const std::optional<bool> isDefault_;
173                     public:
174                     ZoneConfigType(std::vector<VolumeGroupsType> volumeGroups, std::vector<ApplyFadeConfigsType> applyFadeConfigs, std::optional<std::string> name, std::optional<bool> isDefault);
175                     const std::vector<VolumeGroupsType>& getVolumeGroups() const;
176                     bool hasVolumeGroups() const;
177                     const VolumeGroupsType* getFirstVolumeGroups() const;
178                     const std::vector<ApplyFadeConfigsType>& getApplyFadeConfigs() const;
179                     bool hasApplyFadeConfigs() const;
180                     const ApplyFadeConfigsType* getFirstApplyFadeConfigs() const;
181                     const std::string& getName() const;
182                     bool hasName() const;
183                     const bool& getIsDefault() const;
184                     bool hasIsDefault() const;
185                     static ZoneConfigType read(xmlNode *root);
186                 };
187 
188                 class ApplyFadeConfigsType {
189                     private:
190                     const std::vector<ApplyFadeConfigType> fadeConfig_;
191                     public:
192                     explicit ApplyFadeConfigsType(std::vector<ApplyFadeConfigType> fadeConfig);
193                     const std::vector<ApplyFadeConfigType>& getFadeConfig() const;
194                     bool hasFadeConfig() const;
195                     const ApplyFadeConfigType* getFirstFadeConfig() const;
196                     static ApplyFadeConfigsType read(xmlNode *root);
197                 };
198 
199                 class ApplyFadeConfigType {
200                     private:
201                     const std::vector<AudioAttributeUsagesType> audioAttributes_;
202                     const std::optional<std::string> name_;
203                     const std::optional<bool> isDefault_;
204                     public:
205                     ApplyFadeConfigType(std::vector<AudioAttributeUsagesType> audioAttributes, std::optional<std::string> name, std::optional<bool> isDefault);
206                     const std::vector<AudioAttributeUsagesType>& getAudioAttributes() const;
207                     bool hasAudioAttributes() const;
208                     const AudioAttributeUsagesType* getFirstAudioAttributes() const;
209                     const std::string& getName() const;
210                     bool hasName() const;
211                     const bool& getIsDefault() const;
212                     bool hasIsDefault() const;
213                     static ApplyFadeConfigType read(xmlNode *root);
214                 };
215 
216                 class AudioAttributeUsagesType {
217                     private:
218                     const std::vector<UsageType> usage_;
219                     public:
220                     explicit AudioAttributeUsagesType(std::vector<UsageType> usage);
221                     const std::vector<UsageType>& getUsage() const;
222                     bool hasUsage() const;
223                     const UsageType* getFirstUsage() const;
224                     static AudioAttributeUsagesType read(xmlNode *root);
225                 };
226 
227                 class VolumeGroupsType {
228                     private:
229                     const std::vector<VolumeGroupType> group_;
230                     public:
231                     explicit VolumeGroupsType(std::vector<VolumeGroupType> group);
232                     const std::vector<VolumeGroupType>& getGroup() const;
233                     bool hasGroup() const;
234                     const VolumeGroupType* getFirstGroup() const;
235                     static VolumeGroupsType read(xmlNode *root);
236                 };
237 
238                 class VolumeGroupType {
239                     private:
240                     const std::vector<DeviceRoutesType> device_;
241                     const std::optional<std::string> name_;
242                     const std::optional<std::string> activationConfig_;
243                     public:
244                     VolumeGroupType(std::vector<DeviceRoutesType> device, std::optional<std::string> name, std::optional<std::string> activationConfig);
245                     const std::vector<DeviceRoutesType>& getDevice() const;
246                     bool hasDevice() const;
247                     const DeviceRoutesType* getFirstDevice() const;
248                     const std::string& getName() const;
249                     bool hasName() const;
250                     const std::string& getActivationConfig() const;
251                     bool hasActivationConfig() const;
252                     static VolumeGroupType read(xmlNode *root);
253                 };
254 
255                 class DeviceRoutesType {
256                     private:
257                     const std::vector<ContextNameType> context_;
258                     const std::optional<std::string> address_;
259                     const std::optional<OutDeviceType> type_;
260                     public:
261                     DeviceRoutesType(std::vector<ContextNameType> context, std::optional<std::string> address, std::optional<OutDeviceType> type);
262                     const std::vector<ContextNameType>& getContext() const;
263                     bool hasContext() const;
264                     const ContextNameType* getFirstContext() const;
265                     const std::string& getAddress() const;
266                     bool hasAddress() const;
267                     const OutDeviceType& getType() const;
268                     bool hasType() const;
269                     static DeviceRoutesType read(xmlNode *root);
270                 };
271 
272                 class ContextNameType {
273                     private:
274                     const std::optional<std::string> context_;
275                     public:
276                     explicit ContextNameType(std::optional<std::string> context);
277                     const std::string& getContext() const;
278                     bool hasContext() const;
279                     static ContextNameType read(xmlNode *root);
280                 };
281 
282                 class OemContextType {
283                     private:
284                     const std::vector<AudioAttributesUsagesType> audioAttributes_;
285                     const std::optional<std::string> name_;
286                     const std::optional<std::string> id_;
287                     public:
288                     OemContextType(std::vector<AudioAttributesUsagesType> audioAttributes, std::optional<std::string> name, std::optional<std::string> id);
289                     const std::vector<AudioAttributesUsagesType>& getAudioAttributes() const;
290                     bool hasAudioAttributes() const;
291                     const AudioAttributesUsagesType* getFirstAudioAttributes() const;
292                     const std::string& getName() const;
293                     bool hasName() const;
294                     const std::string& getId() const;
295                     bool hasId() const;
296                     static OemContextType read(xmlNode *root);
297                 };
298 
299                 class AudioAttributesUsagesType {
300                     private:
301                     const std::vector<AttributesType> audioAttribute_optional_;
302                     const std::vector<UsageType> usage_optional_;
303                     public:
304                     AudioAttributesUsagesType(std::vector<AttributesType> audioAttribute_optional, std::vector<UsageType> usage_optional);
305                     const std::vector<AttributesType>& getAudioAttribute_optional() const;
306                     bool hasAudioAttribute_optional() const;
307                     const AttributesType* getFirstAudioAttribute_optional() const;
308                     const std::vector<UsageType>& getUsage_optional() const;
309                     bool hasUsage_optional() const;
310                     const UsageType* getFirstUsage_optional() const;
311                     static AudioAttributesUsagesType read(xmlNode *root);
312                 };
313 
314                 class AttributesType {
315                     private:
316                     const std::optional<ContentTypeEnum> contentType_;
317                     const std::optional<UsageEnumType> usage_;
318                     const std::optional<std::string> tags_;
319                     public:
320                     AttributesType(std::optional<ContentTypeEnum> contentType, std::optional<UsageEnumType> usage, std::optional<std::string> tags);
321                     const ContentTypeEnum& getContentType() const;
322                     bool hasContentType() const;
323                     const UsageEnumType& getUsage() const;
324                     bool hasUsage() const;
325                     const std::string& getTags() const;
326                     bool hasTags() const;
327                     static AttributesType read(xmlNode *root);
328                 };
329 
330                 class DeviceConfigurationType {
331                     private:
332                     const std::optional<std::string> name_;
333                     const std::optional<std::string> value_;
334                     public:
335                     DeviceConfigurationType(std::optional<std::string> name, std::optional<std::string> value);
336                     const std::string& getName() const;
337                     bool hasName() const;
338                     const std::string& getValue() const;
339                     bool hasValue() const;
340                     static DeviceConfigurationType read(xmlNode *root);
341                 };
342 
343                 class ContentType {
344                     private:
345                     const ContentTypeEnum value_;
346                     public:
347                     explicit ContentType(ContentTypeEnum value);
348                     const ContentTypeEnum& getValue() const;
349                     bool hasValue() const;
350                     static ContentType read(xmlNode *root);
351                 };
352 
353                 class UsageType {
354                     private:
355                     const UsageEnumType value_;
356                     public:
357                     explicit UsageType(UsageEnumType value);
358                     const UsageEnumType& getValue() const;
359                     bool hasValue() const;
360                     static UsageType read(xmlNode *root);
361                 };
362 
363                 class ActivationVolumeConfigType {
364                     private:
365                     const std::vector<ActivationVolumeConfigEntryType> activationVolumeConfigEntry_;
366                     const std::optional<std::string> name_;
367                     public:
368                     ActivationVolumeConfigType(std::vector<ActivationVolumeConfigEntryType> activationVolumeConfigEntry, std::optional<std::string> name);
369                     const std::vector<ActivationVolumeConfigEntryType>& getActivationVolumeConfigEntry() const;
370                     bool hasActivationVolumeConfigEntry() const;
371                     const ActivationVolumeConfigEntryType* getFirstActivationVolumeConfigEntry() const;
372                     const std::string& getName() const;
373                     bool hasName() const;
374                     static ActivationVolumeConfigType read(xmlNode *root);
375                 };
376 
377                 class ActivationVolumeConfigEntryType {
378                     private:
379                     const std::optional<std::string> maxActivationVolumePercentage_;
380                     const std::optional<std::string> minActivationVolumePercentage_;
381                     const std::optional<ActivationType> invocationType_;
382                     public:
383                     ActivationVolumeConfigEntryType(std::optional<std::string> maxActivationVolumePercentage, std::optional<std::string> minActivationVolumePercentage, std::optional<ActivationType> invocationType);
384                     const std::string& getMaxActivationVolumePercentage() const;
385                     bool hasMaxActivationVolumePercentage() const;
386                     const std::string& getMinActivationVolumePercentage() const;
387                     bool hasMinActivationVolumePercentage() const;
388                     const ActivationType& getInvocationType() const;
389                     bool hasInvocationType() const;
390                     static ActivationVolumeConfigEntryType read(xmlNode *root);
391                 };
392 
393                 class MirroringDevicesType {
394                     private:
395                     const std::vector<MirroringDevice> mirroringDevice_;
396                     public:
397                     explicit MirroringDevicesType(std::vector<MirroringDevice> mirroringDevice);
398                     const std::vector<MirroringDevice>& getMirroringDevice() const;
399                     bool hasMirroringDevice() const;
400                     const MirroringDevice* getFirstMirroringDevice() const;
401                     static MirroringDevicesType read(xmlNode *root);
402                 };
403 
404                 class MirroringDevice {
405                     private:
406                     const std::optional<std::string> address_;
407                     public:
408                     explicit MirroringDevice(std::optional<std::string> address);
409                     const std::string& getAddress() const;
410                     bool hasAddress() const;
411                     static MirroringDevice read(xmlNode *root);
412                 };
413 
414                 class InputDevicesType {
415                     private:
416                     const std::vector<InputDeviceType> inputDevice_;
417                     public:
418                     explicit InputDevicesType(std::vector<InputDeviceType> inputDevice);
419                     const std::vector<InputDeviceType>& getInputDevice() const;
420                     bool hasInputDevice() const;
421                     const InputDeviceType* getFirstInputDevice() const;
422                     static InputDevicesType read(xmlNode *root);
423                 };
424 
425                 class InputDeviceType {
426                     private:
427                     const std::optional<std::string> address_;
428                     const std::optional<InDeviceType> type_;
429                     public:
430                     InputDeviceType(std::optional<std::string> address, std::optional<InDeviceType> type);
431                     const std::string& getAddress() const;
432                     bool hasAddress() const;
433                     const InDeviceType& getType() const;
434                     bool hasType() const;
435                     static InputDeviceType read(xmlNode *root);
436                 };
437 
438             } // audiocontrol
439         } // automotive
440     } // hardware
441 } // android
442 #endif // ANDROID_HARDWARE_AUTOMOTIVE_AUDIOCONTROL_H
443