1 // automatically generated by the FlatBuffers compiler, do not modify
2
3
4 #ifndef FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_
5 #define FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_
6
7 #include "flatbuffers/flatbuffers.h"
8
9 namespace chre {
10 namespace fbs {
11
12 struct NanoappMessage;
13 struct NanoappMessageBuilder;
14
15 struct HubInfoRequest;
16 struct HubInfoRequestBuilder;
17
18 struct HubInfoResponse;
19 struct HubInfoResponseBuilder;
20
21 struct NanoappListRequest;
22 struct NanoappListRequestBuilder;
23
24 struct NanoappRpcService;
25 struct NanoappRpcServiceBuilder;
26
27 struct NanoappListEntry;
28 struct NanoappListEntryBuilder;
29
30 struct NanoappListResponse;
31 struct NanoappListResponseBuilder;
32
33 struct LoadNanoappRequest;
34 struct LoadNanoappRequestBuilder;
35
36 struct LoadNanoappResponse;
37 struct LoadNanoappResponseBuilder;
38
39 struct UnloadNanoappRequest;
40 struct UnloadNanoappRequestBuilder;
41
42 struct UnloadNanoappResponse;
43 struct UnloadNanoappResponseBuilder;
44
45 struct LogMessage;
46 struct LogMessageBuilder;
47
48 struct TimeSyncMessage;
49 struct TimeSyncMessageBuilder;
50
51 struct DebugDumpRequest;
52 struct DebugDumpRequestBuilder;
53
54 struct DebugDumpData;
55 struct DebugDumpDataBuilder;
56
57 struct DebugDumpResponse;
58 struct DebugDumpResponseBuilder;
59
60 struct TimeSyncRequest;
61 struct TimeSyncRequestBuilder;
62
63 struct LowPowerMicAccessRequest;
64 struct LowPowerMicAccessRequestBuilder;
65
66 struct LowPowerMicAccessRelease;
67 struct LowPowerMicAccessReleaseBuilder;
68
69 struct SettingChangeMessage;
70 struct SettingChangeMessageBuilder;
71
72 struct LogMessageV2;
73 struct LogMessageV2Builder;
74
75 struct SelfTestRequest;
76 struct SelfTestRequestBuilder;
77
78 struct SelfTestResponse;
79 struct SelfTestResponseBuilder;
80
81 struct HostEndpointConnected;
82 struct HostEndpointConnectedBuilder;
83
84 struct HostEndpointDisconnected;
85 struct HostEndpointDisconnectedBuilder;
86
87 struct MetricLog;
88 struct MetricLogBuilder;
89
90 struct BatchedMetricLog;
91 struct BatchedMetricLogBuilder;
92
93 struct NanConfigurationRequest;
94 struct NanConfigurationRequestBuilder;
95
96 struct NanConfigurationUpdate;
97 struct NanConfigurationUpdateBuilder;
98
99 struct DebugConfiguration;
100 struct DebugConfigurationBuilder;
101
102 struct HostAddress;
103
104 struct MessageContainer;
105 struct MessageContainerBuilder;
106
107 /// An enum describing the setting type.
108 enum class Setting : int8_t {
109 LOCATION = 0,
110 WIFI_AVAILABLE = 1,
111 AIRPLANE_MODE = 2,
112 MICROPHONE = 3,
113 BLE_AVAILABLE = 4,
114 MIN = LOCATION,
115 MAX = BLE_AVAILABLE
116 };
117
EnumValuesSetting()118 inline const Setting (&EnumValuesSetting())[5] {
119 static const Setting values[] = {
120 Setting::LOCATION,
121 Setting::WIFI_AVAILABLE,
122 Setting::AIRPLANE_MODE,
123 Setting::MICROPHONE,
124 Setting::BLE_AVAILABLE
125 };
126 return values;
127 }
128
EnumNamesSetting()129 inline const char * const *EnumNamesSetting() {
130 static const char * const names[6] = {
131 "LOCATION",
132 "WIFI_AVAILABLE",
133 "AIRPLANE_MODE",
134 "MICROPHONE",
135 "BLE_AVAILABLE",
136 nullptr
137 };
138 return names;
139 }
140
EnumNameSetting(Setting e)141 inline const char *EnumNameSetting(Setting e) {
142 if (flatbuffers::IsOutRange(e, Setting::LOCATION, Setting::BLE_AVAILABLE)) return "";
143 const size_t index = static_cast<size_t>(e);
144 return EnumNamesSetting()[index];
145 }
146
147 /// An enum describing the state of a setting.
148 enum class SettingState : int8_t {
149 DISABLED = 0,
150 ENABLED = 1,
151 MIN = DISABLED,
152 MAX = ENABLED
153 };
154
EnumValuesSettingState()155 inline const SettingState (&EnumValuesSettingState())[2] {
156 static const SettingState values[] = {
157 SettingState::DISABLED,
158 SettingState::ENABLED
159 };
160 return values;
161 }
162
EnumNamesSettingState()163 inline const char * const *EnumNamesSettingState() {
164 static const char * const names[3] = {
165 "DISABLED",
166 "ENABLED",
167 nullptr
168 };
169 return names;
170 }
171
EnumNameSettingState(SettingState e)172 inline const char *EnumNameSettingState(SettingState e) {
173 if (flatbuffers::IsOutRange(e, SettingState::DISABLED, SettingState::ENABLED)) return "";
174 const size_t index = static_cast<size_t>(e);
175 return EnumNamesSettingState()[index];
176 }
177
178 enum class LogLevel : int8_t {
179 ERROR = 1,
180 WARNING = 2,
181 INFO = 3,
182 DEBUG = 4,
183 VERBOSE = 5,
184 MIN = ERROR,
185 MAX = VERBOSE
186 };
187
EnumValuesLogLevel()188 inline const LogLevel (&EnumValuesLogLevel())[5] {
189 static const LogLevel values[] = {
190 LogLevel::ERROR,
191 LogLevel::WARNING,
192 LogLevel::INFO,
193 LogLevel::DEBUG,
194 LogLevel::VERBOSE
195 };
196 return values;
197 }
198
EnumNamesLogLevel()199 inline const char * const *EnumNamesLogLevel() {
200 static const char * const names[6] = {
201 "ERROR",
202 "WARNING",
203 "INFO",
204 "DEBUG",
205 "VERBOSE",
206 nullptr
207 };
208 return names;
209 }
210
EnumNameLogLevel(LogLevel e)211 inline const char *EnumNameLogLevel(LogLevel e) {
212 if (flatbuffers::IsOutRange(e, LogLevel::ERROR, LogLevel::VERBOSE)) return "";
213 const size_t index = static_cast<size_t>(e) - static_cast<size_t>(LogLevel::ERROR);
214 return EnumNamesLogLevel()[index];
215 }
216
217 enum class LogType : int8_t {
218 STRING = 0,
219 TOKENIZED = 1,
220 BLUETOOTH = 2,
221 MIN = STRING,
222 MAX = BLUETOOTH
223 };
224
EnumValuesLogType()225 inline const LogType (&EnumValuesLogType())[3] {
226 static const LogType values[] = {
227 LogType::STRING,
228 LogType::TOKENIZED,
229 LogType::BLUETOOTH
230 };
231 return values;
232 }
233
EnumNamesLogType()234 inline const char * const *EnumNamesLogType() {
235 static const char * const names[4] = {
236 "STRING",
237 "TOKENIZED",
238 "BLUETOOTH",
239 nullptr
240 };
241 return names;
242 }
243
EnumNameLogType(LogType e)244 inline const char *EnumNameLogType(LogType e) {
245 if (flatbuffers::IsOutRange(e, LogType::STRING, LogType::BLUETOOTH)) return "";
246 const size_t index = static_cast<size_t>(e);
247 return EnumNamesLogType()[index];
248 }
249
250 enum class BtSnoopDirection : int8_t {
251 INCOMING_FROM_BT_CONTROLLER = 0,
252 OUTGOING_TO_ARBITER = 1,
253 MIN = INCOMING_FROM_BT_CONTROLLER,
254 MAX = OUTGOING_TO_ARBITER
255 };
256
EnumValuesBtSnoopDirection()257 inline const BtSnoopDirection (&EnumValuesBtSnoopDirection())[2] {
258 static const BtSnoopDirection values[] = {
259 BtSnoopDirection::INCOMING_FROM_BT_CONTROLLER,
260 BtSnoopDirection::OUTGOING_TO_ARBITER
261 };
262 return values;
263 }
264
EnumNamesBtSnoopDirection()265 inline const char * const *EnumNamesBtSnoopDirection() {
266 static const char * const names[3] = {
267 "INCOMING_FROM_BT_CONTROLLER",
268 "OUTGOING_TO_ARBITER",
269 nullptr
270 };
271 return names;
272 }
273
EnumNameBtSnoopDirection(BtSnoopDirection e)274 inline const char *EnumNameBtSnoopDirection(BtSnoopDirection e) {
275 if (flatbuffers::IsOutRange(e, BtSnoopDirection::INCOMING_FROM_BT_CONTROLLER, BtSnoopDirection::OUTGOING_TO_ARBITER)) return "";
276 const size_t index = static_cast<size_t>(e);
277 return EnumNamesBtSnoopDirection()[index];
278 }
279
280 /// A union that joins together all possible messages. Note that in FlatBuffers,
281 /// unions have an implicit type
282 enum class ChreMessage : uint8_t {
283 NONE = 0,
284 NanoappMessage = 1,
285 HubInfoRequest = 2,
286 HubInfoResponse = 3,
287 NanoappListRequest = 4,
288 NanoappListResponse = 5,
289 LoadNanoappRequest = 6,
290 LoadNanoappResponse = 7,
291 UnloadNanoappRequest = 8,
292 UnloadNanoappResponse = 9,
293 LogMessage = 10,
294 TimeSyncMessage = 11,
295 DebugDumpRequest = 12,
296 DebugDumpData = 13,
297 DebugDumpResponse = 14,
298 TimeSyncRequest = 15,
299 LowPowerMicAccessRequest = 16,
300 LowPowerMicAccessRelease = 17,
301 SettingChangeMessage = 18,
302 LogMessageV2 = 19,
303 SelfTestRequest = 20,
304 SelfTestResponse = 21,
305 HostEndpointConnected = 22,
306 HostEndpointDisconnected = 23,
307 MetricLog = 24,
308 BatchedMetricLog = 25,
309 NanConfigurationRequest = 26,
310 NanConfigurationUpdate = 27,
311 DebugConfiguration = 28,
312 MIN = NONE,
313 MAX = DebugConfiguration
314 };
315
EnumValuesChreMessage()316 inline const ChreMessage (&EnumValuesChreMessage())[29] {
317 static const ChreMessage values[] = {
318 ChreMessage::NONE,
319 ChreMessage::NanoappMessage,
320 ChreMessage::HubInfoRequest,
321 ChreMessage::HubInfoResponse,
322 ChreMessage::NanoappListRequest,
323 ChreMessage::NanoappListResponse,
324 ChreMessage::LoadNanoappRequest,
325 ChreMessage::LoadNanoappResponse,
326 ChreMessage::UnloadNanoappRequest,
327 ChreMessage::UnloadNanoappResponse,
328 ChreMessage::LogMessage,
329 ChreMessage::TimeSyncMessage,
330 ChreMessage::DebugDumpRequest,
331 ChreMessage::DebugDumpData,
332 ChreMessage::DebugDumpResponse,
333 ChreMessage::TimeSyncRequest,
334 ChreMessage::LowPowerMicAccessRequest,
335 ChreMessage::LowPowerMicAccessRelease,
336 ChreMessage::SettingChangeMessage,
337 ChreMessage::LogMessageV2,
338 ChreMessage::SelfTestRequest,
339 ChreMessage::SelfTestResponse,
340 ChreMessage::HostEndpointConnected,
341 ChreMessage::HostEndpointDisconnected,
342 ChreMessage::MetricLog,
343 ChreMessage::BatchedMetricLog,
344 ChreMessage::NanConfigurationRequest,
345 ChreMessage::NanConfigurationUpdate,
346 ChreMessage::DebugConfiguration
347 };
348 return values;
349 }
350
EnumNamesChreMessage()351 inline const char * const *EnumNamesChreMessage() {
352 static const char * const names[30] = {
353 "NONE",
354 "NanoappMessage",
355 "HubInfoRequest",
356 "HubInfoResponse",
357 "NanoappListRequest",
358 "NanoappListResponse",
359 "LoadNanoappRequest",
360 "LoadNanoappResponse",
361 "UnloadNanoappRequest",
362 "UnloadNanoappResponse",
363 "LogMessage",
364 "TimeSyncMessage",
365 "DebugDumpRequest",
366 "DebugDumpData",
367 "DebugDumpResponse",
368 "TimeSyncRequest",
369 "LowPowerMicAccessRequest",
370 "LowPowerMicAccessRelease",
371 "SettingChangeMessage",
372 "LogMessageV2",
373 "SelfTestRequest",
374 "SelfTestResponse",
375 "HostEndpointConnected",
376 "HostEndpointDisconnected",
377 "MetricLog",
378 "BatchedMetricLog",
379 "NanConfigurationRequest",
380 "NanConfigurationUpdate",
381 "DebugConfiguration",
382 nullptr
383 };
384 return names;
385 }
386
EnumNameChreMessage(ChreMessage e)387 inline const char *EnumNameChreMessage(ChreMessage e) {
388 if (flatbuffers::IsOutRange(e, ChreMessage::NONE, ChreMessage::DebugConfiguration)) return "";
389 const size_t index = static_cast<size_t>(e);
390 return EnumNamesChreMessage()[index];
391 }
392
393 template<typename T> struct ChreMessageTraits {
394 static const ChreMessage enum_value = ChreMessage::NONE;
395 };
396
397 template<> struct ChreMessageTraits<chre::fbs::NanoappMessage> {
398 static const ChreMessage enum_value = ChreMessage::NanoappMessage;
399 };
400
401 template<> struct ChreMessageTraits<chre::fbs::HubInfoRequest> {
402 static const ChreMessage enum_value = ChreMessage::HubInfoRequest;
403 };
404
405 template<> struct ChreMessageTraits<chre::fbs::HubInfoResponse> {
406 static const ChreMessage enum_value = ChreMessage::HubInfoResponse;
407 };
408
409 template<> struct ChreMessageTraits<chre::fbs::NanoappListRequest> {
410 static const ChreMessage enum_value = ChreMessage::NanoappListRequest;
411 };
412
413 template<> struct ChreMessageTraits<chre::fbs::NanoappListResponse> {
414 static const ChreMessage enum_value = ChreMessage::NanoappListResponse;
415 };
416
417 template<> struct ChreMessageTraits<chre::fbs::LoadNanoappRequest> {
418 static const ChreMessage enum_value = ChreMessage::LoadNanoappRequest;
419 };
420
421 template<> struct ChreMessageTraits<chre::fbs::LoadNanoappResponse> {
422 static const ChreMessage enum_value = ChreMessage::LoadNanoappResponse;
423 };
424
425 template<> struct ChreMessageTraits<chre::fbs::UnloadNanoappRequest> {
426 static const ChreMessage enum_value = ChreMessage::UnloadNanoappRequest;
427 };
428
429 template<> struct ChreMessageTraits<chre::fbs::UnloadNanoappResponse> {
430 static const ChreMessage enum_value = ChreMessage::UnloadNanoappResponse;
431 };
432
433 template<> struct ChreMessageTraits<chre::fbs::LogMessage> {
434 static const ChreMessage enum_value = ChreMessage::LogMessage;
435 };
436
437 template<> struct ChreMessageTraits<chre::fbs::TimeSyncMessage> {
438 static const ChreMessage enum_value = ChreMessage::TimeSyncMessage;
439 };
440
441 template<> struct ChreMessageTraits<chre::fbs::DebugDumpRequest> {
442 static const ChreMessage enum_value = ChreMessage::DebugDumpRequest;
443 };
444
445 template<> struct ChreMessageTraits<chre::fbs::DebugDumpData> {
446 static const ChreMessage enum_value = ChreMessage::DebugDumpData;
447 };
448
449 template<> struct ChreMessageTraits<chre::fbs::DebugDumpResponse> {
450 static const ChreMessage enum_value = ChreMessage::DebugDumpResponse;
451 };
452
453 template<> struct ChreMessageTraits<chre::fbs::TimeSyncRequest> {
454 static const ChreMessage enum_value = ChreMessage::TimeSyncRequest;
455 };
456
457 template<> struct ChreMessageTraits<chre::fbs::LowPowerMicAccessRequest> {
458 static const ChreMessage enum_value = ChreMessage::LowPowerMicAccessRequest;
459 };
460
461 template<> struct ChreMessageTraits<chre::fbs::LowPowerMicAccessRelease> {
462 static const ChreMessage enum_value = ChreMessage::LowPowerMicAccessRelease;
463 };
464
465 template<> struct ChreMessageTraits<chre::fbs::SettingChangeMessage> {
466 static const ChreMessage enum_value = ChreMessage::SettingChangeMessage;
467 };
468
469 template<> struct ChreMessageTraits<chre::fbs::LogMessageV2> {
470 static const ChreMessage enum_value = ChreMessage::LogMessageV2;
471 };
472
473 template<> struct ChreMessageTraits<chre::fbs::SelfTestRequest> {
474 static const ChreMessage enum_value = ChreMessage::SelfTestRequest;
475 };
476
477 template<> struct ChreMessageTraits<chre::fbs::SelfTestResponse> {
478 static const ChreMessage enum_value = ChreMessage::SelfTestResponse;
479 };
480
481 template<> struct ChreMessageTraits<chre::fbs::HostEndpointConnected> {
482 static const ChreMessage enum_value = ChreMessage::HostEndpointConnected;
483 };
484
485 template<> struct ChreMessageTraits<chre::fbs::HostEndpointDisconnected> {
486 static const ChreMessage enum_value = ChreMessage::HostEndpointDisconnected;
487 };
488
489 template<> struct ChreMessageTraits<chre::fbs::MetricLog> {
490 static const ChreMessage enum_value = ChreMessage::MetricLog;
491 };
492
493 template<> struct ChreMessageTraits<chre::fbs::BatchedMetricLog> {
494 static const ChreMessage enum_value = ChreMessage::BatchedMetricLog;
495 };
496
497 template<> struct ChreMessageTraits<chre::fbs::NanConfigurationRequest> {
498 static const ChreMessage enum_value = ChreMessage::NanConfigurationRequest;
499 };
500
501 template<> struct ChreMessageTraits<chre::fbs::NanConfigurationUpdate> {
502 static const ChreMessage enum_value = ChreMessage::NanConfigurationUpdate;
503 };
504
505 template<> struct ChreMessageTraits<chre::fbs::DebugConfiguration> {
506 static const ChreMessage enum_value = ChreMessage::DebugConfiguration;
507 };
508
509 bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type);
510 bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
511
512 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) HostAddress FLATBUFFERS_FINAL_CLASS {
513 private:
514 uint16_t client_id_;
515
516 public:
517 HostAddress() {
518 memset(static_cast<void *>(this), 0, sizeof(HostAddress));
519 }
520 HostAddress(uint16_t _client_id)
521 : client_id_(flatbuffers::EndianScalar(_client_id)) {
522 }
523 uint16_t client_id() const {
524 return flatbuffers::EndianScalar(client_id_);
525 }
526 };
527 FLATBUFFERS_STRUCT_END(HostAddress, 2);
528
529 /// Represents a message sent to/from a nanoapp from/to a client on the host
530 struct NanoappMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
531 typedef NanoappMessageBuilder Builder;
532 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
533 VT_APP_ID = 4,
534 VT_MESSAGE_TYPE = 6,
535 VT_HOST_ENDPOINT = 8,
536 VT_MESSAGE = 10,
537 VT_MESSAGE_PERMISSIONS = 12,
538 VT_PERMISSIONS = 14,
539 VT_WOKE_HOST = 16
540 };
541 uint64_t app_id() const {
542 return GetField<uint64_t>(VT_APP_ID, 0);
543 }
544 uint32_t message_type() const {
545 return GetField<uint32_t>(VT_MESSAGE_TYPE, 0);
546 }
547 /// Identifies the host-side endpoint on the host that sent or should receive
548 /// this message. The default value is a special value defined in the HAL and
549 /// elsewhere that indicates that the endpoint is unspecified.
550 uint16_t host_endpoint() const {
551 return GetField<uint16_t>(VT_HOST_ENDPOINT, 65534);
552 }
553 /// Vector containing arbitrary application-specific message data
554 const flatbuffers::Vector<uint8_t> *message() const {
555 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MESSAGE);
556 }
557 /// List of Android permissions that cover the contents of a message from a
558 /// nanoapp to the host.
559 /// These permissions are used to record and attribute access to
560 /// permissions-controlled resources.
561 uint32_t message_permissions() const {
562 return GetField<uint32_t>(VT_MESSAGE_PERMISSIONS, 0);
563 }
564 /// List of Android permissions declared by the nanoapp / granted to the host.
565 /// For messages from a nanoaapp to the host, this must be a superset of
566 /// message_permissions.
567 uint32_t permissions() const {
568 return GetField<uint32_t>(VT_PERMISSIONS, 0);
569 }
570 bool woke_host() const {
571 return GetField<uint8_t>(VT_WOKE_HOST, 0) != 0;
572 }
573 bool Verify(flatbuffers::Verifier &verifier) const {
574 return VerifyTableStart(verifier) &&
575 VerifyField<uint64_t>(verifier, VT_APP_ID) &&
576 VerifyField<uint32_t>(verifier, VT_MESSAGE_TYPE) &&
577 VerifyField<uint16_t>(verifier, VT_HOST_ENDPOINT) &&
578 VerifyOffsetRequired(verifier, VT_MESSAGE) &&
579 verifier.VerifyVector(message()) &&
580 VerifyField<uint32_t>(verifier, VT_MESSAGE_PERMISSIONS) &&
581 VerifyField<uint32_t>(verifier, VT_PERMISSIONS) &&
582 VerifyField<uint8_t>(verifier, VT_WOKE_HOST) &&
583 verifier.EndTable();
584 }
585 };
586
587 struct NanoappMessageBuilder {
588 typedef NanoappMessage Table;
589 flatbuffers::FlatBufferBuilder &fbb_;
590 flatbuffers::uoffset_t start_;
591 void add_app_id(uint64_t app_id) {
592 fbb_.AddElement<uint64_t>(NanoappMessage::VT_APP_ID, app_id, 0);
593 }
594 void add_message_type(uint32_t message_type) {
595 fbb_.AddElement<uint32_t>(NanoappMessage::VT_MESSAGE_TYPE, message_type, 0);
596 }
597 void add_host_endpoint(uint16_t host_endpoint) {
598 fbb_.AddElement<uint16_t>(NanoappMessage::VT_HOST_ENDPOINT, host_endpoint, 65534);
599 }
600 void add_message(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message) {
601 fbb_.AddOffset(NanoappMessage::VT_MESSAGE, message);
602 }
603 void add_message_permissions(uint32_t message_permissions) {
604 fbb_.AddElement<uint32_t>(NanoappMessage::VT_MESSAGE_PERMISSIONS, message_permissions, 0);
605 }
606 void add_permissions(uint32_t permissions) {
607 fbb_.AddElement<uint32_t>(NanoappMessage::VT_PERMISSIONS, permissions, 0);
608 }
609 void add_woke_host(bool woke_host) {
610 fbb_.AddElement<uint8_t>(NanoappMessage::VT_WOKE_HOST, static_cast<uint8_t>(woke_host), 0);
611 }
612 explicit NanoappMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
613 : fbb_(_fbb) {
614 start_ = fbb_.StartTable();
615 }
616 NanoappMessageBuilder &operator=(const NanoappMessageBuilder &);
617 flatbuffers::Offset<NanoappMessage> Finish() {
618 const auto end = fbb_.EndTable(start_);
619 auto o = flatbuffers::Offset<NanoappMessage>(end);
620 fbb_.Required(o, NanoappMessage::VT_MESSAGE);
621 return o;
622 }
623 };
624
625 inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessage(
626 flatbuffers::FlatBufferBuilder &_fbb,
627 uint64_t app_id = 0,
628 uint32_t message_type = 0,
629 uint16_t host_endpoint = 65534,
630 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message = 0,
631 uint32_t message_permissions = 0,
632 uint32_t permissions = 0,
633 bool woke_host = false) {
634 NanoappMessageBuilder builder_(_fbb);
635 builder_.add_app_id(app_id);
636 builder_.add_permissions(permissions);
637 builder_.add_message_permissions(message_permissions);
638 builder_.add_message(message);
639 builder_.add_message_type(message_type);
640 builder_.add_host_endpoint(host_endpoint);
641 builder_.add_woke_host(woke_host);
642 return builder_.Finish();
643 }
644
645 inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessageDirect(
646 flatbuffers::FlatBufferBuilder &_fbb,
647 uint64_t app_id = 0,
648 uint32_t message_type = 0,
649 uint16_t host_endpoint = 65534,
650 const std::vector<uint8_t> *message = nullptr,
651 uint32_t message_permissions = 0,
652 uint32_t permissions = 0,
653 bool woke_host = false) {
654 auto message__ = message ? _fbb.CreateVector<uint8_t>(*message) : 0;
655 return chre::fbs::CreateNanoappMessage(
656 _fbb,
657 app_id,
658 message_type,
659 host_endpoint,
660 message__,
661 message_permissions,
662 permissions,
663 woke_host);
664 }
665
666 struct HubInfoRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
667 typedef HubInfoRequestBuilder Builder;
668 bool Verify(flatbuffers::Verifier &verifier) const {
669 return VerifyTableStart(verifier) &&
670 verifier.EndTable();
671 }
672 };
673
674 struct HubInfoRequestBuilder {
675 typedef HubInfoRequest Table;
676 flatbuffers::FlatBufferBuilder &fbb_;
677 flatbuffers::uoffset_t start_;
678 explicit HubInfoRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
679 : fbb_(_fbb) {
680 start_ = fbb_.StartTable();
681 }
682 HubInfoRequestBuilder &operator=(const HubInfoRequestBuilder &);
683 flatbuffers::Offset<HubInfoRequest> Finish() {
684 const auto end = fbb_.EndTable(start_);
685 auto o = flatbuffers::Offset<HubInfoRequest>(end);
686 return o;
687 }
688 };
689
690 inline flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest(
691 flatbuffers::FlatBufferBuilder &_fbb) {
692 HubInfoRequestBuilder builder_(_fbb);
693 return builder_.Finish();
694 }
695
696 struct HubInfoResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
697 typedef HubInfoResponseBuilder Builder;
698 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
699 VT_NAME = 4,
700 VT_VENDOR = 6,
701 VT_TOOLCHAIN = 8,
702 VT_PLATFORM_VERSION = 10,
703 VT_TOOLCHAIN_VERSION = 12,
704 VT_PEAK_MIPS = 14,
705 VT_STOPPED_POWER = 16,
706 VT_SLEEP_POWER = 18,
707 VT_PEAK_POWER = 20,
708 VT_MAX_MSG_LEN = 22,
709 VT_PLATFORM_ID = 24,
710 VT_CHRE_PLATFORM_VERSION = 26
711 };
712 /// The name of the hub. Nominally a UTF-8 string, but note that we're not
713 /// using the built-in "string" data type from FlatBuffers here, because the
714 /// generated C++ uses std::string which is not well-supported in CHRE. This
715 /// applies for vendor and toolchain as well.
716 const flatbuffers::Vector<int8_t> *name() const {
717 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_NAME);
718 }
719 const flatbuffers::Vector<int8_t> *vendor() const {
720 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_VENDOR);
721 }
722 const flatbuffers::Vector<int8_t> *toolchain() const {
723 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_TOOLCHAIN);
724 }
725 /// Legacy platform version reported in the HAL; semantics not strictly
726 /// defined
727 uint32_t platform_version() const {
728 return GetField<uint32_t>(VT_PLATFORM_VERSION, 0);
729 }
730 /// Toolchain version reported in the HAL; semantics not strictly defined
731 uint32_t toolchain_version() const {
732 return GetField<uint32_t>(VT_TOOLCHAIN_VERSION, 0);
733 }
734 float peak_mips() const {
735 return GetField<float>(VT_PEAK_MIPS, 0.0f);
736 }
737 float stopped_power() const {
738 return GetField<float>(VT_STOPPED_POWER, 0.0f);
739 }
740 float sleep_power() const {
741 return GetField<float>(VT_SLEEP_POWER, 0.0f);
742 }
743 float peak_power() const {
744 return GetField<float>(VT_PEAK_POWER, 0.0f);
745 }
746 /// Maximum size message that can be sent to a nanoapp
747 uint32_t max_msg_len() const {
748 return GetField<uint32_t>(VT_MAX_MSG_LEN, 0);
749 }
750 /// @see chreGetPlatformId()
751 uint64_t platform_id() const {
752 return GetField<uint64_t>(VT_PLATFORM_ID, 0);
753 }
754 /// @see chreGetVersion()
755 uint32_t chre_platform_version() const {
756 return GetField<uint32_t>(VT_CHRE_PLATFORM_VERSION, 0);
757 }
758 bool Verify(flatbuffers::Verifier &verifier) const {
759 return VerifyTableStart(verifier) &&
760 VerifyOffset(verifier, VT_NAME) &&
761 verifier.VerifyVector(name()) &&
762 VerifyOffset(verifier, VT_VENDOR) &&
763 verifier.VerifyVector(vendor()) &&
764 VerifyOffset(verifier, VT_TOOLCHAIN) &&
765 verifier.VerifyVector(toolchain()) &&
766 VerifyField<uint32_t>(verifier, VT_PLATFORM_VERSION) &&
767 VerifyField<uint32_t>(verifier, VT_TOOLCHAIN_VERSION) &&
768 VerifyField<float>(verifier, VT_PEAK_MIPS) &&
769 VerifyField<float>(verifier, VT_STOPPED_POWER) &&
770 VerifyField<float>(verifier, VT_SLEEP_POWER) &&
771 VerifyField<float>(verifier, VT_PEAK_POWER) &&
772 VerifyField<uint32_t>(verifier, VT_MAX_MSG_LEN) &&
773 VerifyField<uint64_t>(verifier, VT_PLATFORM_ID) &&
774 VerifyField<uint32_t>(verifier, VT_CHRE_PLATFORM_VERSION) &&
775 verifier.EndTable();
776 }
777 };
778
779 struct HubInfoResponseBuilder {
780 typedef HubInfoResponse Table;
781 flatbuffers::FlatBufferBuilder &fbb_;
782 flatbuffers::uoffset_t start_;
783 void add_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> name) {
784 fbb_.AddOffset(HubInfoResponse::VT_NAME, name);
785 }
786 void add_vendor(flatbuffers::Offset<flatbuffers::Vector<int8_t>> vendor) {
787 fbb_.AddOffset(HubInfoResponse::VT_VENDOR, vendor);
788 }
789 void add_toolchain(flatbuffers::Offset<flatbuffers::Vector<int8_t>> toolchain) {
790 fbb_.AddOffset(HubInfoResponse::VT_TOOLCHAIN, toolchain);
791 }
792 void add_platform_version(uint32_t platform_version) {
793 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_PLATFORM_VERSION, platform_version, 0);
794 }
795 void add_toolchain_version(uint32_t toolchain_version) {
796 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_TOOLCHAIN_VERSION, toolchain_version, 0);
797 }
798 void add_peak_mips(float peak_mips) {
799 fbb_.AddElement<float>(HubInfoResponse::VT_PEAK_MIPS, peak_mips, 0.0f);
800 }
801 void add_stopped_power(float stopped_power) {
802 fbb_.AddElement<float>(HubInfoResponse::VT_STOPPED_POWER, stopped_power, 0.0f);
803 }
804 void add_sleep_power(float sleep_power) {
805 fbb_.AddElement<float>(HubInfoResponse::VT_SLEEP_POWER, sleep_power, 0.0f);
806 }
807 void add_peak_power(float peak_power) {
808 fbb_.AddElement<float>(HubInfoResponse::VT_PEAK_POWER, peak_power, 0.0f);
809 }
810 void add_max_msg_len(uint32_t max_msg_len) {
811 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_MAX_MSG_LEN, max_msg_len, 0);
812 }
813 void add_platform_id(uint64_t platform_id) {
814 fbb_.AddElement<uint64_t>(HubInfoResponse::VT_PLATFORM_ID, platform_id, 0);
815 }
816 void add_chre_platform_version(uint32_t chre_platform_version) {
817 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_CHRE_PLATFORM_VERSION, chre_platform_version, 0);
818 }
819 explicit HubInfoResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
820 : fbb_(_fbb) {
821 start_ = fbb_.StartTable();
822 }
823 HubInfoResponseBuilder &operator=(const HubInfoResponseBuilder &);
824 flatbuffers::Offset<HubInfoResponse> Finish() {
825 const auto end = fbb_.EndTable(start_);
826 auto o = flatbuffers::Offset<HubInfoResponse>(end);
827 return o;
828 }
829 };
830
831 inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponse(
832 flatbuffers::FlatBufferBuilder &_fbb,
833 flatbuffers::Offset<flatbuffers::Vector<int8_t>> name = 0,
834 flatbuffers::Offset<flatbuffers::Vector<int8_t>> vendor = 0,
835 flatbuffers::Offset<flatbuffers::Vector<int8_t>> toolchain = 0,
836 uint32_t platform_version = 0,
837 uint32_t toolchain_version = 0,
838 float peak_mips = 0.0f,
839 float stopped_power = 0.0f,
840 float sleep_power = 0.0f,
841 float peak_power = 0.0f,
842 uint32_t max_msg_len = 0,
843 uint64_t platform_id = 0,
844 uint32_t chre_platform_version = 0) {
845 HubInfoResponseBuilder builder_(_fbb);
846 builder_.add_platform_id(platform_id);
847 builder_.add_chre_platform_version(chre_platform_version);
848 builder_.add_max_msg_len(max_msg_len);
849 builder_.add_peak_power(peak_power);
850 builder_.add_sleep_power(sleep_power);
851 builder_.add_stopped_power(stopped_power);
852 builder_.add_peak_mips(peak_mips);
853 builder_.add_toolchain_version(toolchain_version);
854 builder_.add_platform_version(platform_version);
855 builder_.add_toolchain(toolchain);
856 builder_.add_vendor(vendor);
857 builder_.add_name(name);
858 return builder_.Finish();
859 }
860
861 inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponseDirect(
862 flatbuffers::FlatBufferBuilder &_fbb,
863 const std::vector<int8_t> *name = nullptr,
864 const std::vector<int8_t> *vendor = nullptr,
865 const std::vector<int8_t> *toolchain = nullptr,
866 uint32_t platform_version = 0,
867 uint32_t toolchain_version = 0,
868 float peak_mips = 0.0f,
869 float stopped_power = 0.0f,
870 float sleep_power = 0.0f,
871 float peak_power = 0.0f,
872 uint32_t max_msg_len = 0,
873 uint64_t platform_id = 0,
874 uint32_t chre_platform_version = 0) {
875 auto name__ = name ? _fbb.CreateVector<int8_t>(*name) : 0;
876 auto vendor__ = vendor ? _fbb.CreateVector<int8_t>(*vendor) : 0;
877 auto toolchain__ = toolchain ? _fbb.CreateVector<int8_t>(*toolchain) : 0;
878 return chre::fbs::CreateHubInfoResponse(
879 _fbb,
880 name__,
881 vendor__,
882 toolchain__,
883 platform_version,
884 toolchain_version,
885 peak_mips,
886 stopped_power,
887 sleep_power,
888 peak_power,
889 max_msg_len,
890 platform_id,
891 chre_platform_version);
892 }
893
894 struct NanoappListRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
895 typedef NanoappListRequestBuilder Builder;
896 bool Verify(flatbuffers::Verifier &verifier) const {
897 return VerifyTableStart(verifier) &&
898 verifier.EndTable();
899 }
900 };
901
902 struct NanoappListRequestBuilder {
903 typedef NanoappListRequest Table;
904 flatbuffers::FlatBufferBuilder &fbb_;
905 flatbuffers::uoffset_t start_;
906 explicit NanoappListRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
907 : fbb_(_fbb) {
908 start_ = fbb_.StartTable();
909 }
910 NanoappListRequestBuilder &operator=(const NanoappListRequestBuilder &);
911 flatbuffers::Offset<NanoappListRequest> Finish() {
912 const auto end = fbb_.EndTable(start_);
913 auto o = flatbuffers::Offset<NanoappListRequest>(end);
914 return o;
915 }
916 };
917
918 inline flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest(
919 flatbuffers::FlatBufferBuilder &_fbb) {
920 NanoappListRequestBuilder builder_(_fbb);
921 return builder_.Finish();
922 }
923
924 /// Metadata regarding a Nanoapp RPC service. See the Android API
925 /// core/java/android/hardware/location/NanoAppRpcService.java for more details
926 /// on how this value is used by the Android application.
927 struct NanoappRpcService FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
928 typedef NanoappRpcServiceBuilder Builder;
929 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
930 VT_ID = 4,
931 VT_VERSION = 6
932 };
933 uint64_t id() const {
934 return GetField<uint64_t>(VT_ID, 0);
935 }
936 uint32_t version() const {
937 return GetField<uint32_t>(VT_VERSION, 0);
938 }
939 bool Verify(flatbuffers::Verifier &verifier) const {
940 return VerifyTableStart(verifier) &&
941 VerifyField<uint64_t>(verifier, VT_ID) &&
942 VerifyField<uint32_t>(verifier, VT_VERSION) &&
943 verifier.EndTable();
944 }
945 };
946
947 struct NanoappRpcServiceBuilder {
948 typedef NanoappRpcService Table;
949 flatbuffers::FlatBufferBuilder &fbb_;
950 flatbuffers::uoffset_t start_;
951 void add_id(uint64_t id) {
952 fbb_.AddElement<uint64_t>(NanoappRpcService::VT_ID, id, 0);
953 }
954 void add_version(uint32_t version) {
955 fbb_.AddElement<uint32_t>(NanoappRpcService::VT_VERSION, version, 0);
956 }
957 explicit NanoappRpcServiceBuilder(flatbuffers::FlatBufferBuilder &_fbb)
958 : fbb_(_fbb) {
959 start_ = fbb_.StartTable();
960 }
961 NanoappRpcServiceBuilder &operator=(const NanoappRpcServiceBuilder &);
962 flatbuffers::Offset<NanoappRpcService> Finish() {
963 const auto end = fbb_.EndTable(start_);
964 auto o = flatbuffers::Offset<NanoappRpcService>(end);
965 return o;
966 }
967 };
968
969 inline flatbuffers::Offset<NanoappRpcService> CreateNanoappRpcService(
970 flatbuffers::FlatBufferBuilder &_fbb,
971 uint64_t id = 0,
972 uint32_t version = 0) {
973 NanoappRpcServiceBuilder builder_(_fbb);
974 builder_.add_id(id);
975 builder_.add_version(version);
976 return builder_.Finish();
977 }
978
979 struct NanoappListEntry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
980 typedef NanoappListEntryBuilder Builder;
981 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
982 VT_APP_ID = 4,
983 VT_VERSION = 6,
984 VT_ENABLED = 8,
985 VT_IS_SYSTEM = 10,
986 VT_PERMISSIONS = 12,
987 VT_RPC_SERVICES = 14
988 };
989 uint64_t app_id() const {
990 return GetField<uint64_t>(VT_APP_ID, 0);
991 }
992 uint32_t version() const {
993 return GetField<uint32_t>(VT_VERSION, 0);
994 }
995 bool enabled() const {
996 return GetField<uint8_t>(VT_ENABLED, 1) != 0;
997 }
998 /// Whether the nanoapp is a pre-loaded "system" nanoapp, i.e. one that should
999 /// not show up in the list of nanoapps in the context hub HAL. System
1000 /// nanoapps are typically used to leverage CHRE for some device functionality
1001 /// and do not interact via the context hub HAL.
1002 bool is_system() const {
1003 return GetField<uint8_t>(VT_IS_SYSTEM, 0) != 0;
1004 }
1005 /// Nanoapp permissions, if supported. Nanoapp permissions are required on
1006 /// CHRE API v1.5+, and are defined in chre/util/system/napp_permissions.h
1007 uint32_t permissions() const {
1008 return GetField<uint32_t>(VT_PERMISSIONS, 0);
1009 }
1010 /// The list of RPC services supported by this nanoapp.
1011 const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappRpcService>> *rpc_services() const {
1012 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappRpcService>> *>(VT_RPC_SERVICES);
1013 }
1014 bool Verify(flatbuffers::Verifier &verifier) const {
1015 return VerifyTableStart(verifier) &&
1016 VerifyField<uint64_t>(verifier, VT_APP_ID) &&
1017 VerifyField<uint32_t>(verifier, VT_VERSION) &&
1018 VerifyField<uint8_t>(verifier, VT_ENABLED) &&
1019 VerifyField<uint8_t>(verifier, VT_IS_SYSTEM) &&
1020 VerifyField<uint32_t>(verifier, VT_PERMISSIONS) &&
1021 VerifyOffset(verifier, VT_RPC_SERVICES) &&
1022 verifier.VerifyVector(rpc_services()) &&
1023 verifier.VerifyVectorOfTables(rpc_services()) &&
1024 verifier.EndTable();
1025 }
1026 };
1027
1028 struct NanoappListEntryBuilder {
1029 typedef NanoappListEntry Table;
1030 flatbuffers::FlatBufferBuilder &fbb_;
1031 flatbuffers::uoffset_t start_;
1032 void add_app_id(uint64_t app_id) {
1033 fbb_.AddElement<uint64_t>(NanoappListEntry::VT_APP_ID, app_id, 0);
1034 }
1035 void add_version(uint32_t version) {
1036 fbb_.AddElement<uint32_t>(NanoappListEntry::VT_VERSION, version, 0);
1037 }
1038 void add_enabled(bool enabled) {
1039 fbb_.AddElement<uint8_t>(NanoappListEntry::VT_ENABLED, static_cast<uint8_t>(enabled), 1);
1040 }
1041 void add_is_system(bool is_system) {
1042 fbb_.AddElement<uint8_t>(NanoappListEntry::VT_IS_SYSTEM, static_cast<uint8_t>(is_system), 0);
1043 }
1044 void add_permissions(uint32_t permissions) {
1045 fbb_.AddElement<uint32_t>(NanoappListEntry::VT_PERMISSIONS, permissions, 0);
1046 }
1047 void add_rpc_services(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappRpcService>>> rpc_services) {
1048 fbb_.AddOffset(NanoappListEntry::VT_RPC_SERVICES, rpc_services);
1049 }
1050 explicit NanoappListEntryBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1051 : fbb_(_fbb) {
1052 start_ = fbb_.StartTable();
1053 }
1054 NanoappListEntryBuilder &operator=(const NanoappListEntryBuilder &);
1055 flatbuffers::Offset<NanoappListEntry> Finish() {
1056 const auto end = fbb_.EndTable(start_);
1057 auto o = flatbuffers::Offset<NanoappListEntry>(end);
1058 return o;
1059 }
1060 };
1061
1062 inline flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntry(
1063 flatbuffers::FlatBufferBuilder &_fbb,
1064 uint64_t app_id = 0,
1065 uint32_t version = 0,
1066 bool enabled = true,
1067 bool is_system = false,
1068 uint32_t permissions = 0,
1069 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappRpcService>>> rpc_services = 0) {
1070 NanoappListEntryBuilder builder_(_fbb);
1071 builder_.add_app_id(app_id);
1072 builder_.add_rpc_services(rpc_services);
1073 builder_.add_permissions(permissions);
1074 builder_.add_version(version);
1075 builder_.add_is_system(is_system);
1076 builder_.add_enabled(enabled);
1077 return builder_.Finish();
1078 }
1079
1080 inline flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntryDirect(
1081 flatbuffers::FlatBufferBuilder &_fbb,
1082 uint64_t app_id = 0,
1083 uint32_t version = 0,
1084 bool enabled = true,
1085 bool is_system = false,
1086 uint32_t permissions = 0,
1087 const std::vector<flatbuffers::Offset<chre::fbs::NanoappRpcService>> *rpc_services = nullptr) {
1088 auto rpc_services__ = rpc_services ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::NanoappRpcService>>(*rpc_services) : 0;
1089 return chre::fbs::CreateNanoappListEntry(
1090 _fbb,
1091 app_id,
1092 version,
1093 enabled,
1094 is_system,
1095 permissions,
1096 rpc_services__);
1097 }
1098
1099 struct NanoappListResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1100 typedef NanoappListResponseBuilder Builder;
1101 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1102 VT_NANOAPPS = 4
1103 };
1104 const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>> *nanoapps() const {
1105 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>> *>(VT_NANOAPPS);
1106 }
1107 bool Verify(flatbuffers::Verifier &verifier) const {
1108 return VerifyTableStart(verifier) &&
1109 VerifyOffsetRequired(verifier, VT_NANOAPPS) &&
1110 verifier.VerifyVector(nanoapps()) &&
1111 verifier.VerifyVectorOfTables(nanoapps()) &&
1112 verifier.EndTable();
1113 }
1114 };
1115
1116 struct NanoappListResponseBuilder {
1117 typedef NanoappListResponse Table;
1118 flatbuffers::FlatBufferBuilder &fbb_;
1119 flatbuffers::uoffset_t start_;
1120 void add_nanoapps(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>>> nanoapps) {
1121 fbb_.AddOffset(NanoappListResponse::VT_NANOAPPS, nanoapps);
1122 }
1123 explicit NanoappListResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1124 : fbb_(_fbb) {
1125 start_ = fbb_.StartTable();
1126 }
1127 NanoappListResponseBuilder &operator=(const NanoappListResponseBuilder &);
1128 flatbuffers::Offset<NanoappListResponse> Finish() {
1129 const auto end = fbb_.EndTable(start_);
1130 auto o = flatbuffers::Offset<NanoappListResponse>(end);
1131 fbb_.Required(o, NanoappListResponse::VT_NANOAPPS);
1132 return o;
1133 }
1134 };
1135
1136 inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse(
1137 flatbuffers::FlatBufferBuilder &_fbb,
1138 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>>> nanoapps = 0) {
1139 NanoappListResponseBuilder builder_(_fbb);
1140 builder_.add_nanoapps(nanoapps);
1141 return builder_.Finish();
1142 }
1143
1144 inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponseDirect(
1145 flatbuffers::FlatBufferBuilder &_fbb,
1146 const std::vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>> *nanoapps = nullptr) {
1147 auto nanoapps__ = nanoapps ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::NanoappListEntry>>(*nanoapps) : 0;
1148 return chre::fbs::CreateNanoappListResponse(
1149 _fbb,
1150 nanoapps__);
1151 }
1152
1153 /// Represents a request for loading a nanoapp.
1154 /// The nanaopp can either be requested to be loaded via a file or via a buffer.
1155 /// For loading via a file, the following steps will be taken:
1156 /// 1. The loader sends a LoadNanoappRequest message to CHRE. app_binary must
1157 /// be set for legacy purposes, but should be empty. Additionally,
1158 /// fragment_id and total_app_size are unused in this request. The loading
1159 /// that happens as part of this request is serialized, but asynchronous
1160 /// meaning that load requests will be processed in the order they are sent
1161 /// but multiple requests can be outstanding at any given time.
1162 /// 2. CHRE stores the filename and waits until its event loop is able to
1163 /// process the request.
1164 /// 3. Once ready, the nanoapp will be loaded from the file specified in the
1165 /// original request and will send a callback indicating the
1166 /// completion/failure of the request.
1167 /// For loading via a buffer, loading may optionally be fragmented into multiple
1168 /// sequential requests, which will follow the following steps:
1169 /// 1. The loader sends a LoadNanoappRequest message to CHRE. If the request
1170 /// is fragmented, then the fields fragment_id and total_app_size must
1171 /// be defined. Once the first fragment is sent to CHRE, all subsequent
1172 /// fragments must be delivered before a new LoadNanoappRequest can be
1173 /// issued. If a new request is received while a current request has
1174 /// outstanding fragments, the current request will be overridden with the
1175 /// new one.
1176 /// 2. CHRE preallocates the required amount of memory, and loads app_binary,
1177 /// appending to already loaded fragments as appropriate.
1178 /// 3. If the request is fragmented, then the requestor must sequentially send
1179 /// multiple LoadNanoappRequest with incremental nanoapp binary fragments.
1180 /// CHRE will respond with LoadNanoappResponse for each request. For
1181 /// requests starting from the second fragment, all fields except
1182 /// fragment_id and app_binary should be ignored by CHRE.
1183 ///
1184 /// Once the LoadNanoappRepsonse for the last fragment is received
1185 /// by the HAL, the HAL client will receive a callback indicating the
1186 /// completion/failure of a load request.
1187 ///
1188 /// If any request fragment is lost, then the entire load request will be
1189 /// considered to have failed. If the request times out (e.g. the requestor
1190 /// process crashes), then the load request will be cancelled at CHRE and fail.
1191 struct LoadNanoappRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1192 typedef LoadNanoappRequestBuilder Builder;
1193 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1194 VT_TRANSACTION_ID = 4,
1195 VT_APP_ID = 6,
1196 VT_APP_VERSION = 8,
1197 VT_TARGET_API_VERSION = 10,
1198 VT_APP_BINARY = 12,
1199 VT_FRAGMENT_ID = 14,
1200 VT_TOTAL_APP_SIZE = 16,
1201 VT_APP_BINARY_FILE_NAME = 18,
1202 VT_APP_FLAGS = 20,
1203 VT_RESPOND_BEFORE_START = 22
1204 };
1205 uint32_t transaction_id() const {
1206 return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
1207 }
1208 uint64_t app_id() const {
1209 return GetField<uint64_t>(VT_APP_ID, 0);
1210 }
1211 uint32_t app_version() const {
1212 return GetField<uint32_t>(VT_APP_VERSION, 0);
1213 }
1214 uint32_t target_api_version() const {
1215 return GetField<uint32_t>(VT_TARGET_API_VERSION, 0);
1216 }
1217 const flatbuffers::Vector<uint8_t> *app_binary() const {
1218 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_APP_BINARY);
1219 }
1220 /// Fields that are relevant for fragmented loading
1221 /// The framgent count starts at 1 and should end at the total number of
1222 /// fragments. For clients that do not support fragmented loading, the
1223 /// default behavior should be to assume one fragment.
1224 uint32_t fragment_id() const {
1225 return GetField<uint32_t>(VT_FRAGMENT_ID, 0);
1226 }
1227 uint32_t total_app_size() const {
1228 return GetField<uint32_t>(VT_TOTAL_APP_SIZE, 0);
1229 }
1230 /// Null-terminated ASCII string containing the file name that contains the
1231 /// app binary to be loaded.
1232 const flatbuffers::Vector<int8_t> *app_binary_file_name() const {
1233 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_APP_BINARY_FILE_NAME);
1234 }
1235 /// The nanoapp flag values from the nanoapp header defined in
1236 /// build/build_template.mk. Refer to that file for more details.
1237 uint32_t app_flags() const {
1238 return GetField<uint32_t>(VT_APP_FLAGS, 0);
1239 }
1240 /// If true and fragmented loading is requested, the LoadNanoappResponse
1241 /// for the last fragment will be sent after the fragment was confirmed
1242 /// to be placed in memory and no additional response will be sent after
1243 /// the nanoapp is linked and started in the framework.
1244 bool respond_before_start() const {
1245 return GetField<uint8_t>(VT_RESPOND_BEFORE_START, 0) != 0;
1246 }
1247 bool Verify(flatbuffers::Verifier &verifier) const {
1248 return VerifyTableStart(verifier) &&
1249 VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
1250 VerifyField<uint64_t>(verifier, VT_APP_ID) &&
1251 VerifyField<uint32_t>(verifier, VT_APP_VERSION) &&
1252 VerifyField<uint32_t>(verifier, VT_TARGET_API_VERSION) &&
1253 VerifyOffsetRequired(verifier, VT_APP_BINARY) &&
1254 verifier.VerifyVector(app_binary()) &&
1255 VerifyField<uint32_t>(verifier, VT_FRAGMENT_ID) &&
1256 VerifyField<uint32_t>(verifier, VT_TOTAL_APP_SIZE) &&
1257 VerifyOffset(verifier, VT_APP_BINARY_FILE_NAME) &&
1258 verifier.VerifyVector(app_binary_file_name()) &&
1259 VerifyField<uint32_t>(verifier, VT_APP_FLAGS) &&
1260 VerifyField<uint8_t>(verifier, VT_RESPOND_BEFORE_START) &&
1261 verifier.EndTable();
1262 }
1263 };
1264
1265 struct LoadNanoappRequestBuilder {
1266 typedef LoadNanoappRequest Table;
1267 flatbuffers::FlatBufferBuilder &fbb_;
1268 flatbuffers::uoffset_t start_;
1269 void add_transaction_id(uint32_t transaction_id) {
1270 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TRANSACTION_ID, transaction_id, 0);
1271 }
1272 void add_app_id(uint64_t app_id) {
1273 fbb_.AddElement<uint64_t>(LoadNanoappRequest::VT_APP_ID, app_id, 0);
1274 }
1275 void add_app_version(uint32_t app_version) {
1276 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_APP_VERSION, app_version, 0);
1277 }
1278 void add_target_api_version(uint32_t target_api_version) {
1279 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TARGET_API_VERSION, target_api_version, 0);
1280 }
1281 void add_app_binary(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary) {
1282 fbb_.AddOffset(LoadNanoappRequest::VT_APP_BINARY, app_binary);
1283 }
1284 void add_fragment_id(uint32_t fragment_id) {
1285 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_FRAGMENT_ID, fragment_id, 0);
1286 }
1287 void add_total_app_size(uint32_t total_app_size) {
1288 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TOTAL_APP_SIZE, total_app_size, 0);
1289 }
1290 void add_app_binary_file_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> app_binary_file_name) {
1291 fbb_.AddOffset(LoadNanoappRequest::VT_APP_BINARY_FILE_NAME, app_binary_file_name);
1292 }
1293 void add_app_flags(uint32_t app_flags) {
1294 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_APP_FLAGS, app_flags, 0);
1295 }
1296 void add_respond_before_start(bool respond_before_start) {
1297 fbb_.AddElement<uint8_t>(LoadNanoappRequest::VT_RESPOND_BEFORE_START, static_cast<uint8_t>(respond_before_start), 0);
1298 }
1299 explicit LoadNanoappRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1300 : fbb_(_fbb) {
1301 start_ = fbb_.StartTable();
1302 }
1303 LoadNanoappRequestBuilder &operator=(const LoadNanoappRequestBuilder &);
1304 flatbuffers::Offset<LoadNanoappRequest> Finish() {
1305 const auto end = fbb_.EndTable(start_);
1306 auto o = flatbuffers::Offset<LoadNanoappRequest>(end);
1307 fbb_.Required(o, LoadNanoappRequest::VT_APP_BINARY);
1308 return o;
1309 }
1310 };
1311
1312 inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest(
1313 flatbuffers::FlatBufferBuilder &_fbb,
1314 uint32_t transaction_id = 0,
1315 uint64_t app_id = 0,
1316 uint32_t app_version = 0,
1317 uint32_t target_api_version = 0,
1318 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary = 0,
1319 uint32_t fragment_id = 0,
1320 uint32_t total_app_size = 0,
1321 flatbuffers::Offset<flatbuffers::Vector<int8_t>> app_binary_file_name = 0,
1322 uint32_t app_flags = 0,
1323 bool respond_before_start = false) {
1324 LoadNanoappRequestBuilder builder_(_fbb);
1325 builder_.add_app_id(app_id);
1326 builder_.add_app_flags(app_flags);
1327 builder_.add_app_binary_file_name(app_binary_file_name);
1328 builder_.add_total_app_size(total_app_size);
1329 builder_.add_fragment_id(fragment_id);
1330 builder_.add_app_binary(app_binary);
1331 builder_.add_target_api_version(target_api_version);
1332 builder_.add_app_version(app_version);
1333 builder_.add_transaction_id(transaction_id);
1334 builder_.add_respond_before_start(respond_before_start);
1335 return builder_.Finish();
1336 }
1337
1338 inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequestDirect(
1339 flatbuffers::FlatBufferBuilder &_fbb,
1340 uint32_t transaction_id = 0,
1341 uint64_t app_id = 0,
1342 uint32_t app_version = 0,
1343 uint32_t target_api_version = 0,
1344 const std::vector<uint8_t> *app_binary = nullptr,
1345 uint32_t fragment_id = 0,
1346 uint32_t total_app_size = 0,
1347 const std::vector<int8_t> *app_binary_file_name = nullptr,
1348 uint32_t app_flags = 0,
1349 bool respond_before_start = false) {
1350 auto app_binary__ = app_binary ? _fbb.CreateVector<uint8_t>(*app_binary) : 0;
1351 auto app_binary_file_name__ = app_binary_file_name ? _fbb.CreateVector<int8_t>(*app_binary_file_name) : 0;
1352 return chre::fbs::CreateLoadNanoappRequest(
1353 _fbb,
1354 transaction_id,
1355 app_id,
1356 app_version,
1357 target_api_version,
1358 app_binary__,
1359 fragment_id,
1360 total_app_size,
1361 app_binary_file_name__,
1362 app_flags,
1363 respond_before_start);
1364 }
1365
1366 struct LoadNanoappResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1367 typedef LoadNanoappResponseBuilder Builder;
1368 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1369 VT_TRANSACTION_ID = 4,
1370 VT_SUCCESS = 6,
1371 VT_FRAGMENT_ID = 8
1372 };
1373 uint32_t transaction_id() const {
1374 return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
1375 }
1376 /// Denotes whether a load request succeeded or failed.
1377 /// If any fragment of a load request fails, the entire load request for
1378 /// the same transaction will fail.
1379 bool success() const {
1380 return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
1381 }
1382 /// The fragment count of the load reponse is for.
1383 uint32_t fragment_id() const {
1384 return GetField<uint32_t>(VT_FRAGMENT_ID, 0);
1385 }
1386 bool Verify(flatbuffers::Verifier &verifier) const {
1387 return VerifyTableStart(verifier) &&
1388 VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
1389 VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
1390 VerifyField<uint32_t>(verifier, VT_FRAGMENT_ID) &&
1391 verifier.EndTable();
1392 }
1393 };
1394
1395 struct LoadNanoappResponseBuilder {
1396 typedef LoadNanoappResponse Table;
1397 flatbuffers::FlatBufferBuilder &fbb_;
1398 flatbuffers::uoffset_t start_;
1399 void add_transaction_id(uint32_t transaction_id) {
1400 fbb_.AddElement<uint32_t>(LoadNanoappResponse::VT_TRANSACTION_ID, transaction_id, 0);
1401 }
1402 void add_success(bool success) {
1403 fbb_.AddElement<uint8_t>(LoadNanoappResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0);
1404 }
1405 void add_fragment_id(uint32_t fragment_id) {
1406 fbb_.AddElement<uint32_t>(LoadNanoappResponse::VT_FRAGMENT_ID, fragment_id, 0);
1407 }
1408 explicit LoadNanoappResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1409 : fbb_(_fbb) {
1410 start_ = fbb_.StartTable();
1411 }
1412 LoadNanoappResponseBuilder &operator=(const LoadNanoappResponseBuilder &);
1413 flatbuffers::Offset<LoadNanoappResponse> Finish() {
1414 const auto end = fbb_.EndTable(start_);
1415 auto o = flatbuffers::Offset<LoadNanoappResponse>(end);
1416 return o;
1417 }
1418 };
1419
1420 inline flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse(
1421 flatbuffers::FlatBufferBuilder &_fbb,
1422 uint32_t transaction_id = 0,
1423 bool success = false,
1424 uint32_t fragment_id = 0) {
1425 LoadNanoappResponseBuilder builder_(_fbb);
1426 builder_.add_fragment_id(fragment_id);
1427 builder_.add_transaction_id(transaction_id);
1428 builder_.add_success(success);
1429 return builder_.Finish();
1430 }
1431
1432 struct UnloadNanoappRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1433 typedef UnloadNanoappRequestBuilder Builder;
1434 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1435 VT_TRANSACTION_ID = 4,
1436 VT_APP_ID = 6,
1437 VT_ALLOW_SYSTEM_NANOAPP_UNLOAD = 8
1438 };
1439 uint32_t transaction_id() const {
1440 return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
1441 }
1442 uint64_t app_id() const {
1443 return GetField<uint64_t>(VT_APP_ID, 0);
1444 }
1445 /// Set to true to allow this request to unload nanoapps identified as "system
1446 /// nanoapps", i.e. ones with is_system set to true in NanoappListResponse.
1447 bool allow_system_nanoapp_unload() const {
1448 return GetField<uint8_t>(VT_ALLOW_SYSTEM_NANOAPP_UNLOAD, 0) != 0;
1449 }
1450 bool Verify(flatbuffers::Verifier &verifier) const {
1451 return VerifyTableStart(verifier) &&
1452 VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
1453 VerifyField<uint64_t>(verifier, VT_APP_ID) &&
1454 VerifyField<uint8_t>(verifier, VT_ALLOW_SYSTEM_NANOAPP_UNLOAD) &&
1455 verifier.EndTable();
1456 }
1457 };
1458
1459 struct UnloadNanoappRequestBuilder {
1460 typedef UnloadNanoappRequest Table;
1461 flatbuffers::FlatBufferBuilder &fbb_;
1462 flatbuffers::uoffset_t start_;
1463 void add_transaction_id(uint32_t transaction_id) {
1464 fbb_.AddElement<uint32_t>(UnloadNanoappRequest::VT_TRANSACTION_ID, transaction_id, 0);
1465 }
1466 void add_app_id(uint64_t app_id) {
1467 fbb_.AddElement<uint64_t>(UnloadNanoappRequest::VT_APP_ID, app_id, 0);
1468 }
1469 void add_allow_system_nanoapp_unload(bool allow_system_nanoapp_unload) {
1470 fbb_.AddElement<uint8_t>(UnloadNanoappRequest::VT_ALLOW_SYSTEM_NANOAPP_UNLOAD, static_cast<uint8_t>(allow_system_nanoapp_unload), 0);
1471 }
1472 explicit UnloadNanoappRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1473 : fbb_(_fbb) {
1474 start_ = fbb_.StartTable();
1475 }
1476 UnloadNanoappRequestBuilder &operator=(const UnloadNanoappRequestBuilder &);
1477 flatbuffers::Offset<UnloadNanoappRequest> Finish() {
1478 const auto end = fbb_.EndTable(start_);
1479 auto o = flatbuffers::Offset<UnloadNanoappRequest>(end);
1480 return o;
1481 }
1482 };
1483
1484 inline flatbuffers::Offset<UnloadNanoappRequest> CreateUnloadNanoappRequest(
1485 flatbuffers::FlatBufferBuilder &_fbb,
1486 uint32_t transaction_id = 0,
1487 uint64_t app_id = 0,
1488 bool allow_system_nanoapp_unload = false) {
1489 UnloadNanoappRequestBuilder builder_(_fbb);
1490 builder_.add_app_id(app_id);
1491 builder_.add_transaction_id(transaction_id);
1492 builder_.add_allow_system_nanoapp_unload(allow_system_nanoapp_unload);
1493 return builder_.Finish();
1494 }
1495
1496 struct UnloadNanoappResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1497 typedef UnloadNanoappResponseBuilder Builder;
1498 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1499 VT_TRANSACTION_ID = 4,
1500 VT_SUCCESS = 6
1501 };
1502 uint32_t transaction_id() const {
1503 return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
1504 }
1505 bool success() const {
1506 return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
1507 }
1508 bool Verify(flatbuffers::Verifier &verifier) const {
1509 return VerifyTableStart(verifier) &&
1510 VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
1511 VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
1512 verifier.EndTable();
1513 }
1514 };
1515
1516 struct UnloadNanoappResponseBuilder {
1517 typedef UnloadNanoappResponse Table;
1518 flatbuffers::FlatBufferBuilder &fbb_;
1519 flatbuffers::uoffset_t start_;
1520 void add_transaction_id(uint32_t transaction_id) {
1521 fbb_.AddElement<uint32_t>(UnloadNanoappResponse::VT_TRANSACTION_ID, transaction_id, 0);
1522 }
1523 void add_success(bool success) {
1524 fbb_.AddElement<uint8_t>(UnloadNanoappResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0);
1525 }
1526 explicit UnloadNanoappResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1527 : fbb_(_fbb) {
1528 start_ = fbb_.StartTable();
1529 }
1530 UnloadNanoappResponseBuilder &operator=(const UnloadNanoappResponseBuilder &);
1531 flatbuffers::Offset<UnloadNanoappResponse> Finish() {
1532 const auto end = fbb_.EndTable(start_);
1533 auto o = flatbuffers::Offset<UnloadNanoappResponse>(end);
1534 return o;
1535 }
1536 };
1537
1538 inline flatbuffers::Offset<UnloadNanoappResponse> CreateUnloadNanoappResponse(
1539 flatbuffers::FlatBufferBuilder &_fbb,
1540 uint32_t transaction_id = 0,
1541 bool success = false) {
1542 UnloadNanoappResponseBuilder builder_(_fbb);
1543 builder_.add_transaction_id(transaction_id);
1544 builder_.add_success(success);
1545 return builder_.Finish();
1546 }
1547
1548 /// Represents log messages from CHRE.
1549 struct LogMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1550 typedef LogMessageBuilder Builder;
1551 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1552 VT_BUFFER = 4
1553 };
1554 /// A buffer containing formatted log data. A flat array is used here to avoid
1555 /// overhead in serializing and deserializing. The format is as follows:
1556 ///
1557 /// uint8_t - log level (1 = error, 2 = warning,
1558 /// 3 = info, 4 = debug)
1559 /// uint64_t, little-endian - timestamp in nanoseconds
1560 /// char[] - message to log
1561 /// char, \0 - null-terminator
1562 ///
1563 /// This pattern repeats until the end of the buffer for multiple log
1564 /// messages. The last byte will always be a null-terminator. There are no
1565 /// padding bytes between these fields. Treat this like a packed struct and be
1566 /// cautious with unaligned access when reading/writing this buffer.
1567 const flatbuffers::Vector<int8_t> *buffer() const {
1568 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_BUFFER);
1569 }
1570 bool Verify(flatbuffers::Verifier &verifier) const {
1571 return VerifyTableStart(verifier) &&
1572 VerifyOffset(verifier, VT_BUFFER) &&
1573 verifier.VerifyVector(buffer()) &&
1574 verifier.EndTable();
1575 }
1576 };
1577
1578 struct LogMessageBuilder {
1579 typedef LogMessage Table;
1580 flatbuffers::FlatBufferBuilder &fbb_;
1581 flatbuffers::uoffset_t start_;
1582 void add_buffer(flatbuffers::Offset<flatbuffers::Vector<int8_t>> buffer) {
1583 fbb_.AddOffset(LogMessage::VT_BUFFER, buffer);
1584 }
1585 explicit LogMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1586 : fbb_(_fbb) {
1587 start_ = fbb_.StartTable();
1588 }
1589 LogMessageBuilder &operator=(const LogMessageBuilder &);
1590 flatbuffers::Offset<LogMessage> Finish() {
1591 const auto end = fbb_.EndTable(start_);
1592 auto o = flatbuffers::Offset<LogMessage>(end);
1593 return o;
1594 }
1595 };
1596
1597 inline flatbuffers::Offset<LogMessage> CreateLogMessage(
1598 flatbuffers::FlatBufferBuilder &_fbb,
1599 flatbuffers::Offset<flatbuffers::Vector<int8_t>> buffer = 0) {
1600 LogMessageBuilder builder_(_fbb);
1601 builder_.add_buffer(buffer);
1602 return builder_.Finish();
1603 }
1604
1605 inline flatbuffers::Offset<LogMessage> CreateLogMessageDirect(
1606 flatbuffers::FlatBufferBuilder &_fbb,
1607 const std::vector<int8_t> *buffer = nullptr) {
1608 auto buffer__ = buffer ? _fbb.CreateVector<int8_t>(*buffer) : 0;
1609 return chre::fbs::CreateLogMessage(
1610 _fbb,
1611 buffer__);
1612 }
1613
1614 /// Represents a message sent to CHRE to indicate AP timestamp for time sync
1615 struct TimeSyncMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1616 typedef TimeSyncMessageBuilder Builder;
1617 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1618 VT_OFFSET = 4
1619 };
1620 /// Offset between AP and CHRE timestamp
1621 int64_t offset() const {
1622 return GetField<int64_t>(VT_OFFSET, 0);
1623 }
1624 bool Verify(flatbuffers::Verifier &verifier) const {
1625 return VerifyTableStart(verifier) &&
1626 VerifyField<int64_t>(verifier, VT_OFFSET) &&
1627 verifier.EndTable();
1628 }
1629 };
1630
1631 struct TimeSyncMessageBuilder {
1632 typedef TimeSyncMessage Table;
1633 flatbuffers::FlatBufferBuilder &fbb_;
1634 flatbuffers::uoffset_t start_;
1635 void add_offset(int64_t offset) {
1636 fbb_.AddElement<int64_t>(TimeSyncMessage::VT_OFFSET, offset, 0);
1637 }
1638 explicit TimeSyncMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1639 : fbb_(_fbb) {
1640 start_ = fbb_.StartTable();
1641 }
1642 TimeSyncMessageBuilder &operator=(const TimeSyncMessageBuilder &);
1643 flatbuffers::Offset<TimeSyncMessage> Finish() {
1644 const auto end = fbb_.EndTable(start_);
1645 auto o = flatbuffers::Offset<TimeSyncMessage>(end);
1646 return o;
1647 }
1648 };
1649
1650 inline flatbuffers::Offset<TimeSyncMessage> CreateTimeSyncMessage(
1651 flatbuffers::FlatBufferBuilder &_fbb,
1652 int64_t offset = 0) {
1653 TimeSyncMessageBuilder builder_(_fbb);
1654 builder_.add_offset(offset);
1655 return builder_.Finish();
1656 }
1657
1658 /// A request to gather and return debugging information. Only one debug dump
1659 /// session can be active at a time. Upon accepting a request, zero or more
1660 /// DebugDumpData messages are generated, followed by a DebugDumpResponse
1661 /// indicating the completion of the operation.
1662 struct DebugDumpRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1663 typedef DebugDumpRequestBuilder Builder;
1664 bool Verify(flatbuffers::Verifier &verifier) const {
1665 return VerifyTableStart(verifier) &&
1666 verifier.EndTable();
1667 }
1668 };
1669
1670 struct DebugDumpRequestBuilder {
1671 typedef DebugDumpRequest Table;
1672 flatbuffers::FlatBufferBuilder &fbb_;
1673 flatbuffers::uoffset_t start_;
1674 explicit DebugDumpRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1675 : fbb_(_fbb) {
1676 start_ = fbb_.StartTable();
1677 }
1678 DebugDumpRequestBuilder &operator=(const DebugDumpRequestBuilder &);
1679 flatbuffers::Offset<DebugDumpRequest> Finish() {
1680 const auto end = fbb_.EndTable(start_);
1681 auto o = flatbuffers::Offset<DebugDumpRequest>(end);
1682 return o;
1683 }
1684 };
1685
1686 inline flatbuffers::Offset<DebugDumpRequest> CreateDebugDumpRequest(
1687 flatbuffers::FlatBufferBuilder &_fbb) {
1688 DebugDumpRequestBuilder builder_(_fbb);
1689 return builder_.Finish();
1690 }
1691
1692 struct DebugDumpData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1693 typedef DebugDumpDataBuilder Builder;
1694 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1695 VT_DEBUG_STR = 4
1696 };
1697 /// Null-terminated ASCII string containing debugging information
1698 const flatbuffers::Vector<int8_t> *debug_str() const {
1699 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_DEBUG_STR);
1700 }
1701 bool Verify(flatbuffers::Verifier &verifier) const {
1702 return VerifyTableStart(verifier) &&
1703 VerifyOffset(verifier, VT_DEBUG_STR) &&
1704 verifier.VerifyVector(debug_str()) &&
1705 verifier.EndTable();
1706 }
1707 };
1708
1709 struct DebugDumpDataBuilder {
1710 typedef DebugDumpData Table;
1711 flatbuffers::FlatBufferBuilder &fbb_;
1712 flatbuffers::uoffset_t start_;
1713 void add_debug_str(flatbuffers::Offset<flatbuffers::Vector<int8_t>> debug_str) {
1714 fbb_.AddOffset(DebugDumpData::VT_DEBUG_STR, debug_str);
1715 }
1716 explicit DebugDumpDataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1717 : fbb_(_fbb) {
1718 start_ = fbb_.StartTable();
1719 }
1720 DebugDumpDataBuilder &operator=(const DebugDumpDataBuilder &);
1721 flatbuffers::Offset<DebugDumpData> Finish() {
1722 const auto end = fbb_.EndTable(start_);
1723 auto o = flatbuffers::Offset<DebugDumpData>(end);
1724 return o;
1725 }
1726 };
1727
1728 inline flatbuffers::Offset<DebugDumpData> CreateDebugDumpData(
1729 flatbuffers::FlatBufferBuilder &_fbb,
1730 flatbuffers::Offset<flatbuffers::Vector<int8_t>> debug_str = 0) {
1731 DebugDumpDataBuilder builder_(_fbb);
1732 builder_.add_debug_str(debug_str);
1733 return builder_.Finish();
1734 }
1735
1736 inline flatbuffers::Offset<DebugDumpData> CreateDebugDumpDataDirect(
1737 flatbuffers::FlatBufferBuilder &_fbb,
1738 const std::vector<int8_t> *debug_str = nullptr) {
1739 auto debug_str__ = debug_str ? _fbb.CreateVector<int8_t>(*debug_str) : 0;
1740 return chre::fbs::CreateDebugDumpData(
1741 _fbb,
1742 debug_str__);
1743 }
1744
1745 struct DebugDumpResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1746 typedef DebugDumpResponseBuilder Builder;
1747 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1748 VT_SUCCESS = 4,
1749 VT_DATA_COUNT = 6
1750 };
1751 /// true if the request was accepted and a dump was performed, false if it was
1752 /// rejected or failed to complete for some reason
1753 bool success() const {
1754 return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
1755 }
1756 /// The number of DebugDumpData messages sent in this session
1757 uint32_t data_count() const {
1758 return GetField<uint32_t>(VT_DATA_COUNT, 0);
1759 }
1760 bool Verify(flatbuffers::Verifier &verifier) const {
1761 return VerifyTableStart(verifier) &&
1762 VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
1763 VerifyField<uint32_t>(verifier, VT_DATA_COUNT) &&
1764 verifier.EndTable();
1765 }
1766 };
1767
1768 struct DebugDumpResponseBuilder {
1769 typedef DebugDumpResponse Table;
1770 flatbuffers::FlatBufferBuilder &fbb_;
1771 flatbuffers::uoffset_t start_;
1772 void add_success(bool success) {
1773 fbb_.AddElement<uint8_t>(DebugDumpResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0);
1774 }
1775 void add_data_count(uint32_t data_count) {
1776 fbb_.AddElement<uint32_t>(DebugDumpResponse::VT_DATA_COUNT, data_count, 0);
1777 }
1778 explicit DebugDumpResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1779 : fbb_(_fbb) {
1780 start_ = fbb_.StartTable();
1781 }
1782 DebugDumpResponseBuilder &operator=(const DebugDumpResponseBuilder &);
1783 flatbuffers::Offset<DebugDumpResponse> Finish() {
1784 const auto end = fbb_.EndTable(start_);
1785 auto o = flatbuffers::Offset<DebugDumpResponse>(end);
1786 return o;
1787 }
1788 };
1789
1790 inline flatbuffers::Offset<DebugDumpResponse> CreateDebugDumpResponse(
1791 flatbuffers::FlatBufferBuilder &_fbb,
1792 bool success = false,
1793 uint32_t data_count = 0) {
1794 DebugDumpResponseBuilder builder_(_fbb);
1795 builder_.add_data_count(data_count);
1796 builder_.add_success(success);
1797 return builder_.Finish();
1798 }
1799
1800 /// A request from CHRE for host to initiate a time sync message
1801 /// (system feature, platform-specific - not all platforms necessarily use this)
1802 struct TimeSyncRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1803 typedef TimeSyncRequestBuilder Builder;
1804 bool Verify(flatbuffers::Verifier &verifier) const {
1805 return VerifyTableStart(verifier) &&
1806 verifier.EndTable();
1807 }
1808 };
1809
1810 struct TimeSyncRequestBuilder {
1811 typedef TimeSyncRequest Table;
1812 flatbuffers::FlatBufferBuilder &fbb_;
1813 flatbuffers::uoffset_t start_;
1814 explicit TimeSyncRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1815 : fbb_(_fbb) {
1816 start_ = fbb_.StartTable();
1817 }
1818 TimeSyncRequestBuilder &operator=(const TimeSyncRequestBuilder &);
1819 flatbuffers::Offset<TimeSyncRequest> Finish() {
1820 const auto end = fbb_.EndTable(start_);
1821 auto o = flatbuffers::Offset<TimeSyncRequest>(end);
1822 return o;
1823 }
1824 };
1825
1826 inline flatbuffers::Offset<TimeSyncRequest> CreateTimeSyncRequest(
1827 flatbuffers::FlatBufferBuilder &_fbb) {
1828 TimeSyncRequestBuilder builder_(_fbb);
1829 return builder_.Finish();
1830 }
1831
1832 /// Request from CHRE to enable direct access to data from the low-power
1833 /// microphone. On some systems, coordination via the AP (e.g. with
1834 /// SoundTrigger HAL) is needed to ensure this capability is powered up when
1835 /// CHRE needs it. The host does not send a response.
1836 struct LowPowerMicAccessRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1837 typedef LowPowerMicAccessRequestBuilder Builder;
1838 bool Verify(flatbuffers::Verifier &verifier) const {
1839 return VerifyTableStart(verifier) &&
1840 verifier.EndTable();
1841 }
1842 };
1843
1844 struct LowPowerMicAccessRequestBuilder {
1845 typedef LowPowerMicAccessRequest Table;
1846 flatbuffers::FlatBufferBuilder &fbb_;
1847 flatbuffers::uoffset_t start_;
1848 explicit LowPowerMicAccessRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1849 : fbb_(_fbb) {
1850 start_ = fbb_.StartTable();
1851 }
1852 LowPowerMicAccessRequestBuilder &operator=(const LowPowerMicAccessRequestBuilder &);
1853 flatbuffers::Offset<LowPowerMicAccessRequest> Finish() {
1854 const auto end = fbb_.EndTable(start_);
1855 auto o = flatbuffers::Offset<LowPowerMicAccessRequest>(end);
1856 return o;
1857 }
1858 };
1859
1860 inline flatbuffers::Offset<LowPowerMicAccessRequest> CreateLowPowerMicAccessRequest(
1861 flatbuffers::FlatBufferBuilder &_fbb) {
1862 LowPowerMicAccessRequestBuilder builder_(_fbb);
1863 return builder_.Finish();
1864 }
1865
1866 /// Notification from CHRE that it no longer needs direct access to low-power
1867 /// microphone data.
1868 struct LowPowerMicAccessRelease FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1869 typedef LowPowerMicAccessReleaseBuilder Builder;
1870 bool Verify(flatbuffers::Verifier &verifier) const {
1871 return VerifyTableStart(verifier) &&
1872 verifier.EndTable();
1873 }
1874 };
1875
1876 struct LowPowerMicAccessReleaseBuilder {
1877 typedef LowPowerMicAccessRelease Table;
1878 flatbuffers::FlatBufferBuilder &fbb_;
1879 flatbuffers::uoffset_t start_;
1880 explicit LowPowerMicAccessReleaseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1881 : fbb_(_fbb) {
1882 start_ = fbb_.StartTable();
1883 }
1884 LowPowerMicAccessReleaseBuilder &operator=(const LowPowerMicAccessReleaseBuilder &);
1885 flatbuffers::Offset<LowPowerMicAccessRelease> Finish() {
1886 const auto end = fbb_.EndTable(start_);
1887 auto o = flatbuffers::Offset<LowPowerMicAccessRelease>(end);
1888 return o;
1889 }
1890 };
1891
1892 inline flatbuffers::Offset<LowPowerMicAccessRelease> CreateLowPowerMicAccessRelease(
1893 flatbuffers::FlatBufferBuilder &_fbb) {
1894 LowPowerMicAccessReleaseBuilder builder_(_fbb);
1895 return builder_.Finish();
1896 }
1897
1898 /// Notification from the host that a system setting has changed
1899 struct SettingChangeMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1900 typedef SettingChangeMessageBuilder Builder;
1901 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1902 VT_SETTING = 4,
1903 VT_STATE = 6
1904 };
1905 /// The setting that has changed
1906 chre::fbs::Setting setting() const {
1907 return static_cast<chre::fbs::Setting>(GetField<int8_t>(VT_SETTING, 0));
1908 }
1909 /// The new setting value
1910 chre::fbs::SettingState state() const {
1911 return static_cast<chre::fbs::SettingState>(GetField<int8_t>(VT_STATE, 0));
1912 }
1913 bool Verify(flatbuffers::Verifier &verifier) const {
1914 return VerifyTableStart(verifier) &&
1915 VerifyField<int8_t>(verifier, VT_SETTING) &&
1916 VerifyField<int8_t>(verifier, VT_STATE) &&
1917 verifier.EndTable();
1918 }
1919 };
1920
1921 struct SettingChangeMessageBuilder {
1922 typedef SettingChangeMessage Table;
1923 flatbuffers::FlatBufferBuilder &fbb_;
1924 flatbuffers::uoffset_t start_;
1925 void add_setting(chre::fbs::Setting setting) {
1926 fbb_.AddElement<int8_t>(SettingChangeMessage::VT_SETTING, static_cast<int8_t>(setting), 0);
1927 }
1928 void add_state(chre::fbs::SettingState state) {
1929 fbb_.AddElement<int8_t>(SettingChangeMessage::VT_STATE, static_cast<int8_t>(state), 0);
1930 }
1931 explicit SettingChangeMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1932 : fbb_(_fbb) {
1933 start_ = fbb_.StartTable();
1934 }
1935 SettingChangeMessageBuilder &operator=(const SettingChangeMessageBuilder &);
1936 flatbuffers::Offset<SettingChangeMessage> Finish() {
1937 const auto end = fbb_.EndTable(start_);
1938 auto o = flatbuffers::Offset<SettingChangeMessage>(end);
1939 return o;
1940 }
1941 };
1942
1943 inline flatbuffers::Offset<SettingChangeMessage> CreateSettingChangeMessage(
1944 flatbuffers::FlatBufferBuilder &_fbb,
1945 chre::fbs::Setting setting = chre::fbs::Setting::LOCATION,
1946 chre::fbs::SettingState state = chre::fbs::SettingState::DISABLED) {
1947 SettingChangeMessageBuilder builder_(_fbb);
1948 builder_.add_state(state);
1949 builder_.add_setting(setting);
1950 return builder_.Finish();
1951 }
1952
1953 /// Represents V2 log messages from CHRE.
1954 struct LogMessageV2 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1955 typedef LogMessageV2Builder Builder;
1956 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1957 VT_BUFFER = 4,
1958 VT_NUM_LOGS_DROPPED = 6
1959 };
1960 /// A buffer containing formatted log data. A flat array is used here to avoid
1961 /// overhead in serializing and deserializing. The format is as follows:
1962 ///
1963 /// uint8_t - Log metadata, encoded as follows:
1964 /// [EI(Upper nibble) | Level(Lower nibble)]
1965 /// * Log Type
1966 /// (0 = No encoding, 1 = Tokenized log, 2 = BT snoop log)
1967 /// * LogBuffer log level (1 = error, 2 = warn,
1968 /// 3 = info, 4 = debug,
1969 /// 5 = verbose)
1970 /// uint32_t, little-endian - timestamp in milliseconds
1971 /// char[] - Log data buffer
1972 ///
1973 /// The log data buffer format is as follows:
1974 /// * Unencoded (string) logs: The log buffer can be interpreted as a NULL
1975 /// terminated string (eg: pass to string manipulation functions, get its
1976 /// size via strlen(), etc.).
1977 ///
1978 /// * Encoded logs: The first byte of the log buffer indicates the size of
1979 /// the actual encoded data to follow. For example, if a tokenized log of
1980 /// size 24 bytes were to be represented, a buffer of size 25 bytes would
1981 /// be needed to encode this as: [Size(1B) | Data(24B)]. A decoder would
1982 /// then have to decode this starting from a 1 byte offset from the
1983 /// received buffer.
1984 ///
1985 /// * Bt Snoop logs: The first byte of the log buffer indicates the direction
1986 /// of the bt snoop log, depending on whether it is incoming for the BT
1987 /// controller or outgoing to the arbiter. The second byte indicates the size
1988 /// of the actual BT payload followed. For example, if a bt snoop log of
1989 /// size 24 bytes were to be represented, a buffer of size 26 bytes would
1990 /// be needed to encode this as: [Direction(1B) | Size(1B) | Data(24B)].
1991 ///
1992 /// This pattern repeats until the end of the buffer for multiple log
1993 /// messages. The last byte will always be a null-terminator. There are no
1994 /// padding bytes between these fields. Treat this like a packed struct and be
1995 /// cautious with unaligned access when reading/writing this buffer.
1996 /// Note that the log message might not be null-terminated if an encoding is
1997 /// used.
1998 const flatbuffers::Vector<int8_t> *buffer() const {
1999 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_BUFFER);
2000 }
2001 /// The number of logs dropped since CHRE started
2002 uint32_t num_logs_dropped() const {
2003 return GetField<uint32_t>(VT_NUM_LOGS_DROPPED, 0);
2004 }
2005 bool Verify(flatbuffers::Verifier &verifier) const {
2006 return VerifyTableStart(verifier) &&
2007 VerifyOffset(verifier, VT_BUFFER) &&
2008 verifier.VerifyVector(buffer()) &&
2009 VerifyField<uint32_t>(verifier, VT_NUM_LOGS_DROPPED) &&
2010 verifier.EndTable();
2011 }
2012 };
2013
2014 struct LogMessageV2Builder {
2015 typedef LogMessageV2 Table;
2016 flatbuffers::FlatBufferBuilder &fbb_;
2017 flatbuffers::uoffset_t start_;
2018 void add_buffer(flatbuffers::Offset<flatbuffers::Vector<int8_t>> buffer) {
2019 fbb_.AddOffset(LogMessageV2::VT_BUFFER, buffer);
2020 }
2021 void add_num_logs_dropped(uint32_t num_logs_dropped) {
2022 fbb_.AddElement<uint32_t>(LogMessageV2::VT_NUM_LOGS_DROPPED, num_logs_dropped, 0);
2023 }
2024 explicit LogMessageV2Builder(flatbuffers::FlatBufferBuilder &_fbb)
2025 : fbb_(_fbb) {
2026 start_ = fbb_.StartTable();
2027 }
2028 LogMessageV2Builder &operator=(const LogMessageV2Builder &);
2029 flatbuffers::Offset<LogMessageV2> Finish() {
2030 const auto end = fbb_.EndTable(start_);
2031 auto o = flatbuffers::Offset<LogMessageV2>(end);
2032 return o;
2033 }
2034 };
2035
2036 inline flatbuffers::Offset<LogMessageV2> CreateLogMessageV2(
2037 flatbuffers::FlatBufferBuilder &_fbb,
2038 flatbuffers::Offset<flatbuffers::Vector<int8_t>> buffer = 0,
2039 uint32_t num_logs_dropped = 0) {
2040 LogMessageV2Builder builder_(_fbb);
2041 builder_.add_num_logs_dropped(num_logs_dropped);
2042 builder_.add_buffer(buffer);
2043 return builder_.Finish();
2044 }
2045
2046 inline flatbuffers::Offset<LogMessageV2> CreateLogMessageV2Direct(
2047 flatbuffers::FlatBufferBuilder &_fbb,
2048 const std::vector<int8_t> *buffer = nullptr,
2049 uint32_t num_logs_dropped = 0) {
2050 auto buffer__ = buffer ? _fbb.CreateVector<int8_t>(*buffer) : 0;
2051 return chre::fbs::CreateLogMessageV2(
2052 _fbb,
2053 buffer__,
2054 num_logs_dropped);
2055 }
2056
2057 struct SelfTestRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2058 typedef SelfTestRequestBuilder Builder;
2059 bool Verify(flatbuffers::Verifier &verifier) const {
2060 return VerifyTableStart(verifier) &&
2061 verifier.EndTable();
2062 }
2063 };
2064
2065 struct SelfTestRequestBuilder {
2066 typedef SelfTestRequest Table;
2067 flatbuffers::FlatBufferBuilder &fbb_;
2068 flatbuffers::uoffset_t start_;
2069 explicit SelfTestRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2070 : fbb_(_fbb) {
2071 start_ = fbb_.StartTable();
2072 }
2073 SelfTestRequestBuilder &operator=(const SelfTestRequestBuilder &);
2074 flatbuffers::Offset<SelfTestRequest> Finish() {
2075 const auto end = fbb_.EndTable(start_);
2076 auto o = flatbuffers::Offset<SelfTestRequest>(end);
2077 return o;
2078 }
2079 };
2080
2081 inline flatbuffers::Offset<SelfTestRequest> CreateSelfTestRequest(
2082 flatbuffers::FlatBufferBuilder &_fbb) {
2083 SelfTestRequestBuilder builder_(_fbb);
2084 return builder_.Finish();
2085 }
2086
2087 struct SelfTestResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2088 typedef SelfTestResponseBuilder Builder;
2089 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2090 VT_SUCCESS = 4
2091 };
2092 bool success() const {
2093 return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
2094 }
2095 bool Verify(flatbuffers::Verifier &verifier) const {
2096 return VerifyTableStart(verifier) &&
2097 VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
2098 verifier.EndTable();
2099 }
2100 };
2101
2102 struct SelfTestResponseBuilder {
2103 typedef SelfTestResponse Table;
2104 flatbuffers::FlatBufferBuilder &fbb_;
2105 flatbuffers::uoffset_t start_;
2106 void add_success(bool success) {
2107 fbb_.AddElement<uint8_t>(SelfTestResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0);
2108 }
2109 explicit SelfTestResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2110 : fbb_(_fbb) {
2111 start_ = fbb_.StartTable();
2112 }
2113 SelfTestResponseBuilder &operator=(const SelfTestResponseBuilder &);
2114 flatbuffers::Offset<SelfTestResponse> Finish() {
2115 const auto end = fbb_.EndTable(start_);
2116 auto o = flatbuffers::Offset<SelfTestResponse>(end);
2117 return o;
2118 }
2119 };
2120
2121 inline flatbuffers::Offset<SelfTestResponse> CreateSelfTestResponse(
2122 flatbuffers::FlatBufferBuilder &_fbb,
2123 bool success = false) {
2124 SelfTestResponseBuilder builder_(_fbb);
2125 builder_.add_success(success);
2126 return builder_.Finish();
2127 }
2128
2129 struct HostEndpointConnected FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2130 typedef HostEndpointConnectedBuilder Builder;
2131 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2132 VT_HOST_ENDPOINT = 4,
2133 VT_TYPE = 6,
2134 VT_PACKAGE_NAME = 8,
2135 VT_ATTRIBUTION_TAG = 10
2136 };
2137 /// The host-side endpoint that has connected to the framework.
2138 uint16_t host_endpoint() const {
2139 return GetField<uint16_t>(VT_HOST_ENDPOINT, 0);
2140 }
2141 /// The type of host endpoint, which should be any of the CHRE_HOST_ENDPOINT_TYPE_*
2142 /// values defined in the chre_api/chre/event.h.
2143 uint8_t type() const {
2144 return GetField<uint8_t>(VT_TYPE, 0);
2145 }
2146 /// The (optional) package name associated with the host endpoint.
2147 const flatbuffers::Vector<int8_t> *package_name() const {
2148 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_PACKAGE_NAME);
2149 }
2150 /// The (optional) attribution tag associated with this host.
2151 const flatbuffers::Vector<int8_t> *attribution_tag() const {
2152 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_ATTRIBUTION_TAG);
2153 }
2154 bool Verify(flatbuffers::Verifier &verifier) const {
2155 return VerifyTableStart(verifier) &&
2156 VerifyField<uint16_t>(verifier, VT_HOST_ENDPOINT) &&
2157 VerifyField<uint8_t>(verifier, VT_TYPE) &&
2158 VerifyOffset(verifier, VT_PACKAGE_NAME) &&
2159 verifier.VerifyVector(package_name()) &&
2160 VerifyOffset(verifier, VT_ATTRIBUTION_TAG) &&
2161 verifier.VerifyVector(attribution_tag()) &&
2162 verifier.EndTable();
2163 }
2164 };
2165
2166 struct HostEndpointConnectedBuilder {
2167 typedef HostEndpointConnected Table;
2168 flatbuffers::FlatBufferBuilder &fbb_;
2169 flatbuffers::uoffset_t start_;
2170 void add_host_endpoint(uint16_t host_endpoint) {
2171 fbb_.AddElement<uint16_t>(HostEndpointConnected::VT_HOST_ENDPOINT, host_endpoint, 0);
2172 }
2173 void add_type(uint8_t type) {
2174 fbb_.AddElement<uint8_t>(HostEndpointConnected::VT_TYPE, type, 0);
2175 }
2176 void add_package_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> package_name) {
2177 fbb_.AddOffset(HostEndpointConnected::VT_PACKAGE_NAME, package_name);
2178 }
2179 void add_attribution_tag(flatbuffers::Offset<flatbuffers::Vector<int8_t>> attribution_tag) {
2180 fbb_.AddOffset(HostEndpointConnected::VT_ATTRIBUTION_TAG, attribution_tag);
2181 }
2182 explicit HostEndpointConnectedBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2183 : fbb_(_fbb) {
2184 start_ = fbb_.StartTable();
2185 }
2186 HostEndpointConnectedBuilder &operator=(const HostEndpointConnectedBuilder &);
2187 flatbuffers::Offset<HostEndpointConnected> Finish() {
2188 const auto end = fbb_.EndTable(start_);
2189 auto o = flatbuffers::Offset<HostEndpointConnected>(end);
2190 return o;
2191 }
2192 };
2193
2194 inline flatbuffers::Offset<HostEndpointConnected> CreateHostEndpointConnected(
2195 flatbuffers::FlatBufferBuilder &_fbb,
2196 uint16_t host_endpoint = 0,
2197 uint8_t type = 0,
2198 flatbuffers::Offset<flatbuffers::Vector<int8_t>> package_name = 0,
2199 flatbuffers::Offset<flatbuffers::Vector<int8_t>> attribution_tag = 0) {
2200 HostEndpointConnectedBuilder builder_(_fbb);
2201 builder_.add_attribution_tag(attribution_tag);
2202 builder_.add_package_name(package_name);
2203 builder_.add_host_endpoint(host_endpoint);
2204 builder_.add_type(type);
2205 return builder_.Finish();
2206 }
2207
2208 inline flatbuffers::Offset<HostEndpointConnected> CreateHostEndpointConnectedDirect(
2209 flatbuffers::FlatBufferBuilder &_fbb,
2210 uint16_t host_endpoint = 0,
2211 uint8_t type = 0,
2212 const std::vector<int8_t> *package_name = nullptr,
2213 const std::vector<int8_t> *attribution_tag = nullptr) {
2214 auto package_name__ = package_name ? _fbb.CreateVector<int8_t>(*package_name) : 0;
2215 auto attribution_tag__ = attribution_tag ? _fbb.CreateVector<int8_t>(*attribution_tag) : 0;
2216 return chre::fbs::CreateHostEndpointConnected(
2217 _fbb,
2218 host_endpoint,
2219 type,
2220 package_name__,
2221 attribution_tag__);
2222 }
2223
2224 struct HostEndpointDisconnected FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2225 typedef HostEndpointDisconnectedBuilder Builder;
2226 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2227 VT_HOST_ENDPOINT = 4
2228 };
2229 /// The host-side endpoint that has disconnected from the framework.
2230 uint16_t host_endpoint() const {
2231 return GetField<uint16_t>(VT_HOST_ENDPOINT, 0);
2232 }
2233 bool Verify(flatbuffers::Verifier &verifier) const {
2234 return VerifyTableStart(verifier) &&
2235 VerifyField<uint16_t>(verifier, VT_HOST_ENDPOINT) &&
2236 verifier.EndTable();
2237 }
2238 };
2239
2240 struct HostEndpointDisconnectedBuilder {
2241 typedef HostEndpointDisconnected Table;
2242 flatbuffers::FlatBufferBuilder &fbb_;
2243 flatbuffers::uoffset_t start_;
2244 void add_host_endpoint(uint16_t host_endpoint) {
2245 fbb_.AddElement<uint16_t>(HostEndpointDisconnected::VT_HOST_ENDPOINT, host_endpoint, 0);
2246 }
2247 explicit HostEndpointDisconnectedBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2248 : fbb_(_fbb) {
2249 start_ = fbb_.StartTable();
2250 }
2251 HostEndpointDisconnectedBuilder &operator=(const HostEndpointDisconnectedBuilder &);
2252 flatbuffers::Offset<HostEndpointDisconnected> Finish() {
2253 const auto end = fbb_.EndTable(start_);
2254 auto o = flatbuffers::Offset<HostEndpointDisconnected>(end);
2255 return o;
2256 }
2257 };
2258
2259 inline flatbuffers::Offset<HostEndpointDisconnected> CreateHostEndpointDisconnected(
2260 flatbuffers::FlatBufferBuilder &_fbb,
2261 uint16_t host_endpoint = 0) {
2262 HostEndpointDisconnectedBuilder builder_(_fbb);
2263 builder_.add_host_endpoint(host_endpoint);
2264 return builder_.Finish();
2265 }
2266
2267 struct MetricLog FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2268 typedef MetricLogBuilder Builder;
2269 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2270 VT_ID = 4,
2271 VT_ENCODED_METRIC = 6
2272 };
2273 uint32_t id() const {
2274 return GetField<uint32_t>(VT_ID, 0);
2275 }
2276 const flatbuffers::Vector<int8_t> *encoded_metric() const {
2277 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_ENCODED_METRIC);
2278 }
2279 bool Verify(flatbuffers::Verifier &verifier) const {
2280 return VerifyTableStart(verifier) &&
2281 VerifyField<uint32_t>(verifier, VT_ID) &&
2282 VerifyOffset(verifier, VT_ENCODED_METRIC) &&
2283 verifier.VerifyVector(encoded_metric()) &&
2284 verifier.EndTable();
2285 }
2286 };
2287
2288 struct MetricLogBuilder {
2289 typedef MetricLog Table;
2290 flatbuffers::FlatBufferBuilder &fbb_;
2291 flatbuffers::uoffset_t start_;
2292 void add_id(uint32_t id) {
2293 fbb_.AddElement<uint32_t>(MetricLog::VT_ID, id, 0);
2294 }
2295 void add_encoded_metric(flatbuffers::Offset<flatbuffers::Vector<int8_t>> encoded_metric) {
2296 fbb_.AddOffset(MetricLog::VT_ENCODED_METRIC, encoded_metric);
2297 }
2298 explicit MetricLogBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2299 : fbb_(_fbb) {
2300 start_ = fbb_.StartTable();
2301 }
2302 MetricLogBuilder &operator=(const MetricLogBuilder &);
2303 flatbuffers::Offset<MetricLog> Finish() {
2304 const auto end = fbb_.EndTable(start_);
2305 auto o = flatbuffers::Offset<MetricLog>(end);
2306 return o;
2307 }
2308 };
2309
2310 inline flatbuffers::Offset<MetricLog> CreateMetricLog(
2311 flatbuffers::FlatBufferBuilder &_fbb,
2312 uint32_t id = 0,
2313 flatbuffers::Offset<flatbuffers::Vector<int8_t>> encoded_metric = 0) {
2314 MetricLogBuilder builder_(_fbb);
2315 builder_.add_encoded_metric(encoded_metric);
2316 builder_.add_id(id);
2317 return builder_.Finish();
2318 }
2319
2320 inline flatbuffers::Offset<MetricLog> CreateMetricLogDirect(
2321 flatbuffers::FlatBufferBuilder &_fbb,
2322 uint32_t id = 0,
2323 const std::vector<int8_t> *encoded_metric = nullptr) {
2324 auto encoded_metric__ = encoded_metric ? _fbb.CreateVector<int8_t>(*encoded_metric) : 0;
2325 return chre::fbs::CreateMetricLog(
2326 _fbb,
2327 id,
2328 encoded_metric__);
2329 }
2330
2331 struct BatchedMetricLog FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2332 typedef BatchedMetricLogBuilder Builder;
2333 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2334 VT_METRICS = 4
2335 };
2336 const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MetricLog>> *metrics() const {
2337 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MetricLog>> *>(VT_METRICS);
2338 }
2339 bool Verify(flatbuffers::Verifier &verifier) const {
2340 return VerifyTableStart(verifier) &&
2341 VerifyOffset(verifier, VT_METRICS) &&
2342 verifier.VerifyVector(metrics()) &&
2343 verifier.VerifyVectorOfTables(metrics()) &&
2344 verifier.EndTable();
2345 }
2346 };
2347
2348 struct BatchedMetricLogBuilder {
2349 typedef BatchedMetricLog Table;
2350 flatbuffers::FlatBufferBuilder &fbb_;
2351 flatbuffers::uoffset_t start_;
2352 void add_metrics(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MetricLog>>> metrics) {
2353 fbb_.AddOffset(BatchedMetricLog::VT_METRICS, metrics);
2354 }
2355 explicit BatchedMetricLogBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2356 : fbb_(_fbb) {
2357 start_ = fbb_.StartTable();
2358 }
2359 BatchedMetricLogBuilder &operator=(const BatchedMetricLogBuilder &);
2360 flatbuffers::Offset<BatchedMetricLog> Finish() {
2361 const auto end = fbb_.EndTable(start_);
2362 auto o = flatbuffers::Offset<BatchedMetricLog>(end);
2363 return o;
2364 }
2365 };
2366
2367 inline flatbuffers::Offset<BatchedMetricLog> CreateBatchedMetricLog(
2368 flatbuffers::FlatBufferBuilder &_fbb,
2369 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MetricLog>>> metrics = 0) {
2370 BatchedMetricLogBuilder builder_(_fbb);
2371 builder_.add_metrics(metrics);
2372 return builder_.Finish();
2373 }
2374
2375 inline flatbuffers::Offset<BatchedMetricLog> CreateBatchedMetricLogDirect(
2376 flatbuffers::FlatBufferBuilder &_fbb,
2377 const std::vector<flatbuffers::Offset<chre::fbs::MetricLog>> *metrics = nullptr) {
2378 auto metrics__ = metrics ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::MetricLog>>(*metrics) : 0;
2379 return chre::fbs::CreateBatchedMetricLog(
2380 _fbb,
2381 metrics__);
2382 }
2383
2384 struct NanConfigurationRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2385 typedef NanConfigurationRequestBuilder Builder;
2386 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2387 VT_ENABLE = 4
2388 };
2389 bool enable() const {
2390 return GetField<uint8_t>(VT_ENABLE, 0) != 0;
2391 }
2392 bool Verify(flatbuffers::Verifier &verifier) const {
2393 return VerifyTableStart(verifier) &&
2394 VerifyField<uint8_t>(verifier, VT_ENABLE) &&
2395 verifier.EndTable();
2396 }
2397 };
2398
2399 struct NanConfigurationRequestBuilder {
2400 typedef NanConfigurationRequest Table;
2401 flatbuffers::FlatBufferBuilder &fbb_;
2402 flatbuffers::uoffset_t start_;
2403 void add_enable(bool enable) {
2404 fbb_.AddElement<uint8_t>(NanConfigurationRequest::VT_ENABLE, static_cast<uint8_t>(enable), 0);
2405 }
2406 explicit NanConfigurationRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2407 : fbb_(_fbb) {
2408 start_ = fbb_.StartTable();
2409 }
2410 NanConfigurationRequestBuilder &operator=(const NanConfigurationRequestBuilder &);
2411 flatbuffers::Offset<NanConfigurationRequest> Finish() {
2412 const auto end = fbb_.EndTable(start_);
2413 auto o = flatbuffers::Offset<NanConfigurationRequest>(end);
2414 return o;
2415 }
2416 };
2417
2418 inline flatbuffers::Offset<NanConfigurationRequest> CreateNanConfigurationRequest(
2419 flatbuffers::FlatBufferBuilder &_fbb,
2420 bool enable = false) {
2421 NanConfigurationRequestBuilder builder_(_fbb);
2422 builder_.add_enable(enable);
2423 return builder_.Finish();
2424 }
2425
2426 struct NanConfigurationUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2427 typedef NanConfigurationUpdateBuilder Builder;
2428 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2429 VT_ENABLED = 4
2430 };
2431 bool enabled() const {
2432 return GetField<uint8_t>(VT_ENABLED, 0) != 0;
2433 }
2434 bool Verify(flatbuffers::Verifier &verifier) const {
2435 return VerifyTableStart(verifier) &&
2436 VerifyField<uint8_t>(verifier, VT_ENABLED) &&
2437 verifier.EndTable();
2438 }
2439 };
2440
2441 struct NanConfigurationUpdateBuilder {
2442 typedef NanConfigurationUpdate Table;
2443 flatbuffers::FlatBufferBuilder &fbb_;
2444 flatbuffers::uoffset_t start_;
2445 void add_enabled(bool enabled) {
2446 fbb_.AddElement<uint8_t>(NanConfigurationUpdate::VT_ENABLED, static_cast<uint8_t>(enabled), 0);
2447 }
2448 explicit NanConfigurationUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2449 : fbb_(_fbb) {
2450 start_ = fbb_.StartTable();
2451 }
2452 NanConfigurationUpdateBuilder &operator=(const NanConfigurationUpdateBuilder &);
2453 flatbuffers::Offset<NanConfigurationUpdate> Finish() {
2454 const auto end = fbb_.EndTable(start_);
2455 auto o = flatbuffers::Offset<NanConfigurationUpdate>(end);
2456 return o;
2457 }
2458 };
2459
2460 inline flatbuffers::Offset<NanConfigurationUpdate> CreateNanConfigurationUpdate(
2461 flatbuffers::FlatBufferBuilder &_fbb,
2462 bool enabled = false) {
2463 NanConfigurationUpdateBuilder builder_(_fbb);
2464 builder_.add_enabled(enabled);
2465 return builder_.Finish();
2466 }
2467
2468 struct DebugConfiguration FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2469 typedef DebugConfigurationBuilder Builder;
2470 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2471 VT_HEALTH_MONITOR_FAILURE_CRASH = 4
2472 };
2473 bool health_monitor_failure_crash() const {
2474 return GetField<uint8_t>(VT_HEALTH_MONITOR_FAILURE_CRASH, 0) != 0;
2475 }
2476 bool Verify(flatbuffers::Verifier &verifier) const {
2477 return VerifyTableStart(verifier) &&
2478 VerifyField<uint8_t>(verifier, VT_HEALTH_MONITOR_FAILURE_CRASH) &&
2479 verifier.EndTable();
2480 }
2481 };
2482
2483 struct DebugConfigurationBuilder {
2484 typedef DebugConfiguration Table;
2485 flatbuffers::FlatBufferBuilder &fbb_;
2486 flatbuffers::uoffset_t start_;
2487 void add_health_monitor_failure_crash(bool health_monitor_failure_crash) {
2488 fbb_.AddElement<uint8_t>(DebugConfiguration::VT_HEALTH_MONITOR_FAILURE_CRASH, static_cast<uint8_t>(health_monitor_failure_crash), 0);
2489 }
2490 explicit DebugConfigurationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2491 : fbb_(_fbb) {
2492 start_ = fbb_.StartTable();
2493 }
2494 DebugConfigurationBuilder &operator=(const DebugConfigurationBuilder &);
2495 flatbuffers::Offset<DebugConfiguration> Finish() {
2496 const auto end = fbb_.EndTable(start_);
2497 auto o = flatbuffers::Offset<DebugConfiguration>(end);
2498 return o;
2499 }
2500 };
2501
2502 inline flatbuffers::Offset<DebugConfiguration> CreateDebugConfiguration(
2503 flatbuffers::FlatBufferBuilder &_fbb,
2504 bool health_monitor_failure_crash = false) {
2505 DebugConfigurationBuilder builder_(_fbb);
2506 builder_.add_health_monitor_failure_crash(health_monitor_failure_crash);
2507 return builder_.Finish();
2508 }
2509
2510 /// The top-level container that encapsulates all possible messages. Note that
2511 /// per FlatBuffers requirements, we can't use a union as the top-level
2512 /// structure (root type), so we must wrap it in a table.
2513 struct MessageContainer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2514 typedef MessageContainerBuilder Builder;
2515 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2516 VT_MESSAGE_TYPE = 4,
2517 VT_MESSAGE = 6,
2518 VT_HOST_ADDR = 8
2519 };
2520 chre::fbs::ChreMessage message_type() const {
2521 return static_cast<chre::fbs::ChreMessage>(GetField<uint8_t>(VT_MESSAGE_TYPE, 0));
2522 }
2523 const void *message() const {
2524 return GetPointer<const void *>(VT_MESSAGE);
2525 }
2526 template<typename T> const T *message_as() const;
2527 const chre::fbs::NanoappMessage *message_as_NanoappMessage() const {
2528 return message_type() == chre::fbs::ChreMessage::NanoappMessage ? static_cast<const chre::fbs::NanoappMessage *>(message()) : nullptr;
2529 }
2530 const chre::fbs::HubInfoRequest *message_as_HubInfoRequest() const {
2531 return message_type() == chre::fbs::ChreMessage::HubInfoRequest ? static_cast<const chre::fbs::HubInfoRequest *>(message()) : nullptr;
2532 }
2533 const chre::fbs::HubInfoResponse *message_as_HubInfoResponse() const {
2534 return message_type() == chre::fbs::ChreMessage::HubInfoResponse ? static_cast<const chre::fbs::HubInfoResponse *>(message()) : nullptr;
2535 }
2536 const chre::fbs::NanoappListRequest *message_as_NanoappListRequest() const {
2537 return message_type() == chre::fbs::ChreMessage::NanoappListRequest ? static_cast<const chre::fbs::NanoappListRequest *>(message()) : nullptr;
2538 }
2539 const chre::fbs::NanoappListResponse *message_as_NanoappListResponse() const {
2540 return message_type() == chre::fbs::ChreMessage::NanoappListResponse ? static_cast<const chre::fbs::NanoappListResponse *>(message()) : nullptr;
2541 }
2542 const chre::fbs::LoadNanoappRequest *message_as_LoadNanoappRequest() const {
2543 return message_type() == chre::fbs::ChreMessage::LoadNanoappRequest ? static_cast<const chre::fbs::LoadNanoappRequest *>(message()) : nullptr;
2544 }
2545 const chre::fbs::LoadNanoappResponse *message_as_LoadNanoappResponse() const {
2546 return message_type() == chre::fbs::ChreMessage::LoadNanoappResponse ? static_cast<const chre::fbs::LoadNanoappResponse *>(message()) : nullptr;
2547 }
2548 const chre::fbs::UnloadNanoappRequest *message_as_UnloadNanoappRequest() const {
2549 return message_type() == chre::fbs::ChreMessage::UnloadNanoappRequest ? static_cast<const chre::fbs::UnloadNanoappRequest *>(message()) : nullptr;
2550 }
2551 const chre::fbs::UnloadNanoappResponse *message_as_UnloadNanoappResponse() const {
2552 return message_type() == chre::fbs::ChreMessage::UnloadNanoappResponse ? static_cast<const chre::fbs::UnloadNanoappResponse *>(message()) : nullptr;
2553 }
2554 const chre::fbs::LogMessage *message_as_LogMessage() const {
2555 return message_type() == chre::fbs::ChreMessage::LogMessage ? static_cast<const chre::fbs::LogMessage *>(message()) : nullptr;
2556 }
2557 const chre::fbs::TimeSyncMessage *message_as_TimeSyncMessage() const {
2558 return message_type() == chre::fbs::ChreMessage::TimeSyncMessage ? static_cast<const chre::fbs::TimeSyncMessage *>(message()) : nullptr;
2559 }
2560 const chre::fbs::DebugDumpRequest *message_as_DebugDumpRequest() const {
2561 return message_type() == chre::fbs::ChreMessage::DebugDumpRequest ? static_cast<const chre::fbs::DebugDumpRequest *>(message()) : nullptr;
2562 }
2563 const chre::fbs::DebugDumpData *message_as_DebugDumpData() const {
2564 return message_type() == chre::fbs::ChreMessage::DebugDumpData ? static_cast<const chre::fbs::DebugDumpData *>(message()) : nullptr;
2565 }
2566 const chre::fbs::DebugDumpResponse *message_as_DebugDumpResponse() const {
2567 return message_type() == chre::fbs::ChreMessage::DebugDumpResponse ? static_cast<const chre::fbs::DebugDumpResponse *>(message()) : nullptr;
2568 }
2569 const chre::fbs::TimeSyncRequest *message_as_TimeSyncRequest() const {
2570 return message_type() == chre::fbs::ChreMessage::TimeSyncRequest ? static_cast<const chre::fbs::TimeSyncRequest *>(message()) : nullptr;
2571 }
2572 const chre::fbs::LowPowerMicAccessRequest *message_as_LowPowerMicAccessRequest() const {
2573 return message_type() == chre::fbs::ChreMessage::LowPowerMicAccessRequest ? static_cast<const chre::fbs::LowPowerMicAccessRequest *>(message()) : nullptr;
2574 }
2575 const chre::fbs::LowPowerMicAccessRelease *message_as_LowPowerMicAccessRelease() const {
2576 return message_type() == chre::fbs::ChreMessage::LowPowerMicAccessRelease ? static_cast<const chre::fbs::LowPowerMicAccessRelease *>(message()) : nullptr;
2577 }
2578 const chre::fbs::SettingChangeMessage *message_as_SettingChangeMessage() const {
2579 return message_type() == chre::fbs::ChreMessage::SettingChangeMessage ? static_cast<const chre::fbs::SettingChangeMessage *>(message()) : nullptr;
2580 }
2581 const chre::fbs::LogMessageV2 *message_as_LogMessageV2() const {
2582 return message_type() == chre::fbs::ChreMessage::LogMessageV2 ? static_cast<const chre::fbs::LogMessageV2 *>(message()) : nullptr;
2583 }
2584 const chre::fbs::SelfTestRequest *message_as_SelfTestRequest() const {
2585 return message_type() == chre::fbs::ChreMessage::SelfTestRequest ? static_cast<const chre::fbs::SelfTestRequest *>(message()) : nullptr;
2586 }
2587 const chre::fbs::SelfTestResponse *message_as_SelfTestResponse() const {
2588 return message_type() == chre::fbs::ChreMessage::SelfTestResponse ? static_cast<const chre::fbs::SelfTestResponse *>(message()) : nullptr;
2589 }
2590 const chre::fbs::HostEndpointConnected *message_as_HostEndpointConnected() const {
2591 return message_type() == chre::fbs::ChreMessage::HostEndpointConnected ? static_cast<const chre::fbs::HostEndpointConnected *>(message()) : nullptr;
2592 }
2593 const chre::fbs::HostEndpointDisconnected *message_as_HostEndpointDisconnected() const {
2594 return message_type() == chre::fbs::ChreMessage::HostEndpointDisconnected ? static_cast<const chre::fbs::HostEndpointDisconnected *>(message()) : nullptr;
2595 }
2596 const chre::fbs::MetricLog *message_as_MetricLog() const {
2597 return message_type() == chre::fbs::ChreMessage::MetricLog ? static_cast<const chre::fbs::MetricLog *>(message()) : nullptr;
2598 }
2599 const chre::fbs::BatchedMetricLog *message_as_BatchedMetricLog() const {
2600 return message_type() == chre::fbs::ChreMessage::BatchedMetricLog ? static_cast<const chre::fbs::BatchedMetricLog *>(message()) : nullptr;
2601 }
2602 const chre::fbs::NanConfigurationRequest *message_as_NanConfigurationRequest() const {
2603 return message_type() == chre::fbs::ChreMessage::NanConfigurationRequest ? static_cast<const chre::fbs::NanConfigurationRequest *>(message()) : nullptr;
2604 }
2605 const chre::fbs::NanConfigurationUpdate *message_as_NanConfigurationUpdate() const {
2606 return message_type() == chre::fbs::ChreMessage::NanConfigurationUpdate ? static_cast<const chre::fbs::NanConfigurationUpdate *>(message()) : nullptr;
2607 }
2608 const chre::fbs::DebugConfiguration *message_as_DebugConfiguration() const {
2609 return message_type() == chre::fbs::ChreMessage::DebugConfiguration ? static_cast<const chre::fbs::DebugConfiguration *>(message()) : nullptr;
2610 }
2611 /// The originating or destination client ID on the host side, used to direct
2612 /// responses only to the client that sent the request. Although initially
2613 /// populated by the requesting client, this is enforced to be the correct
2614 /// value by the entity guarding access to CHRE.
2615 /// This is wrapped in a struct to ensure that it is always included when
2616 /// encoding the message, so it can be mutated by the host daemon.
2617 const chre::fbs::HostAddress *host_addr() const {
2618 return GetStruct<const chre::fbs::HostAddress *>(VT_HOST_ADDR);
2619 }
2620 bool Verify(flatbuffers::Verifier &verifier) const {
2621 return VerifyTableStart(verifier) &&
2622 VerifyField<uint8_t>(verifier, VT_MESSAGE_TYPE) &&
2623 VerifyOffsetRequired(verifier, VT_MESSAGE) &&
2624 VerifyChreMessage(verifier, message(), message_type()) &&
2625 VerifyFieldRequired<chre::fbs::HostAddress>(verifier, VT_HOST_ADDR) &&
2626 verifier.EndTable();
2627 }
2628 };
2629
2630 template<> inline const chre::fbs::NanoappMessage *MessageContainer::message_as<chre::fbs::NanoappMessage>() const {
2631 return message_as_NanoappMessage();
2632 }
2633
2634 template<> inline const chre::fbs::HubInfoRequest *MessageContainer::message_as<chre::fbs::HubInfoRequest>() const {
2635 return message_as_HubInfoRequest();
2636 }
2637
2638 template<> inline const chre::fbs::HubInfoResponse *MessageContainer::message_as<chre::fbs::HubInfoResponse>() const {
2639 return message_as_HubInfoResponse();
2640 }
2641
2642 template<> inline const chre::fbs::NanoappListRequest *MessageContainer::message_as<chre::fbs::NanoappListRequest>() const {
2643 return message_as_NanoappListRequest();
2644 }
2645
2646 template<> inline const chre::fbs::NanoappListResponse *MessageContainer::message_as<chre::fbs::NanoappListResponse>() const {
2647 return message_as_NanoappListResponse();
2648 }
2649
2650 template<> inline const chre::fbs::LoadNanoappRequest *MessageContainer::message_as<chre::fbs::LoadNanoappRequest>() const {
2651 return message_as_LoadNanoappRequest();
2652 }
2653
2654 template<> inline const chre::fbs::LoadNanoappResponse *MessageContainer::message_as<chre::fbs::LoadNanoappResponse>() const {
2655 return message_as_LoadNanoappResponse();
2656 }
2657
2658 template<> inline const chre::fbs::UnloadNanoappRequest *MessageContainer::message_as<chre::fbs::UnloadNanoappRequest>() const {
2659 return message_as_UnloadNanoappRequest();
2660 }
2661
2662 template<> inline const chre::fbs::UnloadNanoappResponse *MessageContainer::message_as<chre::fbs::UnloadNanoappResponse>() const {
2663 return message_as_UnloadNanoappResponse();
2664 }
2665
2666 template<> inline const chre::fbs::LogMessage *MessageContainer::message_as<chre::fbs::LogMessage>() const {
2667 return message_as_LogMessage();
2668 }
2669
2670 template<> inline const chre::fbs::TimeSyncMessage *MessageContainer::message_as<chre::fbs::TimeSyncMessage>() const {
2671 return message_as_TimeSyncMessage();
2672 }
2673
2674 template<> inline const chre::fbs::DebugDumpRequest *MessageContainer::message_as<chre::fbs::DebugDumpRequest>() const {
2675 return message_as_DebugDumpRequest();
2676 }
2677
2678 template<> inline const chre::fbs::DebugDumpData *MessageContainer::message_as<chre::fbs::DebugDumpData>() const {
2679 return message_as_DebugDumpData();
2680 }
2681
2682 template<> inline const chre::fbs::DebugDumpResponse *MessageContainer::message_as<chre::fbs::DebugDumpResponse>() const {
2683 return message_as_DebugDumpResponse();
2684 }
2685
2686 template<> inline const chre::fbs::TimeSyncRequest *MessageContainer::message_as<chre::fbs::TimeSyncRequest>() const {
2687 return message_as_TimeSyncRequest();
2688 }
2689
2690 template<> inline const chre::fbs::LowPowerMicAccessRequest *MessageContainer::message_as<chre::fbs::LowPowerMicAccessRequest>() const {
2691 return message_as_LowPowerMicAccessRequest();
2692 }
2693
2694 template<> inline const chre::fbs::LowPowerMicAccessRelease *MessageContainer::message_as<chre::fbs::LowPowerMicAccessRelease>() const {
2695 return message_as_LowPowerMicAccessRelease();
2696 }
2697
2698 template<> inline const chre::fbs::SettingChangeMessage *MessageContainer::message_as<chre::fbs::SettingChangeMessage>() const {
2699 return message_as_SettingChangeMessage();
2700 }
2701
2702 template<> inline const chre::fbs::LogMessageV2 *MessageContainer::message_as<chre::fbs::LogMessageV2>() const {
2703 return message_as_LogMessageV2();
2704 }
2705
2706 template<> inline const chre::fbs::SelfTestRequest *MessageContainer::message_as<chre::fbs::SelfTestRequest>() const {
2707 return message_as_SelfTestRequest();
2708 }
2709
2710 template<> inline const chre::fbs::SelfTestResponse *MessageContainer::message_as<chre::fbs::SelfTestResponse>() const {
2711 return message_as_SelfTestResponse();
2712 }
2713
2714 template<> inline const chre::fbs::HostEndpointConnected *MessageContainer::message_as<chre::fbs::HostEndpointConnected>() const {
2715 return message_as_HostEndpointConnected();
2716 }
2717
2718 template<> inline const chre::fbs::HostEndpointDisconnected *MessageContainer::message_as<chre::fbs::HostEndpointDisconnected>() const {
2719 return message_as_HostEndpointDisconnected();
2720 }
2721
2722 template<> inline const chre::fbs::MetricLog *MessageContainer::message_as<chre::fbs::MetricLog>() const {
2723 return message_as_MetricLog();
2724 }
2725
2726 template<> inline const chre::fbs::BatchedMetricLog *MessageContainer::message_as<chre::fbs::BatchedMetricLog>() const {
2727 return message_as_BatchedMetricLog();
2728 }
2729
2730 template<> inline const chre::fbs::NanConfigurationRequest *MessageContainer::message_as<chre::fbs::NanConfigurationRequest>() const {
2731 return message_as_NanConfigurationRequest();
2732 }
2733
2734 template<> inline const chre::fbs::NanConfigurationUpdate *MessageContainer::message_as<chre::fbs::NanConfigurationUpdate>() const {
2735 return message_as_NanConfigurationUpdate();
2736 }
2737
2738 template<> inline const chre::fbs::DebugConfiguration *MessageContainer::message_as<chre::fbs::DebugConfiguration>() const {
2739 return message_as_DebugConfiguration();
2740 }
2741
2742 struct MessageContainerBuilder {
2743 typedef MessageContainer Table;
2744 flatbuffers::FlatBufferBuilder &fbb_;
2745 flatbuffers::uoffset_t start_;
2746 void add_message_type(chre::fbs::ChreMessage message_type) {
2747 fbb_.AddElement<uint8_t>(MessageContainer::VT_MESSAGE_TYPE, static_cast<uint8_t>(message_type), 0);
2748 }
2749 void add_message(flatbuffers::Offset<void> message) {
2750 fbb_.AddOffset(MessageContainer::VT_MESSAGE, message);
2751 }
2752 void add_host_addr(const chre::fbs::HostAddress *host_addr) {
2753 fbb_.AddStruct(MessageContainer::VT_HOST_ADDR, host_addr);
2754 }
2755 explicit MessageContainerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2756 : fbb_(_fbb) {
2757 start_ = fbb_.StartTable();
2758 }
2759 MessageContainerBuilder &operator=(const MessageContainerBuilder &);
2760 flatbuffers::Offset<MessageContainer> Finish() {
2761 const auto end = fbb_.EndTable(start_);
2762 auto o = flatbuffers::Offset<MessageContainer>(end);
2763 fbb_.Required(o, MessageContainer::VT_MESSAGE);
2764 fbb_.Required(o, MessageContainer::VT_HOST_ADDR);
2765 return o;
2766 }
2767 };
2768
2769 inline flatbuffers::Offset<MessageContainer> CreateMessageContainer(
2770 flatbuffers::FlatBufferBuilder &_fbb,
2771 chre::fbs::ChreMessage message_type = chre::fbs::ChreMessage::NONE,
2772 flatbuffers::Offset<void> message = 0,
2773 const chre::fbs::HostAddress *host_addr = 0) {
2774 MessageContainerBuilder builder_(_fbb);
2775 builder_.add_host_addr(host_addr);
2776 builder_.add_message(message);
2777 builder_.add_message_type(message_type);
2778 return builder_.Finish();
2779 }
2780
2781 inline bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type) {
2782 switch (type) {
2783 case ChreMessage::NONE: {
2784 return true;
2785 }
2786 case ChreMessage::NanoappMessage: {
2787 auto ptr = reinterpret_cast<const chre::fbs::NanoappMessage *>(obj);
2788 return verifier.VerifyTable(ptr);
2789 }
2790 case ChreMessage::HubInfoRequest: {
2791 auto ptr = reinterpret_cast<const chre::fbs::HubInfoRequest *>(obj);
2792 return verifier.VerifyTable(ptr);
2793 }
2794 case ChreMessage::HubInfoResponse: {
2795 auto ptr = reinterpret_cast<const chre::fbs::HubInfoResponse *>(obj);
2796 return verifier.VerifyTable(ptr);
2797 }
2798 case ChreMessage::NanoappListRequest: {
2799 auto ptr = reinterpret_cast<const chre::fbs::NanoappListRequest *>(obj);
2800 return verifier.VerifyTable(ptr);
2801 }
2802 case ChreMessage::NanoappListResponse: {
2803 auto ptr = reinterpret_cast<const chre::fbs::NanoappListResponse *>(obj);
2804 return verifier.VerifyTable(ptr);
2805 }
2806 case ChreMessage::LoadNanoappRequest: {
2807 auto ptr = reinterpret_cast<const chre::fbs::LoadNanoappRequest *>(obj);
2808 return verifier.VerifyTable(ptr);
2809 }
2810 case ChreMessage::LoadNanoappResponse: {
2811 auto ptr = reinterpret_cast<const chre::fbs::LoadNanoappResponse *>(obj);
2812 return verifier.VerifyTable(ptr);
2813 }
2814 case ChreMessage::UnloadNanoappRequest: {
2815 auto ptr = reinterpret_cast<const chre::fbs::UnloadNanoappRequest *>(obj);
2816 return verifier.VerifyTable(ptr);
2817 }
2818 case ChreMessage::UnloadNanoappResponse: {
2819 auto ptr = reinterpret_cast<const chre::fbs::UnloadNanoappResponse *>(obj);
2820 return verifier.VerifyTable(ptr);
2821 }
2822 case ChreMessage::LogMessage: {
2823 auto ptr = reinterpret_cast<const chre::fbs::LogMessage *>(obj);
2824 return verifier.VerifyTable(ptr);
2825 }
2826 case ChreMessage::TimeSyncMessage: {
2827 auto ptr = reinterpret_cast<const chre::fbs::TimeSyncMessage *>(obj);
2828 return verifier.VerifyTable(ptr);
2829 }
2830 case ChreMessage::DebugDumpRequest: {
2831 auto ptr = reinterpret_cast<const chre::fbs::DebugDumpRequest *>(obj);
2832 return verifier.VerifyTable(ptr);
2833 }
2834 case ChreMessage::DebugDumpData: {
2835 auto ptr = reinterpret_cast<const chre::fbs::DebugDumpData *>(obj);
2836 return verifier.VerifyTable(ptr);
2837 }
2838 case ChreMessage::DebugDumpResponse: {
2839 auto ptr = reinterpret_cast<const chre::fbs::DebugDumpResponse *>(obj);
2840 return verifier.VerifyTable(ptr);
2841 }
2842 case ChreMessage::TimeSyncRequest: {
2843 auto ptr = reinterpret_cast<const chre::fbs::TimeSyncRequest *>(obj);
2844 return verifier.VerifyTable(ptr);
2845 }
2846 case ChreMessage::LowPowerMicAccessRequest: {
2847 auto ptr = reinterpret_cast<const chre::fbs::LowPowerMicAccessRequest *>(obj);
2848 return verifier.VerifyTable(ptr);
2849 }
2850 case ChreMessage::LowPowerMicAccessRelease: {
2851 auto ptr = reinterpret_cast<const chre::fbs::LowPowerMicAccessRelease *>(obj);
2852 return verifier.VerifyTable(ptr);
2853 }
2854 case ChreMessage::SettingChangeMessage: {
2855 auto ptr = reinterpret_cast<const chre::fbs::SettingChangeMessage *>(obj);
2856 return verifier.VerifyTable(ptr);
2857 }
2858 case ChreMessage::LogMessageV2: {
2859 auto ptr = reinterpret_cast<const chre::fbs::LogMessageV2 *>(obj);
2860 return verifier.VerifyTable(ptr);
2861 }
2862 case ChreMessage::SelfTestRequest: {
2863 auto ptr = reinterpret_cast<const chre::fbs::SelfTestRequest *>(obj);
2864 return verifier.VerifyTable(ptr);
2865 }
2866 case ChreMessage::SelfTestResponse: {
2867 auto ptr = reinterpret_cast<const chre::fbs::SelfTestResponse *>(obj);
2868 return verifier.VerifyTable(ptr);
2869 }
2870 case ChreMessage::HostEndpointConnected: {
2871 auto ptr = reinterpret_cast<const chre::fbs::HostEndpointConnected *>(obj);
2872 return verifier.VerifyTable(ptr);
2873 }
2874 case ChreMessage::HostEndpointDisconnected: {
2875 auto ptr = reinterpret_cast<const chre::fbs::HostEndpointDisconnected *>(obj);
2876 return verifier.VerifyTable(ptr);
2877 }
2878 case ChreMessage::MetricLog: {
2879 auto ptr = reinterpret_cast<const chre::fbs::MetricLog *>(obj);
2880 return verifier.VerifyTable(ptr);
2881 }
2882 case ChreMessage::BatchedMetricLog: {
2883 auto ptr = reinterpret_cast<const chre::fbs::BatchedMetricLog *>(obj);
2884 return verifier.VerifyTable(ptr);
2885 }
2886 case ChreMessage::NanConfigurationRequest: {
2887 auto ptr = reinterpret_cast<const chre::fbs::NanConfigurationRequest *>(obj);
2888 return verifier.VerifyTable(ptr);
2889 }
2890 case ChreMessage::NanConfigurationUpdate: {
2891 auto ptr = reinterpret_cast<const chre::fbs::NanConfigurationUpdate *>(obj);
2892 return verifier.VerifyTable(ptr);
2893 }
2894 case ChreMessage::DebugConfiguration: {
2895 auto ptr = reinterpret_cast<const chre::fbs::DebugConfiguration *>(obj);
2896 return verifier.VerifyTable(ptr);
2897 }
2898 default: return true;
2899 }
2900 }
2901
2902 inline bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
2903 if (!values || !types) return !values && !types;
2904 if (values->size() != types->size()) return false;
2905 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
2906 if (!VerifyChreMessage(
2907 verifier, values->Get(i), types->GetEnum<ChreMessage>(i))) {
2908 return false;
2909 }
2910 }
2911 return true;
2912 }
2913
2914 inline const chre::fbs::MessageContainer *GetMessageContainer(const void *buf) {
2915 return flatbuffers::GetRoot<chre::fbs::MessageContainer>(buf);
2916 }
2917
2918 inline const chre::fbs::MessageContainer *GetSizePrefixedMessageContainer(const void *buf) {
2919 return flatbuffers::GetSizePrefixedRoot<chre::fbs::MessageContainer>(buf);
2920 }
2921
2922 inline bool VerifyMessageContainerBuffer(
2923 flatbuffers::Verifier &verifier) {
2924 return verifier.VerifyBuffer<chre::fbs::MessageContainer>(nullptr);
2925 }
2926
2927 inline bool VerifySizePrefixedMessageContainerBuffer(
2928 flatbuffers::Verifier &verifier) {
2929 return verifier.VerifySizePrefixedBuffer<chre::fbs::MessageContainer>(nullptr);
2930 }
2931
2932 inline void FinishMessageContainerBuffer(
2933 flatbuffers::FlatBufferBuilder &fbb,
2934 flatbuffers::Offset<chre::fbs::MessageContainer> root) {
2935 fbb.Finish(root);
2936 }
2937
2938 inline void FinishSizePrefixedMessageContainerBuffer(
2939 flatbuffers::FlatBufferBuilder &fbb,
2940 flatbuffers::Offset<chre::fbs::MessageContainer> root) {
2941 fbb.FinishSizePrefixed(root);
2942 }
2943
2944 } // namespace fbs
2945 } // namespace chre
2946
2947 #endif // FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_
2948