1 #ifndef AIDL_ANDROID_HARDWARE_BLUETOOTH_AUDIO_SETTING_H
2 #define AIDL_ANDROID_HARDWARE_BLUETOOTH_AUDIO_SETTING_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 "aidl_android_hardware_bluetooth_audio_setting_enums.h"
19 
20 namespace aidl {
21     namespace android {
22         namespace hardware {
23             namespace bluetooth {
24                 namespace audio {
25                     namespace setting {
26                         class LeAudioOffloadSetting;
27                         class ScenarioList;
28                         class ConfigurationList;
29                         class CodecConfigurationList;
30                         class StrategyConfigurationList;
31                         class Scenario;
32                         class Configuration;
33                         class CodecConfiguration;
34                         class StrategyConfiguration;
35                         std::optional<LeAudioOffloadSetting> readLeAudioOffloadSetting(const char* configFile);
36 
37                         std::optional<LeAudioOffloadSetting> parseLeAudioOffloadSetting(const char* xml);
38 
39                         class LeAudioOffloadSetting {
40                             private:
41                             const std::vector<ScenarioList> scenarioList_;
42                             const std::vector<ConfigurationList> configurationList_;
43                             const std::vector<CodecConfigurationList> codecConfigurationList_;
44                             const std::vector<StrategyConfigurationList> strategyConfigurationList_;
45                             public:
46                             LeAudioOffloadSetting(std::vector<ScenarioList> scenarioList, std::vector<ConfigurationList> configurationList, std::vector<CodecConfigurationList> codecConfigurationList, std::vector<StrategyConfigurationList> strategyConfigurationList);
47                             const std::vector<ScenarioList>& getScenarioList() const;
48                             bool hasScenarioList() const;
49                             const ScenarioList* getFirstScenarioList() const;
50                             const std::vector<ConfigurationList>& getConfigurationList() const;
51                             bool hasConfigurationList() const;
52                             const ConfigurationList* getFirstConfigurationList() const;
53                             const std::vector<CodecConfigurationList>& getCodecConfigurationList() const;
54                             bool hasCodecConfigurationList() const;
55                             const CodecConfigurationList* getFirstCodecConfigurationList() const;
56                             const std::vector<StrategyConfigurationList>& getStrategyConfigurationList() const;
57                             bool hasStrategyConfigurationList() const;
58                             const StrategyConfigurationList* getFirstStrategyConfigurationList() const;
59                             static LeAudioOffloadSetting read(xmlNode *root);
60                         };
61 
62                         class ScenarioList {
63                             private:
64                             const std::vector<Scenario> scenario_;
65                             public:
66                             explicit ScenarioList(std::vector<Scenario> scenario);
67                             const std::vector<Scenario>& getScenario() const;
68                             bool hasScenario() const;
69                             const Scenario* getFirstScenario() const;
70                             static ScenarioList read(xmlNode *root);
71                         };
72 
73                         class ConfigurationList {
74                             private:
75                             const std::vector<Configuration> configuration_;
76                             public:
77                             explicit ConfigurationList(std::vector<Configuration> configuration);
78                             const std::vector<Configuration>& getConfiguration() const;
79                             bool hasConfiguration() const;
80                             const Configuration* getFirstConfiguration() const;
81                             static ConfigurationList read(xmlNode *root);
82                         };
83 
84                         class CodecConfigurationList {
85                             private:
86                             const std::vector<CodecConfiguration> codecConfiguration_;
87                             public:
88                             explicit CodecConfigurationList(std::vector<CodecConfiguration> codecConfiguration);
89                             const std::vector<CodecConfiguration>& getCodecConfiguration() const;
90                             bool hasCodecConfiguration() const;
91                             const CodecConfiguration* getFirstCodecConfiguration() const;
92                             static CodecConfigurationList read(xmlNode *root);
93                         };
94 
95                         class StrategyConfigurationList {
96                             private:
97                             const std::vector<StrategyConfiguration> strategyConfiguration_;
98                             public:
99                             explicit StrategyConfigurationList(std::vector<StrategyConfiguration> strategyConfiguration);
100                             const std::vector<StrategyConfiguration>& getStrategyConfiguration() const;
101                             bool hasStrategyConfiguration() const;
102                             const StrategyConfiguration* getFirstStrategyConfiguration() const;
103                             static StrategyConfigurationList read(xmlNode *root);
104                         };
105 
106                         class Scenario {
107                             private:
108                             const std::optional<std::string> encode_;
109                             const std::optional<std::string> decode_;
110                             const std::optional<std::string> broadcast_;
111                             public:
112                             Scenario(std::optional<std::string> encode, std::optional<std::string> decode, std::optional<std::string> broadcast);
113                             const std::string& getEncode() const;
114                             bool hasEncode() const;
115                             const std::string& getDecode() const;
116                             bool hasDecode() const;
117                             const std::string& getBroadcast() const;
118                             bool hasBroadcast() const;
119                             static Scenario read(xmlNode *root);
120                         };
121 
122                         class Configuration {
123                             private:
124                             const std::optional<std::string> name_;
125                             const std::optional<std::string> codecConfiguration_;
126                             const std::optional<std::string> strategyConfiguration_;
127                             public:
128                             Configuration(std::optional<std::string> name, std::optional<std::string> codecConfiguration, std::optional<std::string> strategyConfiguration);
129                             const std::string& getName() const;
130                             bool hasName() const;
131                             const std::string& getCodecConfiguration() const;
132                             bool hasCodecConfiguration() const;
133                             const std::string& getStrategyConfiguration() const;
134                             bool hasStrategyConfiguration() const;
135                             static Configuration read(xmlNode *root);
136                         };
137 
138                         class CodecConfiguration {
139                             private:
140                             const std::optional<std::string> name_;
141                             const std::optional<CodecType> codec_;
142                             const std::optional<unsigned char> pcmBitDepth_;
143                             const std::optional<int> samplingFrequency_;
144                             const std::optional<int> frameDurationUs_;
145                             const std::optional<int> octetsPerCodecFrame_;
146                             const std::optional<unsigned char> codecFrameBlocksPerSdu_;
147                             public:
148                             CodecConfiguration(std::optional<std::string> name, std::optional<CodecType> codec, std::optional<unsigned char> pcmBitDepth, std::optional<int> samplingFrequency, std::optional<int> frameDurationUs, std::optional<int> octetsPerCodecFrame, std::optional<unsigned char> codecFrameBlocksPerSdu);
149                             const std::string& getName() const;
150                             bool hasName() const;
151                             const CodecType& getCodec() const;
152                             bool hasCodec() const;
153                             const unsigned char& getPcmBitDepth() const;
154                             bool hasPcmBitDepth() const;
155                             const int& getSamplingFrequency() const;
156                             bool hasSamplingFrequency() const;
157                             const int& getFrameDurationUs() const;
158                             bool hasFrameDurationUs() const;
159                             const int& getOctetsPerCodecFrame() const;
160                             bool hasOctetsPerCodecFrame() const;
161                             const unsigned char& getCodecFrameBlocksPerSdu() const;
162                             bool hasCodecFrameBlocksPerSdu() const;
163                             static CodecConfiguration read(xmlNode *root);
164                         };
165 
166                         class StrategyConfiguration {
167                             private:
168                             const std::optional<std::string> name_;
169                             const std::optional<AudioLocation> audioLocation_;
170                             const std::optional<unsigned char> connectedDevice_;
171                             const std::optional<unsigned char> channelCount_;
172                             const std::optional<int> audioChannelAllocation_;
173                             public:
174                             StrategyConfiguration(std::optional<std::string> name, std::optional<AudioLocation> audioLocation, std::optional<unsigned char> connectedDevice, std::optional<unsigned char> channelCount, std::optional<int> audioChannelAllocation);
175                             const std::string& getName() const;
176                             bool hasName() const;
177                             const AudioLocation& getAudioLocation() const;
178                             bool hasAudioLocation() const;
179                             const unsigned char& getConnectedDevice() const;
180                             bool hasConnectedDevice() const;
181                             const unsigned char& getChannelCount() const;
182                             bool hasChannelCount() const;
183                             const int& getAudioChannelAllocation() const;
184                             bool hasAudioChannelAllocation() const;
185                             static StrategyConfiguration read(xmlNode *root);
186                         };
187 
188                     } // setting
189                 } // audio
190             } // bluetooth
191         } // hardware
192     } // android
193 } // aidl
194 #endif // AIDL_ANDROID_HARDWARE_BLUETOOTH_AUDIO_SETTING_H
195