1 #ifndef ANDROID_HARDWARE_AUTOMOTIVE_AUDIOCONTROL_FADE_H
2 #define ANDROID_HARDWARE_AUTOMOTIVE_AUDIOCONTROL_FADE_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_fade_enums.h"
19 
20 namespace android {
21     namespace hardware {
22         namespace automotive {
23             namespace audiocontrol {
24                 namespace fade {
25                     class CarAudioFadeConfigurationType;
26                     class FadeConfigurationConfigs;
27                     class FadeConfigurationConfig;
28                     class FadeStateType;
29                     class FadeableUsagesType;
30                     class UsageType;
31                     class UnfadeableContentTypesType;
32                     class ContentType;
33                     class UnfadeableAudioAttributesType;
34                     class AudioAttributesUsagesType;
35                     class AttributesType;
36                     class FadeOutConfigurationsType;
37                     class FadeConfigurationType;
38                     class FadeInConfigurationsType;
39                     std::optional<CarAudioFadeConfigurationType> read(const char* configFile);
40 
41                     std::optional<CarAudioFadeConfigurationType> parse(const char* xml);
42 
43                     class CarAudioFadeConfigurationType {
44                         private:
45                         const std::vector<FadeConfigurationConfigs> configs_;
46                         public:
47                         explicit CarAudioFadeConfigurationType(std::vector<FadeConfigurationConfigs> configs);
48                         const std::vector<FadeConfigurationConfigs>& getConfigs() const;
49                         bool hasConfigs() const;
50                         const FadeConfigurationConfigs* getFirstConfigs() const;
51                         static CarAudioFadeConfigurationType read(xmlNode *root);
52                     };
53 
54                     class FadeConfigurationConfigs {
55                         private:
56                         const std::vector<FadeConfigurationConfig> config_;
57                         public:
58                         explicit FadeConfigurationConfigs(std::vector<FadeConfigurationConfig> config);
59                         const std::vector<FadeConfigurationConfig>& getConfig() const;
60                         bool hasConfig() const;
61                         const FadeConfigurationConfig* getFirstConfig() const;
62                         static FadeConfigurationConfigs read(xmlNode *root);
63                     };
64 
65                     class FadeConfigurationConfig {
66                         private:
67                         const std::vector<FadeStateType> fadeState_;
68                         const std::vector<FadeableUsagesType> fadeableUsages_;
69                         const std::vector<UnfadeableContentTypesType> unfadeableContentTypes_;
70                         const std::vector<UnfadeableAudioAttributesType> unfadeableAudioAttributes_;
71                         const std::vector<FadeOutConfigurationsType> fadeOutConfigurations_;
72                         const std::vector<FadeInConfigurationsType> fadeInConfigurations_;
73                         const std::optional<std::string> name_;
74                         const std::optional<std::string> defaultFadeOutDurationInMillis_;
75                         const std::optional<std::string> defaultFadeInDurationInMillis_;
76                         const std::optional<std::string> defaultFadeInDelayForOffenders_;
77                         public:
78                         FadeConfigurationConfig(std::vector<FadeStateType> fadeState, std::vector<FadeableUsagesType> fadeableUsages, std::vector<UnfadeableContentTypesType> unfadeableContentTypes, std::vector<UnfadeableAudioAttributesType> unfadeableAudioAttributes, std::vector<FadeOutConfigurationsType> fadeOutConfigurations, std::vector<FadeInConfigurationsType> fadeInConfigurations, std::optional<std::string> name, std::optional<std::string> defaultFadeOutDurationInMillis, std::optional<std::string> defaultFadeInDurationInMillis, std::optional<std::string> defaultFadeInDelayForOffenders);
79                         const std::vector<FadeStateType>& getFadeState() const;
80                         bool hasFadeState() const;
81                         const FadeStateType* getFirstFadeState() const;
82                         const std::vector<FadeableUsagesType>& getFadeableUsages() const;
83                         bool hasFadeableUsages() const;
84                         const FadeableUsagesType* getFirstFadeableUsages() const;
85                         const std::vector<UnfadeableContentTypesType>& getUnfadeableContentTypes() const;
86                         bool hasUnfadeableContentTypes() const;
87                         const UnfadeableContentTypesType* getFirstUnfadeableContentTypes() const;
88                         const std::vector<UnfadeableAudioAttributesType>& getUnfadeableAudioAttributes() const;
89                         bool hasUnfadeableAudioAttributes() const;
90                         const UnfadeableAudioAttributesType* getFirstUnfadeableAudioAttributes() const;
91                         const std::vector<FadeOutConfigurationsType>& getFadeOutConfigurations() const;
92                         bool hasFadeOutConfigurations() const;
93                         const FadeOutConfigurationsType* getFirstFadeOutConfigurations() const;
94                         const std::vector<FadeInConfigurationsType>& getFadeInConfigurations() const;
95                         bool hasFadeInConfigurations() const;
96                         const FadeInConfigurationsType* getFirstFadeInConfigurations() const;
97                         const std::string& getName() const;
98                         bool hasName() const;
99                         const std::string& getDefaultFadeOutDurationInMillis() const;
100                         bool hasDefaultFadeOutDurationInMillis() const;
101                         const std::string& getDefaultFadeInDurationInMillis() const;
102                         bool hasDefaultFadeInDurationInMillis() const;
103                         const std::string& getDefaultFadeInDelayForOffenders() const;
104                         bool hasDefaultFadeInDelayForOffenders() const;
105                         static FadeConfigurationConfig read(xmlNode *root);
106                     };
107 
108                     class FadeStateType {
109                         private:
110                         const std::optional<FadeStateEnumType> value_;
111                         public:
112                         explicit FadeStateType(std::optional<FadeStateEnumType> value);
113                         const FadeStateEnumType& getValue() const;
114                         bool hasValue() const;
115                         static FadeStateType read(xmlNode *root);
116                     };
117 
118                     class FadeableUsagesType {
119                         private:
120                         const std::vector<UsageType> usage_;
121                         public:
122                         explicit FadeableUsagesType(std::vector<UsageType> usage);
123                         const std::vector<UsageType>& getUsage() const;
124                         bool hasUsage() const;
125                         const UsageType* getFirstUsage() const;
126                         static FadeableUsagesType read(xmlNode *root);
127                     };
128 
129                     class UsageType {
130                         private:
131                         const std::optional<UsageEnumType> value_;
132                         public:
133                         explicit UsageType(std::optional<UsageEnumType> value);
134                         const UsageEnumType& getValue() const;
135                         bool hasValue() const;
136                         static UsageType read(xmlNode *root);
137                     };
138 
139                     class UnfadeableContentTypesType {
140                         private:
141                         const std::vector<ContentType> contentType_;
142                         public:
143                         explicit UnfadeableContentTypesType(std::vector<ContentType> contentType);
144                         const std::vector<ContentType>& getContentType() const;
145                         bool hasContentType() const;
146                         const ContentType* getFirstContentType() const;
147                         static UnfadeableContentTypesType read(xmlNode *root);
148                     };
149 
150                     class ContentType {
151                         private:
152                         const std::optional<ContentTypeEnum> value_;
153                         public:
154                         explicit ContentType(std::optional<ContentTypeEnum> value);
155                         const ContentTypeEnum& getValue() const;
156                         bool hasValue() const;
157                         static ContentType read(xmlNode *root);
158                     };
159 
160                     class UnfadeableAudioAttributesType {
161                         private:
162                         const std::vector<AudioAttributesUsagesType> audioAttributes_;
163                         public:
164                         explicit UnfadeableAudioAttributesType(std::vector<AudioAttributesUsagesType> audioAttributes);
165                         const std::vector<AudioAttributesUsagesType>& getAudioAttributes() const;
166                         bool hasAudioAttributes() const;
167                         const AudioAttributesUsagesType* getFirstAudioAttributes() const;
168                         static UnfadeableAudioAttributesType read(xmlNode *root);
169                     };
170 
171                     class AudioAttributesUsagesType {
172                         private:
173                         const std::vector<AttributesType> audioAttribute_optional_;
174                         const std::vector<UsageType> usage_optional_;
175                         public:
176                         AudioAttributesUsagesType(std::vector<AttributesType> audioAttribute_optional, std::vector<UsageType> usage_optional);
177                         const std::vector<AttributesType>& getAudioAttribute_optional() const;
178                         bool hasAudioAttribute_optional() const;
179                         const AttributesType* getFirstAudioAttribute_optional() const;
180                         const std::vector<UsageType>& getUsage_optional() const;
181                         bool hasUsage_optional() const;
182                         const UsageType* getFirstUsage_optional() const;
183                         static AudioAttributesUsagesType read(xmlNode *root);
184                     };
185 
186                     class AttributesType {
187                         private:
188                         const std::optional<ContentTypeEnum> contentType_;
189                         const std::optional<UsageEnumType> usage_;
190                         const std::optional<std::string> tags_;
191                         public:
192                         AttributesType(std::optional<ContentTypeEnum> contentType, std::optional<UsageEnumType> usage, std::optional<std::string> tags);
193                         const ContentTypeEnum& getContentType() const;
194                         bool hasContentType() const;
195                         const UsageEnumType& getUsage() const;
196                         bool hasUsage() const;
197                         const std::string& getTags() const;
198                         bool hasTags() const;
199                         static AttributesType read(xmlNode *root);
200                     };
201 
202                     class FadeOutConfigurationsType {
203                         private:
204                         const std::vector<FadeConfigurationType> fadeConfiguration_;
205                         public:
206                         explicit FadeOutConfigurationsType(std::vector<FadeConfigurationType> fadeConfiguration);
207                         const std::vector<FadeConfigurationType>& getFadeConfiguration() const;
208                         bool hasFadeConfiguration() const;
209                         const FadeConfigurationType* getFirstFadeConfiguration() const;
210                         static FadeOutConfigurationsType read(xmlNode *root);
211                     };
212 
213                     class FadeConfigurationType {
214                         private:
215                         const std::vector<AudioAttributesUsagesType> audioAttributes_;
216                         const std::optional<std::string> fadeDurationMillis_;
217                         public:
218                         FadeConfigurationType(std::vector<AudioAttributesUsagesType> audioAttributes, std::optional<std::string> fadeDurationMillis);
219                         const std::vector<AudioAttributesUsagesType>& getAudioAttributes() const;
220                         bool hasAudioAttributes() const;
221                         const AudioAttributesUsagesType* getFirstAudioAttributes() const;
222                         const std::string& getFadeDurationMillis() const;
223                         bool hasFadeDurationMillis() const;
224                         static FadeConfigurationType read(xmlNode *root);
225                     };
226 
227                     class FadeInConfigurationsType {
228                         private:
229                         const std::vector<FadeConfigurationType> fadeConfiguration_;
230                         public:
231                         explicit FadeInConfigurationsType(std::vector<FadeConfigurationType> fadeConfiguration);
232                         const std::vector<FadeConfigurationType>& getFadeConfiguration() const;
233                         bool hasFadeConfiguration() const;
234                         const FadeConfigurationType* getFirstFadeConfiguration() const;
235                         static FadeInConfigurationsType read(xmlNode *root);
236                     };
237 
238                 } // fade
239             } // audiocontrol
240         } // automotive
241     } // hardware
242 } // android
243 #endif // ANDROID_HARDWARE_AUTOMOTIVE_AUDIOCONTROL_FADE_H
244