xref: /aosp_15_r20/system/chre/apps/power_test/common/include/generated/chre_power_test_generated.h (revision 84e339476a462649f82315436d70fd732297a399) 
1 // automatically generated by the FlatBuffers compiler, do not modify
2 
3 
4 #ifndef FLATBUFFERS_GENERATED_CHREPOWERTEST_CHRE_POWER_TEST_H_
5 #define FLATBUFFERS_GENERATED_CHREPOWERTEST_CHRE_POWER_TEST_H_
6 
7 #include "flatbuffers/flatbuffers.h"
8 
9 namespace chre {
10 namespace power_test {
11 
12 struct TimerMessage;
13 struct TimerMessageBuilder;
14 
15 struct WifiScanMessage;
16 struct WifiScanMessageBuilder;
17 
18 struct GnssLocationMessage;
19 struct GnssLocationMessageBuilder;
20 
21 struct CellQueryMessage;
22 struct CellQueryMessageBuilder;
23 
24 struct AudioRequestMessage;
25 struct AudioRequestMessageBuilder;
26 
27 struct SensorRequestMessage;
28 struct SensorRequestMessageBuilder;
29 
30 struct BreakItMessage;
31 struct BreakItMessageBuilder;
32 
33 struct NanoappResponseMessage;
34 struct NanoappResponseMessageBuilder;
35 
36 struct GnssMeasurementMessage;
37 struct GnssMeasurementMessageBuilder;
38 
39 struct WifiNanSubMessage;
40 struct WifiNanSubMessageBuilder;
41 
42 struct WifiNanSubCancelMessage;
43 struct WifiNanSubCancelMessageBuilder;
44 
45 struct WifiNanSubResponseMessage;
46 struct WifiNanSubResponseMessageBuilder;
47 
48 /// Indicates which of the following messages is being sent to / from the
49 /// nanoapp. Use uint as the base type to match the message type in
50 /// chreMessageFromHostData.
51 enum class MessageType : uint32_t {
52   UNSPECIFIED = 0,
53   /// Should be used with TimerMessage
54   TIMER_TEST = 1,
55   /// Should be used with WifiScanMessage
56   WIFI_SCAN_TEST = 2,
57   /// Should be used with GnssLocationMessage
58   GNSS_LOCATION_TEST = 3,
59   /// Should be used with CellQueryMessage
60   CELL_QUERY_TEST = 4,
61   /// Should be used with AudioRequestMessage
62   AUDIO_REQUEST_TEST = 5,
63   /// Should be used with SensorRequestMessage
64   SENSOR_REQUEST_TEST = 6,
65   /// Should be used with BreakItMessage
66   BREAK_IT_TEST = 7,
67   /// Should be used with NanoappResponseMessage
68   NANOAPP_RESPONSE = 8,
69   /// Should be used with GnssMeasurementMessage
70   GNSS_MEASUREMENT_TEST = 9,
71   /// Should be used with WifiNanSubMessage
72   WIFI_NAN_SUB = 10,
73   /// Should be used with WifiNanSubCancelMessage
74   WIFI_NAN_SUB_CANCEL = 11,
75   /// Should be used with WifiNanSubResponseMessage
76   WIFI_NAN_SUB_RESP = 12,
77   MIN = UNSPECIFIED,
78   MAX = WIFI_NAN_SUB_RESP
79 };
80 
EnumValuesMessageType()81 inline const MessageType (&EnumValuesMessageType())[13] {
82   static const MessageType values[] = {
83     MessageType::UNSPECIFIED,
84     MessageType::TIMER_TEST,
85     MessageType::WIFI_SCAN_TEST,
86     MessageType::GNSS_LOCATION_TEST,
87     MessageType::CELL_QUERY_TEST,
88     MessageType::AUDIO_REQUEST_TEST,
89     MessageType::SENSOR_REQUEST_TEST,
90     MessageType::BREAK_IT_TEST,
91     MessageType::NANOAPP_RESPONSE,
92     MessageType::GNSS_MEASUREMENT_TEST,
93     MessageType::WIFI_NAN_SUB,
94     MessageType::WIFI_NAN_SUB_CANCEL,
95     MessageType::WIFI_NAN_SUB_RESP
96   };
97   return values;
98 }
99 
EnumNamesMessageType()100 inline const char * const *EnumNamesMessageType() {
101   static const char * const names[14] = {
102     "UNSPECIFIED",
103     "TIMER_TEST",
104     "WIFI_SCAN_TEST",
105     "GNSS_LOCATION_TEST",
106     "CELL_QUERY_TEST",
107     "AUDIO_REQUEST_TEST",
108     "SENSOR_REQUEST_TEST",
109     "BREAK_IT_TEST",
110     "NANOAPP_RESPONSE",
111     "GNSS_MEASUREMENT_TEST",
112     "WIFI_NAN_SUB",
113     "WIFI_NAN_SUB_CANCEL",
114     "WIFI_NAN_SUB_RESP",
115     nullptr
116   };
117   return names;
118 }
119 
EnumNameMessageType(MessageType e)120 inline const char *EnumNameMessageType(MessageType e) {
121   if (flatbuffers::IsOutRange(e, MessageType::UNSPECIFIED, MessageType::WIFI_NAN_SUB_RESP)) return "";
122   const size_t index = static_cast<size_t>(e);
123   return EnumNamesMessageType()[index];
124 }
125 
126 /// All the various WiFi scan types that can be interacted with inside the
127 /// nanoapp. The values used here map directly to values from the CHRE API.
128 enum class WifiScanType : uint8_t {
129   ACTIVE = 0,
130   ACTIVE_PLUS_PASSIVE_DFS = 1,
131   PASSIVE = 2,
132   NO_PREFERENCE = 3,
133   MIN = ACTIVE,
134   MAX = NO_PREFERENCE
135 };
136 
EnumValuesWifiScanType()137 inline const WifiScanType (&EnumValuesWifiScanType())[4] {
138   static const WifiScanType values[] = {
139     WifiScanType::ACTIVE,
140     WifiScanType::ACTIVE_PLUS_PASSIVE_DFS,
141     WifiScanType::PASSIVE,
142     WifiScanType::NO_PREFERENCE
143   };
144   return values;
145 }
146 
EnumNamesWifiScanType()147 inline const char * const *EnumNamesWifiScanType() {
148   static const char * const names[5] = {
149     "ACTIVE",
150     "ACTIVE_PLUS_PASSIVE_DFS",
151     "PASSIVE",
152     "NO_PREFERENCE",
153     nullptr
154   };
155   return names;
156 }
157 
EnumNameWifiScanType(WifiScanType e)158 inline const char *EnumNameWifiScanType(WifiScanType e) {
159   if (flatbuffers::IsOutRange(e, WifiScanType::ACTIVE, WifiScanType::NO_PREFERENCE)) return "";
160   const size_t index = static_cast<size_t>(e);
161   return EnumNamesWifiScanType()[index];
162 }
163 
164 /// All the various WiFi radio chain preferences that can be interacted with
165 /// inside the nanoapp. The values used here map directly to values from the
166 /// CHRE API.
167 enum class WifiRadioChain : uint8_t {
168   DEFAULT = 0,
169   LOW_LATENCY = 1,
170   LOW_POWER = 2,
171   HIGH_ACCURACY = 3,
172   MIN = DEFAULT,
173   MAX = HIGH_ACCURACY
174 };
175 
EnumValuesWifiRadioChain()176 inline const WifiRadioChain (&EnumValuesWifiRadioChain())[4] {
177   static const WifiRadioChain values[] = {
178     WifiRadioChain::DEFAULT,
179     WifiRadioChain::LOW_LATENCY,
180     WifiRadioChain::LOW_POWER,
181     WifiRadioChain::HIGH_ACCURACY
182   };
183   return values;
184 }
185 
EnumNamesWifiRadioChain()186 inline const char * const *EnumNamesWifiRadioChain() {
187   static const char * const names[5] = {
188     "DEFAULT",
189     "LOW_LATENCY",
190     "LOW_POWER",
191     "HIGH_ACCURACY",
192     nullptr
193   };
194   return names;
195 }
196 
EnumNameWifiRadioChain(WifiRadioChain e)197 inline const char *EnumNameWifiRadioChain(WifiRadioChain e) {
198   if (flatbuffers::IsOutRange(e, WifiRadioChain::DEFAULT, WifiRadioChain::HIGH_ACCURACY)) return "";
199   const size_t index = static_cast<size_t>(e);
200   return EnumNamesWifiRadioChain()[index];
201 }
202 
203 /// All the various WiFi channel sets that can be interacted with inside the
204 /// nanoapp. The values used here map directly to values from the CHRE API.
205 enum class WifiChannelSet : uint8_t {
206   NON_DFS = 0,
207   ALL = 1,
208   MIN = NON_DFS,
209   MAX = ALL
210 };
211 
EnumValuesWifiChannelSet()212 inline const WifiChannelSet (&EnumValuesWifiChannelSet())[2] {
213   static const WifiChannelSet values[] = {
214     WifiChannelSet::NON_DFS,
215     WifiChannelSet::ALL
216   };
217   return values;
218 }
219 
EnumNamesWifiChannelSet()220 inline const char * const *EnumNamesWifiChannelSet() {
221   static const char * const names[3] = {
222     "NON_DFS",
223     "ALL",
224     nullptr
225   };
226   return names;
227 }
228 
EnumNameWifiChannelSet(WifiChannelSet e)229 inline const char *EnumNameWifiChannelSet(WifiChannelSet e) {
230   if (flatbuffers::IsOutRange(e, WifiChannelSet::NON_DFS, WifiChannelSet::ALL)) return "";
231   const size_t index = static_cast<size_t>(e);
232   return EnumNamesWifiChannelSet()[index];
233 }
234 
235 /// All the various sensors that can be interacted with inside the nanoapp.
236 /// The values used here map directly to values from the CHRE API
237 enum class SensorType : uint8_t {
238   UNKNOWN = 0,
239   ACCELEROMETER = 1,
240   INSTANT_MOTION_DETECT = 2,
241   STATIONARY_DETECT = 3,
242   GYROSCOPE = 6,
243   UNCALIBRATED_GYROSCOPE = 7,
244   GEOMAGNETIC_FIELD = 8,
245   UNCALIBRATED_GEOMAGNETIC_FIELD = 9,
246   PRESSURE = 10,
247   LIGHT = 12,
248   PROXIMITY = 13,
249   STEP_DETECT = 23,
250   STEP_COUNTER = 24,
251   UNCALIBRATED_ACCELEROMETER = 55,
252   ACCELEROMETER_TEMPERATURE = 56,
253   GYROSCOPE_TEMPERATURE = 57,
254   GEOMAGNETIC_FIELD_TEMPERATURE = 58,
255   MIN = UNKNOWN,
256   MAX = GEOMAGNETIC_FIELD_TEMPERATURE
257 };
258 
EnumValuesSensorType()259 inline const SensorType (&EnumValuesSensorType())[17] {
260   static const SensorType values[] = {
261     SensorType::UNKNOWN,
262     SensorType::ACCELEROMETER,
263     SensorType::INSTANT_MOTION_DETECT,
264     SensorType::STATIONARY_DETECT,
265     SensorType::GYROSCOPE,
266     SensorType::UNCALIBRATED_GYROSCOPE,
267     SensorType::GEOMAGNETIC_FIELD,
268     SensorType::UNCALIBRATED_GEOMAGNETIC_FIELD,
269     SensorType::PRESSURE,
270     SensorType::LIGHT,
271     SensorType::PROXIMITY,
272     SensorType::STEP_DETECT,
273     SensorType::STEP_COUNTER,
274     SensorType::UNCALIBRATED_ACCELEROMETER,
275     SensorType::ACCELEROMETER_TEMPERATURE,
276     SensorType::GYROSCOPE_TEMPERATURE,
277     SensorType::GEOMAGNETIC_FIELD_TEMPERATURE
278   };
279   return values;
280 }
281 
EnumNamesSensorType()282 inline const char * const *EnumNamesSensorType() {
283   static const char * const names[60] = {
284     "UNKNOWN",
285     "ACCELEROMETER",
286     "INSTANT_MOTION_DETECT",
287     "STATIONARY_DETECT",
288     "",
289     "",
290     "GYROSCOPE",
291     "UNCALIBRATED_GYROSCOPE",
292     "GEOMAGNETIC_FIELD",
293     "UNCALIBRATED_GEOMAGNETIC_FIELD",
294     "PRESSURE",
295     "",
296     "LIGHT",
297     "PROXIMITY",
298     "",
299     "",
300     "",
301     "",
302     "",
303     "",
304     "",
305     "",
306     "",
307     "STEP_DETECT",
308     "STEP_COUNTER",
309     "",
310     "",
311     "",
312     "",
313     "",
314     "",
315     "",
316     "",
317     "",
318     "",
319     "",
320     "",
321     "",
322     "",
323     "",
324     "",
325     "",
326     "",
327     "",
328     "",
329     "",
330     "",
331     "",
332     "",
333     "",
334     "",
335     "",
336     "",
337     "",
338     "",
339     "UNCALIBRATED_ACCELEROMETER",
340     "ACCELEROMETER_TEMPERATURE",
341     "GYROSCOPE_TEMPERATURE",
342     "GEOMAGNETIC_FIELD_TEMPERATURE",
343     nullptr
344   };
345   return names;
346 }
347 
EnumNameSensorType(SensorType e)348 inline const char *EnumNameSensorType(SensorType e) {
349   if (flatbuffers::IsOutRange(e, SensorType::UNKNOWN, SensorType::GEOMAGNETIC_FIELD_TEMPERATURE)) return "";
350   const size_t index = static_cast<size_t>(e);
351   return EnumNamesSensorType()[index];
352 }
353 
354 /// Represents a message to ask the nanoapp to create a timer that wakes up at
355 /// the given interval
356 struct TimerMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
357   typedef TimerMessageBuilder Builder;
358   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
359     VT_ENABLE = 4,
360     VT_WAKEUP_INTERVAL_NS = 6
361   };
enableFLATBUFFERS_FINAL_CLASS362   bool enable() const {
363     return GetField<uint8_t>(VT_ENABLE, 0) != 0;
364   }
wakeup_interval_nsFLATBUFFERS_FINAL_CLASS365   uint64_t wakeup_interval_ns() const {
366     return GetField<uint64_t>(VT_WAKEUP_INTERVAL_NS, 0);
367   }
VerifyFLATBUFFERS_FINAL_CLASS368   bool Verify(flatbuffers::Verifier &verifier) const {
369     return VerifyTableStart(verifier) &&
370            VerifyField<uint8_t>(verifier, VT_ENABLE) &&
371            VerifyField<uint64_t>(verifier, VT_WAKEUP_INTERVAL_NS) &&
372            verifier.EndTable();
373   }
374 };
375 
376 struct TimerMessageBuilder {
377   typedef TimerMessage Table;
378   flatbuffers::FlatBufferBuilder &fbb_;
379   flatbuffers::uoffset_t start_;
add_enableTimerMessageBuilder380   void add_enable(bool enable) {
381     fbb_.AddElement<uint8_t>(TimerMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
382   }
add_wakeup_interval_nsTimerMessageBuilder383   void add_wakeup_interval_ns(uint64_t wakeup_interval_ns) {
384     fbb_.AddElement<uint64_t>(TimerMessage::VT_WAKEUP_INTERVAL_NS, wakeup_interval_ns, 0);
385   }
TimerMessageBuilderTimerMessageBuilder386   explicit TimerMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
387         : fbb_(_fbb) {
388     start_ = fbb_.StartTable();
389   }
390   TimerMessageBuilder &operator=(const TimerMessageBuilder &);
FinishTimerMessageBuilder391   flatbuffers::Offset<TimerMessage> Finish() {
392     const auto end = fbb_.EndTable(start_);
393     auto o = flatbuffers::Offset<TimerMessage>(end);
394     return o;
395   }
396 };
397 
398 inline flatbuffers::Offset<TimerMessage> CreateTimerMessage(
399     flatbuffers::FlatBufferBuilder &_fbb,
400     bool enable = false,
401     uint64_t wakeup_interval_ns = 0) {
402   TimerMessageBuilder builder_(_fbb);
403   builder_.add_wakeup_interval_ns(wakeup_interval_ns);
404   builder_.add_enable(enable);
405   return builder_.Finish();
406 }
407 
408 /// Represents a message to ask the nanoapp to start or stop WiFi scanning and
409 /// the scan interval to use if scanning is being started
410 struct WifiScanMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
411   typedef WifiScanMessageBuilder Builder;
412   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
413     VT_ENABLE = 4,
414     VT_SCAN_INTERVAL_NS = 6,
415     VT_SCAN_TYPE = 8,
416     VT_RADIO_CHAIN = 10,
417     VT_CHANNEL_SET = 12
418   };
enableFLATBUFFERS_FINAL_CLASS419   bool enable() const {
420     return GetField<uint8_t>(VT_ENABLE, 0) != 0;
421   }
scan_interval_nsFLATBUFFERS_FINAL_CLASS422   uint64_t scan_interval_ns() const {
423     return GetField<uint64_t>(VT_SCAN_INTERVAL_NS, 0);
424   }
scan_typeFLATBUFFERS_FINAL_CLASS425   chre::power_test::WifiScanType scan_type() const {
426     return static_cast<chre::power_test::WifiScanType>(GetField<uint8_t>(VT_SCAN_TYPE, 0));
427   }
radio_chainFLATBUFFERS_FINAL_CLASS428   chre::power_test::WifiRadioChain radio_chain() const {
429     return static_cast<chre::power_test::WifiRadioChain>(GetField<uint8_t>(VT_RADIO_CHAIN, 0));
430   }
channel_setFLATBUFFERS_FINAL_CLASS431   chre::power_test::WifiChannelSet channel_set() const {
432     return static_cast<chre::power_test::WifiChannelSet>(GetField<uint8_t>(VT_CHANNEL_SET, 0));
433   }
VerifyFLATBUFFERS_FINAL_CLASS434   bool Verify(flatbuffers::Verifier &verifier) const {
435     return VerifyTableStart(verifier) &&
436            VerifyField<uint8_t>(verifier, VT_ENABLE) &&
437            VerifyField<uint64_t>(verifier, VT_SCAN_INTERVAL_NS) &&
438            VerifyField<uint8_t>(verifier, VT_SCAN_TYPE) &&
439            VerifyField<uint8_t>(verifier, VT_RADIO_CHAIN) &&
440            VerifyField<uint8_t>(verifier, VT_CHANNEL_SET) &&
441            verifier.EndTable();
442   }
443 };
444 
445 struct WifiScanMessageBuilder {
446   typedef WifiScanMessage Table;
447   flatbuffers::FlatBufferBuilder &fbb_;
448   flatbuffers::uoffset_t start_;
add_enableWifiScanMessageBuilder449   void add_enable(bool enable) {
450     fbb_.AddElement<uint8_t>(WifiScanMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
451   }
add_scan_interval_nsWifiScanMessageBuilder452   void add_scan_interval_ns(uint64_t scan_interval_ns) {
453     fbb_.AddElement<uint64_t>(WifiScanMessage::VT_SCAN_INTERVAL_NS, scan_interval_ns, 0);
454   }
add_scan_typeWifiScanMessageBuilder455   void add_scan_type(chre::power_test::WifiScanType scan_type) {
456     fbb_.AddElement<uint8_t>(WifiScanMessage::VT_SCAN_TYPE, static_cast<uint8_t>(scan_type), 0);
457   }
add_radio_chainWifiScanMessageBuilder458   void add_radio_chain(chre::power_test::WifiRadioChain radio_chain) {
459     fbb_.AddElement<uint8_t>(WifiScanMessage::VT_RADIO_CHAIN, static_cast<uint8_t>(radio_chain), 0);
460   }
add_channel_setWifiScanMessageBuilder461   void add_channel_set(chre::power_test::WifiChannelSet channel_set) {
462     fbb_.AddElement<uint8_t>(WifiScanMessage::VT_CHANNEL_SET, static_cast<uint8_t>(channel_set), 0);
463   }
WifiScanMessageBuilderWifiScanMessageBuilder464   explicit WifiScanMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
465         : fbb_(_fbb) {
466     start_ = fbb_.StartTable();
467   }
468   WifiScanMessageBuilder &operator=(const WifiScanMessageBuilder &);
FinishWifiScanMessageBuilder469   flatbuffers::Offset<WifiScanMessage> Finish() {
470     const auto end = fbb_.EndTable(start_);
471     auto o = flatbuffers::Offset<WifiScanMessage>(end);
472     return o;
473   }
474 };
475 
476 inline flatbuffers::Offset<WifiScanMessage> CreateWifiScanMessage(
477     flatbuffers::FlatBufferBuilder &_fbb,
478     bool enable = false,
479     uint64_t scan_interval_ns = 0,
480     chre::power_test::WifiScanType scan_type = chre::power_test::WifiScanType::ACTIVE,
481     chre::power_test::WifiRadioChain radio_chain = chre::power_test::WifiRadioChain::DEFAULT,
482     chre::power_test::WifiChannelSet channel_set = chre::power_test::WifiChannelSet::NON_DFS) {
483   WifiScanMessageBuilder builder_(_fbb);
484   builder_.add_scan_interval_ns(scan_interval_ns);
485   builder_.add_channel_set(channel_set);
486   builder_.add_radio_chain(radio_chain);
487   builder_.add_scan_type(scan_type);
488   builder_.add_enable(enable);
489   return builder_.Finish();
490 }
491 
492 /// Represents a message to ask the nanoapp to start or stop Gnss location
493 /// sampling at the requested interval
494 struct GnssLocationMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
495   typedef GnssLocationMessageBuilder Builder;
496   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
497     VT_ENABLE = 4,
498     VT_SCAN_INTERVAL_MILLIS = 6,
499     VT_MIN_TIME_TO_NEXT_FIX_MILLIS = 8
500   };
enableFLATBUFFERS_FINAL_CLASS501   bool enable() const {
502     return GetField<uint8_t>(VT_ENABLE, 0) != 0;
503   }
scan_interval_millisFLATBUFFERS_FINAL_CLASS504   uint32_t scan_interval_millis() const {
505     return GetField<uint32_t>(VT_SCAN_INTERVAL_MILLIS, 0);
506   }
min_time_to_next_fix_millisFLATBUFFERS_FINAL_CLASS507   uint32_t min_time_to_next_fix_millis() const {
508     return GetField<uint32_t>(VT_MIN_TIME_TO_NEXT_FIX_MILLIS, 0);
509   }
VerifyFLATBUFFERS_FINAL_CLASS510   bool Verify(flatbuffers::Verifier &verifier) const {
511     return VerifyTableStart(verifier) &&
512            VerifyField<uint8_t>(verifier, VT_ENABLE) &&
513            VerifyField<uint32_t>(verifier, VT_SCAN_INTERVAL_MILLIS) &&
514            VerifyField<uint32_t>(verifier, VT_MIN_TIME_TO_NEXT_FIX_MILLIS) &&
515            verifier.EndTable();
516   }
517 };
518 
519 struct GnssLocationMessageBuilder {
520   typedef GnssLocationMessage Table;
521   flatbuffers::FlatBufferBuilder &fbb_;
522   flatbuffers::uoffset_t start_;
add_enableGnssLocationMessageBuilder523   void add_enable(bool enable) {
524     fbb_.AddElement<uint8_t>(GnssLocationMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
525   }
add_scan_interval_millisGnssLocationMessageBuilder526   void add_scan_interval_millis(uint32_t scan_interval_millis) {
527     fbb_.AddElement<uint32_t>(GnssLocationMessage::VT_SCAN_INTERVAL_MILLIS, scan_interval_millis, 0);
528   }
add_min_time_to_next_fix_millisGnssLocationMessageBuilder529   void add_min_time_to_next_fix_millis(uint32_t min_time_to_next_fix_millis) {
530     fbb_.AddElement<uint32_t>(GnssLocationMessage::VT_MIN_TIME_TO_NEXT_FIX_MILLIS, min_time_to_next_fix_millis, 0);
531   }
GnssLocationMessageBuilderGnssLocationMessageBuilder532   explicit GnssLocationMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
533         : fbb_(_fbb) {
534     start_ = fbb_.StartTable();
535   }
536   GnssLocationMessageBuilder &operator=(const GnssLocationMessageBuilder &);
FinishGnssLocationMessageBuilder537   flatbuffers::Offset<GnssLocationMessage> Finish() {
538     const auto end = fbb_.EndTable(start_);
539     auto o = flatbuffers::Offset<GnssLocationMessage>(end);
540     return o;
541   }
542 };
543 
544 inline flatbuffers::Offset<GnssLocationMessage> CreateGnssLocationMessage(
545     flatbuffers::FlatBufferBuilder &_fbb,
546     bool enable = false,
547     uint32_t scan_interval_millis = 0,
548     uint32_t min_time_to_next_fix_millis = 0) {
549   GnssLocationMessageBuilder builder_(_fbb);
550   builder_.add_min_time_to_next_fix_millis(min_time_to_next_fix_millis);
551   builder_.add_scan_interval_millis(scan_interval_millis);
552   builder_.add_enable(enable);
553   return builder_.Finish();
554 }
555 
556 /// Represents a message to ask the nanoapp to start or stop querying the cell
557 /// modem for the latest cell scan results on the given interval
558 struct CellQueryMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
559   typedef CellQueryMessageBuilder Builder;
560   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
561     VT_ENABLE = 4,
562     VT_QUERY_INTERVAL_NS = 6
563   };
enableFLATBUFFERS_FINAL_CLASS564   bool enable() const {
565     return GetField<uint8_t>(VT_ENABLE, 0) != 0;
566   }
query_interval_nsFLATBUFFERS_FINAL_CLASS567   uint64_t query_interval_ns() const {
568     return GetField<uint64_t>(VT_QUERY_INTERVAL_NS, 0);
569   }
VerifyFLATBUFFERS_FINAL_CLASS570   bool Verify(flatbuffers::Verifier &verifier) const {
571     return VerifyTableStart(verifier) &&
572            VerifyField<uint8_t>(verifier, VT_ENABLE) &&
573            VerifyField<uint64_t>(verifier, VT_QUERY_INTERVAL_NS) &&
574            verifier.EndTable();
575   }
576 };
577 
578 struct CellQueryMessageBuilder {
579   typedef CellQueryMessage Table;
580   flatbuffers::FlatBufferBuilder &fbb_;
581   flatbuffers::uoffset_t start_;
add_enableCellQueryMessageBuilder582   void add_enable(bool enable) {
583     fbb_.AddElement<uint8_t>(CellQueryMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
584   }
add_query_interval_nsCellQueryMessageBuilder585   void add_query_interval_ns(uint64_t query_interval_ns) {
586     fbb_.AddElement<uint64_t>(CellQueryMessage::VT_QUERY_INTERVAL_NS, query_interval_ns, 0);
587   }
CellQueryMessageBuilderCellQueryMessageBuilder588   explicit CellQueryMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
589         : fbb_(_fbb) {
590     start_ = fbb_.StartTable();
591   }
592   CellQueryMessageBuilder &operator=(const CellQueryMessageBuilder &);
FinishCellQueryMessageBuilder593   flatbuffers::Offset<CellQueryMessage> Finish() {
594     const auto end = fbb_.EndTable(start_);
595     auto o = flatbuffers::Offset<CellQueryMessage>(end);
596     return o;
597   }
598 };
599 
600 inline flatbuffers::Offset<CellQueryMessage> CreateCellQueryMessage(
601     flatbuffers::FlatBufferBuilder &_fbb,
602     bool enable = false,
603     uint64_t query_interval_ns = 0) {
604   CellQueryMessageBuilder builder_(_fbb);
605   builder_.add_query_interval_ns(query_interval_ns);
606   builder_.add_enable(enable);
607   return builder_.Finish();
608 }
609 
610 /// Represents a message to ask the nanoapp to start / stop requesting Audio
611 /// data buffered at given interval. Note: If there is more than one audio
612 /// source, the nanoapp will only request audio from the first source.
613 struct AudioRequestMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
614   typedef AudioRequestMessageBuilder Builder;
615   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
616     VT_ENABLE = 4,
617     VT_BUFFER_DURATION_NS = 6
618   };
enableFLATBUFFERS_FINAL_CLASS619   bool enable() const {
620     return GetField<uint8_t>(VT_ENABLE, 0) != 0;
621   }
622   /// The buffer duration is also used as the interval for how often
623   /// the buffer should be delivered to the nanoapp.
buffer_duration_nsFLATBUFFERS_FINAL_CLASS624   uint64_t buffer_duration_ns() const {
625     return GetField<uint64_t>(VT_BUFFER_DURATION_NS, 0);
626   }
VerifyFLATBUFFERS_FINAL_CLASS627   bool Verify(flatbuffers::Verifier &verifier) const {
628     return VerifyTableStart(verifier) &&
629            VerifyField<uint8_t>(verifier, VT_ENABLE) &&
630            VerifyField<uint64_t>(verifier, VT_BUFFER_DURATION_NS) &&
631            verifier.EndTable();
632   }
633 };
634 
635 struct AudioRequestMessageBuilder {
636   typedef AudioRequestMessage Table;
637   flatbuffers::FlatBufferBuilder &fbb_;
638   flatbuffers::uoffset_t start_;
add_enableAudioRequestMessageBuilder639   void add_enable(bool enable) {
640     fbb_.AddElement<uint8_t>(AudioRequestMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
641   }
add_buffer_duration_nsAudioRequestMessageBuilder642   void add_buffer_duration_ns(uint64_t buffer_duration_ns) {
643     fbb_.AddElement<uint64_t>(AudioRequestMessage::VT_BUFFER_DURATION_NS, buffer_duration_ns, 0);
644   }
AudioRequestMessageBuilderAudioRequestMessageBuilder645   explicit AudioRequestMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
646         : fbb_(_fbb) {
647     start_ = fbb_.StartTable();
648   }
649   AudioRequestMessageBuilder &operator=(const AudioRequestMessageBuilder &);
FinishAudioRequestMessageBuilder650   flatbuffers::Offset<AudioRequestMessage> Finish() {
651     const auto end = fbb_.EndTable(start_);
652     auto o = flatbuffers::Offset<AudioRequestMessage>(end);
653     return o;
654   }
655 };
656 
657 inline flatbuffers::Offset<AudioRequestMessage> CreateAudioRequestMessage(
658     flatbuffers::FlatBufferBuilder &_fbb,
659     bool enable = false,
660     uint64_t buffer_duration_ns = 0) {
661   AudioRequestMessageBuilder builder_(_fbb);
662   builder_.add_buffer_duration_ns(buffer_duration_ns);
663   builder_.add_enable(enable);
664   return builder_.Finish();
665 }
666 
667 /// Represents a message to ask the nanoapp to start / stop sampling / batching
668 /// a given sensor
669 struct SensorRequestMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
670   typedef SensorRequestMessageBuilder Builder;
671   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
672     VT_ENABLE = 4,
673     VT_SENSOR = 6,
674     VT_SAMPLING_INTERVAL_NS = 8,
675     VT_LATENCY_NS = 10
676   };
enableFLATBUFFERS_FINAL_CLASS677   bool enable() const {
678     return GetField<uint8_t>(VT_ENABLE, 0) != 0;
679   }
sensorFLATBUFFERS_FINAL_CLASS680   chre::power_test::SensorType sensor() const {
681     return static_cast<chre::power_test::SensorType>(GetField<uint8_t>(VT_SENSOR, 0));
682   }
sampling_interval_nsFLATBUFFERS_FINAL_CLASS683   uint64_t sampling_interval_ns() const {
684     return GetField<uint64_t>(VT_SAMPLING_INTERVAL_NS, 0);
685   }
latency_nsFLATBUFFERS_FINAL_CLASS686   uint64_t latency_ns() const {
687     return GetField<uint64_t>(VT_LATENCY_NS, 0);
688   }
VerifyFLATBUFFERS_FINAL_CLASS689   bool Verify(flatbuffers::Verifier &verifier) const {
690     return VerifyTableStart(verifier) &&
691            VerifyField<uint8_t>(verifier, VT_ENABLE) &&
692            VerifyField<uint8_t>(verifier, VT_SENSOR) &&
693            VerifyField<uint64_t>(verifier, VT_SAMPLING_INTERVAL_NS) &&
694            VerifyField<uint64_t>(verifier, VT_LATENCY_NS) &&
695            verifier.EndTable();
696   }
697 };
698 
699 struct SensorRequestMessageBuilder {
700   typedef SensorRequestMessage Table;
701   flatbuffers::FlatBufferBuilder &fbb_;
702   flatbuffers::uoffset_t start_;
add_enableSensorRequestMessageBuilder703   void add_enable(bool enable) {
704     fbb_.AddElement<uint8_t>(SensorRequestMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
705   }
add_sensorSensorRequestMessageBuilder706   void add_sensor(chre::power_test::SensorType sensor) {
707     fbb_.AddElement<uint8_t>(SensorRequestMessage::VT_SENSOR, static_cast<uint8_t>(sensor), 0);
708   }
add_sampling_interval_nsSensorRequestMessageBuilder709   void add_sampling_interval_ns(uint64_t sampling_interval_ns) {
710     fbb_.AddElement<uint64_t>(SensorRequestMessage::VT_SAMPLING_INTERVAL_NS, sampling_interval_ns, 0);
711   }
add_latency_nsSensorRequestMessageBuilder712   void add_latency_ns(uint64_t latency_ns) {
713     fbb_.AddElement<uint64_t>(SensorRequestMessage::VT_LATENCY_NS, latency_ns, 0);
714   }
SensorRequestMessageBuilderSensorRequestMessageBuilder715   explicit SensorRequestMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
716         : fbb_(_fbb) {
717     start_ = fbb_.StartTable();
718   }
719   SensorRequestMessageBuilder &operator=(const SensorRequestMessageBuilder &);
FinishSensorRequestMessageBuilder720   flatbuffers::Offset<SensorRequestMessage> Finish() {
721     const auto end = fbb_.EndTable(start_);
722     auto o = flatbuffers::Offset<SensorRequestMessage>(end);
723     return o;
724   }
725 };
726 
727 inline flatbuffers::Offset<SensorRequestMessage> CreateSensorRequestMessage(
728     flatbuffers::FlatBufferBuilder &_fbb,
729     bool enable = false,
730     chre::power_test::SensorType sensor = chre::power_test::SensorType::UNKNOWN,
731     uint64_t sampling_interval_ns = 0,
732     uint64_t latency_ns = 0) {
733   SensorRequestMessageBuilder builder_(_fbb);
734   builder_.add_latency_ns(latency_ns);
735   builder_.add_sampling_interval_ns(sampling_interval_ns);
736   builder_.add_sensor(sensor);
737   builder_.add_enable(enable);
738   return builder_.Finish();
739 }
740 
741 /// Represents a message to enable / disable break-it mode inside the nanoapp.
742 /// Break-it mode enables WiFi / GNSS / Cell to be queried every second and
743 /// enables all sensors at their fastest sampling rate.
744 struct BreakItMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
745   typedef BreakItMessageBuilder Builder;
746   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
747     VT_ENABLE = 4
748   };
enableFLATBUFFERS_FINAL_CLASS749   bool enable() const {
750     return GetField<uint8_t>(VT_ENABLE, 0) != 0;
751   }
VerifyFLATBUFFERS_FINAL_CLASS752   bool Verify(flatbuffers::Verifier &verifier) const {
753     return VerifyTableStart(verifier) &&
754            VerifyField<uint8_t>(verifier, VT_ENABLE) &&
755            verifier.EndTable();
756   }
757 };
758 
759 struct BreakItMessageBuilder {
760   typedef BreakItMessage Table;
761   flatbuffers::FlatBufferBuilder &fbb_;
762   flatbuffers::uoffset_t start_;
add_enableBreakItMessageBuilder763   void add_enable(bool enable) {
764     fbb_.AddElement<uint8_t>(BreakItMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
765   }
BreakItMessageBuilderBreakItMessageBuilder766   explicit BreakItMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
767         : fbb_(_fbb) {
768     start_ = fbb_.StartTable();
769   }
770   BreakItMessageBuilder &operator=(const BreakItMessageBuilder &);
FinishBreakItMessageBuilder771   flatbuffers::Offset<BreakItMessage> Finish() {
772     const auto end = fbb_.EndTable(start_);
773     auto o = flatbuffers::Offset<BreakItMessage>(end);
774     return o;
775   }
776 };
777 
778 inline flatbuffers::Offset<BreakItMessage> CreateBreakItMessage(
779     flatbuffers::FlatBufferBuilder &_fbb,
780     bool enable = false) {
781   BreakItMessageBuilder builder_(_fbb);
782   builder_.add_enable(enable);
783   return builder_.Finish();
784 }
785 
786 /// Indicates whether the nanoapp successfully performed the requested action.
787 /// Any failures will be printed to the logs.
788 struct NanoappResponseMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
789   typedef NanoappResponseMessageBuilder Builder;
790   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
791     VT_SUCCESS = 4
792   };
successFLATBUFFERS_FINAL_CLASS793   bool success() const {
794     return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
795   }
VerifyFLATBUFFERS_FINAL_CLASS796   bool Verify(flatbuffers::Verifier &verifier) const {
797     return VerifyTableStart(verifier) &&
798            VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
799            verifier.EndTable();
800   }
801 };
802 
803 struct NanoappResponseMessageBuilder {
804   typedef NanoappResponseMessage Table;
805   flatbuffers::FlatBufferBuilder &fbb_;
806   flatbuffers::uoffset_t start_;
add_successNanoappResponseMessageBuilder807   void add_success(bool success) {
808     fbb_.AddElement<uint8_t>(NanoappResponseMessage::VT_SUCCESS, static_cast<uint8_t>(success), 0);
809   }
NanoappResponseMessageBuilderNanoappResponseMessageBuilder810   explicit NanoappResponseMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
811         : fbb_(_fbb) {
812     start_ = fbb_.StartTable();
813   }
814   NanoappResponseMessageBuilder &operator=(const NanoappResponseMessageBuilder &);
FinishNanoappResponseMessageBuilder815   flatbuffers::Offset<NanoappResponseMessage> Finish() {
816     const auto end = fbb_.EndTable(start_);
817     auto o = flatbuffers::Offset<NanoappResponseMessage>(end);
818     return o;
819   }
820 };
821 
822 inline flatbuffers::Offset<NanoappResponseMessage> CreateNanoappResponseMessage(
823     flatbuffers::FlatBufferBuilder &_fbb,
824     bool success = false) {
825   NanoappResponseMessageBuilder builder_(_fbb);
826   builder_.add_success(success);
827   return builder_.Finish();
828 }
829 
830 /// Represents a message to ask the nanoapp to start or stop Gnss measurement
831 /// sampling at the requested interval
832 struct GnssMeasurementMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
833   typedef GnssMeasurementMessageBuilder Builder;
834   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
835     VT_ENABLE = 4,
836     VT_MIN_INTERVAL_MILLIS = 6
837   };
enableFLATBUFFERS_FINAL_CLASS838   bool enable() const {
839     return GetField<uint8_t>(VT_ENABLE, 0) != 0;
840   }
min_interval_millisFLATBUFFERS_FINAL_CLASS841   uint32_t min_interval_millis() const {
842     return GetField<uint32_t>(VT_MIN_INTERVAL_MILLIS, 0);
843   }
VerifyFLATBUFFERS_FINAL_CLASS844   bool Verify(flatbuffers::Verifier &verifier) const {
845     return VerifyTableStart(verifier) &&
846            VerifyField<uint8_t>(verifier, VT_ENABLE) &&
847            VerifyField<uint32_t>(verifier, VT_MIN_INTERVAL_MILLIS) &&
848            verifier.EndTable();
849   }
850 };
851 
852 struct GnssMeasurementMessageBuilder {
853   typedef GnssMeasurementMessage Table;
854   flatbuffers::FlatBufferBuilder &fbb_;
855   flatbuffers::uoffset_t start_;
add_enableGnssMeasurementMessageBuilder856   void add_enable(bool enable) {
857     fbb_.AddElement<uint8_t>(GnssMeasurementMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
858   }
add_min_interval_millisGnssMeasurementMessageBuilder859   void add_min_interval_millis(uint32_t min_interval_millis) {
860     fbb_.AddElement<uint32_t>(GnssMeasurementMessage::VT_MIN_INTERVAL_MILLIS, min_interval_millis, 0);
861   }
GnssMeasurementMessageBuilderGnssMeasurementMessageBuilder862   explicit GnssMeasurementMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
863         : fbb_(_fbb) {
864     start_ = fbb_.StartTable();
865   }
866   GnssMeasurementMessageBuilder &operator=(const GnssMeasurementMessageBuilder &);
FinishGnssMeasurementMessageBuilder867   flatbuffers::Offset<GnssMeasurementMessage> Finish() {
868     const auto end = fbb_.EndTable(start_);
869     auto o = flatbuffers::Offset<GnssMeasurementMessage>(end);
870     return o;
871   }
872 };
873 
874 inline flatbuffers::Offset<GnssMeasurementMessage> CreateGnssMeasurementMessage(
875     flatbuffers::FlatBufferBuilder &_fbb,
876     bool enable = false,
877     uint32_t min_interval_millis = 0) {
878   GnssMeasurementMessageBuilder builder_(_fbb);
879   builder_.add_min_interval_millis(min_interval_millis);
880   builder_.add_enable(enable);
881   return builder_.Finish();
882 }
883 
884 /// Represents a message to ask the nanoapp to start a NAN subscription session.
885 /// See chreWifiNanSubscribeConfig for how to fill in this message.
886 struct WifiNanSubMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
887   typedef WifiNanSubMessageBuilder Builder;
888   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
889     VT_SUB_TYPE = 4,
890     VT_SERVICE_NAME = 6,
891     VT_SERVICE_SPECIFIC_INFO = 8,
892     VT_MATCH_FILTER = 10
893   };
sub_typeFLATBUFFERS_FINAL_CLASS894   uint8_t sub_type() const {
895     return GetField<uint8_t>(VT_SUB_TYPE, 0);
896   }
service_nameFLATBUFFERS_FINAL_CLASS897   const flatbuffers::Vector<uint8_t> *service_name() const {
898     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_SERVICE_NAME);
899   }
service_specific_infoFLATBUFFERS_FINAL_CLASS900   const flatbuffers::Vector<uint8_t> *service_specific_info() const {
901     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_SERVICE_SPECIFIC_INFO);
902   }
match_filterFLATBUFFERS_FINAL_CLASS903   const flatbuffers::Vector<uint8_t> *match_filter() const {
904     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MATCH_FILTER);
905   }
VerifyFLATBUFFERS_FINAL_CLASS906   bool Verify(flatbuffers::Verifier &verifier) const {
907     return VerifyTableStart(verifier) &&
908            VerifyField<uint8_t>(verifier, VT_SUB_TYPE) &&
909            VerifyOffset(verifier, VT_SERVICE_NAME) &&
910            verifier.VerifyVector(service_name()) &&
911            VerifyOffset(verifier, VT_SERVICE_SPECIFIC_INFO) &&
912            verifier.VerifyVector(service_specific_info()) &&
913            VerifyOffset(verifier, VT_MATCH_FILTER) &&
914            verifier.VerifyVector(match_filter()) &&
915            verifier.EndTable();
916   }
917 };
918 
919 struct WifiNanSubMessageBuilder {
920   typedef WifiNanSubMessage Table;
921   flatbuffers::FlatBufferBuilder &fbb_;
922   flatbuffers::uoffset_t start_;
add_sub_typeWifiNanSubMessageBuilder923   void add_sub_type(uint8_t sub_type) {
924     fbb_.AddElement<uint8_t>(WifiNanSubMessage::VT_SUB_TYPE, sub_type, 0);
925   }
add_service_nameWifiNanSubMessageBuilder926   void add_service_name(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> service_name) {
927     fbb_.AddOffset(WifiNanSubMessage::VT_SERVICE_NAME, service_name);
928   }
add_service_specific_infoWifiNanSubMessageBuilder929   void add_service_specific_info(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> service_specific_info) {
930     fbb_.AddOffset(WifiNanSubMessage::VT_SERVICE_SPECIFIC_INFO, service_specific_info);
931   }
add_match_filterWifiNanSubMessageBuilder932   void add_match_filter(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> match_filter) {
933     fbb_.AddOffset(WifiNanSubMessage::VT_MATCH_FILTER, match_filter);
934   }
WifiNanSubMessageBuilderWifiNanSubMessageBuilder935   explicit WifiNanSubMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
936         : fbb_(_fbb) {
937     start_ = fbb_.StartTable();
938   }
939   WifiNanSubMessageBuilder &operator=(const WifiNanSubMessageBuilder &);
FinishWifiNanSubMessageBuilder940   flatbuffers::Offset<WifiNanSubMessage> Finish() {
941     const auto end = fbb_.EndTable(start_);
942     auto o = flatbuffers::Offset<WifiNanSubMessage>(end);
943     return o;
944   }
945 };
946 
947 inline flatbuffers::Offset<WifiNanSubMessage> CreateWifiNanSubMessage(
948     flatbuffers::FlatBufferBuilder &_fbb,
949     uint8_t sub_type = 0,
950     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> service_name = 0,
951     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> service_specific_info = 0,
952     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> match_filter = 0) {
953   WifiNanSubMessageBuilder builder_(_fbb);
954   builder_.add_match_filter(match_filter);
955   builder_.add_service_specific_info(service_specific_info);
956   builder_.add_service_name(service_name);
957   builder_.add_sub_type(sub_type);
958   return builder_.Finish();
959 }
960 
961 inline flatbuffers::Offset<WifiNanSubMessage> CreateWifiNanSubMessageDirect(
962     flatbuffers::FlatBufferBuilder &_fbb,
963     uint8_t sub_type = 0,
964     const std::vector<uint8_t> *service_name = nullptr,
965     const std::vector<uint8_t> *service_specific_info = nullptr,
966     const std::vector<uint8_t> *match_filter = nullptr) {
967   auto service_name__ = service_name ? _fbb.CreateVector<uint8_t>(*service_name) : 0;
968   auto service_specific_info__ = service_specific_info ? _fbb.CreateVector<uint8_t>(*service_specific_info) : 0;
969   auto match_filter__ = match_filter ? _fbb.CreateVector<uint8_t>(*match_filter) : 0;
970   return chre::power_test::CreateWifiNanSubMessage(
971       _fbb,
972       sub_type,
973       service_name__,
974       service_specific_info__,
975       match_filter__);
976 }
977 
978 /// Represents a messages to ask the nanoapp to cancel an ongoing subscription
979 struct WifiNanSubCancelMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
980   typedef WifiNanSubCancelMessageBuilder Builder;
981   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
982     VT_SUBSCRIPTION_ID = 4
983   };
subscription_idFLATBUFFERS_FINAL_CLASS984   uint32_t subscription_id() const {
985     return GetField<uint32_t>(VT_SUBSCRIPTION_ID, 0);
986   }
VerifyFLATBUFFERS_FINAL_CLASS987   bool Verify(flatbuffers::Verifier &verifier) const {
988     return VerifyTableStart(verifier) &&
989            VerifyField<uint32_t>(verifier, VT_SUBSCRIPTION_ID) &&
990            verifier.EndTable();
991   }
992 };
993 
994 struct WifiNanSubCancelMessageBuilder {
995   typedef WifiNanSubCancelMessage Table;
996   flatbuffers::FlatBufferBuilder &fbb_;
997   flatbuffers::uoffset_t start_;
add_subscription_idWifiNanSubCancelMessageBuilder998   void add_subscription_id(uint32_t subscription_id) {
999     fbb_.AddElement<uint32_t>(WifiNanSubCancelMessage::VT_SUBSCRIPTION_ID, subscription_id, 0);
1000   }
WifiNanSubCancelMessageBuilderWifiNanSubCancelMessageBuilder1001   explicit WifiNanSubCancelMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1002         : fbb_(_fbb) {
1003     start_ = fbb_.StartTable();
1004   }
1005   WifiNanSubCancelMessageBuilder &operator=(const WifiNanSubCancelMessageBuilder &);
FinishWifiNanSubCancelMessageBuilder1006   flatbuffers::Offset<WifiNanSubCancelMessage> Finish() {
1007     const auto end = fbb_.EndTable(start_);
1008     auto o = flatbuffers::Offset<WifiNanSubCancelMessage>(end);
1009     return o;
1010   }
1011 };
1012 
1013 inline flatbuffers::Offset<WifiNanSubCancelMessage> CreateWifiNanSubCancelMessage(
1014     flatbuffers::FlatBufferBuilder &_fbb,
1015     uint32_t subscription_id = 0) {
1016   WifiNanSubCancelMessageBuilder builder_(_fbb);
1017   builder_.add_subscription_id(subscription_id);
1018   return builder_.Finish();
1019 }
1020 
1021 /// Represents a message from the nanoapp indicating whether a subscription
1022 /// request succeeded
1023 struct WifiNanSubResponseMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1024   typedef WifiNanSubResponseMessageBuilder Builder;
1025   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1026     VT_SUCCESS = 4,
1027     VT_SUBSCRIPTION_ID = 6
1028   };
successFLATBUFFERS_FINAL_CLASS1029   bool success() const {
1030     return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
1031   }
subscription_idFLATBUFFERS_FINAL_CLASS1032   uint32_t subscription_id() const {
1033     return GetField<uint32_t>(VT_SUBSCRIPTION_ID, 0);
1034   }
VerifyFLATBUFFERS_FINAL_CLASS1035   bool Verify(flatbuffers::Verifier &verifier) const {
1036     return VerifyTableStart(verifier) &&
1037            VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
1038            VerifyField<uint32_t>(verifier, VT_SUBSCRIPTION_ID) &&
1039            verifier.EndTable();
1040   }
1041 };
1042 
1043 struct WifiNanSubResponseMessageBuilder {
1044   typedef WifiNanSubResponseMessage Table;
1045   flatbuffers::FlatBufferBuilder &fbb_;
1046   flatbuffers::uoffset_t start_;
add_successWifiNanSubResponseMessageBuilder1047   void add_success(bool success) {
1048     fbb_.AddElement<uint8_t>(WifiNanSubResponseMessage::VT_SUCCESS, static_cast<uint8_t>(success), 0);
1049   }
add_subscription_idWifiNanSubResponseMessageBuilder1050   void add_subscription_id(uint32_t subscription_id) {
1051     fbb_.AddElement<uint32_t>(WifiNanSubResponseMessage::VT_SUBSCRIPTION_ID, subscription_id, 0);
1052   }
WifiNanSubResponseMessageBuilderWifiNanSubResponseMessageBuilder1053   explicit WifiNanSubResponseMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1054         : fbb_(_fbb) {
1055     start_ = fbb_.StartTable();
1056   }
1057   WifiNanSubResponseMessageBuilder &operator=(const WifiNanSubResponseMessageBuilder &);
FinishWifiNanSubResponseMessageBuilder1058   flatbuffers::Offset<WifiNanSubResponseMessage> Finish() {
1059     const auto end = fbb_.EndTable(start_);
1060     auto o = flatbuffers::Offset<WifiNanSubResponseMessage>(end);
1061     return o;
1062   }
1063 };
1064 
1065 inline flatbuffers::Offset<WifiNanSubResponseMessage> CreateWifiNanSubResponseMessage(
1066     flatbuffers::FlatBufferBuilder &_fbb,
1067     bool success = false,
1068     uint32_t subscription_id = 0) {
1069   WifiNanSubResponseMessageBuilder builder_(_fbb);
1070   builder_.add_subscription_id(subscription_id);
1071   builder_.add_success(success);
1072   return builder_.Finish();
1073 }
1074 
1075 }  // namespace power_test
1076 }  // namespace chre
1077 
1078 #endif  // FLATBUFFERS_GENERATED_CHREPOWERTEST_CHRE_POWER_TEST_H_
1079