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 /// Indicates which of the following messages is being sent to / from the
40 /// nanoapp. Use uint as the base type to match the message type in
41 /// chreMessageFromHostData.
42 enum class MessageType : uint32_t {
43 UNSPECIFIED = 0,
44 /// Should be used with TimerMessage
45 TIMER_TEST = 1,
46 /// Should be used with WifiScanMessage
47 WIFI_SCAN_TEST = 2,
48 /// Should be used with GnssLocationMessage
49 GNSS_LOCATION_TEST = 3,
50 /// Should be used with CellQueryMessage
51 CELL_QUERY_TEST = 4,
52 /// Should be used with AudioRequestMessage
53 AUDIO_REQUEST_TEST = 5,
54 /// Should be used with SensorRequestMessage
55 SENSOR_REQUEST_TEST = 6,
56 /// Should be used with BreakItMessage
57 BREAK_IT_TEST = 7,
58 /// Should be used with NanoappResponseMessage
59 NANOAPP_RESPONSE = 8,
60 /// Should be used with GnssMeasurementMessage
61 GNSS_MEASUREMENT_TEST = 9,
62 MIN = UNSPECIFIED,
63 MAX = GNSS_MEASUREMENT_TEST
64 };
65
EnumValuesMessageType()66 inline const MessageType (&EnumValuesMessageType())[10] {
67 static const MessageType values[] = {
68 MessageType::UNSPECIFIED,
69 MessageType::TIMER_TEST,
70 MessageType::WIFI_SCAN_TEST,
71 MessageType::GNSS_LOCATION_TEST,
72 MessageType::CELL_QUERY_TEST,
73 MessageType::AUDIO_REQUEST_TEST,
74 MessageType::SENSOR_REQUEST_TEST,
75 MessageType::BREAK_IT_TEST,
76 MessageType::NANOAPP_RESPONSE,
77 MessageType::GNSS_MEASUREMENT_TEST
78 };
79 return values;
80 }
81
EnumNamesMessageType()82 inline const char * const *EnumNamesMessageType() {
83 static const char * const names[11] = {
84 "UNSPECIFIED",
85 "TIMER_TEST",
86 "WIFI_SCAN_TEST",
87 "GNSS_LOCATION_TEST",
88 "CELL_QUERY_TEST",
89 "AUDIO_REQUEST_TEST",
90 "SENSOR_REQUEST_TEST",
91 "BREAK_IT_TEST",
92 "NANOAPP_RESPONSE",
93 "GNSS_MEASUREMENT_TEST",
94 nullptr
95 };
96 return names;
97 }
98
EnumNameMessageType(MessageType e)99 inline const char *EnumNameMessageType(MessageType e) {
100 if (flatbuffers::IsOutRange(e, MessageType::UNSPECIFIED, MessageType::GNSS_MEASUREMENT_TEST)) return "";
101 const size_t index = static_cast<size_t>(e);
102 return EnumNamesMessageType()[index];
103 }
104
105 /// All the various WiFi scan types that can be interacted with inside the
106 /// nanoapp. The values used here map directly to values from the CHRE API.
107 enum class WifiScanType : uint8_t {
108 ACTIVE = 0,
109 ACTIVE_PLUS_PASSIVE_DFS = 1,
110 PASSIVE = 2,
111 NO_PREFERENCE = 3,
112 MIN = ACTIVE,
113 MAX = NO_PREFERENCE
114 };
115
EnumValuesWifiScanType()116 inline const WifiScanType (&EnumValuesWifiScanType())[4] {
117 static const WifiScanType values[] = {
118 WifiScanType::ACTIVE,
119 WifiScanType::ACTIVE_PLUS_PASSIVE_DFS,
120 WifiScanType::PASSIVE,
121 WifiScanType::NO_PREFERENCE
122 };
123 return values;
124 }
125
EnumNamesWifiScanType()126 inline const char * const *EnumNamesWifiScanType() {
127 static const char * const names[5] = {
128 "ACTIVE",
129 "ACTIVE_PLUS_PASSIVE_DFS",
130 "PASSIVE",
131 "NO_PREFERENCE",
132 nullptr
133 };
134 return names;
135 }
136
EnumNameWifiScanType(WifiScanType e)137 inline const char *EnumNameWifiScanType(WifiScanType e) {
138 if (flatbuffers::IsOutRange(e, WifiScanType::ACTIVE, WifiScanType::NO_PREFERENCE)) return "";
139 const size_t index = static_cast<size_t>(e);
140 return EnumNamesWifiScanType()[index];
141 }
142
143 /// All the various WiFi radio chain preferences that can be interacted with
144 /// inside the nanoapp. The values used here map directly to values from the
145 /// CHRE API.
146 enum class WifiRadioChain : uint8_t {
147 DEFAULT = 0,
148 LOW_LATENCY = 1,
149 LOW_POWER = 2,
150 HIGH_ACCURACY = 3,
151 MIN = DEFAULT,
152 MAX = HIGH_ACCURACY
153 };
154
EnumValuesWifiRadioChain()155 inline const WifiRadioChain (&EnumValuesWifiRadioChain())[4] {
156 static const WifiRadioChain values[] = {
157 WifiRadioChain::DEFAULT,
158 WifiRadioChain::LOW_LATENCY,
159 WifiRadioChain::LOW_POWER,
160 WifiRadioChain::HIGH_ACCURACY
161 };
162 return values;
163 }
164
EnumNamesWifiRadioChain()165 inline const char * const *EnumNamesWifiRadioChain() {
166 static const char * const names[5] = {
167 "DEFAULT",
168 "LOW_LATENCY",
169 "LOW_POWER",
170 "HIGH_ACCURACY",
171 nullptr
172 };
173 return names;
174 }
175
EnumNameWifiRadioChain(WifiRadioChain e)176 inline const char *EnumNameWifiRadioChain(WifiRadioChain e) {
177 if (flatbuffers::IsOutRange(e, WifiRadioChain::DEFAULT, WifiRadioChain::HIGH_ACCURACY)) return "";
178 const size_t index = static_cast<size_t>(e);
179 return EnumNamesWifiRadioChain()[index];
180 }
181
182 /// All the various WiFi channel sets that can be interacted with inside the
183 /// nanoapp. The values used here map directly to values from the CHRE API.
184 enum class WifiChannelSet : uint8_t {
185 NON_DFS = 0,
186 ALL = 1,
187 MIN = NON_DFS,
188 MAX = ALL
189 };
190
EnumValuesWifiChannelSet()191 inline const WifiChannelSet (&EnumValuesWifiChannelSet())[2] {
192 static const WifiChannelSet values[] = {
193 WifiChannelSet::NON_DFS,
194 WifiChannelSet::ALL
195 };
196 return values;
197 }
198
EnumNamesWifiChannelSet()199 inline const char * const *EnumNamesWifiChannelSet() {
200 static const char * const names[3] = {
201 "NON_DFS",
202 "ALL",
203 nullptr
204 };
205 return names;
206 }
207
EnumNameWifiChannelSet(WifiChannelSet e)208 inline const char *EnumNameWifiChannelSet(WifiChannelSet e) {
209 if (flatbuffers::IsOutRange(e, WifiChannelSet::NON_DFS, WifiChannelSet::ALL)) return "";
210 const size_t index = static_cast<size_t>(e);
211 return EnumNamesWifiChannelSet()[index];
212 }
213
214 /// All the various sensors that can be interacted with inside the nanoapp.
215 /// The values used here map directly to values from the CHRE API
216 enum class SensorType : uint8_t {
217 UNKNOWN = 0,
218 ACCELEROMETER = 1,
219 INSTANT_MOTION_DETECT = 2,
220 STATIONARY_DETECT = 3,
221 GYROSCOPE = 6,
222 UNCALIBRATED_GYROSCOPE = 7,
223 GEOMAGNETIC_FIELD = 8,
224 UNCALIBRATED_GEOMAGNETIC_FIELD = 9,
225 PRESSURE = 10,
226 LIGHT = 12,
227 PROXIMITY = 13,
228 STEP_DETECT = 23,
229 STEP_COUNTER = 24,
230 UNCALIBRATED_ACCELEROMETER = 55,
231 ACCELEROMETER_TEMPERATURE = 56,
232 GYROSCOPE_TEMPERATURE = 57,
233 GEOMAGNETIC_FIELD_TEMPERATURE = 58,
234 MIN = UNKNOWN,
235 MAX = GEOMAGNETIC_FIELD_TEMPERATURE
236 };
237
EnumValuesSensorType()238 inline const SensorType (&EnumValuesSensorType())[17] {
239 static const SensorType values[] = {
240 SensorType::UNKNOWN,
241 SensorType::ACCELEROMETER,
242 SensorType::INSTANT_MOTION_DETECT,
243 SensorType::STATIONARY_DETECT,
244 SensorType::GYROSCOPE,
245 SensorType::UNCALIBRATED_GYROSCOPE,
246 SensorType::GEOMAGNETIC_FIELD,
247 SensorType::UNCALIBRATED_GEOMAGNETIC_FIELD,
248 SensorType::PRESSURE,
249 SensorType::LIGHT,
250 SensorType::PROXIMITY,
251 SensorType::STEP_DETECT,
252 SensorType::STEP_COUNTER,
253 SensorType::UNCALIBRATED_ACCELEROMETER,
254 SensorType::ACCELEROMETER_TEMPERATURE,
255 SensorType::GYROSCOPE_TEMPERATURE,
256 SensorType::GEOMAGNETIC_FIELD_TEMPERATURE
257 };
258 return values;
259 }
260
EnumNamesSensorType()261 inline const char * const *EnumNamesSensorType() {
262 static const char * const names[60] = {
263 "UNKNOWN",
264 "ACCELEROMETER",
265 "INSTANT_MOTION_DETECT",
266 "STATIONARY_DETECT",
267 "",
268 "",
269 "GYROSCOPE",
270 "UNCALIBRATED_GYROSCOPE",
271 "GEOMAGNETIC_FIELD",
272 "UNCALIBRATED_GEOMAGNETIC_FIELD",
273 "PRESSURE",
274 "",
275 "LIGHT",
276 "PROXIMITY",
277 "",
278 "",
279 "",
280 "",
281 "",
282 "",
283 "",
284 "",
285 "",
286 "STEP_DETECT",
287 "STEP_COUNTER",
288 "",
289 "",
290 "",
291 "",
292 "",
293 "",
294 "",
295 "",
296 "",
297 "",
298 "",
299 "",
300 "",
301 "",
302 "",
303 "",
304 "",
305 "",
306 "",
307 "",
308 "",
309 "",
310 "",
311 "",
312 "",
313 "",
314 "",
315 "",
316 "",
317 "",
318 "UNCALIBRATED_ACCELEROMETER",
319 "ACCELEROMETER_TEMPERATURE",
320 "GYROSCOPE_TEMPERATURE",
321 "GEOMAGNETIC_FIELD_TEMPERATURE",
322 nullptr
323 };
324 return names;
325 }
326
EnumNameSensorType(SensorType e)327 inline const char *EnumNameSensorType(SensorType e) {
328 if (flatbuffers::IsOutRange(e, SensorType::UNKNOWN, SensorType::GEOMAGNETIC_FIELD_TEMPERATURE)) return "";
329 const size_t index = static_cast<size_t>(e);
330 return EnumNamesSensorType()[index];
331 }
332
333 /// Represents a message to ask the nanoapp to create a timer that wakes up at
334 /// the given interval
335 struct TimerMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
336 typedef TimerMessageBuilder Builder;
337 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
338 VT_ENABLE = 4,
339 VT_WAKEUP_INTERVAL_NS = 6
340 };
enableFLATBUFFERS_FINAL_CLASS341 bool enable() const {
342 return GetField<uint8_t>(VT_ENABLE, 0) != 0;
343 }
wakeup_interval_nsFLATBUFFERS_FINAL_CLASS344 uint64_t wakeup_interval_ns() const {
345 return GetField<uint64_t>(VT_WAKEUP_INTERVAL_NS, 0);
346 }
VerifyFLATBUFFERS_FINAL_CLASS347 bool Verify(flatbuffers::Verifier &verifier) const {
348 return VerifyTableStart(verifier) &&
349 VerifyField<uint8_t>(verifier, VT_ENABLE) &&
350 VerifyField<uint64_t>(verifier, VT_WAKEUP_INTERVAL_NS) &&
351 verifier.EndTable();
352 }
353 };
354
355 struct TimerMessageBuilder {
356 typedef TimerMessage Table;
357 flatbuffers::FlatBufferBuilder &fbb_;
358 flatbuffers::uoffset_t start_;
add_enableTimerMessageBuilder359 void add_enable(bool enable) {
360 fbb_.AddElement<uint8_t>(TimerMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
361 }
add_wakeup_interval_nsTimerMessageBuilder362 void add_wakeup_interval_ns(uint64_t wakeup_interval_ns) {
363 fbb_.AddElement<uint64_t>(TimerMessage::VT_WAKEUP_INTERVAL_NS, wakeup_interval_ns, 0);
364 }
TimerMessageBuilderTimerMessageBuilder365 explicit TimerMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
366 : fbb_(_fbb) {
367 start_ = fbb_.StartTable();
368 }
369 TimerMessageBuilder &operator=(const TimerMessageBuilder &);
FinishTimerMessageBuilder370 flatbuffers::Offset<TimerMessage> Finish() {
371 const auto end = fbb_.EndTable(start_);
372 auto o = flatbuffers::Offset<TimerMessage>(end);
373 return o;
374 }
375 };
376
377 inline flatbuffers::Offset<TimerMessage> CreateTimerMessage(
378 flatbuffers::FlatBufferBuilder &_fbb,
379 bool enable = false,
380 uint64_t wakeup_interval_ns = 0) {
381 TimerMessageBuilder builder_(_fbb);
382 builder_.add_wakeup_interval_ns(wakeup_interval_ns);
383 builder_.add_enable(enable);
384 return builder_.Finish();
385 }
386
387 /// Represents a message to ask the nanoapp to start or stop WiFi scanning and
388 /// the scan interval to use if scanning is being started
389 struct WifiScanMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
390 typedef WifiScanMessageBuilder Builder;
391 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
392 VT_ENABLE = 4,
393 VT_SCAN_INTERVAL_NS = 6,
394 VT_SCAN_TYPE = 8,
395 VT_RADIO_CHAIN = 10,
396 VT_CHANNEL_SET = 12
397 };
enableFLATBUFFERS_FINAL_CLASS398 bool enable() const {
399 return GetField<uint8_t>(VT_ENABLE, 0) != 0;
400 }
scan_interval_nsFLATBUFFERS_FINAL_CLASS401 uint64_t scan_interval_ns() const {
402 return GetField<uint64_t>(VT_SCAN_INTERVAL_NS, 0);
403 }
scan_typeFLATBUFFERS_FINAL_CLASS404 chre::power_test::WifiScanType scan_type() const {
405 return static_cast<chre::power_test::WifiScanType>(GetField<uint8_t>(VT_SCAN_TYPE, 0));
406 }
radio_chainFLATBUFFERS_FINAL_CLASS407 chre::power_test::WifiRadioChain radio_chain() const {
408 return static_cast<chre::power_test::WifiRadioChain>(GetField<uint8_t>(VT_RADIO_CHAIN, 0));
409 }
channel_setFLATBUFFERS_FINAL_CLASS410 chre::power_test::WifiChannelSet channel_set() const {
411 return static_cast<chre::power_test::WifiChannelSet>(GetField<uint8_t>(VT_CHANNEL_SET, 0));
412 }
VerifyFLATBUFFERS_FINAL_CLASS413 bool Verify(flatbuffers::Verifier &verifier) const {
414 return VerifyTableStart(verifier) &&
415 VerifyField<uint8_t>(verifier, VT_ENABLE) &&
416 VerifyField<uint64_t>(verifier, VT_SCAN_INTERVAL_NS) &&
417 VerifyField<uint8_t>(verifier, VT_SCAN_TYPE) &&
418 VerifyField<uint8_t>(verifier, VT_RADIO_CHAIN) &&
419 VerifyField<uint8_t>(verifier, VT_CHANNEL_SET) &&
420 verifier.EndTable();
421 }
422 };
423
424 struct WifiScanMessageBuilder {
425 typedef WifiScanMessage Table;
426 flatbuffers::FlatBufferBuilder &fbb_;
427 flatbuffers::uoffset_t start_;
add_enableWifiScanMessageBuilder428 void add_enable(bool enable) {
429 fbb_.AddElement<uint8_t>(WifiScanMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
430 }
add_scan_interval_nsWifiScanMessageBuilder431 void add_scan_interval_ns(uint64_t scan_interval_ns) {
432 fbb_.AddElement<uint64_t>(WifiScanMessage::VT_SCAN_INTERVAL_NS, scan_interval_ns, 0);
433 }
add_scan_typeWifiScanMessageBuilder434 void add_scan_type(chre::power_test::WifiScanType scan_type) {
435 fbb_.AddElement<uint8_t>(WifiScanMessage::VT_SCAN_TYPE, static_cast<uint8_t>(scan_type), 0);
436 }
add_radio_chainWifiScanMessageBuilder437 void add_radio_chain(chre::power_test::WifiRadioChain radio_chain) {
438 fbb_.AddElement<uint8_t>(WifiScanMessage::VT_RADIO_CHAIN, static_cast<uint8_t>(radio_chain), 0);
439 }
add_channel_setWifiScanMessageBuilder440 void add_channel_set(chre::power_test::WifiChannelSet channel_set) {
441 fbb_.AddElement<uint8_t>(WifiScanMessage::VT_CHANNEL_SET, static_cast<uint8_t>(channel_set), 0);
442 }
WifiScanMessageBuilderWifiScanMessageBuilder443 explicit WifiScanMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
444 : fbb_(_fbb) {
445 start_ = fbb_.StartTable();
446 }
447 WifiScanMessageBuilder &operator=(const WifiScanMessageBuilder &);
FinishWifiScanMessageBuilder448 flatbuffers::Offset<WifiScanMessage> Finish() {
449 const auto end = fbb_.EndTable(start_);
450 auto o = flatbuffers::Offset<WifiScanMessage>(end);
451 return o;
452 }
453 };
454
455 inline flatbuffers::Offset<WifiScanMessage> CreateWifiScanMessage(
456 flatbuffers::FlatBufferBuilder &_fbb,
457 bool enable = false,
458 uint64_t scan_interval_ns = 0,
459 chre::power_test::WifiScanType scan_type = chre::power_test::WifiScanType::ACTIVE,
460 chre::power_test::WifiRadioChain radio_chain = chre::power_test::WifiRadioChain::DEFAULT,
461 chre::power_test::WifiChannelSet channel_set = chre::power_test::WifiChannelSet::NON_DFS) {
462 WifiScanMessageBuilder builder_(_fbb);
463 builder_.add_scan_interval_ns(scan_interval_ns);
464 builder_.add_channel_set(channel_set);
465 builder_.add_radio_chain(radio_chain);
466 builder_.add_scan_type(scan_type);
467 builder_.add_enable(enable);
468 return builder_.Finish();
469 }
470
471 /// Represents a message to ask the nanoapp to start or stop Gnss location
472 /// sampling at the requested interval
473 struct GnssLocationMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
474 typedef GnssLocationMessageBuilder Builder;
475 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
476 VT_ENABLE = 4,
477 VT_SCAN_INTERVAL_MILLIS = 6,
478 VT_MIN_TIME_TO_NEXT_FIX_MILLIS = 8
479 };
enableFLATBUFFERS_FINAL_CLASS480 bool enable() const {
481 return GetField<uint8_t>(VT_ENABLE, 0) != 0;
482 }
scan_interval_millisFLATBUFFERS_FINAL_CLASS483 uint32_t scan_interval_millis() const {
484 return GetField<uint32_t>(VT_SCAN_INTERVAL_MILLIS, 0);
485 }
min_time_to_next_fix_millisFLATBUFFERS_FINAL_CLASS486 uint32_t min_time_to_next_fix_millis() const {
487 return GetField<uint32_t>(VT_MIN_TIME_TO_NEXT_FIX_MILLIS, 0);
488 }
VerifyFLATBUFFERS_FINAL_CLASS489 bool Verify(flatbuffers::Verifier &verifier) const {
490 return VerifyTableStart(verifier) &&
491 VerifyField<uint8_t>(verifier, VT_ENABLE) &&
492 VerifyField<uint32_t>(verifier, VT_SCAN_INTERVAL_MILLIS) &&
493 VerifyField<uint32_t>(verifier, VT_MIN_TIME_TO_NEXT_FIX_MILLIS) &&
494 verifier.EndTable();
495 }
496 };
497
498 struct GnssLocationMessageBuilder {
499 typedef GnssLocationMessage Table;
500 flatbuffers::FlatBufferBuilder &fbb_;
501 flatbuffers::uoffset_t start_;
add_enableGnssLocationMessageBuilder502 void add_enable(bool enable) {
503 fbb_.AddElement<uint8_t>(GnssLocationMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
504 }
add_scan_interval_millisGnssLocationMessageBuilder505 void add_scan_interval_millis(uint32_t scan_interval_millis) {
506 fbb_.AddElement<uint32_t>(GnssLocationMessage::VT_SCAN_INTERVAL_MILLIS, scan_interval_millis, 0);
507 }
add_min_time_to_next_fix_millisGnssLocationMessageBuilder508 void add_min_time_to_next_fix_millis(uint32_t min_time_to_next_fix_millis) {
509 fbb_.AddElement<uint32_t>(GnssLocationMessage::VT_MIN_TIME_TO_NEXT_FIX_MILLIS, min_time_to_next_fix_millis, 0);
510 }
GnssLocationMessageBuilderGnssLocationMessageBuilder511 explicit GnssLocationMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
512 : fbb_(_fbb) {
513 start_ = fbb_.StartTable();
514 }
515 GnssLocationMessageBuilder &operator=(const GnssLocationMessageBuilder &);
FinishGnssLocationMessageBuilder516 flatbuffers::Offset<GnssLocationMessage> Finish() {
517 const auto end = fbb_.EndTable(start_);
518 auto o = flatbuffers::Offset<GnssLocationMessage>(end);
519 return o;
520 }
521 };
522
523 inline flatbuffers::Offset<GnssLocationMessage> CreateGnssLocationMessage(
524 flatbuffers::FlatBufferBuilder &_fbb,
525 bool enable = false,
526 uint32_t scan_interval_millis = 0,
527 uint32_t min_time_to_next_fix_millis = 0) {
528 GnssLocationMessageBuilder builder_(_fbb);
529 builder_.add_min_time_to_next_fix_millis(min_time_to_next_fix_millis);
530 builder_.add_scan_interval_millis(scan_interval_millis);
531 builder_.add_enable(enable);
532 return builder_.Finish();
533 }
534
535 /// Represents a message to ask the nanoapp to start or stop querying the cell
536 /// modem for the latest cell scan results on the given interval
537 struct CellQueryMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
538 typedef CellQueryMessageBuilder Builder;
539 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
540 VT_ENABLE = 4,
541 VT_QUERY_INTERVAL_NS = 6
542 };
enableFLATBUFFERS_FINAL_CLASS543 bool enable() const {
544 return GetField<uint8_t>(VT_ENABLE, 0) != 0;
545 }
query_interval_nsFLATBUFFERS_FINAL_CLASS546 uint64_t query_interval_ns() const {
547 return GetField<uint64_t>(VT_QUERY_INTERVAL_NS, 0);
548 }
VerifyFLATBUFFERS_FINAL_CLASS549 bool Verify(flatbuffers::Verifier &verifier) const {
550 return VerifyTableStart(verifier) &&
551 VerifyField<uint8_t>(verifier, VT_ENABLE) &&
552 VerifyField<uint64_t>(verifier, VT_QUERY_INTERVAL_NS) &&
553 verifier.EndTable();
554 }
555 };
556
557 struct CellQueryMessageBuilder {
558 typedef CellQueryMessage Table;
559 flatbuffers::FlatBufferBuilder &fbb_;
560 flatbuffers::uoffset_t start_;
add_enableCellQueryMessageBuilder561 void add_enable(bool enable) {
562 fbb_.AddElement<uint8_t>(CellQueryMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
563 }
add_query_interval_nsCellQueryMessageBuilder564 void add_query_interval_ns(uint64_t query_interval_ns) {
565 fbb_.AddElement<uint64_t>(CellQueryMessage::VT_QUERY_INTERVAL_NS, query_interval_ns, 0);
566 }
CellQueryMessageBuilderCellQueryMessageBuilder567 explicit CellQueryMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
568 : fbb_(_fbb) {
569 start_ = fbb_.StartTable();
570 }
571 CellQueryMessageBuilder &operator=(const CellQueryMessageBuilder &);
FinishCellQueryMessageBuilder572 flatbuffers::Offset<CellQueryMessage> Finish() {
573 const auto end = fbb_.EndTable(start_);
574 auto o = flatbuffers::Offset<CellQueryMessage>(end);
575 return o;
576 }
577 };
578
579 inline flatbuffers::Offset<CellQueryMessage> CreateCellQueryMessage(
580 flatbuffers::FlatBufferBuilder &_fbb,
581 bool enable = false,
582 uint64_t query_interval_ns = 0) {
583 CellQueryMessageBuilder builder_(_fbb);
584 builder_.add_query_interval_ns(query_interval_ns);
585 builder_.add_enable(enable);
586 return builder_.Finish();
587 }
588
589 /// Represents a message to ask the nanoapp to start / stop requesting Audio
590 /// data buffered at given interval. Note: If there is more than one audio
591 /// source, the nanoapp will only request audio from the first source.
592 struct AudioRequestMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
593 typedef AudioRequestMessageBuilder Builder;
594 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
595 VT_ENABLE = 4,
596 VT_BUFFER_DURATION_NS = 6
597 };
enableFLATBUFFERS_FINAL_CLASS598 bool enable() const {
599 return GetField<uint8_t>(VT_ENABLE, 0) != 0;
600 }
601 /// The buffer duration is also used as the interval for how often
602 /// the buffer should be delivered to the nanoapp.
buffer_duration_nsFLATBUFFERS_FINAL_CLASS603 uint64_t buffer_duration_ns() const {
604 return GetField<uint64_t>(VT_BUFFER_DURATION_NS, 0);
605 }
VerifyFLATBUFFERS_FINAL_CLASS606 bool Verify(flatbuffers::Verifier &verifier) const {
607 return VerifyTableStart(verifier) &&
608 VerifyField<uint8_t>(verifier, VT_ENABLE) &&
609 VerifyField<uint64_t>(verifier, VT_BUFFER_DURATION_NS) &&
610 verifier.EndTable();
611 }
612 };
613
614 struct AudioRequestMessageBuilder {
615 typedef AudioRequestMessage Table;
616 flatbuffers::FlatBufferBuilder &fbb_;
617 flatbuffers::uoffset_t start_;
add_enableAudioRequestMessageBuilder618 void add_enable(bool enable) {
619 fbb_.AddElement<uint8_t>(AudioRequestMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
620 }
add_buffer_duration_nsAudioRequestMessageBuilder621 void add_buffer_duration_ns(uint64_t buffer_duration_ns) {
622 fbb_.AddElement<uint64_t>(AudioRequestMessage::VT_BUFFER_DURATION_NS, buffer_duration_ns, 0);
623 }
AudioRequestMessageBuilderAudioRequestMessageBuilder624 explicit AudioRequestMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
625 : fbb_(_fbb) {
626 start_ = fbb_.StartTable();
627 }
628 AudioRequestMessageBuilder &operator=(const AudioRequestMessageBuilder &);
FinishAudioRequestMessageBuilder629 flatbuffers::Offset<AudioRequestMessage> Finish() {
630 const auto end = fbb_.EndTable(start_);
631 auto o = flatbuffers::Offset<AudioRequestMessage>(end);
632 return o;
633 }
634 };
635
636 inline flatbuffers::Offset<AudioRequestMessage> CreateAudioRequestMessage(
637 flatbuffers::FlatBufferBuilder &_fbb,
638 bool enable = false,
639 uint64_t buffer_duration_ns = 0) {
640 AudioRequestMessageBuilder builder_(_fbb);
641 builder_.add_buffer_duration_ns(buffer_duration_ns);
642 builder_.add_enable(enable);
643 return builder_.Finish();
644 }
645
646 /// Represents a message to ask the nanoapp to start / stop sampling / batching
647 /// a given sensor
648 struct SensorRequestMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
649 typedef SensorRequestMessageBuilder Builder;
650 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
651 VT_ENABLE = 4,
652 VT_SENSOR = 6,
653 VT_SAMPLING_INTERVAL_NS = 8,
654 VT_LATENCY_NS = 10
655 };
enableFLATBUFFERS_FINAL_CLASS656 bool enable() const {
657 return GetField<uint8_t>(VT_ENABLE, 0) != 0;
658 }
sensorFLATBUFFERS_FINAL_CLASS659 chre::power_test::SensorType sensor() const {
660 return static_cast<chre::power_test::SensorType>(GetField<uint8_t>(VT_SENSOR, 0));
661 }
sampling_interval_nsFLATBUFFERS_FINAL_CLASS662 uint64_t sampling_interval_ns() const {
663 return GetField<uint64_t>(VT_SAMPLING_INTERVAL_NS, 0);
664 }
latency_nsFLATBUFFERS_FINAL_CLASS665 uint64_t latency_ns() const {
666 return GetField<uint64_t>(VT_LATENCY_NS, 0);
667 }
VerifyFLATBUFFERS_FINAL_CLASS668 bool Verify(flatbuffers::Verifier &verifier) const {
669 return VerifyTableStart(verifier) &&
670 VerifyField<uint8_t>(verifier, VT_ENABLE) &&
671 VerifyField<uint8_t>(verifier, VT_SENSOR) &&
672 VerifyField<uint64_t>(verifier, VT_SAMPLING_INTERVAL_NS) &&
673 VerifyField<uint64_t>(verifier, VT_LATENCY_NS) &&
674 verifier.EndTable();
675 }
676 };
677
678 struct SensorRequestMessageBuilder {
679 typedef SensorRequestMessage Table;
680 flatbuffers::FlatBufferBuilder &fbb_;
681 flatbuffers::uoffset_t start_;
add_enableSensorRequestMessageBuilder682 void add_enable(bool enable) {
683 fbb_.AddElement<uint8_t>(SensorRequestMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
684 }
add_sensorSensorRequestMessageBuilder685 void add_sensor(chre::power_test::SensorType sensor) {
686 fbb_.AddElement<uint8_t>(SensorRequestMessage::VT_SENSOR, static_cast<uint8_t>(sensor), 0);
687 }
add_sampling_interval_nsSensorRequestMessageBuilder688 void add_sampling_interval_ns(uint64_t sampling_interval_ns) {
689 fbb_.AddElement<uint64_t>(SensorRequestMessage::VT_SAMPLING_INTERVAL_NS, sampling_interval_ns, 0);
690 }
add_latency_nsSensorRequestMessageBuilder691 void add_latency_ns(uint64_t latency_ns) {
692 fbb_.AddElement<uint64_t>(SensorRequestMessage::VT_LATENCY_NS, latency_ns, 0);
693 }
SensorRequestMessageBuilderSensorRequestMessageBuilder694 explicit SensorRequestMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
695 : fbb_(_fbb) {
696 start_ = fbb_.StartTable();
697 }
698 SensorRequestMessageBuilder &operator=(const SensorRequestMessageBuilder &);
FinishSensorRequestMessageBuilder699 flatbuffers::Offset<SensorRequestMessage> Finish() {
700 const auto end = fbb_.EndTable(start_);
701 auto o = flatbuffers::Offset<SensorRequestMessage>(end);
702 return o;
703 }
704 };
705
706 inline flatbuffers::Offset<SensorRequestMessage> CreateSensorRequestMessage(
707 flatbuffers::FlatBufferBuilder &_fbb,
708 bool enable = false,
709 chre::power_test::SensorType sensor = chre::power_test::SensorType::UNKNOWN,
710 uint64_t sampling_interval_ns = 0,
711 uint64_t latency_ns = 0) {
712 SensorRequestMessageBuilder builder_(_fbb);
713 builder_.add_latency_ns(latency_ns);
714 builder_.add_sampling_interval_ns(sampling_interval_ns);
715 builder_.add_sensor(sensor);
716 builder_.add_enable(enable);
717 return builder_.Finish();
718 }
719
720 /// Represents a message to enable / disable break-it mode inside the nanoapp.
721 /// Break-it mode enables WiFi / GNSS / Cell to be queried every second and
722 /// enables all sensors at their fastest sampling rate.
723 struct BreakItMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
724 typedef BreakItMessageBuilder Builder;
725 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
726 VT_ENABLE = 4
727 };
enableFLATBUFFERS_FINAL_CLASS728 bool enable() const {
729 return GetField<uint8_t>(VT_ENABLE, 0) != 0;
730 }
VerifyFLATBUFFERS_FINAL_CLASS731 bool Verify(flatbuffers::Verifier &verifier) const {
732 return VerifyTableStart(verifier) &&
733 VerifyField<uint8_t>(verifier, VT_ENABLE) &&
734 verifier.EndTable();
735 }
736 };
737
738 struct BreakItMessageBuilder {
739 typedef BreakItMessage Table;
740 flatbuffers::FlatBufferBuilder &fbb_;
741 flatbuffers::uoffset_t start_;
add_enableBreakItMessageBuilder742 void add_enable(bool enable) {
743 fbb_.AddElement<uint8_t>(BreakItMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
744 }
BreakItMessageBuilderBreakItMessageBuilder745 explicit BreakItMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
746 : fbb_(_fbb) {
747 start_ = fbb_.StartTable();
748 }
749 BreakItMessageBuilder &operator=(const BreakItMessageBuilder &);
FinishBreakItMessageBuilder750 flatbuffers::Offset<BreakItMessage> Finish() {
751 const auto end = fbb_.EndTable(start_);
752 auto o = flatbuffers::Offset<BreakItMessage>(end);
753 return o;
754 }
755 };
756
757 inline flatbuffers::Offset<BreakItMessage> CreateBreakItMessage(
758 flatbuffers::FlatBufferBuilder &_fbb,
759 bool enable = false) {
760 BreakItMessageBuilder builder_(_fbb);
761 builder_.add_enable(enable);
762 return builder_.Finish();
763 }
764
765 /// Indicates whether the nanoapp successfully performed the requested action.
766 /// Any failures will be printed to the logs.
767 struct NanoappResponseMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
768 typedef NanoappResponseMessageBuilder Builder;
769 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
770 VT_SUCCESS = 4
771 };
successFLATBUFFERS_FINAL_CLASS772 bool success() const {
773 return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
774 }
VerifyFLATBUFFERS_FINAL_CLASS775 bool Verify(flatbuffers::Verifier &verifier) const {
776 return VerifyTableStart(verifier) &&
777 VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
778 verifier.EndTable();
779 }
780 };
781
782 struct NanoappResponseMessageBuilder {
783 typedef NanoappResponseMessage Table;
784 flatbuffers::FlatBufferBuilder &fbb_;
785 flatbuffers::uoffset_t start_;
add_successNanoappResponseMessageBuilder786 void add_success(bool success) {
787 fbb_.AddElement<uint8_t>(NanoappResponseMessage::VT_SUCCESS, static_cast<uint8_t>(success), 0);
788 }
NanoappResponseMessageBuilderNanoappResponseMessageBuilder789 explicit NanoappResponseMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
790 : fbb_(_fbb) {
791 start_ = fbb_.StartTable();
792 }
793 NanoappResponseMessageBuilder &operator=(const NanoappResponseMessageBuilder &);
FinishNanoappResponseMessageBuilder794 flatbuffers::Offset<NanoappResponseMessage> Finish() {
795 const auto end = fbb_.EndTable(start_);
796 auto o = flatbuffers::Offset<NanoappResponseMessage>(end);
797 return o;
798 }
799 };
800
801 inline flatbuffers::Offset<NanoappResponseMessage> CreateNanoappResponseMessage(
802 flatbuffers::FlatBufferBuilder &_fbb,
803 bool success = false) {
804 NanoappResponseMessageBuilder builder_(_fbb);
805 builder_.add_success(success);
806 return builder_.Finish();
807 }
808
809 /// Represents a message to ask the nanoapp to start or stop Gnss measurement
810 /// sampling at the requested interval
811 struct GnssMeasurementMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
812 typedef GnssMeasurementMessageBuilder Builder;
813 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
814 VT_ENABLE = 4,
815 VT_MIN_INTERVAL_MILLIS = 6
816 };
enableFLATBUFFERS_FINAL_CLASS817 bool enable() const {
818 return GetField<uint8_t>(VT_ENABLE, 0) != 0;
819 }
min_interval_millisFLATBUFFERS_FINAL_CLASS820 uint32_t min_interval_millis() const {
821 return GetField<uint32_t>(VT_MIN_INTERVAL_MILLIS, 0);
822 }
VerifyFLATBUFFERS_FINAL_CLASS823 bool Verify(flatbuffers::Verifier &verifier) const {
824 return VerifyTableStart(verifier) &&
825 VerifyField<uint8_t>(verifier, VT_ENABLE) &&
826 VerifyField<uint32_t>(verifier, VT_MIN_INTERVAL_MILLIS) &&
827 verifier.EndTable();
828 }
829 };
830
831 struct GnssMeasurementMessageBuilder {
832 typedef GnssMeasurementMessage Table;
833 flatbuffers::FlatBufferBuilder &fbb_;
834 flatbuffers::uoffset_t start_;
add_enableGnssMeasurementMessageBuilder835 void add_enable(bool enable) {
836 fbb_.AddElement<uint8_t>(GnssMeasurementMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
837 }
add_min_interval_millisGnssMeasurementMessageBuilder838 void add_min_interval_millis(uint32_t min_interval_millis) {
839 fbb_.AddElement<uint32_t>(GnssMeasurementMessage::VT_MIN_INTERVAL_MILLIS, min_interval_millis, 0);
840 }
GnssMeasurementMessageBuilderGnssMeasurementMessageBuilder841 explicit GnssMeasurementMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
842 : fbb_(_fbb) {
843 start_ = fbb_.StartTable();
844 }
845 GnssMeasurementMessageBuilder &operator=(const GnssMeasurementMessageBuilder &);
FinishGnssMeasurementMessageBuilder846 flatbuffers::Offset<GnssMeasurementMessage> Finish() {
847 const auto end = fbb_.EndTable(start_);
848 auto o = flatbuffers::Offset<GnssMeasurementMessage>(end);
849 return o;
850 }
851 };
852
853 inline flatbuffers::Offset<GnssMeasurementMessage> CreateGnssMeasurementMessage(
854 flatbuffers::FlatBufferBuilder &_fbb,
855 bool enable = false,
856 uint32_t min_interval_millis = 0) {
857 GnssMeasurementMessageBuilder builder_(_fbb);
858 builder_.add_min_interval_millis(min_interval_millis);
859 builder_.add_enable(enable);
860 return builder_.Finish();
861 }
862
863 } // namespace power_test
864 } // namespace chre
865
866 #endif // FLATBUFFERS_GENERATED_CHREPOWERTEST_CHRE_POWER_TEST_H_
867