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 MessageDeliveryStatus;
16 struct MessageDeliveryStatusBuilder;
17
18 struct HubInfoRequest;
19 struct HubInfoRequestBuilder;
20
21 struct HubInfoResponse;
22 struct HubInfoResponseBuilder;
23
24 struct NanoappListRequest;
25 struct NanoappListRequestBuilder;
26
27 struct NanoappRpcService;
28 struct NanoappRpcServiceBuilder;
29
30 struct NanoappListEntry;
31 struct NanoappListEntryBuilder;
32
33 struct NanoappListResponse;
34 struct NanoappListResponseBuilder;
35
36 struct LoadNanoappRequest;
37 struct LoadNanoappRequestBuilder;
38
39 struct LoadNanoappResponse;
40 struct LoadNanoappResponseBuilder;
41
42 struct NanoappTokenDatabaseInfo;
43 struct NanoappTokenDatabaseInfoBuilder;
44
45 struct UnloadNanoappRequest;
46 struct UnloadNanoappRequestBuilder;
47
48 struct UnloadNanoappResponse;
49 struct UnloadNanoappResponseBuilder;
50
51 struct LogMessage;
52 struct LogMessageBuilder;
53
54 struct TimeSyncMessage;
55 struct TimeSyncMessageBuilder;
56
57 struct DebugDumpRequest;
58 struct DebugDumpRequestBuilder;
59
60 struct DebugDumpData;
61 struct DebugDumpDataBuilder;
62
63 struct DebugDumpResponse;
64 struct DebugDumpResponseBuilder;
65
66 struct TimeSyncRequest;
67 struct TimeSyncRequestBuilder;
68
69 struct LowPowerMicAccessRequest;
70 struct LowPowerMicAccessRequestBuilder;
71
72 struct LowPowerMicAccessRelease;
73 struct LowPowerMicAccessReleaseBuilder;
74
75 struct SettingChangeMessage;
76 struct SettingChangeMessageBuilder;
77
78 struct LogMessageV2;
79 struct LogMessageV2Builder;
80
81 struct SelfTestRequest;
82 struct SelfTestRequestBuilder;
83
84 struct SelfTestResponse;
85 struct SelfTestResponseBuilder;
86
87 struct HostEndpointConnected;
88 struct HostEndpointConnectedBuilder;
89
90 struct HostEndpointDisconnected;
91 struct HostEndpointDisconnectedBuilder;
92
93 struct MetricLog;
94 struct MetricLogBuilder;
95
96 struct BatchedMetricLog;
97 struct BatchedMetricLogBuilder;
98
99 struct NanConfigurationRequest;
100 struct NanConfigurationRequestBuilder;
101
102 struct NanConfigurationUpdate;
103 struct NanConfigurationUpdateBuilder;
104
105 struct DebugConfiguration;
106 struct DebugConfigurationBuilder;
107
108 struct PulseRequest;
109 struct PulseRequestBuilder;
110
111 struct PulseResponse;
112 struct PulseResponseBuilder;
113
114 struct LeCocChannelInfo;
115 struct LeCocChannelInfoBuilder;
116
117 struct BtSocketOpen;
118 struct BtSocketOpenBuilder;
119
120 struct BtSocketOpenResponse;
121 struct BtSocketOpenResponseBuilder;
122
123 struct BtSocketClose;
124 struct BtSocketCloseBuilder;
125
126 struct BtSocketCloseResponse;
127 struct BtSocketCloseResponseBuilder;
128
129 struct BtSocketCapabilitiesRequest;
130 struct BtSocketCapabilitiesRequestBuilder;
131
132 struct BtSocketLeCocCapabilities;
133 struct BtSocketLeCocCapabilitiesBuilder;
134
135 struct BtSocketRfcommCapabilities;
136 struct BtSocketRfcommCapabilitiesBuilder;
137
138 struct BtSocketCapabilitiesResponse;
139 struct BtSocketCapabilitiesResponseBuilder;
140
141 struct VendorHubInfo;
142 struct VendorHubInfoBuilder;
143
144 struct MessageHub;
145 struct MessageHubBuilder;
146
147 struct RegisterMessageHub;
148 struct RegisterMessageHubBuilder;
149
150 struct UnregisterMessageHub;
151 struct UnregisterMessageHubBuilder;
152
153 struct EndpointId;
154 struct EndpointIdBuilder;
155
156 struct Service;
157 struct ServiceBuilder;
158
159 struct EndpointInfo;
160 struct EndpointInfoBuilder;
161
162 struct RegisterEndpoint;
163 struct RegisterEndpointBuilder;
164
165 struct AddServiceToEndpoint;
166 struct AddServiceToEndpointBuilder;
167
168 struct EndpointReady;
169 struct EndpointReadyBuilder;
170
171 struct UnregisterEndpoint;
172 struct UnregisterEndpointBuilder;
173
174 struct GetMessageHubsAndEndpointsRequest;
175 struct GetMessageHubsAndEndpointsRequestBuilder;
176
177 struct GetMessageHubsAndEndpointsResponse;
178 struct GetMessageHubsAndEndpointsResponseBuilder;
179
180 struct OpenEndpointSessionRequest;
181 struct OpenEndpointSessionRequestBuilder;
182
183 struct EndpointSessionOpened;
184 struct EndpointSessionOpenedBuilder;
185
186 struct EndpointSessionClosed;
187 struct EndpointSessionClosedBuilder;
188
189 struct EndpointSessionMessage;
190 struct EndpointSessionMessageBuilder;
191
192 struct EndpointSessionMessageDeliveryStatus;
193 struct EndpointSessionMessageDeliveryStatusBuilder;
194
195 struct HostAddress;
196
197 struct MessageContainer;
198 struct MessageContainerBuilder;
199
200 /// An enum describing the setting type.
201 enum class Setting : int8_t {
202 LOCATION = 0,
203 WIFI_AVAILABLE = 1,
204 AIRPLANE_MODE = 2,
205 MICROPHONE = 3,
206 BLE_AVAILABLE = 4,
207 MIN = LOCATION,
208 MAX = BLE_AVAILABLE
209 };
210
EnumValuesSetting()211 inline const Setting (&EnumValuesSetting())[5] {
212 static const Setting values[] = {
213 Setting::LOCATION,
214 Setting::WIFI_AVAILABLE,
215 Setting::AIRPLANE_MODE,
216 Setting::MICROPHONE,
217 Setting::BLE_AVAILABLE
218 };
219 return values;
220 }
221
EnumNamesSetting()222 inline const char * const *EnumNamesSetting() {
223 static const char * const names[6] = {
224 "LOCATION",
225 "WIFI_AVAILABLE",
226 "AIRPLANE_MODE",
227 "MICROPHONE",
228 "BLE_AVAILABLE",
229 nullptr
230 };
231 return names;
232 }
233
EnumNameSetting(Setting e)234 inline const char *EnumNameSetting(Setting e) {
235 if (flatbuffers::IsOutRange(e, Setting::LOCATION, Setting::BLE_AVAILABLE)) return "";
236 const size_t index = static_cast<size_t>(e);
237 return EnumNamesSetting()[index];
238 }
239
240 /// An enum describing the state of a setting.
241 enum class SettingState : int8_t {
242 DISABLED = 0,
243 ENABLED = 1,
244 MIN = DISABLED,
245 MAX = ENABLED
246 };
247
EnumValuesSettingState()248 inline const SettingState (&EnumValuesSettingState())[2] {
249 static const SettingState values[] = {
250 SettingState::DISABLED,
251 SettingState::ENABLED
252 };
253 return values;
254 }
255
EnumNamesSettingState()256 inline const char * const *EnumNamesSettingState() {
257 static const char * const names[3] = {
258 "DISABLED",
259 "ENABLED",
260 nullptr
261 };
262 return names;
263 }
264
EnumNameSettingState(SettingState e)265 inline const char *EnumNameSettingState(SettingState e) {
266 if (flatbuffers::IsOutRange(e, SettingState::DISABLED, SettingState::ENABLED)) return "";
267 const size_t index = static_cast<size_t>(e);
268 return EnumNamesSettingState()[index];
269 }
270
271 enum class LogLevel : int8_t {
272 ERROR = 1,
273 WARNING = 2,
274 INFO = 3,
275 DEBUG = 4,
276 VERBOSE = 5,
277 MIN = ERROR,
278 MAX = VERBOSE
279 };
280
EnumValuesLogLevel()281 inline const LogLevel (&EnumValuesLogLevel())[5] {
282 static const LogLevel values[] = {
283 LogLevel::ERROR,
284 LogLevel::WARNING,
285 LogLevel::INFO,
286 LogLevel::DEBUG,
287 LogLevel::VERBOSE
288 };
289 return values;
290 }
291
EnumNamesLogLevel()292 inline const char * const *EnumNamesLogLevel() {
293 static const char * const names[6] = {
294 "ERROR",
295 "WARNING",
296 "INFO",
297 "DEBUG",
298 "VERBOSE",
299 nullptr
300 };
301 return names;
302 }
303
EnumNameLogLevel(LogLevel e)304 inline const char *EnumNameLogLevel(LogLevel e) {
305 if (flatbuffers::IsOutRange(e, LogLevel::ERROR, LogLevel::VERBOSE)) return "";
306 const size_t index = static_cast<size_t>(e) - static_cast<size_t>(LogLevel::ERROR);
307 return EnumNamesLogLevel()[index];
308 }
309
310 enum class LogType : int8_t {
311 STRING = 0,
312 TOKENIZED = 1,
313 BLUETOOTH = 2,
314 NANOAPP_TOKENIZED = 3,
315 MIN = STRING,
316 MAX = NANOAPP_TOKENIZED
317 };
318
EnumValuesLogType()319 inline const LogType (&EnumValuesLogType())[4] {
320 static const LogType values[] = {
321 LogType::STRING,
322 LogType::TOKENIZED,
323 LogType::BLUETOOTH,
324 LogType::NANOAPP_TOKENIZED
325 };
326 return values;
327 }
328
EnumNamesLogType()329 inline const char * const *EnumNamesLogType() {
330 static const char * const names[5] = {
331 "STRING",
332 "TOKENIZED",
333 "BLUETOOTH",
334 "NANOAPP_TOKENIZED",
335 nullptr
336 };
337 return names;
338 }
339
EnumNameLogType(LogType e)340 inline const char *EnumNameLogType(LogType e) {
341 if (flatbuffers::IsOutRange(e, LogType::STRING, LogType::NANOAPP_TOKENIZED)) return "";
342 const size_t index = static_cast<size_t>(e);
343 return EnumNamesLogType()[index];
344 }
345
346 enum class BtSnoopDirection : int8_t {
347 INCOMING_FROM_BT_CONTROLLER = 0,
348 OUTGOING_TO_ARBITER = 1,
349 MIN = INCOMING_FROM_BT_CONTROLLER,
350 MAX = OUTGOING_TO_ARBITER
351 };
352
EnumValuesBtSnoopDirection()353 inline const BtSnoopDirection (&EnumValuesBtSnoopDirection())[2] {
354 static const BtSnoopDirection values[] = {
355 BtSnoopDirection::INCOMING_FROM_BT_CONTROLLER,
356 BtSnoopDirection::OUTGOING_TO_ARBITER
357 };
358 return values;
359 }
360
EnumNamesBtSnoopDirection()361 inline const char * const *EnumNamesBtSnoopDirection() {
362 static const char * const names[3] = {
363 "INCOMING_FROM_BT_CONTROLLER",
364 "OUTGOING_TO_ARBITER",
365 nullptr
366 };
367 return names;
368 }
369
EnumNameBtSnoopDirection(BtSnoopDirection e)370 inline const char *EnumNameBtSnoopDirection(BtSnoopDirection e) {
371 if (flatbuffers::IsOutRange(e, BtSnoopDirection::INCOMING_FROM_BT_CONTROLLER, BtSnoopDirection::OUTGOING_TO_ARBITER)) return "";
372 const size_t index = static_cast<size_t>(e);
373 return EnumNamesBtSnoopDirection()[index];
374 }
375
376 enum class ChannelInfo : uint8_t {
377 NONE = 0,
378 LeCocChannelInfo = 1,
379 MIN = NONE,
380 MAX = LeCocChannelInfo
381 };
382
EnumValuesChannelInfo()383 inline const ChannelInfo (&EnumValuesChannelInfo())[2] {
384 static const ChannelInfo values[] = {
385 ChannelInfo::NONE,
386 ChannelInfo::LeCocChannelInfo
387 };
388 return values;
389 }
390
EnumNamesChannelInfo()391 inline const char * const *EnumNamesChannelInfo() {
392 static const char * const names[3] = {
393 "NONE",
394 "LeCocChannelInfo",
395 nullptr
396 };
397 return names;
398 }
399
EnumNameChannelInfo(ChannelInfo e)400 inline const char *EnumNameChannelInfo(ChannelInfo e) {
401 if (flatbuffers::IsOutRange(e, ChannelInfo::NONE, ChannelInfo::LeCocChannelInfo)) return "";
402 const size_t index = static_cast<size_t>(e);
403 return EnumNamesChannelInfo()[index];
404 }
405
406 template<typename T> struct ChannelInfoTraits {
407 static const ChannelInfo enum_value = ChannelInfo::NONE;
408 };
409
410 template<> struct ChannelInfoTraits<chre::fbs::LeCocChannelInfo> {
411 static const ChannelInfo enum_value = ChannelInfo::LeCocChannelInfo;
412 };
413
414 bool VerifyChannelInfo(flatbuffers::Verifier &verifier, const void *obj, ChannelInfo type);
415 bool VerifyChannelInfoVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
416
417 enum class BtSocketOpenStatus : int8_t {
418 SUCCESS = 0,
419 FAILURE = 1,
420 MIN = SUCCESS,
421 MAX = FAILURE
422 };
423
424 inline const BtSocketOpenStatus (&EnumValuesBtSocketOpenStatus())[2] {
425 static const BtSocketOpenStatus values[] = {
426 BtSocketOpenStatus::SUCCESS,
427 BtSocketOpenStatus::FAILURE
428 };
429 return values;
430 }
431
432 inline const char * const *EnumNamesBtSocketOpenStatus() {
433 static const char * const names[3] = {
434 "SUCCESS",
435 "FAILURE",
436 nullptr
437 };
438 return names;
439 }
440
441 inline const char *EnumNameBtSocketOpenStatus(BtSocketOpenStatus e) {
442 if (flatbuffers::IsOutRange(e, BtSocketOpenStatus::SUCCESS, BtSocketOpenStatus::FAILURE)) return "";
443 const size_t index = static_cast<size_t>(e);
444 return EnumNamesBtSocketOpenStatus()[index];
445 }
446
447 enum class MessageHubDetails : uint8_t {
448 NONE = 0,
449 HubInfoResponse = 1,
450 VendorHubInfo = 2,
451 MIN = NONE,
452 MAX = VendorHubInfo
453 };
454
455 inline const MessageHubDetails (&EnumValuesMessageHubDetails())[3] {
456 static const MessageHubDetails values[] = {
457 MessageHubDetails::NONE,
458 MessageHubDetails::HubInfoResponse,
459 MessageHubDetails::VendorHubInfo
460 };
461 return values;
462 }
463
464 inline const char * const *EnumNamesMessageHubDetails() {
465 static const char * const names[4] = {
466 "NONE",
467 "HubInfoResponse",
468 "VendorHubInfo",
469 nullptr
470 };
471 return names;
472 }
473
474 inline const char *EnumNameMessageHubDetails(MessageHubDetails e) {
475 if (flatbuffers::IsOutRange(e, MessageHubDetails::NONE, MessageHubDetails::VendorHubInfo)) return "";
476 const size_t index = static_cast<size_t>(e);
477 return EnumNamesMessageHubDetails()[index];
478 }
479
480 template<typename T> struct MessageHubDetailsTraits {
481 static const MessageHubDetails enum_value = MessageHubDetails::NONE;
482 };
483
484 template<> struct MessageHubDetailsTraits<chre::fbs::HubInfoResponse> {
485 static const MessageHubDetails enum_value = MessageHubDetails::HubInfoResponse;
486 };
487
488 template<> struct MessageHubDetailsTraits<chre::fbs::VendorHubInfo> {
489 static const MessageHubDetails enum_value = MessageHubDetails::VendorHubInfo;
490 };
491
492 bool VerifyMessageHubDetails(flatbuffers::Verifier &verifier, const void *obj, MessageHubDetails type);
493 bool VerifyMessageHubDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
494
495 /// An enum describing the type of an endpoint.
496 enum class EndpointType : uint8_t {
497 INVALID = 0,
498 /// The endpoint is part of the Android Framework
499 FRAMEWORK = 1,
500 /// The endpoint is an Android app
501 APP = 2,
502 /// The endpoint is a native Android program
503 NATIVE = 3,
504 /// The endpoint is a nanoapp
505 NANOAPP = 4,
506 /// A generic, non-nanoapp endpoint
507 GENERIC = 5,
508 MIN = INVALID,
509 MAX = GENERIC
510 };
511
512 inline const EndpointType (&EnumValuesEndpointType())[6] {
513 static const EndpointType values[] = {
514 EndpointType::INVALID,
515 EndpointType::FRAMEWORK,
516 EndpointType::APP,
517 EndpointType::NATIVE,
518 EndpointType::NANOAPP,
519 EndpointType::GENERIC
520 };
521 return values;
522 }
523
524 inline const char * const *EnumNamesEndpointType() {
525 static const char * const names[7] = {
526 "INVALID",
527 "FRAMEWORK",
528 "APP",
529 "NATIVE",
530 "NANOAPP",
531 "GENERIC",
532 nullptr
533 };
534 return names;
535 }
536
537 inline const char *EnumNameEndpointType(EndpointType e) {
538 if (flatbuffers::IsOutRange(e, EndpointType::INVALID, EndpointType::GENERIC)) return "";
539 const size_t index = static_cast<size_t>(e);
540 return EnumNamesEndpointType()[index];
541 }
542
543 enum class RpcFormat : uint8_t {
544 /// Fully custom format
545 CUSTOM = 0,
546 /// Stable AIDL defined interface using Binder marshalling
547 AIDL = 1,
548 /// Pigweed RPC defined interface using Protobuf marshalling
549 PW_RPC = 2,
550 MIN = CUSTOM,
551 MAX = PW_RPC
552 };
553
554 inline const RpcFormat (&EnumValuesRpcFormat())[3] {
555 static const RpcFormat values[] = {
556 RpcFormat::CUSTOM,
557 RpcFormat::AIDL,
558 RpcFormat::PW_RPC
559 };
560 return values;
561 }
562
563 inline const char * const *EnumNamesRpcFormat() {
564 static const char * const names[4] = {
565 "CUSTOM",
566 "AIDL",
567 "PW_RPC",
568 nullptr
569 };
570 return names;
571 }
572
573 inline const char *EnumNameRpcFormat(RpcFormat e) {
574 if (flatbuffers::IsOutRange(e, RpcFormat::CUSTOM, RpcFormat::PW_RPC)) return "";
575 const size_t index = static_cast<size_t>(e);
576 return EnumNamesRpcFormat()[index];
577 }
578
579 /// "Reason"s for stopping an endpoint or session over an endpoint.
580 enum class Reason : uint8_t {
581 /// Unspecified reason.
582 UNSPECIFIED = 0,
583 /// Out of memory. There's not enough memory to perform this operation.
584 OUT_OF_MEMORY = 1,
585 /// Timeout. This operation timed out.
586 TIMEOUT = 2,
587 /// Endpoint rejected this openEndpointSession request.
588 OPEN_ENDPOINT_SESSION_REQUEST_REJECTED = 3,
589 /// Endpoint requested closeEndpointSession.
590 CLOSE_ENDPOINT_SESSION_REQUESTED = 4,
591 /// Invalid endpoint.
592 ENDPOINT_INVALID = 5,
593 /// Endpoint is now stopped.
594 ENDPOINT_GONE = 6,
595 /// Endpoint crashed.
596 ENDPOINT_CRASHED = 7,
597 /// Hub was reset or is resetting.
598 HUB_RESET = 8,
599 MIN = UNSPECIFIED,
600 MAX = HUB_RESET
601 };
602
603 inline const Reason (&EnumValuesReason())[9] {
604 static const Reason values[] = {
605 Reason::UNSPECIFIED,
606 Reason::OUT_OF_MEMORY,
607 Reason::TIMEOUT,
608 Reason::OPEN_ENDPOINT_SESSION_REQUEST_REJECTED,
609 Reason::CLOSE_ENDPOINT_SESSION_REQUESTED,
610 Reason::ENDPOINT_INVALID,
611 Reason::ENDPOINT_GONE,
612 Reason::ENDPOINT_CRASHED,
613 Reason::HUB_RESET
614 };
615 return values;
616 }
617
618 inline const char * const *EnumNamesReason() {
619 static const char * const names[10] = {
620 "UNSPECIFIED",
621 "OUT_OF_MEMORY",
622 "TIMEOUT",
623 "OPEN_ENDPOINT_SESSION_REQUEST_REJECTED",
624 "CLOSE_ENDPOINT_SESSION_REQUESTED",
625 "ENDPOINT_INVALID",
626 "ENDPOINT_GONE",
627 "ENDPOINT_CRASHED",
628 "HUB_RESET",
629 nullptr
630 };
631 return names;
632 }
633
634 inline const char *EnumNameReason(Reason e) {
635 if (flatbuffers::IsOutRange(e, Reason::UNSPECIFIED, Reason::HUB_RESET)) return "";
636 const size_t index = static_cast<size_t>(e);
637 return EnumNamesReason()[index];
638 }
639
640 /// A union that joins together all possible messages. Note that in FlatBuffers,
641 /// unions have an implicit type
642 enum class ChreMessage : uint8_t {
643 NONE = 0,
644 NanoappMessage = 1,
645 HubInfoRequest = 2,
646 HubInfoResponse = 3,
647 NanoappListRequest = 4,
648 NanoappListResponse = 5,
649 LoadNanoappRequest = 6,
650 LoadNanoappResponse = 7,
651 UnloadNanoappRequest = 8,
652 UnloadNanoappResponse = 9,
653 LogMessage = 10,
654 TimeSyncMessage = 11,
655 DebugDumpRequest = 12,
656 DebugDumpData = 13,
657 DebugDumpResponse = 14,
658 TimeSyncRequest = 15,
659 LowPowerMicAccessRequest = 16,
660 LowPowerMicAccessRelease = 17,
661 SettingChangeMessage = 18,
662 LogMessageV2 = 19,
663 SelfTestRequest = 20,
664 SelfTestResponse = 21,
665 HostEndpointConnected = 22,
666 HostEndpointDisconnected = 23,
667 MetricLog = 24,
668 BatchedMetricLog = 25,
669 NanConfigurationRequest = 26,
670 NanConfigurationUpdate = 27,
671 DebugConfiguration = 28,
672 PulseRequest = 29,
673 PulseResponse = 30,
674 NanoappTokenDatabaseInfo = 31,
675 MessageDeliveryStatus = 32,
676 BtSocketOpen = 33,
677 BtSocketOpenResponse = 34,
678 BtSocketClose = 35,
679 BtSocketCloseResponse = 36,
680 GetMessageHubsAndEndpointsRequest = 37,
681 GetMessageHubsAndEndpointsResponse = 38,
682 RegisterMessageHub = 39,
683 UnregisterMessageHub = 40,
684 RegisterEndpoint = 41,
685 UnregisterEndpoint = 42,
686 OpenEndpointSessionRequest = 43,
687 EndpointSessionOpened = 44,
688 EndpointSessionClosed = 45,
689 EndpointSessionMessage = 46,
690 EndpointSessionMessageDeliveryStatus = 47,
691 BtSocketCapabilitiesRequest = 48,
692 BtSocketCapabilitiesResponse = 49,
693 AddServiceToEndpoint = 50,
694 EndpointReady = 51,
695 MIN = NONE,
696 MAX = EndpointReady
697 };
698
699 inline const ChreMessage (&EnumValuesChreMessage())[52] {
700 static const ChreMessage values[] = {
701 ChreMessage::NONE,
702 ChreMessage::NanoappMessage,
703 ChreMessage::HubInfoRequest,
704 ChreMessage::HubInfoResponse,
705 ChreMessage::NanoappListRequest,
706 ChreMessage::NanoappListResponse,
707 ChreMessage::LoadNanoappRequest,
708 ChreMessage::LoadNanoappResponse,
709 ChreMessage::UnloadNanoappRequest,
710 ChreMessage::UnloadNanoappResponse,
711 ChreMessage::LogMessage,
712 ChreMessage::TimeSyncMessage,
713 ChreMessage::DebugDumpRequest,
714 ChreMessage::DebugDumpData,
715 ChreMessage::DebugDumpResponse,
716 ChreMessage::TimeSyncRequest,
717 ChreMessage::LowPowerMicAccessRequest,
718 ChreMessage::LowPowerMicAccessRelease,
719 ChreMessage::SettingChangeMessage,
720 ChreMessage::LogMessageV2,
721 ChreMessage::SelfTestRequest,
722 ChreMessage::SelfTestResponse,
723 ChreMessage::HostEndpointConnected,
724 ChreMessage::HostEndpointDisconnected,
725 ChreMessage::MetricLog,
726 ChreMessage::BatchedMetricLog,
727 ChreMessage::NanConfigurationRequest,
728 ChreMessage::NanConfigurationUpdate,
729 ChreMessage::DebugConfiguration,
730 ChreMessage::PulseRequest,
731 ChreMessage::PulseResponse,
732 ChreMessage::NanoappTokenDatabaseInfo,
733 ChreMessage::MessageDeliveryStatus,
734 ChreMessage::BtSocketOpen,
735 ChreMessage::BtSocketOpenResponse,
736 ChreMessage::BtSocketClose,
737 ChreMessage::BtSocketCloseResponse,
738 ChreMessage::GetMessageHubsAndEndpointsRequest,
739 ChreMessage::GetMessageHubsAndEndpointsResponse,
740 ChreMessage::RegisterMessageHub,
741 ChreMessage::UnregisterMessageHub,
742 ChreMessage::RegisterEndpoint,
743 ChreMessage::UnregisterEndpoint,
744 ChreMessage::OpenEndpointSessionRequest,
745 ChreMessage::EndpointSessionOpened,
746 ChreMessage::EndpointSessionClosed,
747 ChreMessage::EndpointSessionMessage,
748 ChreMessage::EndpointSessionMessageDeliveryStatus,
749 ChreMessage::BtSocketCapabilitiesRequest,
750 ChreMessage::BtSocketCapabilitiesResponse,
751 ChreMessage::AddServiceToEndpoint,
752 ChreMessage::EndpointReady
753 };
754 return values;
755 }
756
757 inline const char * const *EnumNamesChreMessage() {
758 static const char * const names[53] = {
759 "NONE",
760 "NanoappMessage",
761 "HubInfoRequest",
762 "HubInfoResponse",
763 "NanoappListRequest",
764 "NanoappListResponse",
765 "LoadNanoappRequest",
766 "LoadNanoappResponse",
767 "UnloadNanoappRequest",
768 "UnloadNanoappResponse",
769 "LogMessage",
770 "TimeSyncMessage",
771 "DebugDumpRequest",
772 "DebugDumpData",
773 "DebugDumpResponse",
774 "TimeSyncRequest",
775 "LowPowerMicAccessRequest",
776 "LowPowerMicAccessRelease",
777 "SettingChangeMessage",
778 "LogMessageV2",
779 "SelfTestRequest",
780 "SelfTestResponse",
781 "HostEndpointConnected",
782 "HostEndpointDisconnected",
783 "MetricLog",
784 "BatchedMetricLog",
785 "NanConfigurationRequest",
786 "NanConfigurationUpdate",
787 "DebugConfiguration",
788 "PulseRequest",
789 "PulseResponse",
790 "NanoappTokenDatabaseInfo",
791 "MessageDeliveryStatus",
792 "BtSocketOpen",
793 "BtSocketOpenResponse",
794 "BtSocketClose",
795 "BtSocketCloseResponse",
796 "GetMessageHubsAndEndpointsRequest",
797 "GetMessageHubsAndEndpointsResponse",
798 "RegisterMessageHub",
799 "UnregisterMessageHub",
800 "RegisterEndpoint",
801 "UnregisterEndpoint",
802 "OpenEndpointSessionRequest",
803 "EndpointSessionOpened",
804 "EndpointSessionClosed",
805 "EndpointSessionMessage",
806 "EndpointSessionMessageDeliveryStatus",
807 "BtSocketCapabilitiesRequest",
808 "BtSocketCapabilitiesResponse",
809 "AddServiceToEndpoint",
810 "EndpointReady",
811 nullptr
812 };
813 return names;
814 }
815
816 inline const char *EnumNameChreMessage(ChreMessage e) {
817 if (flatbuffers::IsOutRange(e, ChreMessage::NONE, ChreMessage::EndpointReady)) return "";
818 const size_t index = static_cast<size_t>(e);
819 return EnumNamesChreMessage()[index];
820 }
821
822 template<typename T> struct ChreMessageTraits {
823 static const ChreMessage enum_value = ChreMessage::NONE;
824 };
825
826 template<> struct ChreMessageTraits<chre::fbs::NanoappMessage> {
827 static const ChreMessage enum_value = ChreMessage::NanoappMessage;
828 };
829
830 template<> struct ChreMessageTraits<chre::fbs::HubInfoRequest> {
831 static const ChreMessage enum_value = ChreMessage::HubInfoRequest;
832 };
833
834 template<> struct ChreMessageTraits<chre::fbs::HubInfoResponse> {
835 static const ChreMessage enum_value = ChreMessage::HubInfoResponse;
836 };
837
838 template<> struct ChreMessageTraits<chre::fbs::NanoappListRequest> {
839 static const ChreMessage enum_value = ChreMessage::NanoappListRequest;
840 };
841
842 template<> struct ChreMessageTraits<chre::fbs::NanoappListResponse> {
843 static const ChreMessage enum_value = ChreMessage::NanoappListResponse;
844 };
845
846 template<> struct ChreMessageTraits<chre::fbs::LoadNanoappRequest> {
847 static const ChreMessage enum_value = ChreMessage::LoadNanoappRequest;
848 };
849
850 template<> struct ChreMessageTraits<chre::fbs::LoadNanoappResponse> {
851 static const ChreMessage enum_value = ChreMessage::LoadNanoappResponse;
852 };
853
854 template<> struct ChreMessageTraits<chre::fbs::UnloadNanoappRequest> {
855 static const ChreMessage enum_value = ChreMessage::UnloadNanoappRequest;
856 };
857
858 template<> struct ChreMessageTraits<chre::fbs::UnloadNanoappResponse> {
859 static const ChreMessage enum_value = ChreMessage::UnloadNanoappResponse;
860 };
861
862 template<> struct ChreMessageTraits<chre::fbs::LogMessage> {
863 static const ChreMessage enum_value = ChreMessage::LogMessage;
864 };
865
866 template<> struct ChreMessageTraits<chre::fbs::TimeSyncMessage> {
867 static const ChreMessage enum_value = ChreMessage::TimeSyncMessage;
868 };
869
870 template<> struct ChreMessageTraits<chre::fbs::DebugDumpRequest> {
871 static const ChreMessage enum_value = ChreMessage::DebugDumpRequest;
872 };
873
874 template<> struct ChreMessageTraits<chre::fbs::DebugDumpData> {
875 static const ChreMessage enum_value = ChreMessage::DebugDumpData;
876 };
877
878 template<> struct ChreMessageTraits<chre::fbs::DebugDumpResponse> {
879 static const ChreMessage enum_value = ChreMessage::DebugDumpResponse;
880 };
881
882 template<> struct ChreMessageTraits<chre::fbs::TimeSyncRequest> {
883 static const ChreMessage enum_value = ChreMessage::TimeSyncRequest;
884 };
885
886 template<> struct ChreMessageTraits<chre::fbs::LowPowerMicAccessRequest> {
887 static const ChreMessage enum_value = ChreMessage::LowPowerMicAccessRequest;
888 };
889
890 template<> struct ChreMessageTraits<chre::fbs::LowPowerMicAccessRelease> {
891 static const ChreMessage enum_value = ChreMessage::LowPowerMicAccessRelease;
892 };
893
894 template<> struct ChreMessageTraits<chre::fbs::SettingChangeMessage> {
895 static const ChreMessage enum_value = ChreMessage::SettingChangeMessage;
896 };
897
898 template<> struct ChreMessageTraits<chre::fbs::LogMessageV2> {
899 static const ChreMessage enum_value = ChreMessage::LogMessageV2;
900 };
901
902 template<> struct ChreMessageTraits<chre::fbs::SelfTestRequest> {
903 static const ChreMessage enum_value = ChreMessage::SelfTestRequest;
904 };
905
906 template<> struct ChreMessageTraits<chre::fbs::SelfTestResponse> {
907 static const ChreMessage enum_value = ChreMessage::SelfTestResponse;
908 };
909
910 template<> struct ChreMessageTraits<chre::fbs::HostEndpointConnected> {
911 static const ChreMessage enum_value = ChreMessage::HostEndpointConnected;
912 };
913
914 template<> struct ChreMessageTraits<chre::fbs::HostEndpointDisconnected> {
915 static const ChreMessage enum_value = ChreMessage::HostEndpointDisconnected;
916 };
917
918 template<> struct ChreMessageTraits<chre::fbs::MetricLog> {
919 static const ChreMessage enum_value = ChreMessage::MetricLog;
920 };
921
922 template<> struct ChreMessageTraits<chre::fbs::BatchedMetricLog> {
923 static const ChreMessage enum_value = ChreMessage::BatchedMetricLog;
924 };
925
926 template<> struct ChreMessageTraits<chre::fbs::NanConfigurationRequest> {
927 static const ChreMessage enum_value = ChreMessage::NanConfigurationRequest;
928 };
929
930 template<> struct ChreMessageTraits<chre::fbs::NanConfigurationUpdate> {
931 static const ChreMessage enum_value = ChreMessage::NanConfigurationUpdate;
932 };
933
934 template<> struct ChreMessageTraits<chre::fbs::DebugConfiguration> {
935 static const ChreMessage enum_value = ChreMessage::DebugConfiguration;
936 };
937
938 template<> struct ChreMessageTraits<chre::fbs::PulseRequest> {
939 static const ChreMessage enum_value = ChreMessage::PulseRequest;
940 };
941
942 template<> struct ChreMessageTraits<chre::fbs::PulseResponse> {
943 static const ChreMessage enum_value = ChreMessage::PulseResponse;
944 };
945
946 template<> struct ChreMessageTraits<chre::fbs::NanoappTokenDatabaseInfo> {
947 static const ChreMessage enum_value = ChreMessage::NanoappTokenDatabaseInfo;
948 };
949
950 template<> struct ChreMessageTraits<chre::fbs::MessageDeliveryStatus> {
951 static const ChreMessage enum_value = ChreMessage::MessageDeliveryStatus;
952 };
953
954 template<> struct ChreMessageTraits<chre::fbs::BtSocketOpen> {
955 static const ChreMessage enum_value = ChreMessage::BtSocketOpen;
956 };
957
958 template<> struct ChreMessageTraits<chre::fbs::BtSocketOpenResponse> {
959 static const ChreMessage enum_value = ChreMessage::BtSocketOpenResponse;
960 };
961
962 template<> struct ChreMessageTraits<chre::fbs::BtSocketClose> {
963 static const ChreMessage enum_value = ChreMessage::BtSocketClose;
964 };
965
966 template<> struct ChreMessageTraits<chre::fbs::BtSocketCloseResponse> {
967 static const ChreMessage enum_value = ChreMessage::BtSocketCloseResponse;
968 };
969
970 template<> struct ChreMessageTraits<chre::fbs::GetMessageHubsAndEndpointsRequest> {
971 static const ChreMessage enum_value = ChreMessage::GetMessageHubsAndEndpointsRequest;
972 };
973
974 template<> struct ChreMessageTraits<chre::fbs::GetMessageHubsAndEndpointsResponse> {
975 static const ChreMessage enum_value = ChreMessage::GetMessageHubsAndEndpointsResponse;
976 };
977
978 template<> struct ChreMessageTraits<chre::fbs::RegisterMessageHub> {
979 static const ChreMessage enum_value = ChreMessage::RegisterMessageHub;
980 };
981
982 template<> struct ChreMessageTraits<chre::fbs::UnregisterMessageHub> {
983 static const ChreMessage enum_value = ChreMessage::UnregisterMessageHub;
984 };
985
986 template<> struct ChreMessageTraits<chre::fbs::RegisterEndpoint> {
987 static const ChreMessage enum_value = ChreMessage::RegisterEndpoint;
988 };
989
990 template<> struct ChreMessageTraits<chre::fbs::UnregisterEndpoint> {
991 static const ChreMessage enum_value = ChreMessage::UnregisterEndpoint;
992 };
993
994 template<> struct ChreMessageTraits<chre::fbs::OpenEndpointSessionRequest> {
995 static const ChreMessage enum_value = ChreMessage::OpenEndpointSessionRequest;
996 };
997
998 template<> struct ChreMessageTraits<chre::fbs::EndpointSessionOpened> {
999 static const ChreMessage enum_value = ChreMessage::EndpointSessionOpened;
1000 };
1001
1002 template<> struct ChreMessageTraits<chre::fbs::EndpointSessionClosed> {
1003 static const ChreMessage enum_value = ChreMessage::EndpointSessionClosed;
1004 };
1005
1006 template<> struct ChreMessageTraits<chre::fbs::EndpointSessionMessage> {
1007 static const ChreMessage enum_value = ChreMessage::EndpointSessionMessage;
1008 };
1009
1010 template<> struct ChreMessageTraits<chre::fbs::EndpointSessionMessageDeliveryStatus> {
1011 static const ChreMessage enum_value = ChreMessage::EndpointSessionMessageDeliveryStatus;
1012 };
1013
1014 template<> struct ChreMessageTraits<chre::fbs::BtSocketCapabilitiesRequest> {
1015 static const ChreMessage enum_value = ChreMessage::BtSocketCapabilitiesRequest;
1016 };
1017
1018 template<> struct ChreMessageTraits<chre::fbs::BtSocketCapabilitiesResponse> {
1019 static const ChreMessage enum_value = ChreMessage::BtSocketCapabilitiesResponse;
1020 };
1021
1022 template<> struct ChreMessageTraits<chre::fbs::AddServiceToEndpoint> {
1023 static const ChreMessage enum_value = ChreMessage::AddServiceToEndpoint;
1024 };
1025
1026 template<> struct ChreMessageTraits<chre::fbs::EndpointReady> {
1027 static const ChreMessage enum_value = ChreMessage::EndpointReady;
1028 };
1029
1030 bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type);
1031 bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
1032
1033 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) HostAddress FLATBUFFERS_FINAL_CLASS {
1034 private:
1035 uint16_t client_id_;
1036
1037 public:
1038 HostAddress() {
1039 memset(static_cast<void *>(this), 0, sizeof(HostAddress));
1040 }
1041 HostAddress(uint16_t _client_id)
1042 : client_id_(flatbuffers::EndianScalar(_client_id)) {
1043 }
1044 uint16_t client_id() const {
1045 return flatbuffers::EndianScalar(client_id_);
1046 }
1047 };
1048 FLATBUFFERS_STRUCT_END(HostAddress, 2);
1049
1050 /// Represents a message sent to/from a nanoapp from/to a client on the host
1051 struct NanoappMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1052 typedef NanoappMessageBuilder Builder;
1053 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1054 VT_APP_ID = 4,
1055 VT_MESSAGE_TYPE = 6,
1056 VT_HOST_ENDPOINT = 8,
1057 VT_MESSAGE = 10,
1058 VT_MESSAGE_PERMISSIONS = 12,
1059 VT_PERMISSIONS = 14,
1060 VT_WOKE_HOST = 16,
1061 VT_IS_RELIABLE = 18,
1062 VT_MESSAGE_SEQUENCE_NUMBER = 20
1063 };
1064 uint64_t app_id() const {
1065 return GetField<uint64_t>(VT_APP_ID, 0);
1066 }
1067 uint32_t message_type() const {
1068 return GetField<uint32_t>(VT_MESSAGE_TYPE, 0);
1069 }
1070 /// Identifies the host-side endpoint on the host that sent or should receive
1071 /// this message. The default value is a special value defined in the HAL and
1072 /// elsewhere that indicates that the endpoint is unspecified.
1073 uint16_t host_endpoint() const {
1074 return GetField<uint16_t>(VT_HOST_ENDPOINT, 65534);
1075 }
1076 /// Vector containing arbitrary application-specific message data
1077 const flatbuffers::Vector<uint8_t> *message() const {
1078 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MESSAGE);
1079 }
1080 /// List of Android permissions that cover the contents of a message from a
1081 /// nanoapp to the host.
1082 /// These permissions are used to record and attribute access to
1083 /// permissions-controlled resources.
1084 uint32_t message_permissions() const {
1085 return GetField<uint32_t>(VT_MESSAGE_PERMISSIONS, 0);
1086 }
1087 /// List of Android permissions declared by the nanoapp / granted to the host.
1088 /// For messages from a nanoaapp to the host, this must be a superset of
1089 /// message_permissions.
1090 uint32_t permissions() const {
1091 return GetField<uint32_t>(VT_PERMISSIONS, 0);
1092 }
1093 bool woke_host() const {
1094 return GetField<uint8_t>(VT_WOKE_HOST, 0) != 0;
1095 }
1096 bool is_reliable() const {
1097 return GetField<uint8_t>(VT_IS_RELIABLE, 0) != 0;
1098 }
1099 uint32_t message_sequence_number() const {
1100 return GetField<uint32_t>(VT_MESSAGE_SEQUENCE_NUMBER, 0);
1101 }
1102 bool Verify(flatbuffers::Verifier &verifier) const {
1103 return VerifyTableStart(verifier) &&
1104 VerifyField<uint64_t>(verifier, VT_APP_ID) &&
1105 VerifyField<uint32_t>(verifier, VT_MESSAGE_TYPE) &&
1106 VerifyField<uint16_t>(verifier, VT_HOST_ENDPOINT) &&
1107 VerifyOffsetRequired(verifier, VT_MESSAGE) &&
1108 verifier.VerifyVector(message()) &&
1109 VerifyField<uint32_t>(verifier, VT_MESSAGE_PERMISSIONS) &&
1110 VerifyField<uint32_t>(verifier, VT_PERMISSIONS) &&
1111 VerifyField<uint8_t>(verifier, VT_WOKE_HOST) &&
1112 VerifyField<uint8_t>(verifier, VT_IS_RELIABLE) &&
1113 VerifyField<uint32_t>(verifier, VT_MESSAGE_SEQUENCE_NUMBER) &&
1114 verifier.EndTable();
1115 }
1116 };
1117
1118 struct NanoappMessageBuilder {
1119 typedef NanoappMessage Table;
1120 flatbuffers::FlatBufferBuilder &fbb_;
1121 flatbuffers::uoffset_t start_;
1122 void add_app_id(uint64_t app_id) {
1123 fbb_.AddElement<uint64_t>(NanoappMessage::VT_APP_ID, app_id, 0);
1124 }
1125 void add_message_type(uint32_t message_type) {
1126 fbb_.AddElement<uint32_t>(NanoappMessage::VT_MESSAGE_TYPE, message_type, 0);
1127 }
1128 void add_host_endpoint(uint16_t host_endpoint) {
1129 fbb_.AddElement<uint16_t>(NanoappMessage::VT_HOST_ENDPOINT, host_endpoint, 65534);
1130 }
1131 void add_message(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message) {
1132 fbb_.AddOffset(NanoappMessage::VT_MESSAGE, message);
1133 }
1134 void add_message_permissions(uint32_t message_permissions) {
1135 fbb_.AddElement<uint32_t>(NanoappMessage::VT_MESSAGE_PERMISSIONS, message_permissions, 0);
1136 }
1137 void add_permissions(uint32_t permissions) {
1138 fbb_.AddElement<uint32_t>(NanoappMessage::VT_PERMISSIONS, permissions, 0);
1139 }
1140 void add_woke_host(bool woke_host) {
1141 fbb_.AddElement<uint8_t>(NanoappMessage::VT_WOKE_HOST, static_cast<uint8_t>(woke_host), 0);
1142 }
1143 void add_is_reliable(bool is_reliable) {
1144 fbb_.AddElement<uint8_t>(NanoappMessage::VT_IS_RELIABLE, static_cast<uint8_t>(is_reliable), 0);
1145 }
1146 void add_message_sequence_number(uint32_t message_sequence_number) {
1147 fbb_.AddElement<uint32_t>(NanoappMessage::VT_MESSAGE_SEQUENCE_NUMBER, message_sequence_number, 0);
1148 }
1149 explicit NanoappMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1150 : fbb_(_fbb) {
1151 start_ = fbb_.StartTable();
1152 }
1153 NanoappMessageBuilder &operator=(const NanoappMessageBuilder &);
1154 flatbuffers::Offset<NanoappMessage> Finish() {
1155 const auto end = fbb_.EndTable(start_);
1156 auto o = flatbuffers::Offset<NanoappMessage>(end);
1157 fbb_.Required(o, NanoappMessage::VT_MESSAGE);
1158 return o;
1159 }
1160 };
1161
1162 inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessage(
1163 flatbuffers::FlatBufferBuilder &_fbb,
1164 uint64_t app_id = 0,
1165 uint32_t message_type = 0,
1166 uint16_t host_endpoint = 65534,
1167 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message = 0,
1168 uint32_t message_permissions = 0,
1169 uint32_t permissions = 0,
1170 bool woke_host = false,
1171 bool is_reliable = false,
1172 uint32_t message_sequence_number = 0) {
1173 NanoappMessageBuilder builder_(_fbb);
1174 builder_.add_app_id(app_id);
1175 builder_.add_message_sequence_number(message_sequence_number);
1176 builder_.add_permissions(permissions);
1177 builder_.add_message_permissions(message_permissions);
1178 builder_.add_message(message);
1179 builder_.add_message_type(message_type);
1180 builder_.add_host_endpoint(host_endpoint);
1181 builder_.add_is_reliable(is_reliable);
1182 builder_.add_woke_host(woke_host);
1183 return builder_.Finish();
1184 }
1185
1186 inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessageDirect(
1187 flatbuffers::FlatBufferBuilder &_fbb,
1188 uint64_t app_id = 0,
1189 uint32_t message_type = 0,
1190 uint16_t host_endpoint = 65534,
1191 const std::vector<uint8_t> *message = nullptr,
1192 uint32_t message_permissions = 0,
1193 uint32_t permissions = 0,
1194 bool woke_host = false,
1195 bool is_reliable = false,
1196 uint32_t message_sequence_number = 0) {
1197 auto message__ = message ? _fbb.CreateVector<uint8_t>(*message) : 0;
1198 return chre::fbs::CreateNanoappMessage(
1199 _fbb,
1200 app_id,
1201 message_type,
1202 host_endpoint,
1203 message__,
1204 message_permissions,
1205 permissions,
1206 woke_host,
1207 is_reliable,
1208 message_sequence_number);
1209 }
1210
1211 struct MessageDeliveryStatus FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1212 typedef MessageDeliveryStatusBuilder Builder;
1213 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1214 VT_MESSAGE_SEQUENCE_NUMBER = 4,
1215 VT_ERROR_CODE = 6
1216 };
1217 uint32_t message_sequence_number() const {
1218 return GetField<uint32_t>(VT_MESSAGE_SEQUENCE_NUMBER, 0);
1219 }
1220 int8_t error_code() const {
1221 return GetField<int8_t>(VT_ERROR_CODE, 0);
1222 }
1223 bool Verify(flatbuffers::Verifier &verifier) const {
1224 return VerifyTableStart(verifier) &&
1225 VerifyField<uint32_t>(verifier, VT_MESSAGE_SEQUENCE_NUMBER) &&
1226 VerifyField<int8_t>(verifier, VT_ERROR_CODE) &&
1227 verifier.EndTable();
1228 }
1229 };
1230
1231 struct MessageDeliveryStatusBuilder {
1232 typedef MessageDeliveryStatus Table;
1233 flatbuffers::FlatBufferBuilder &fbb_;
1234 flatbuffers::uoffset_t start_;
1235 void add_message_sequence_number(uint32_t message_sequence_number) {
1236 fbb_.AddElement<uint32_t>(MessageDeliveryStatus::VT_MESSAGE_SEQUENCE_NUMBER, message_sequence_number, 0);
1237 }
1238 void add_error_code(int8_t error_code) {
1239 fbb_.AddElement<int8_t>(MessageDeliveryStatus::VT_ERROR_CODE, error_code, 0);
1240 }
1241 explicit MessageDeliveryStatusBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1242 : fbb_(_fbb) {
1243 start_ = fbb_.StartTable();
1244 }
1245 MessageDeliveryStatusBuilder &operator=(const MessageDeliveryStatusBuilder &);
1246 flatbuffers::Offset<MessageDeliveryStatus> Finish() {
1247 const auto end = fbb_.EndTable(start_);
1248 auto o = flatbuffers::Offset<MessageDeliveryStatus>(end);
1249 return o;
1250 }
1251 };
1252
1253 inline flatbuffers::Offset<MessageDeliveryStatus> CreateMessageDeliveryStatus(
1254 flatbuffers::FlatBufferBuilder &_fbb,
1255 uint32_t message_sequence_number = 0,
1256 int8_t error_code = 0) {
1257 MessageDeliveryStatusBuilder builder_(_fbb);
1258 builder_.add_message_sequence_number(message_sequence_number);
1259 builder_.add_error_code(error_code);
1260 return builder_.Finish();
1261 }
1262
1263 struct HubInfoRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1264 typedef HubInfoRequestBuilder Builder;
1265 bool Verify(flatbuffers::Verifier &verifier) const {
1266 return VerifyTableStart(verifier) &&
1267 verifier.EndTable();
1268 }
1269 };
1270
1271 struct HubInfoRequestBuilder {
1272 typedef HubInfoRequest Table;
1273 flatbuffers::FlatBufferBuilder &fbb_;
1274 flatbuffers::uoffset_t start_;
1275 explicit HubInfoRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1276 : fbb_(_fbb) {
1277 start_ = fbb_.StartTable();
1278 }
1279 HubInfoRequestBuilder &operator=(const HubInfoRequestBuilder &);
1280 flatbuffers::Offset<HubInfoRequest> Finish() {
1281 const auto end = fbb_.EndTable(start_);
1282 auto o = flatbuffers::Offset<HubInfoRequest>(end);
1283 return o;
1284 }
1285 };
1286
1287 inline flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest(
1288 flatbuffers::FlatBufferBuilder &_fbb) {
1289 HubInfoRequestBuilder builder_(_fbb);
1290 return builder_.Finish();
1291 }
1292
1293 struct HubInfoResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1294 typedef HubInfoResponseBuilder Builder;
1295 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1296 VT_NAME = 4,
1297 VT_VENDOR = 6,
1298 VT_TOOLCHAIN = 8,
1299 VT_PLATFORM_VERSION = 10,
1300 VT_TOOLCHAIN_VERSION = 12,
1301 VT_PEAK_MIPS = 14,
1302 VT_STOPPED_POWER = 16,
1303 VT_SLEEP_POWER = 18,
1304 VT_PEAK_POWER = 20,
1305 VT_MAX_MSG_LEN = 22,
1306 VT_PLATFORM_ID = 24,
1307 VT_CHRE_PLATFORM_VERSION = 26,
1308 VT_SUPPORTS_RELIABLE_MESSAGES = 28
1309 };
1310 /// The name of the hub. Nominally a UTF-8 string, but note that we're not
1311 /// using the built-in "string" data type from FlatBuffers here, because the
1312 /// generated C++ uses std::string which is not well-supported in CHRE. This
1313 /// applies for vendor and toolchain as well.
1314 const flatbuffers::Vector<int8_t> *name() const {
1315 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_NAME);
1316 }
1317 const flatbuffers::Vector<int8_t> *vendor() const {
1318 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_VENDOR);
1319 }
1320 const flatbuffers::Vector<int8_t> *toolchain() const {
1321 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_TOOLCHAIN);
1322 }
1323 /// Legacy platform version reported in the HAL; semantics not strictly
1324 /// defined
1325 uint32_t platform_version() const {
1326 return GetField<uint32_t>(VT_PLATFORM_VERSION, 0);
1327 }
1328 /// Toolchain version reported in the HAL; semantics not strictly defined
1329 uint32_t toolchain_version() const {
1330 return GetField<uint32_t>(VT_TOOLCHAIN_VERSION, 0);
1331 }
1332 float peak_mips() const {
1333 return GetField<float>(VT_PEAK_MIPS, 0.0f);
1334 }
1335 float stopped_power() const {
1336 return GetField<float>(VT_STOPPED_POWER, 0.0f);
1337 }
1338 float sleep_power() const {
1339 return GetField<float>(VT_SLEEP_POWER, 0.0f);
1340 }
1341 float peak_power() const {
1342 return GetField<float>(VT_PEAK_POWER, 0.0f);
1343 }
1344 /// Maximum size regular message that can be sent to a nanoapp
1345 uint32_t max_msg_len() const {
1346 return GetField<uint32_t>(VT_MAX_MSG_LEN, 0);
1347 }
1348 /// @see chreGetPlatformId()
1349 uint64_t platform_id() const {
1350 return GetField<uint64_t>(VT_PLATFORM_ID, 0);
1351 }
1352 /// @see chreGetVersion()
1353 uint32_t chre_platform_version() const {
1354 return GetField<uint32_t>(VT_CHRE_PLATFORM_VERSION, 0);
1355 }
1356 /// Whether reliable messages are supported
1357 bool supports_reliable_messages() const {
1358 return GetField<uint8_t>(VT_SUPPORTS_RELIABLE_MESSAGES, 0) != 0;
1359 }
1360 bool Verify(flatbuffers::Verifier &verifier) const {
1361 return VerifyTableStart(verifier) &&
1362 VerifyOffset(verifier, VT_NAME) &&
1363 verifier.VerifyVector(name()) &&
1364 VerifyOffset(verifier, VT_VENDOR) &&
1365 verifier.VerifyVector(vendor()) &&
1366 VerifyOffset(verifier, VT_TOOLCHAIN) &&
1367 verifier.VerifyVector(toolchain()) &&
1368 VerifyField<uint32_t>(verifier, VT_PLATFORM_VERSION) &&
1369 VerifyField<uint32_t>(verifier, VT_TOOLCHAIN_VERSION) &&
1370 VerifyField<float>(verifier, VT_PEAK_MIPS) &&
1371 VerifyField<float>(verifier, VT_STOPPED_POWER) &&
1372 VerifyField<float>(verifier, VT_SLEEP_POWER) &&
1373 VerifyField<float>(verifier, VT_PEAK_POWER) &&
1374 VerifyField<uint32_t>(verifier, VT_MAX_MSG_LEN) &&
1375 VerifyField<uint64_t>(verifier, VT_PLATFORM_ID) &&
1376 VerifyField<uint32_t>(verifier, VT_CHRE_PLATFORM_VERSION) &&
1377 VerifyField<uint8_t>(verifier, VT_SUPPORTS_RELIABLE_MESSAGES) &&
1378 verifier.EndTable();
1379 }
1380 };
1381
1382 struct HubInfoResponseBuilder {
1383 typedef HubInfoResponse Table;
1384 flatbuffers::FlatBufferBuilder &fbb_;
1385 flatbuffers::uoffset_t start_;
1386 void add_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> name) {
1387 fbb_.AddOffset(HubInfoResponse::VT_NAME, name);
1388 }
1389 void add_vendor(flatbuffers::Offset<flatbuffers::Vector<int8_t>> vendor) {
1390 fbb_.AddOffset(HubInfoResponse::VT_VENDOR, vendor);
1391 }
1392 void add_toolchain(flatbuffers::Offset<flatbuffers::Vector<int8_t>> toolchain) {
1393 fbb_.AddOffset(HubInfoResponse::VT_TOOLCHAIN, toolchain);
1394 }
1395 void add_platform_version(uint32_t platform_version) {
1396 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_PLATFORM_VERSION, platform_version, 0);
1397 }
1398 void add_toolchain_version(uint32_t toolchain_version) {
1399 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_TOOLCHAIN_VERSION, toolchain_version, 0);
1400 }
1401 void add_peak_mips(float peak_mips) {
1402 fbb_.AddElement<float>(HubInfoResponse::VT_PEAK_MIPS, peak_mips, 0.0f);
1403 }
1404 void add_stopped_power(float stopped_power) {
1405 fbb_.AddElement<float>(HubInfoResponse::VT_STOPPED_POWER, stopped_power, 0.0f);
1406 }
1407 void add_sleep_power(float sleep_power) {
1408 fbb_.AddElement<float>(HubInfoResponse::VT_SLEEP_POWER, sleep_power, 0.0f);
1409 }
1410 void add_peak_power(float peak_power) {
1411 fbb_.AddElement<float>(HubInfoResponse::VT_PEAK_POWER, peak_power, 0.0f);
1412 }
1413 void add_max_msg_len(uint32_t max_msg_len) {
1414 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_MAX_MSG_LEN, max_msg_len, 0);
1415 }
1416 void add_platform_id(uint64_t platform_id) {
1417 fbb_.AddElement<uint64_t>(HubInfoResponse::VT_PLATFORM_ID, platform_id, 0);
1418 }
1419 void add_chre_platform_version(uint32_t chre_platform_version) {
1420 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_CHRE_PLATFORM_VERSION, chre_platform_version, 0);
1421 }
1422 void add_supports_reliable_messages(bool supports_reliable_messages) {
1423 fbb_.AddElement<uint8_t>(HubInfoResponse::VT_SUPPORTS_RELIABLE_MESSAGES, static_cast<uint8_t>(supports_reliable_messages), 0);
1424 }
1425 explicit HubInfoResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1426 : fbb_(_fbb) {
1427 start_ = fbb_.StartTable();
1428 }
1429 HubInfoResponseBuilder &operator=(const HubInfoResponseBuilder &);
1430 flatbuffers::Offset<HubInfoResponse> Finish() {
1431 const auto end = fbb_.EndTable(start_);
1432 auto o = flatbuffers::Offset<HubInfoResponse>(end);
1433 return o;
1434 }
1435 };
1436
1437 inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponse(
1438 flatbuffers::FlatBufferBuilder &_fbb,
1439 flatbuffers::Offset<flatbuffers::Vector<int8_t>> name = 0,
1440 flatbuffers::Offset<flatbuffers::Vector<int8_t>> vendor = 0,
1441 flatbuffers::Offset<flatbuffers::Vector<int8_t>> toolchain = 0,
1442 uint32_t platform_version = 0,
1443 uint32_t toolchain_version = 0,
1444 float peak_mips = 0.0f,
1445 float stopped_power = 0.0f,
1446 float sleep_power = 0.0f,
1447 float peak_power = 0.0f,
1448 uint32_t max_msg_len = 0,
1449 uint64_t platform_id = 0,
1450 uint32_t chre_platform_version = 0,
1451 bool supports_reliable_messages = false) {
1452 HubInfoResponseBuilder builder_(_fbb);
1453 builder_.add_platform_id(platform_id);
1454 builder_.add_chre_platform_version(chre_platform_version);
1455 builder_.add_max_msg_len(max_msg_len);
1456 builder_.add_peak_power(peak_power);
1457 builder_.add_sleep_power(sleep_power);
1458 builder_.add_stopped_power(stopped_power);
1459 builder_.add_peak_mips(peak_mips);
1460 builder_.add_toolchain_version(toolchain_version);
1461 builder_.add_platform_version(platform_version);
1462 builder_.add_toolchain(toolchain);
1463 builder_.add_vendor(vendor);
1464 builder_.add_name(name);
1465 builder_.add_supports_reliable_messages(supports_reliable_messages);
1466 return builder_.Finish();
1467 }
1468
1469 inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponseDirect(
1470 flatbuffers::FlatBufferBuilder &_fbb,
1471 const std::vector<int8_t> *name = nullptr,
1472 const std::vector<int8_t> *vendor = nullptr,
1473 const std::vector<int8_t> *toolchain = nullptr,
1474 uint32_t platform_version = 0,
1475 uint32_t toolchain_version = 0,
1476 float peak_mips = 0.0f,
1477 float stopped_power = 0.0f,
1478 float sleep_power = 0.0f,
1479 float peak_power = 0.0f,
1480 uint32_t max_msg_len = 0,
1481 uint64_t platform_id = 0,
1482 uint32_t chre_platform_version = 0,
1483 bool supports_reliable_messages = false) {
1484 auto name__ = name ? _fbb.CreateVector<int8_t>(*name) : 0;
1485 auto vendor__ = vendor ? _fbb.CreateVector<int8_t>(*vendor) : 0;
1486 auto toolchain__ = toolchain ? _fbb.CreateVector<int8_t>(*toolchain) : 0;
1487 return chre::fbs::CreateHubInfoResponse(
1488 _fbb,
1489 name__,
1490 vendor__,
1491 toolchain__,
1492 platform_version,
1493 toolchain_version,
1494 peak_mips,
1495 stopped_power,
1496 sleep_power,
1497 peak_power,
1498 max_msg_len,
1499 platform_id,
1500 chre_platform_version,
1501 supports_reliable_messages);
1502 }
1503
1504 struct NanoappListRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1505 typedef NanoappListRequestBuilder Builder;
1506 bool Verify(flatbuffers::Verifier &verifier) const {
1507 return VerifyTableStart(verifier) &&
1508 verifier.EndTable();
1509 }
1510 };
1511
1512 struct NanoappListRequestBuilder {
1513 typedef NanoappListRequest Table;
1514 flatbuffers::FlatBufferBuilder &fbb_;
1515 flatbuffers::uoffset_t start_;
1516 explicit NanoappListRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1517 : fbb_(_fbb) {
1518 start_ = fbb_.StartTable();
1519 }
1520 NanoappListRequestBuilder &operator=(const NanoappListRequestBuilder &);
1521 flatbuffers::Offset<NanoappListRequest> Finish() {
1522 const auto end = fbb_.EndTable(start_);
1523 auto o = flatbuffers::Offset<NanoappListRequest>(end);
1524 return o;
1525 }
1526 };
1527
1528 inline flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest(
1529 flatbuffers::FlatBufferBuilder &_fbb) {
1530 NanoappListRequestBuilder builder_(_fbb);
1531 return builder_.Finish();
1532 }
1533
1534 /// Metadata regarding a Nanoapp RPC service. See the Android API
1535 /// core/java/android/hardware/location/NanoAppRpcService.java for more details
1536 /// on how this value is used by the Android application.
1537 struct NanoappRpcService FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1538 typedef NanoappRpcServiceBuilder Builder;
1539 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1540 VT_ID = 4,
1541 VT_VERSION = 6
1542 };
1543 uint64_t id() const {
1544 return GetField<uint64_t>(VT_ID, 0);
1545 }
1546 uint32_t version() const {
1547 return GetField<uint32_t>(VT_VERSION, 0);
1548 }
1549 bool Verify(flatbuffers::Verifier &verifier) const {
1550 return VerifyTableStart(verifier) &&
1551 VerifyField<uint64_t>(verifier, VT_ID) &&
1552 VerifyField<uint32_t>(verifier, VT_VERSION) &&
1553 verifier.EndTable();
1554 }
1555 };
1556
1557 struct NanoappRpcServiceBuilder {
1558 typedef NanoappRpcService Table;
1559 flatbuffers::FlatBufferBuilder &fbb_;
1560 flatbuffers::uoffset_t start_;
1561 void add_id(uint64_t id) {
1562 fbb_.AddElement<uint64_t>(NanoappRpcService::VT_ID, id, 0);
1563 }
1564 void add_version(uint32_t version) {
1565 fbb_.AddElement<uint32_t>(NanoappRpcService::VT_VERSION, version, 0);
1566 }
1567 explicit NanoappRpcServiceBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1568 : fbb_(_fbb) {
1569 start_ = fbb_.StartTable();
1570 }
1571 NanoappRpcServiceBuilder &operator=(const NanoappRpcServiceBuilder &);
1572 flatbuffers::Offset<NanoappRpcService> Finish() {
1573 const auto end = fbb_.EndTable(start_);
1574 auto o = flatbuffers::Offset<NanoappRpcService>(end);
1575 return o;
1576 }
1577 };
1578
1579 inline flatbuffers::Offset<NanoappRpcService> CreateNanoappRpcService(
1580 flatbuffers::FlatBufferBuilder &_fbb,
1581 uint64_t id = 0,
1582 uint32_t version = 0) {
1583 NanoappRpcServiceBuilder builder_(_fbb);
1584 builder_.add_id(id);
1585 builder_.add_version(version);
1586 return builder_.Finish();
1587 }
1588
1589 struct NanoappListEntry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1590 typedef NanoappListEntryBuilder Builder;
1591 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1592 VT_APP_ID = 4,
1593 VT_VERSION = 6,
1594 VT_ENABLED = 8,
1595 VT_IS_SYSTEM = 10,
1596 VT_PERMISSIONS = 12,
1597 VT_RPC_SERVICES = 14
1598 };
1599 uint64_t app_id() const {
1600 return GetField<uint64_t>(VT_APP_ID, 0);
1601 }
1602 uint32_t version() const {
1603 return GetField<uint32_t>(VT_VERSION, 0);
1604 }
1605 bool enabled() const {
1606 return GetField<uint8_t>(VT_ENABLED, 1) != 0;
1607 }
1608 /// Whether the nanoapp is a pre-loaded "system" nanoapp, i.e. one that should
1609 /// not show up in the list of nanoapps in the context hub HAL. System
1610 /// nanoapps are typically used to leverage CHRE for some device functionality
1611 /// and do not interact via the context hub HAL.
1612 bool is_system() const {
1613 return GetField<uint8_t>(VT_IS_SYSTEM, 0) != 0;
1614 }
1615 /// Nanoapp permissions, if supported. Nanoapp permissions are required on
1616 /// CHRE API v1.5+, and are defined in chre/util/system/napp_permissions.h
1617 uint32_t permissions() const {
1618 return GetField<uint32_t>(VT_PERMISSIONS, 0);
1619 }
1620 /// The list of RPC services supported by this nanoapp.
1621 const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappRpcService>> *rpc_services() const {
1622 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappRpcService>> *>(VT_RPC_SERVICES);
1623 }
1624 bool Verify(flatbuffers::Verifier &verifier) const {
1625 return VerifyTableStart(verifier) &&
1626 VerifyField<uint64_t>(verifier, VT_APP_ID) &&
1627 VerifyField<uint32_t>(verifier, VT_VERSION) &&
1628 VerifyField<uint8_t>(verifier, VT_ENABLED) &&
1629 VerifyField<uint8_t>(verifier, VT_IS_SYSTEM) &&
1630 VerifyField<uint32_t>(verifier, VT_PERMISSIONS) &&
1631 VerifyOffset(verifier, VT_RPC_SERVICES) &&
1632 verifier.VerifyVector(rpc_services()) &&
1633 verifier.VerifyVectorOfTables(rpc_services()) &&
1634 verifier.EndTable();
1635 }
1636 };
1637
1638 struct NanoappListEntryBuilder {
1639 typedef NanoappListEntry Table;
1640 flatbuffers::FlatBufferBuilder &fbb_;
1641 flatbuffers::uoffset_t start_;
1642 void add_app_id(uint64_t app_id) {
1643 fbb_.AddElement<uint64_t>(NanoappListEntry::VT_APP_ID, app_id, 0);
1644 }
1645 void add_version(uint32_t version) {
1646 fbb_.AddElement<uint32_t>(NanoappListEntry::VT_VERSION, version, 0);
1647 }
1648 void add_enabled(bool enabled) {
1649 fbb_.AddElement<uint8_t>(NanoappListEntry::VT_ENABLED, static_cast<uint8_t>(enabled), 1);
1650 }
1651 void add_is_system(bool is_system) {
1652 fbb_.AddElement<uint8_t>(NanoappListEntry::VT_IS_SYSTEM, static_cast<uint8_t>(is_system), 0);
1653 }
1654 void add_permissions(uint32_t permissions) {
1655 fbb_.AddElement<uint32_t>(NanoappListEntry::VT_PERMISSIONS, permissions, 0);
1656 }
1657 void add_rpc_services(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappRpcService>>> rpc_services) {
1658 fbb_.AddOffset(NanoappListEntry::VT_RPC_SERVICES, rpc_services);
1659 }
1660 explicit NanoappListEntryBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1661 : fbb_(_fbb) {
1662 start_ = fbb_.StartTable();
1663 }
1664 NanoappListEntryBuilder &operator=(const NanoappListEntryBuilder &);
1665 flatbuffers::Offset<NanoappListEntry> Finish() {
1666 const auto end = fbb_.EndTable(start_);
1667 auto o = flatbuffers::Offset<NanoappListEntry>(end);
1668 return o;
1669 }
1670 };
1671
1672 inline flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntry(
1673 flatbuffers::FlatBufferBuilder &_fbb,
1674 uint64_t app_id = 0,
1675 uint32_t version = 0,
1676 bool enabled = true,
1677 bool is_system = false,
1678 uint32_t permissions = 0,
1679 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappRpcService>>> rpc_services = 0) {
1680 NanoappListEntryBuilder builder_(_fbb);
1681 builder_.add_app_id(app_id);
1682 builder_.add_rpc_services(rpc_services);
1683 builder_.add_permissions(permissions);
1684 builder_.add_version(version);
1685 builder_.add_is_system(is_system);
1686 builder_.add_enabled(enabled);
1687 return builder_.Finish();
1688 }
1689
1690 inline flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntryDirect(
1691 flatbuffers::FlatBufferBuilder &_fbb,
1692 uint64_t app_id = 0,
1693 uint32_t version = 0,
1694 bool enabled = true,
1695 bool is_system = false,
1696 uint32_t permissions = 0,
1697 const std::vector<flatbuffers::Offset<chre::fbs::NanoappRpcService>> *rpc_services = nullptr) {
1698 auto rpc_services__ = rpc_services ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::NanoappRpcService>>(*rpc_services) : 0;
1699 return chre::fbs::CreateNanoappListEntry(
1700 _fbb,
1701 app_id,
1702 version,
1703 enabled,
1704 is_system,
1705 permissions,
1706 rpc_services__);
1707 }
1708
1709 struct NanoappListResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1710 typedef NanoappListResponseBuilder Builder;
1711 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1712 VT_NANOAPPS = 4
1713 };
1714 const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>> *nanoapps() const {
1715 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>> *>(VT_NANOAPPS);
1716 }
1717 bool Verify(flatbuffers::Verifier &verifier) const {
1718 return VerifyTableStart(verifier) &&
1719 VerifyOffsetRequired(verifier, VT_NANOAPPS) &&
1720 verifier.VerifyVector(nanoapps()) &&
1721 verifier.VerifyVectorOfTables(nanoapps()) &&
1722 verifier.EndTable();
1723 }
1724 };
1725
1726 struct NanoappListResponseBuilder {
1727 typedef NanoappListResponse Table;
1728 flatbuffers::FlatBufferBuilder &fbb_;
1729 flatbuffers::uoffset_t start_;
1730 void add_nanoapps(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>>> nanoapps) {
1731 fbb_.AddOffset(NanoappListResponse::VT_NANOAPPS, nanoapps);
1732 }
1733 explicit NanoappListResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1734 : fbb_(_fbb) {
1735 start_ = fbb_.StartTable();
1736 }
1737 NanoappListResponseBuilder &operator=(const NanoappListResponseBuilder &);
1738 flatbuffers::Offset<NanoappListResponse> Finish() {
1739 const auto end = fbb_.EndTable(start_);
1740 auto o = flatbuffers::Offset<NanoappListResponse>(end);
1741 fbb_.Required(o, NanoappListResponse::VT_NANOAPPS);
1742 return o;
1743 }
1744 };
1745
1746 inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse(
1747 flatbuffers::FlatBufferBuilder &_fbb,
1748 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>>> nanoapps = 0) {
1749 NanoappListResponseBuilder builder_(_fbb);
1750 builder_.add_nanoapps(nanoapps);
1751 return builder_.Finish();
1752 }
1753
1754 inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponseDirect(
1755 flatbuffers::FlatBufferBuilder &_fbb,
1756 const std::vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>> *nanoapps = nullptr) {
1757 auto nanoapps__ = nanoapps ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::NanoappListEntry>>(*nanoapps) : 0;
1758 return chre::fbs::CreateNanoappListResponse(
1759 _fbb,
1760 nanoapps__);
1761 }
1762
1763 /// Represents a request for loading a nanoapp.
1764 /// The nanaopp can either be requested to be loaded via a file or via a buffer.
1765 /// For loading via a file, the following steps will be taken:
1766 /// 1. The loader sends a LoadNanoappRequest message to CHRE. app_binary must
1767 /// be set for legacy purposes, but should be empty. Additionally,
1768 /// fragment_id and total_app_size are unused in this request. The loading
1769 /// that happens as part of this request is serialized, but asynchronous
1770 /// meaning that load requests will be processed in the order they are sent
1771 /// but multiple requests can be outstanding at any given time.
1772 /// 2. CHRE stores the filename and waits until its event loop is able to
1773 /// process the request.
1774 /// 3. Once ready, the nanoapp will be loaded from the file specified in the
1775 /// original request and will send a callback indicating the
1776 /// completion/failure of the request.
1777 /// For loading via a buffer, loading may optionally be fragmented into multiple
1778 /// sequential requests, which will follow the following steps:
1779 /// 1. The loader sends a LoadNanoappRequest message to CHRE. If the request
1780 /// is fragmented, then the fields fragment_id and total_app_size must
1781 /// be defined. Once the first fragment is sent to CHRE, all subsequent
1782 /// fragments must be delivered before a new LoadNanoappRequest can be
1783 /// issued. If a new request is received while a current request has
1784 /// outstanding fragments, the current request will be overridden with the
1785 /// new one.
1786 /// 2. CHRE preallocates the required amount of memory, and loads app_binary,
1787 /// appending to already loaded fragments as appropriate.
1788 /// 3. If the request is fragmented, then the requestor must sequentially send
1789 /// multiple LoadNanoappRequest with incremental nanoapp binary fragments.
1790 /// CHRE will respond with LoadNanoappResponse for each request. For
1791 /// requests starting from the second fragment, all fields except
1792 /// fragment_id and app_binary should be ignored by CHRE.
1793 ///
1794 /// Once the LoadNanoappRepsonse for the last fragment is received
1795 /// by the HAL, the HAL client will receive a callback indicating the
1796 /// completion/failure of a load request.
1797 ///
1798 /// If any request fragment is lost, then the entire load request will be
1799 /// considered to have failed. If the request times out (e.g. the requestor
1800 /// process crashes), then the load request will be cancelled at CHRE and fail.
1801 struct LoadNanoappRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1802 typedef LoadNanoappRequestBuilder Builder;
1803 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1804 VT_TRANSACTION_ID = 4,
1805 VT_APP_ID = 6,
1806 VT_APP_VERSION = 8,
1807 VT_TARGET_API_VERSION = 10,
1808 VT_APP_BINARY = 12,
1809 VT_FRAGMENT_ID = 14,
1810 VT_TOTAL_APP_SIZE = 16,
1811 VT_APP_BINARY_FILE_NAME = 18,
1812 VT_APP_FLAGS = 20,
1813 VT_RESPOND_BEFORE_START = 22
1814 };
1815 uint32_t transaction_id() const {
1816 return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
1817 }
1818 uint64_t app_id() const {
1819 return GetField<uint64_t>(VT_APP_ID, 0);
1820 }
1821 uint32_t app_version() const {
1822 return GetField<uint32_t>(VT_APP_VERSION, 0);
1823 }
1824 uint32_t target_api_version() const {
1825 return GetField<uint32_t>(VT_TARGET_API_VERSION, 0);
1826 }
1827 const flatbuffers::Vector<uint8_t> *app_binary() const {
1828 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_APP_BINARY);
1829 }
1830 /// Fields that are relevant for fragmented loading
1831 /// The framgent count starts at 1 and should end at the total number of
1832 /// fragments. For clients that do not support fragmented loading, the
1833 /// default behavior should be to assume one fragment.
1834 uint32_t fragment_id() const {
1835 return GetField<uint32_t>(VT_FRAGMENT_ID, 0);
1836 }
1837 uint32_t total_app_size() const {
1838 return GetField<uint32_t>(VT_TOTAL_APP_SIZE, 0);
1839 }
1840 /// Null-terminated ASCII string containing the file name that contains the
1841 /// app binary to be loaded.
1842 const flatbuffers::Vector<int8_t> *app_binary_file_name() const {
1843 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_APP_BINARY_FILE_NAME);
1844 }
1845 /// The nanoapp flag values from the nanoapp header defined in
1846 /// build/build_template.mk. Refer to that file for more details.
1847 uint32_t app_flags() const {
1848 return GetField<uint32_t>(VT_APP_FLAGS, 0);
1849 }
1850 /// If true and fragmented loading is requested, the LoadNanoappResponse
1851 /// for the last fragment will be sent after the fragment was confirmed
1852 /// to be placed in memory and no additional response will be sent after
1853 /// the nanoapp is linked and started in the framework.
1854 bool respond_before_start() const {
1855 return GetField<uint8_t>(VT_RESPOND_BEFORE_START, 0) != 0;
1856 }
1857 bool Verify(flatbuffers::Verifier &verifier) const {
1858 return VerifyTableStart(verifier) &&
1859 VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
1860 VerifyField<uint64_t>(verifier, VT_APP_ID) &&
1861 VerifyField<uint32_t>(verifier, VT_APP_VERSION) &&
1862 VerifyField<uint32_t>(verifier, VT_TARGET_API_VERSION) &&
1863 VerifyOffsetRequired(verifier, VT_APP_BINARY) &&
1864 verifier.VerifyVector(app_binary()) &&
1865 VerifyField<uint32_t>(verifier, VT_FRAGMENT_ID) &&
1866 VerifyField<uint32_t>(verifier, VT_TOTAL_APP_SIZE) &&
1867 VerifyOffset(verifier, VT_APP_BINARY_FILE_NAME) &&
1868 verifier.VerifyVector(app_binary_file_name()) &&
1869 VerifyField<uint32_t>(verifier, VT_APP_FLAGS) &&
1870 VerifyField<uint8_t>(verifier, VT_RESPOND_BEFORE_START) &&
1871 verifier.EndTable();
1872 }
1873 };
1874
1875 struct LoadNanoappRequestBuilder {
1876 typedef LoadNanoappRequest Table;
1877 flatbuffers::FlatBufferBuilder &fbb_;
1878 flatbuffers::uoffset_t start_;
1879 void add_transaction_id(uint32_t transaction_id) {
1880 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TRANSACTION_ID, transaction_id, 0);
1881 }
1882 void add_app_id(uint64_t app_id) {
1883 fbb_.AddElement<uint64_t>(LoadNanoappRequest::VT_APP_ID, app_id, 0);
1884 }
1885 void add_app_version(uint32_t app_version) {
1886 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_APP_VERSION, app_version, 0);
1887 }
1888 void add_target_api_version(uint32_t target_api_version) {
1889 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TARGET_API_VERSION, target_api_version, 0);
1890 }
1891 void add_app_binary(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary) {
1892 fbb_.AddOffset(LoadNanoappRequest::VT_APP_BINARY, app_binary);
1893 }
1894 void add_fragment_id(uint32_t fragment_id) {
1895 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_FRAGMENT_ID, fragment_id, 0);
1896 }
1897 void add_total_app_size(uint32_t total_app_size) {
1898 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TOTAL_APP_SIZE, total_app_size, 0);
1899 }
1900 void add_app_binary_file_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> app_binary_file_name) {
1901 fbb_.AddOffset(LoadNanoappRequest::VT_APP_BINARY_FILE_NAME, app_binary_file_name);
1902 }
1903 void add_app_flags(uint32_t app_flags) {
1904 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_APP_FLAGS, app_flags, 0);
1905 }
1906 void add_respond_before_start(bool respond_before_start) {
1907 fbb_.AddElement<uint8_t>(LoadNanoappRequest::VT_RESPOND_BEFORE_START, static_cast<uint8_t>(respond_before_start), 0);
1908 }
1909 explicit LoadNanoappRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1910 : fbb_(_fbb) {
1911 start_ = fbb_.StartTable();
1912 }
1913 LoadNanoappRequestBuilder &operator=(const LoadNanoappRequestBuilder &);
1914 flatbuffers::Offset<LoadNanoappRequest> Finish() {
1915 const auto end = fbb_.EndTable(start_);
1916 auto o = flatbuffers::Offset<LoadNanoappRequest>(end);
1917 fbb_.Required(o, LoadNanoappRequest::VT_APP_BINARY);
1918 return o;
1919 }
1920 };
1921
1922 inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest(
1923 flatbuffers::FlatBufferBuilder &_fbb,
1924 uint32_t transaction_id = 0,
1925 uint64_t app_id = 0,
1926 uint32_t app_version = 0,
1927 uint32_t target_api_version = 0,
1928 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary = 0,
1929 uint32_t fragment_id = 0,
1930 uint32_t total_app_size = 0,
1931 flatbuffers::Offset<flatbuffers::Vector<int8_t>> app_binary_file_name = 0,
1932 uint32_t app_flags = 0,
1933 bool respond_before_start = false) {
1934 LoadNanoappRequestBuilder builder_(_fbb);
1935 builder_.add_app_id(app_id);
1936 builder_.add_app_flags(app_flags);
1937 builder_.add_app_binary_file_name(app_binary_file_name);
1938 builder_.add_total_app_size(total_app_size);
1939 builder_.add_fragment_id(fragment_id);
1940 builder_.add_app_binary(app_binary);
1941 builder_.add_target_api_version(target_api_version);
1942 builder_.add_app_version(app_version);
1943 builder_.add_transaction_id(transaction_id);
1944 builder_.add_respond_before_start(respond_before_start);
1945 return builder_.Finish();
1946 }
1947
1948 inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequestDirect(
1949 flatbuffers::FlatBufferBuilder &_fbb,
1950 uint32_t transaction_id = 0,
1951 uint64_t app_id = 0,
1952 uint32_t app_version = 0,
1953 uint32_t target_api_version = 0,
1954 const std::vector<uint8_t> *app_binary = nullptr,
1955 uint32_t fragment_id = 0,
1956 uint32_t total_app_size = 0,
1957 const std::vector<int8_t> *app_binary_file_name = nullptr,
1958 uint32_t app_flags = 0,
1959 bool respond_before_start = false) {
1960 auto app_binary__ = app_binary ? _fbb.CreateVector<uint8_t>(*app_binary) : 0;
1961 auto app_binary_file_name__ = app_binary_file_name ? _fbb.CreateVector<int8_t>(*app_binary_file_name) : 0;
1962 return chre::fbs::CreateLoadNanoappRequest(
1963 _fbb,
1964 transaction_id,
1965 app_id,
1966 app_version,
1967 target_api_version,
1968 app_binary__,
1969 fragment_id,
1970 total_app_size,
1971 app_binary_file_name__,
1972 app_flags,
1973 respond_before_start);
1974 }
1975
1976 struct LoadNanoappResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1977 typedef LoadNanoappResponseBuilder Builder;
1978 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1979 VT_TRANSACTION_ID = 4,
1980 VT_SUCCESS = 6,
1981 VT_FRAGMENT_ID = 8
1982 };
1983 uint32_t transaction_id() const {
1984 return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
1985 }
1986 /// Denotes whether a load request succeeded or failed.
1987 /// If any fragment of a load request fails, the entire load request for
1988 /// the same transaction will fail.
1989 bool success() const {
1990 return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
1991 }
1992 /// The fragment count of the load reponse is for.
1993 uint32_t fragment_id() const {
1994 return GetField<uint32_t>(VT_FRAGMENT_ID, 0);
1995 }
1996 bool Verify(flatbuffers::Verifier &verifier) const {
1997 return VerifyTableStart(verifier) &&
1998 VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
1999 VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
2000 VerifyField<uint32_t>(verifier, VT_FRAGMENT_ID) &&
2001 verifier.EndTable();
2002 }
2003 };
2004
2005 struct LoadNanoappResponseBuilder {
2006 typedef LoadNanoappResponse Table;
2007 flatbuffers::FlatBufferBuilder &fbb_;
2008 flatbuffers::uoffset_t start_;
2009 void add_transaction_id(uint32_t transaction_id) {
2010 fbb_.AddElement<uint32_t>(LoadNanoappResponse::VT_TRANSACTION_ID, transaction_id, 0);
2011 }
2012 void add_success(bool success) {
2013 fbb_.AddElement<uint8_t>(LoadNanoappResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0);
2014 }
2015 void add_fragment_id(uint32_t fragment_id) {
2016 fbb_.AddElement<uint32_t>(LoadNanoappResponse::VT_FRAGMENT_ID, fragment_id, 0);
2017 }
2018 explicit LoadNanoappResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2019 : fbb_(_fbb) {
2020 start_ = fbb_.StartTable();
2021 }
2022 LoadNanoappResponseBuilder &operator=(const LoadNanoappResponseBuilder &);
2023 flatbuffers::Offset<LoadNanoappResponse> Finish() {
2024 const auto end = fbb_.EndTable(start_);
2025 auto o = flatbuffers::Offset<LoadNanoappResponse>(end);
2026 return o;
2027 }
2028 };
2029
2030 inline flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse(
2031 flatbuffers::FlatBufferBuilder &_fbb,
2032 uint32_t transaction_id = 0,
2033 bool success = false,
2034 uint32_t fragment_id = 0) {
2035 LoadNanoappResponseBuilder builder_(_fbb);
2036 builder_.add_fragment_id(fragment_id);
2037 builder_.add_transaction_id(transaction_id);
2038 builder_.add_success(success);
2039 return builder_.Finish();
2040 }
2041
2042 /// Contains information needed for the host to load the token database for the
2043 /// nanoapp. This message is only sent if a token database section is found in
2044 /// the nanoapp elf binary.
2045 struct NanoappTokenDatabaseInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2046 typedef NanoappTokenDatabaseInfoBuilder Builder;
2047 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2048 VT_INSTANCE_ID = 4,
2049 VT_APP_ID = 6,
2050 VT_DATABASE_OFFSET_BYTES = 8,
2051 VT_DATABASE_SIZE_BYTES = 10
2052 };
2053 uint32_t instance_id() const {
2054 return GetField<uint32_t>(VT_INSTANCE_ID, 0);
2055 }
2056 uint64_t app_id() const {
2057 return GetField<uint64_t>(VT_APP_ID, 0);
2058 }
2059 /// The size offset of the token database from the start of the address of
2060 /// the ELF binary in bytes.
2061 uint32_t database_offset_bytes() const {
2062 return GetField<uint32_t>(VT_DATABASE_OFFSET_BYTES, 0);
2063 }
2064 /// The size of the token database section in the ELF binary in bytes.
2065 uint32_t database_size_bytes() const {
2066 return GetField<uint32_t>(VT_DATABASE_SIZE_BYTES, 0);
2067 }
2068 bool Verify(flatbuffers::Verifier &verifier) const {
2069 return VerifyTableStart(verifier) &&
2070 VerifyField<uint32_t>(verifier, VT_INSTANCE_ID) &&
2071 VerifyField<uint64_t>(verifier, VT_APP_ID) &&
2072 VerifyField<uint32_t>(verifier, VT_DATABASE_OFFSET_BYTES) &&
2073 VerifyField<uint32_t>(verifier, VT_DATABASE_SIZE_BYTES) &&
2074 verifier.EndTable();
2075 }
2076 };
2077
2078 struct NanoappTokenDatabaseInfoBuilder {
2079 typedef NanoappTokenDatabaseInfo Table;
2080 flatbuffers::FlatBufferBuilder &fbb_;
2081 flatbuffers::uoffset_t start_;
2082 void add_instance_id(uint32_t instance_id) {
2083 fbb_.AddElement<uint32_t>(NanoappTokenDatabaseInfo::VT_INSTANCE_ID, instance_id, 0);
2084 }
2085 void add_app_id(uint64_t app_id) {
2086 fbb_.AddElement<uint64_t>(NanoappTokenDatabaseInfo::VT_APP_ID, app_id, 0);
2087 }
2088 void add_database_offset_bytes(uint32_t database_offset_bytes) {
2089 fbb_.AddElement<uint32_t>(NanoappTokenDatabaseInfo::VT_DATABASE_OFFSET_BYTES, database_offset_bytes, 0);
2090 }
2091 void add_database_size_bytes(uint32_t database_size_bytes) {
2092 fbb_.AddElement<uint32_t>(NanoappTokenDatabaseInfo::VT_DATABASE_SIZE_BYTES, database_size_bytes, 0);
2093 }
2094 explicit NanoappTokenDatabaseInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2095 : fbb_(_fbb) {
2096 start_ = fbb_.StartTable();
2097 }
2098 NanoappTokenDatabaseInfoBuilder &operator=(const NanoappTokenDatabaseInfoBuilder &);
2099 flatbuffers::Offset<NanoappTokenDatabaseInfo> Finish() {
2100 const auto end = fbb_.EndTable(start_);
2101 auto o = flatbuffers::Offset<NanoappTokenDatabaseInfo>(end);
2102 return o;
2103 }
2104 };
2105
2106 inline flatbuffers::Offset<NanoappTokenDatabaseInfo> CreateNanoappTokenDatabaseInfo(
2107 flatbuffers::FlatBufferBuilder &_fbb,
2108 uint32_t instance_id = 0,
2109 uint64_t app_id = 0,
2110 uint32_t database_offset_bytes = 0,
2111 uint32_t database_size_bytes = 0) {
2112 NanoappTokenDatabaseInfoBuilder builder_(_fbb);
2113 builder_.add_app_id(app_id);
2114 builder_.add_database_size_bytes(database_size_bytes);
2115 builder_.add_database_offset_bytes(database_offset_bytes);
2116 builder_.add_instance_id(instance_id);
2117 return builder_.Finish();
2118 }
2119
2120 struct UnloadNanoappRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2121 typedef UnloadNanoappRequestBuilder Builder;
2122 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2123 VT_TRANSACTION_ID = 4,
2124 VT_APP_ID = 6,
2125 VT_ALLOW_SYSTEM_NANOAPP_UNLOAD = 8
2126 };
2127 uint32_t transaction_id() const {
2128 return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
2129 }
2130 uint64_t app_id() const {
2131 return GetField<uint64_t>(VT_APP_ID, 0);
2132 }
2133 /// Set to true to allow this request to unload nanoapps identified as "system
2134 /// nanoapps", i.e. ones with is_system set to true in NanoappListResponse.
2135 bool allow_system_nanoapp_unload() const {
2136 return GetField<uint8_t>(VT_ALLOW_SYSTEM_NANOAPP_UNLOAD, 0) != 0;
2137 }
2138 bool Verify(flatbuffers::Verifier &verifier) const {
2139 return VerifyTableStart(verifier) &&
2140 VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
2141 VerifyField<uint64_t>(verifier, VT_APP_ID) &&
2142 VerifyField<uint8_t>(verifier, VT_ALLOW_SYSTEM_NANOAPP_UNLOAD) &&
2143 verifier.EndTable();
2144 }
2145 };
2146
2147 struct UnloadNanoappRequestBuilder {
2148 typedef UnloadNanoappRequest Table;
2149 flatbuffers::FlatBufferBuilder &fbb_;
2150 flatbuffers::uoffset_t start_;
2151 void add_transaction_id(uint32_t transaction_id) {
2152 fbb_.AddElement<uint32_t>(UnloadNanoappRequest::VT_TRANSACTION_ID, transaction_id, 0);
2153 }
2154 void add_app_id(uint64_t app_id) {
2155 fbb_.AddElement<uint64_t>(UnloadNanoappRequest::VT_APP_ID, app_id, 0);
2156 }
2157 void add_allow_system_nanoapp_unload(bool allow_system_nanoapp_unload) {
2158 fbb_.AddElement<uint8_t>(UnloadNanoappRequest::VT_ALLOW_SYSTEM_NANOAPP_UNLOAD, static_cast<uint8_t>(allow_system_nanoapp_unload), 0);
2159 }
2160 explicit UnloadNanoappRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2161 : fbb_(_fbb) {
2162 start_ = fbb_.StartTable();
2163 }
2164 UnloadNanoappRequestBuilder &operator=(const UnloadNanoappRequestBuilder &);
2165 flatbuffers::Offset<UnloadNanoappRequest> Finish() {
2166 const auto end = fbb_.EndTable(start_);
2167 auto o = flatbuffers::Offset<UnloadNanoappRequest>(end);
2168 return o;
2169 }
2170 };
2171
2172 inline flatbuffers::Offset<UnloadNanoappRequest> CreateUnloadNanoappRequest(
2173 flatbuffers::FlatBufferBuilder &_fbb,
2174 uint32_t transaction_id = 0,
2175 uint64_t app_id = 0,
2176 bool allow_system_nanoapp_unload = false) {
2177 UnloadNanoappRequestBuilder builder_(_fbb);
2178 builder_.add_app_id(app_id);
2179 builder_.add_transaction_id(transaction_id);
2180 builder_.add_allow_system_nanoapp_unload(allow_system_nanoapp_unload);
2181 return builder_.Finish();
2182 }
2183
2184 struct UnloadNanoappResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2185 typedef UnloadNanoappResponseBuilder Builder;
2186 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2187 VT_TRANSACTION_ID = 4,
2188 VT_SUCCESS = 6
2189 };
2190 uint32_t transaction_id() const {
2191 return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
2192 }
2193 bool success() const {
2194 return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
2195 }
2196 bool Verify(flatbuffers::Verifier &verifier) const {
2197 return VerifyTableStart(verifier) &&
2198 VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
2199 VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
2200 verifier.EndTable();
2201 }
2202 };
2203
2204 struct UnloadNanoappResponseBuilder {
2205 typedef UnloadNanoappResponse Table;
2206 flatbuffers::FlatBufferBuilder &fbb_;
2207 flatbuffers::uoffset_t start_;
2208 void add_transaction_id(uint32_t transaction_id) {
2209 fbb_.AddElement<uint32_t>(UnloadNanoappResponse::VT_TRANSACTION_ID, transaction_id, 0);
2210 }
2211 void add_success(bool success) {
2212 fbb_.AddElement<uint8_t>(UnloadNanoappResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0);
2213 }
2214 explicit UnloadNanoappResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2215 : fbb_(_fbb) {
2216 start_ = fbb_.StartTable();
2217 }
2218 UnloadNanoappResponseBuilder &operator=(const UnloadNanoappResponseBuilder &);
2219 flatbuffers::Offset<UnloadNanoappResponse> Finish() {
2220 const auto end = fbb_.EndTable(start_);
2221 auto o = flatbuffers::Offset<UnloadNanoappResponse>(end);
2222 return o;
2223 }
2224 };
2225
2226 inline flatbuffers::Offset<UnloadNanoappResponse> CreateUnloadNanoappResponse(
2227 flatbuffers::FlatBufferBuilder &_fbb,
2228 uint32_t transaction_id = 0,
2229 bool success = false) {
2230 UnloadNanoappResponseBuilder builder_(_fbb);
2231 builder_.add_transaction_id(transaction_id);
2232 builder_.add_success(success);
2233 return builder_.Finish();
2234 }
2235
2236 /// Represents log messages from CHRE.
2237 struct LogMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2238 typedef LogMessageBuilder Builder;
2239 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2240 VT_BUFFER = 4
2241 };
2242 /// A buffer containing formatted log data. A flat array is used here to avoid
2243 /// overhead in serializing and deserializing. The format is as follows:
2244 ///
2245 /// uint8_t - log level (1 = error, 2 = warning,
2246 /// 3 = info, 4 = debug)
2247 /// uint64_t, little-endian - timestamp in nanoseconds
2248 /// char[] - message to log
2249 /// char, \0 - null-terminator
2250 ///
2251 /// This pattern repeats until the end of the buffer for multiple log
2252 /// messages. The last byte will always be a null-terminator. There are no
2253 /// padding bytes between these fields. Treat this like a packed struct and be
2254 /// cautious with unaligned access when reading/writing this buffer.
2255 const flatbuffers::Vector<int8_t> *buffer() const {
2256 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_BUFFER);
2257 }
2258 bool Verify(flatbuffers::Verifier &verifier) const {
2259 return VerifyTableStart(verifier) &&
2260 VerifyOffset(verifier, VT_BUFFER) &&
2261 verifier.VerifyVector(buffer()) &&
2262 verifier.EndTable();
2263 }
2264 };
2265
2266 struct LogMessageBuilder {
2267 typedef LogMessage Table;
2268 flatbuffers::FlatBufferBuilder &fbb_;
2269 flatbuffers::uoffset_t start_;
2270 void add_buffer(flatbuffers::Offset<flatbuffers::Vector<int8_t>> buffer) {
2271 fbb_.AddOffset(LogMessage::VT_BUFFER, buffer);
2272 }
2273 explicit LogMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2274 : fbb_(_fbb) {
2275 start_ = fbb_.StartTable();
2276 }
2277 LogMessageBuilder &operator=(const LogMessageBuilder &);
2278 flatbuffers::Offset<LogMessage> Finish() {
2279 const auto end = fbb_.EndTable(start_);
2280 auto o = flatbuffers::Offset<LogMessage>(end);
2281 return o;
2282 }
2283 };
2284
2285 inline flatbuffers::Offset<LogMessage> CreateLogMessage(
2286 flatbuffers::FlatBufferBuilder &_fbb,
2287 flatbuffers::Offset<flatbuffers::Vector<int8_t>> buffer = 0) {
2288 LogMessageBuilder builder_(_fbb);
2289 builder_.add_buffer(buffer);
2290 return builder_.Finish();
2291 }
2292
2293 inline flatbuffers::Offset<LogMessage> CreateLogMessageDirect(
2294 flatbuffers::FlatBufferBuilder &_fbb,
2295 const std::vector<int8_t> *buffer = nullptr) {
2296 auto buffer__ = buffer ? _fbb.CreateVector<int8_t>(*buffer) : 0;
2297 return chre::fbs::CreateLogMessage(
2298 _fbb,
2299 buffer__);
2300 }
2301
2302 /// Represents a message sent to CHRE to indicate AP timestamp for time sync
2303 struct TimeSyncMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2304 typedef TimeSyncMessageBuilder Builder;
2305 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2306 VT_OFFSET = 4
2307 };
2308 /// Offset between AP and CHRE timestamp
2309 int64_t offset() const {
2310 return GetField<int64_t>(VT_OFFSET, 0);
2311 }
2312 bool Verify(flatbuffers::Verifier &verifier) const {
2313 return VerifyTableStart(verifier) &&
2314 VerifyField<int64_t>(verifier, VT_OFFSET) &&
2315 verifier.EndTable();
2316 }
2317 };
2318
2319 struct TimeSyncMessageBuilder {
2320 typedef TimeSyncMessage Table;
2321 flatbuffers::FlatBufferBuilder &fbb_;
2322 flatbuffers::uoffset_t start_;
2323 void add_offset(int64_t offset) {
2324 fbb_.AddElement<int64_t>(TimeSyncMessage::VT_OFFSET, offset, 0);
2325 }
2326 explicit TimeSyncMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2327 : fbb_(_fbb) {
2328 start_ = fbb_.StartTable();
2329 }
2330 TimeSyncMessageBuilder &operator=(const TimeSyncMessageBuilder &);
2331 flatbuffers::Offset<TimeSyncMessage> Finish() {
2332 const auto end = fbb_.EndTable(start_);
2333 auto o = flatbuffers::Offset<TimeSyncMessage>(end);
2334 return o;
2335 }
2336 };
2337
2338 inline flatbuffers::Offset<TimeSyncMessage> CreateTimeSyncMessage(
2339 flatbuffers::FlatBufferBuilder &_fbb,
2340 int64_t offset = 0) {
2341 TimeSyncMessageBuilder builder_(_fbb);
2342 builder_.add_offset(offset);
2343 return builder_.Finish();
2344 }
2345
2346 /// A request to gather and return debugging information. Only one debug dump
2347 /// session can be active at a time. Upon accepting a request, zero or more
2348 /// DebugDumpData messages are generated, followed by a DebugDumpResponse
2349 /// indicating the completion of the operation.
2350 struct DebugDumpRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2351 typedef DebugDumpRequestBuilder Builder;
2352 bool Verify(flatbuffers::Verifier &verifier) const {
2353 return VerifyTableStart(verifier) &&
2354 verifier.EndTable();
2355 }
2356 };
2357
2358 struct DebugDumpRequestBuilder {
2359 typedef DebugDumpRequest Table;
2360 flatbuffers::FlatBufferBuilder &fbb_;
2361 flatbuffers::uoffset_t start_;
2362 explicit DebugDumpRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2363 : fbb_(_fbb) {
2364 start_ = fbb_.StartTable();
2365 }
2366 DebugDumpRequestBuilder &operator=(const DebugDumpRequestBuilder &);
2367 flatbuffers::Offset<DebugDumpRequest> Finish() {
2368 const auto end = fbb_.EndTable(start_);
2369 auto o = flatbuffers::Offset<DebugDumpRequest>(end);
2370 return o;
2371 }
2372 };
2373
2374 inline flatbuffers::Offset<DebugDumpRequest> CreateDebugDumpRequest(
2375 flatbuffers::FlatBufferBuilder &_fbb) {
2376 DebugDumpRequestBuilder builder_(_fbb);
2377 return builder_.Finish();
2378 }
2379
2380 struct DebugDumpData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2381 typedef DebugDumpDataBuilder Builder;
2382 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2383 VT_DEBUG_STR = 4
2384 };
2385 /// Null-terminated ASCII string containing debugging information
2386 const flatbuffers::Vector<int8_t> *debug_str() const {
2387 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_DEBUG_STR);
2388 }
2389 bool Verify(flatbuffers::Verifier &verifier) const {
2390 return VerifyTableStart(verifier) &&
2391 VerifyOffset(verifier, VT_DEBUG_STR) &&
2392 verifier.VerifyVector(debug_str()) &&
2393 verifier.EndTable();
2394 }
2395 };
2396
2397 struct DebugDumpDataBuilder {
2398 typedef DebugDumpData Table;
2399 flatbuffers::FlatBufferBuilder &fbb_;
2400 flatbuffers::uoffset_t start_;
2401 void add_debug_str(flatbuffers::Offset<flatbuffers::Vector<int8_t>> debug_str) {
2402 fbb_.AddOffset(DebugDumpData::VT_DEBUG_STR, debug_str);
2403 }
2404 explicit DebugDumpDataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2405 : fbb_(_fbb) {
2406 start_ = fbb_.StartTable();
2407 }
2408 DebugDumpDataBuilder &operator=(const DebugDumpDataBuilder &);
2409 flatbuffers::Offset<DebugDumpData> Finish() {
2410 const auto end = fbb_.EndTable(start_);
2411 auto o = flatbuffers::Offset<DebugDumpData>(end);
2412 return o;
2413 }
2414 };
2415
2416 inline flatbuffers::Offset<DebugDumpData> CreateDebugDumpData(
2417 flatbuffers::FlatBufferBuilder &_fbb,
2418 flatbuffers::Offset<flatbuffers::Vector<int8_t>> debug_str = 0) {
2419 DebugDumpDataBuilder builder_(_fbb);
2420 builder_.add_debug_str(debug_str);
2421 return builder_.Finish();
2422 }
2423
2424 inline flatbuffers::Offset<DebugDumpData> CreateDebugDumpDataDirect(
2425 flatbuffers::FlatBufferBuilder &_fbb,
2426 const std::vector<int8_t> *debug_str = nullptr) {
2427 auto debug_str__ = debug_str ? _fbb.CreateVector<int8_t>(*debug_str) : 0;
2428 return chre::fbs::CreateDebugDumpData(
2429 _fbb,
2430 debug_str__);
2431 }
2432
2433 struct DebugDumpResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2434 typedef DebugDumpResponseBuilder Builder;
2435 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2436 VT_SUCCESS = 4,
2437 VT_DATA_COUNT = 6
2438 };
2439 /// true if the request was accepted and a dump was performed, false if it was
2440 /// rejected or failed to complete for some reason
2441 bool success() const {
2442 return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
2443 }
2444 /// The number of DebugDumpData messages sent in this session
2445 uint32_t data_count() const {
2446 return GetField<uint32_t>(VT_DATA_COUNT, 0);
2447 }
2448 bool Verify(flatbuffers::Verifier &verifier) const {
2449 return VerifyTableStart(verifier) &&
2450 VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
2451 VerifyField<uint32_t>(verifier, VT_DATA_COUNT) &&
2452 verifier.EndTable();
2453 }
2454 };
2455
2456 struct DebugDumpResponseBuilder {
2457 typedef DebugDumpResponse Table;
2458 flatbuffers::FlatBufferBuilder &fbb_;
2459 flatbuffers::uoffset_t start_;
2460 void add_success(bool success) {
2461 fbb_.AddElement<uint8_t>(DebugDumpResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0);
2462 }
2463 void add_data_count(uint32_t data_count) {
2464 fbb_.AddElement<uint32_t>(DebugDumpResponse::VT_DATA_COUNT, data_count, 0);
2465 }
2466 explicit DebugDumpResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2467 : fbb_(_fbb) {
2468 start_ = fbb_.StartTable();
2469 }
2470 DebugDumpResponseBuilder &operator=(const DebugDumpResponseBuilder &);
2471 flatbuffers::Offset<DebugDumpResponse> Finish() {
2472 const auto end = fbb_.EndTable(start_);
2473 auto o = flatbuffers::Offset<DebugDumpResponse>(end);
2474 return o;
2475 }
2476 };
2477
2478 inline flatbuffers::Offset<DebugDumpResponse> CreateDebugDumpResponse(
2479 flatbuffers::FlatBufferBuilder &_fbb,
2480 bool success = false,
2481 uint32_t data_count = 0) {
2482 DebugDumpResponseBuilder builder_(_fbb);
2483 builder_.add_data_count(data_count);
2484 builder_.add_success(success);
2485 return builder_.Finish();
2486 }
2487
2488 /// A request from CHRE for host to initiate a time sync message
2489 /// (system feature, platform-specific - not all platforms necessarily use this)
2490 struct TimeSyncRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2491 typedef TimeSyncRequestBuilder Builder;
2492 bool Verify(flatbuffers::Verifier &verifier) const {
2493 return VerifyTableStart(verifier) &&
2494 verifier.EndTable();
2495 }
2496 };
2497
2498 struct TimeSyncRequestBuilder {
2499 typedef TimeSyncRequest Table;
2500 flatbuffers::FlatBufferBuilder &fbb_;
2501 flatbuffers::uoffset_t start_;
2502 explicit TimeSyncRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2503 : fbb_(_fbb) {
2504 start_ = fbb_.StartTable();
2505 }
2506 TimeSyncRequestBuilder &operator=(const TimeSyncRequestBuilder &);
2507 flatbuffers::Offset<TimeSyncRequest> Finish() {
2508 const auto end = fbb_.EndTable(start_);
2509 auto o = flatbuffers::Offset<TimeSyncRequest>(end);
2510 return o;
2511 }
2512 };
2513
2514 inline flatbuffers::Offset<TimeSyncRequest> CreateTimeSyncRequest(
2515 flatbuffers::FlatBufferBuilder &_fbb) {
2516 TimeSyncRequestBuilder builder_(_fbb);
2517 return builder_.Finish();
2518 }
2519
2520 /// Request from CHRE to enable direct access to data from the low-power
2521 /// microphone. On some systems, coordination via the AP (e.g. with
2522 /// SoundTrigger HAL) is needed to ensure this capability is powered up when
2523 /// CHRE needs it. The host does not send a response.
2524 struct LowPowerMicAccessRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2525 typedef LowPowerMicAccessRequestBuilder Builder;
2526 bool Verify(flatbuffers::Verifier &verifier) const {
2527 return VerifyTableStart(verifier) &&
2528 verifier.EndTable();
2529 }
2530 };
2531
2532 struct LowPowerMicAccessRequestBuilder {
2533 typedef LowPowerMicAccessRequest Table;
2534 flatbuffers::FlatBufferBuilder &fbb_;
2535 flatbuffers::uoffset_t start_;
2536 explicit LowPowerMicAccessRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2537 : fbb_(_fbb) {
2538 start_ = fbb_.StartTable();
2539 }
2540 LowPowerMicAccessRequestBuilder &operator=(const LowPowerMicAccessRequestBuilder &);
2541 flatbuffers::Offset<LowPowerMicAccessRequest> Finish() {
2542 const auto end = fbb_.EndTable(start_);
2543 auto o = flatbuffers::Offset<LowPowerMicAccessRequest>(end);
2544 return o;
2545 }
2546 };
2547
2548 inline flatbuffers::Offset<LowPowerMicAccessRequest> CreateLowPowerMicAccessRequest(
2549 flatbuffers::FlatBufferBuilder &_fbb) {
2550 LowPowerMicAccessRequestBuilder builder_(_fbb);
2551 return builder_.Finish();
2552 }
2553
2554 /// Notification from CHRE that it no longer needs direct access to low-power
2555 /// microphone data.
2556 struct LowPowerMicAccessRelease FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2557 typedef LowPowerMicAccessReleaseBuilder Builder;
2558 bool Verify(flatbuffers::Verifier &verifier) const {
2559 return VerifyTableStart(verifier) &&
2560 verifier.EndTable();
2561 }
2562 };
2563
2564 struct LowPowerMicAccessReleaseBuilder {
2565 typedef LowPowerMicAccessRelease Table;
2566 flatbuffers::FlatBufferBuilder &fbb_;
2567 flatbuffers::uoffset_t start_;
2568 explicit LowPowerMicAccessReleaseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2569 : fbb_(_fbb) {
2570 start_ = fbb_.StartTable();
2571 }
2572 LowPowerMicAccessReleaseBuilder &operator=(const LowPowerMicAccessReleaseBuilder &);
2573 flatbuffers::Offset<LowPowerMicAccessRelease> Finish() {
2574 const auto end = fbb_.EndTable(start_);
2575 auto o = flatbuffers::Offset<LowPowerMicAccessRelease>(end);
2576 return o;
2577 }
2578 };
2579
2580 inline flatbuffers::Offset<LowPowerMicAccessRelease> CreateLowPowerMicAccessRelease(
2581 flatbuffers::FlatBufferBuilder &_fbb) {
2582 LowPowerMicAccessReleaseBuilder builder_(_fbb);
2583 return builder_.Finish();
2584 }
2585
2586 /// Notification from the host that a system setting has changed
2587 struct SettingChangeMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2588 typedef SettingChangeMessageBuilder Builder;
2589 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2590 VT_SETTING = 4,
2591 VT_STATE = 6
2592 };
2593 /// The setting that has changed
2594 chre::fbs::Setting setting() const {
2595 return static_cast<chre::fbs::Setting>(GetField<int8_t>(VT_SETTING, 0));
2596 }
2597 /// The new setting value
2598 chre::fbs::SettingState state() const {
2599 return static_cast<chre::fbs::SettingState>(GetField<int8_t>(VT_STATE, 0));
2600 }
2601 bool Verify(flatbuffers::Verifier &verifier) const {
2602 return VerifyTableStart(verifier) &&
2603 VerifyField<int8_t>(verifier, VT_SETTING) &&
2604 VerifyField<int8_t>(verifier, VT_STATE) &&
2605 verifier.EndTable();
2606 }
2607 };
2608
2609 struct SettingChangeMessageBuilder {
2610 typedef SettingChangeMessage Table;
2611 flatbuffers::FlatBufferBuilder &fbb_;
2612 flatbuffers::uoffset_t start_;
2613 void add_setting(chre::fbs::Setting setting) {
2614 fbb_.AddElement<int8_t>(SettingChangeMessage::VT_SETTING, static_cast<int8_t>(setting), 0);
2615 }
2616 void add_state(chre::fbs::SettingState state) {
2617 fbb_.AddElement<int8_t>(SettingChangeMessage::VT_STATE, static_cast<int8_t>(state), 0);
2618 }
2619 explicit SettingChangeMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2620 : fbb_(_fbb) {
2621 start_ = fbb_.StartTable();
2622 }
2623 SettingChangeMessageBuilder &operator=(const SettingChangeMessageBuilder &);
2624 flatbuffers::Offset<SettingChangeMessage> Finish() {
2625 const auto end = fbb_.EndTable(start_);
2626 auto o = flatbuffers::Offset<SettingChangeMessage>(end);
2627 return o;
2628 }
2629 };
2630
2631 inline flatbuffers::Offset<SettingChangeMessage> CreateSettingChangeMessage(
2632 flatbuffers::FlatBufferBuilder &_fbb,
2633 chre::fbs::Setting setting = chre::fbs::Setting::LOCATION,
2634 chre::fbs::SettingState state = chre::fbs::SettingState::DISABLED) {
2635 SettingChangeMessageBuilder builder_(_fbb);
2636 builder_.add_state(state);
2637 builder_.add_setting(setting);
2638 return builder_.Finish();
2639 }
2640
2641 /// Represents V2 log messages from CHRE.
2642 struct LogMessageV2 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2643 typedef LogMessageV2Builder Builder;
2644 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2645 VT_BUFFER = 4,
2646 VT_NUM_LOGS_DROPPED = 6
2647 };
2648 /// A buffer containing formatted log data. A flat array is used here to avoid
2649 /// overhead in serializing and deserializing. The format is as follows:
2650 ///
2651 /// uint8_t - Log metadata, encoded as follows:
2652 /// [EI(Upper nibble) | Level(Lower nibble)]
2653 /// * Log Type
2654 /// (0 = No encoding, 1 = Tokenized log,
2655 /// 2 = BT snoop log, 3 = Nanoapp Tokenized log)
2656 /// * LogBuffer log level (1 = error, 2 = warn,
2657 /// 3 = info, 4 = debug,
2658 /// 5 = verbose)
2659 /// uint32_t, little-endian - timestamp in milliseconds
2660 /// char[] - Log data buffer
2661 ///
2662 /// The log data buffer format is as follows:
2663 /// * Unencoded (string) logs: The log buffer can be interpreted as a NULL
2664 /// terminated string (eg: pass to string manipulation functions, get its
2665 /// size via strlen(), etc.).
2666 ///
2667 /// * Tokenized logs: The first byte of the log buffer indicates the size of
2668 /// the actual encoded data to follow. For example, if a tokenized log of
2669 /// size 24 bytes were to be represented, a buffer of size 25 bytes would
2670 /// be needed to encode this as: [Size(1B) | Data(24B)]. A decoder would
2671 /// then have to decode this starting from a 1 byte offset from the
2672 /// received buffer.
2673 ///
2674 /// * Bt Snoop logs: The first byte of the log buffer indicates the direction
2675 /// of the bt snoop log, depending on whether it is incoming for the BT
2676 /// controller or outgoing to the arbiter. The second byte indicates the size
2677 /// of the actual BT payload followed. For example, if a bt snoop log of
2678 /// size 24 bytes were to be represented, a buffer of size 26 bytes would
2679 /// be needed to encode this as: [Direction(1B) | Size(1B) | Data(24B)].
2680 ///
2681 /// * Tokenized nanoapp logs: This log type is specifically for nanoapps with
2682 /// tokenized logs enabled. The first two bytes is the instance ID of the
2683 /// nanoapp which sends this tokenized log message. This instance ID will be
2684 /// used to map to the corresponding detokenizer in the log message parser.
2685 /// The rest is similar to tokenized logs with one byte of the size followed
2686 /// by the payload. For example, if a nanoapp tokenized log of size 24 bytes
2687 /// were to be sent, a buffer of size 27 bytes would be to encoded as:
2688 /// [InstanceId (2B) | Size(1B) | Data(24B)].
2689 ///
2690 /// This pattern repeats until the end of the buffer for multiple log
2691 /// messages. The last byte will always be a null-terminator. There are no
2692 /// padding bytes between these fields. Treat this like a packed struct and be
2693 /// cautious with unaligned access when reading/writing this buffer.
2694 /// Note that the log message might not be null-terminated if an encoding is
2695 /// used.
2696 const flatbuffers::Vector<int8_t> *buffer() const {
2697 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_BUFFER);
2698 }
2699 /// The number of logs dropped since CHRE started
2700 uint32_t num_logs_dropped() const {
2701 return GetField<uint32_t>(VT_NUM_LOGS_DROPPED, 0);
2702 }
2703 bool Verify(flatbuffers::Verifier &verifier) const {
2704 return VerifyTableStart(verifier) &&
2705 VerifyOffset(verifier, VT_BUFFER) &&
2706 verifier.VerifyVector(buffer()) &&
2707 VerifyField<uint32_t>(verifier, VT_NUM_LOGS_DROPPED) &&
2708 verifier.EndTable();
2709 }
2710 };
2711
2712 struct LogMessageV2Builder {
2713 typedef LogMessageV2 Table;
2714 flatbuffers::FlatBufferBuilder &fbb_;
2715 flatbuffers::uoffset_t start_;
2716 void add_buffer(flatbuffers::Offset<flatbuffers::Vector<int8_t>> buffer) {
2717 fbb_.AddOffset(LogMessageV2::VT_BUFFER, buffer);
2718 }
2719 void add_num_logs_dropped(uint32_t num_logs_dropped) {
2720 fbb_.AddElement<uint32_t>(LogMessageV2::VT_NUM_LOGS_DROPPED, num_logs_dropped, 0);
2721 }
2722 explicit LogMessageV2Builder(flatbuffers::FlatBufferBuilder &_fbb)
2723 : fbb_(_fbb) {
2724 start_ = fbb_.StartTable();
2725 }
2726 LogMessageV2Builder &operator=(const LogMessageV2Builder &);
2727 flatbuffers::Offset<LogMessageV2> Finish() {
2728 const auto end = fbb_.EndTable(start_);
2729 auto o = flatbuffers::Offset<LogMessageV2>(end);
2730 return o;
2731 }
2732 };
2733
2734 inline flatbuffers::Offset<LogMessageV2> CreateLogMessageV2(
2735 flatbuffers::FlatBufferBuilder &_fbb,
2736 flatbuffers::Offset<flatbuffers::Vector<int8_t>> buffer = 0,
2737 uint32_t num_logs_dropped = 0) {
2738 LogMessageV2Builder builder_(_fbb);
2739 builder_.add_num_logs_dropped(num_logs_dropped);
2740 builder_.add_buffer(buffer);
2741 return builder_.Finish();
2742 }
2743
2744 inline flatbuffers::Offset<LogMessageV2> CreateLogMessageV2Direct(
2745 flatbuffers::FlatBufferBuilder &_fbb,
2746 const std::vector<int8_t> *buffer = nullptr,
2747 uint32_t num_logs_dropped = 0) {
2748 auto buffer__ = buffer ? _fbb.CreateVector<int8_t>(*buffer) : 0;
2749 return chre::fbs::CreateLogMessageV2(
2750 _fbb,
2751 buffer__,
2752 num_logs_dropped);
2753 }
2754
2755 struct SelfTestRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2756 typedef SelfTestRequestBuilder Builder;
2757 bool Verify(flatbuffers::Verifier &verifier) const {
2758 return VerifyTableStart(verifier) &&
2759 verifier.EndTable();
2760 }
2761 };
2762
2763 struct SelfTestRequestBuilder {
2764 typedef SelfTestRequest Table;
2765 flatbuffers::FlatBufferBuilder &fbb_;
2766 flatbuffers::uoffset_t start_;
2767 explicit SelfTestRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2768 : fbb_(_fbb) {
2769 start_ = fbb_.StartTable();
2770 }
2771 SelfTestRequestBuilder &operator=(const SelfTestRequestBuilder &);
2772 flatbuffers::Offset<SelfTestRequest> Finish() {
2773 const auto end = fbb_.EndTable(start_);
2774 auto o = flatbuffers::Offset<SelfTestRequest>(end);
2775 return o;
2776 }
2777 };
2778
2779 inline flatbuffers::Offset<SelfTestRequest> CreateSelfTestRequest(
2780 flatbuffers::FlatBufferBuilder &_fbb) {
2781 SelfTestRequestBuilder builder_(_fbb);
2782 return builder_.Finish();
2783 }
2784
2785 struct SelfTestResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2786 typedef SelfTestResponseBuilder Builder;
2787 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2788 VT_SUCCESS = 4
2789 };
2790 bool success() const {
2791 return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
2792 }
2793 bool Verify(flatbuffers::Verifier &verifier) const {
2794 return VerifyTableStart(verifier) &&
2795 VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
2796 verifier.EndTable();
2797 }
2798 };
2799
2800 struct SelfTestResponseBuilder {
2801 typedef SelfTestResponse Table;
2802 flatbuffers::FlatBufferBuilder &fbb_;
2803 flatbuffers::uoffset_t start_;
2804 void add_success(bool success) {
2805 fbb_.AddElement<uint8_t>(SelfTestResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0);
2806 }
2807 explicit SelfTestResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2808 : fbb_(_fbb) {
2809 start_ = fbb_.StartTable();
2810 }
2811 SelfTestResponseBuilder &operator=(const SelfTestResponseBuilder &);
2812 flatbuffers::Offset<SelfTestResponse> Finish() {
2813 const auto end = fbb_.EndTable(start_);
2814 auto o = flatbuffers::Offset<SelfTestResponse>(end);
2815 return o;
2816 }
2817 };
2818
2819 inline flatbuffers::Offset<SelfTestResponse> CreateSelfTestResponse(
2820 flatbuffers::FlatBufferBuilder &_fbb,
2821 bool success = false) {
2822 SelfTestResponseBuilder builder_(_fbb);
2823 builder_.add_success(success);
2824 return builder_.Finish();
2825 }
2826
2827 struct HostEndpointConnected FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2828 typedef HostEndpointConnectedBuilder Builder;
2829 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2830 VT_HOST_ENDPOINT = 4,
2831 VT_TYPE = 6,
2832 VT_PACKAGE_NAME = 8,
2833 VT_ATTRIBUTION_TAG = 10
2834 };
2835 /// The host-side endpoint that has connected to the framework.
2836 uint16_t host_endpoint() const {
2837 return GetField<uint16_t>(VT_HOST_ENDPOINT, 0);
2838 }
2839 /// The type of host endpoint, which should be any of the CHRE_HOST_ENDPOINT_TYPE_*
2840 /// values defined in the chre_api/chre/event.h.
2841 uint8_t type() const {
2842 return GetField<uint8_t>(VT_TYPE, 0);
2843 }
2844 /// The (optional) package name associated with the host endpoint.
2845 const flatbuffers::Vector<int8_t> *package_name() const {
2846 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_PACKAGE_NAME);
2847 }
2848 /// The (optional) attribution tag associated with this host.
2849 const flatbuffers::Vector<int8_t> *attribution_tag() const {
2850 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_ATTRIBUTION_TAG);
2851 }
2852 bool Verify(flatbuffers::Verifier &verifier) const {
2853 return VerifyTableStart(verifier) &&
2854 VerifyField<uint16_t>(verifier, VT_HOST_ENDPOINT) &&
2855 VerifyField<uint8_t>(verifier, VT_TYPE) &&
2856 VerifyOffset(verifier, VT_PACKAGE_NAME) &&
2857 verifier.VerifyVector(package_name()) &&
2858 VerifyOffset(verifier, VT_ATTRIBUTION_TAG) &&
2859 verifier.VerifyVector(attribution_tag()) &&
2860 verifier.EndTable();
2861 }
2862 };
2863
2864 struct HostEndpointConnectedBuilder {
2865 typedef HostEndpointConnected Table;
2866 flatbuffers::FlatBufferBuilder &fbb_;
2867 flatbuffers::uoffset_t start_;
2868 void add_host_endpoint(uint16_t host_endpoint) {
2869 fbb_.AddElement<uint16_t>(HostEndpointConnected::VT_HOST_ENDPOINT, host_endpoint, 0);
2870 }
2871 void add_type(uint8_t type) {
2872 fbb_.AddElement<uint8_t>(HostEndpointConnected::VT_TYPE, type, 0);
2873 }
2874 void add_package_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> package_name) {
2875 fbb_.AddOffset(HostEndpointConnected::VT_PACKAGE_NAME, package_name);
2876 }
2877 void add_attribution_tag(flatbuffers::Offset<flatbuffers::Vector<int8_t>> attribution_tag) {
2878 fbb_.AddOffset(HostEndpointConnected::VT_ATTRIBUTION_TAG, attribution_tag);
2879 }
2880 explicit HostEndpointConnectedBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2881 : fbb_(_fbb) {
2882 start_ = fbb_.StartTable();
2883 }
2884 HostEndpointConnectedBuilder &operator=(const HostEndpointConnectedBuilder &);
2885 flatbuffers::Offset<HostEndpointConnected> Finish() {
2886 const auto end = fbb_.EndTable(start_);
2887 auto o = flatbuffers::Offset<HostEndpointConnected>(end);
2888 return o;
2889 }
2890 };
2891
2892 inline flatbuffers::Offset<HostEndpointConnected> CreateHostEndpointConnected(
2893 flatbuffers::FlatBufferBuilder &_fbb,
2894 uint16_t host_endpoint = 0,
2895 uint8_t type = 0,
2896 flatbuffers::Offset<flatbuffers::Vector<int8_t>> package_name = 0,
2897 flatbuffers::Offset<flatbuffers::Vector<int8_t>> attribution_tag = 0) {
2898 HostEndpointConnectedBuilder builder_(_fbb);
2899 builder_.add_attribution_tag(attribution_tag);
2900 builder_.add_package_name(package_name);
2901 builder_.add_host_endpoint(host_endpoint);
2902 builder_.add_type(type);
2903 return builder_.Finish();
2904 }
2905
2906 inline flatbuffers::Offset<HostEndpointConnected> CreateHostEndpointConnectedDirect(
2907 flatbuffers::FlatBufferBuilder &_fbb,
2908 uint16_t host_endpoint = 0,
2909 uint8_t type = 0,
2910 const std::vector<int8_t> *package_name = nullptr,
2911 const std::vector<int8_t> *attribution_tag = nullptr) {
2912 auto package_name__ = package_name ? _fbb.CreateVector<int8_t>(*package_name) : 0;
2913 auto attribution_tag__ = attribution_tag ? _fbb.CreateVector<int8_t>(*attribution_tag) : 0;
2914 return chre::fbs::CreateHostEndpointConnected(
2915 _fbb,
2916 host_endpoint,
2917 type,
2918 package_name__,
2919 attribution_tag__);
2920 }
2921
2922 struct HostEndpointDisconnected FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2923 typedef HostEndpointDisconnectedBuilder Builder;
2924 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2925 VT_HOST_ENDPOINT = 4
2926 };
2927 /// The host-side endpoint that has disconnected from the framework.
2928 uint16_t host_endpoint() const {
2929 return GetField<uint16_t>(VT_HOST_ENDPOINT, 0);
2930 }
2931 bool Verify(flatbuffers::Verifier &verifier) const {
2932 return VerifyTableStart(verifier) &&
2933 VerifyField<uint16_t>(verifier, VT_HOST_ENDPOINT) &&
2934 verifier.EndTable();
2935 }
2936 };
2937
2938 struct HostEndpointDisconnectedBuilder {
2939 typedef HostEndpointDisconnected Table;
2940 flatbuffers::FlatBufferBuilder &fbb_;
2941 flatbuffers::uoffset_t start_;
2942 void add_host_endpoint(uint16_t host_endpoint) {
2943 fbb_.AddElement<uint16_t>(HostEndpointDisconnected::VT_HOST_ENDPOINT, host_endpoint, 0);
2944 }
2945 explicit HostEndpointDisconnectedBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2946 : fbb_(_fbb) {
2947 start_ = fbb_.StartTable();
2948 }
2949 HostEndpointDisconnectedBuilder &operator=(const HostEndpointDisconnectedBuilder &);
2950 flatbuffers::Offset<HostEndpointDisconnected> Finish() {
2951 const auto end = fbb_.EndTable(start_);
2952 auto o = flatbuffers::Offset<HostEndpointDisconnected>(end);
2953 return o;
2954 }
2955 };
2956
2957 inline flatbuffers::Offset<HostEndpointDisconnected> CreateHostEndpointDisconnected(
2958 flatbuffers::FlatBufferBuilder &_fbb,
2959 uint16_t host_endpoint = 0) {
2960 HostEndpointDisconnectedBuilder builder_(_fbb);
2961 builder_.add_host_endpoint(host_endpoint);
2962 return builder_.Finish();
2963 }
2964
2965 struct MetricLog FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2966 typedef MetricLogBuilder Builder;
2967 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2968 VT_ID = 4,
2969 VT_ENCODED_METRIC = 6
2970 };
2971 uint32_t id() const {
2972 return GetField<uint32_t>(VT_ID, 0);
2973 }
2974 const flatbuffers::Vector<int8_t> *encoded_metric() const {
2975 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_ENCODED_METRIC);
2976 }
2977 bool Verify(flatbuffers::Verifier &verifier) const {
2978 return VerifyTableStart(verifier) &&
2979 VerifyField<uint32_t>(verifier, VT_ID) &&
2980 VerifyOffset(verifier, VT_ENCODED_METRIC) &&
2981 verifier.VerifyVector(encoded_metric()) &&
2982 verifier.EndTable();
2983 }
2984 };
2985
2986 struct MetricLogBuilder {
2987 typedef MetricLog Table;
2988 flatbuffers::FlatBufferBuilder &fbb_;
2989 flatbuffers::uoffset_t start_;
2990 void add_id(uint32_t id) {
2991 fbb_.AddElement<uint32_t>(MetricLog::VT_ID, id, 0);
2992 }
2993 void add_encoded_metric(flatbuffers::Offset<flatbuffers::Vector<int8_t>> encoded_metric) {
2994 fbb_.AddOffset(MetricLog::VT_ENCODED_METRIC, encoded_metric);
2995 }
2996 explicit MetricLogBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2997 : fbb_(_fbb) {
2998 start_ = fbb_.StartTable();
2999 }
3000 MetricLogBuilder &operator=(const MetricLogBuilder &);
3001 flatbuffers::Offset<MetricLog> Finish() {
3002 const auto end = fbb_.EndTable(start_);
3003 auto o = flatbuffers::Offset<MetricLog>(end);
3004 return o;
3005 }
3006 };
3007
3008 inline flatbuffers::Offset<MetricLog> CreateMetricLog(
3009 flatbuffers::FlatBufferBuilder &_fbb,
3010 uint32_t id = 0,
3011 flatbuffers::Offset<flatbuffers::Vector<int8_t>> encoded_metric = 0) {
3012 MetricLogBuilder builder_(_fbb);
3013 builder_.add_encoded_metric(encoded_metric);
3014 builder_.add_id(id);
3015 return builder_.Finish();
3016 }
3017
3018 inline flatbuffers::Offset<MetricLog> CreateMetricLogDirect(
3019 flatbuffers::FlatBufferBuilder &_fbb,
3020 uint32_t id = 0,
3021 const std::vector<int8_t> *encoded_metric = nullptr) {
3022 auto encoded_metric__ = encoded_metric ? _fbb.CreateVector<int8_t>(*encoded_metric) : 0;
3023 return chre::fbs::CreateMetricLog(
3024 _fbb,
3025 id,
3026 encoded_metric__);
3027 }
3028
3029 struct BatchedMetricLog FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3030 typedef BatchedMetricLogBuilder Builder;
3031 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3032 VT_METRICS = 4
3033 };
3034 const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MetricLog>> *metrics() const {
3035 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MetricLog>> *>(VT_METRICS);
3036 }
3037 bool Verify(flatbuffers::Verifier &verifier) const {
3038 return VerifyTableStart(verifier) &&
3039 VerifyOffset(verifier, VT_METRICS) &&
3040 verifier.VerifyVector(metrics()) &&
3041 verifier.VerifyVectorOfTables(metrics()) &&
3042 verifier.EndTable();
3043 }
3044 };
3045
3046 struct BatchedMetricLogBuilder {
3047 typedef BatchedMetricLog Table;
3048 flatbuffers::FlatBufferBuilder &fbb_;
3049 flatbuffers::uoffset_t start_;
3050 void add_metrics(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MetricLog>>> metrics) {
3051 fbb_.AddOffset(BatchedMetricLog::VT_METRICS, metrics);
3052 }
3053 explicit BatchedMetricLogBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3054 : fbb_(_fbb) {
3055 start_ = fbb_.StartTable();
3056 }
3057 BatchedMetricLogBuilder &operator=(const BatchedMetricLogBuilder &);
3058 flatbuffers::Offset<BatchedMetricLog> Finish() {
3059 const auto end = fbb_.EndTable(start_);
3060 auto o = flatbuffers::Offset<BatchedMetricLog>(end);
3061 return o;
3062 }
3063 };
3064
3065 inline flatbuffers::Offset<BatchedMetricLog> CreateBatchedMetricLog(
3066 flatbuffers::FlatBufferBuilder &_fbb,
3067 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MetricLog>>> metrics = 0) {
3068 BatchedMetricLogBuilder builder_(_fbb);
3069 builder_.add_metrics(metrics);
3070 return builder_.Finish();
3071 }
3072
3073 inline flatbuffers::Offset<BatchedMetricLog> CreateBatchedMetricLogDirect(
3074 flatbuffers::FlatBufferBuilder &_fbb,
3075 const std::vector<flatbuffers::Offset<chre::fbs::MetricLog>> *metrics = nullptr) {
3076 auto metrics__ = metrics ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::MetricLog>>(*metrics) : 0;
3077 return chre::fbs::CreateBatchedMetricLog(
3078 _fbb,
3079 metrics__);
3080 }
3081
3082 struct NanConfigurationRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3083 typedef NanConfigurationRequestBuilder Builder;
3084 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3085 VT_ENABLE = 4
3086 };
3087 bool enable() const {
3088 return GetField<uint8_t>(VT_ENABLE, 0) != 0;
3089 }
3090 bool Verify(flatbuffers::Verifier &verifier) const {
3091 return VerifyTableStart(verifier) &&
3092 VerifyField<uint8_t>(verifier, VT_ENABLE) &&
3093 verifier.EndTable();
3094 }
3095 };
3096
3097 struct NanConfigurationRequestBuilder {
3098 typedef NanConfigurationRequest Table;
3099 flatbuffers::FlatBufferBuilder &fbb_;
3100 flatbuffers::uoffset_t start_;
3101 void add_enable(bool enable) {
3102 fbb_.AddElement<uint8_t>(NanConfigurationRequest::VT_ENABLE, static_cast<uint8_t>(enable), 0);
3103 }
3104 explicit NanConfigurationRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3105 : fbb_(_fbb) {
3106 start_ = fbb_.StartTable();
3107 }
3108 NanConfigurationRequestBuilder &operator=(const NanConfigurationRequestBuilder &);
3109 flatbuffers::Offset<NanConfigurationRequest> Finish() {
3110 const auto end = fbb_.EndTable(start_);
3111 auto o = flatbuffers::Offset<NanConfigurationRequest>(end);
3112 return o;
3113 }
3114 };
3115
3116 inline flatbuffers::Offset<NanConfigurationRequest> CreateNanConfigurationRequest(
3117 flatbuffers::FlatBufferBuilder &_fbb,
3118 bool enable = false) {
3119 NanConfigurationRequestBuilder builder_(_fbb);
3120 builder_.add_enable(enable);
3121 return builder_.Finish();
3122 }
3123
3124 struct NanConfigurationUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3125 typedef NanConfigurationUpdateBuilder Builder;
3126 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3127 VT_ENABLED = 4
3128 };
3129 bool enabled() const {
3130 return GetField<uint8_t>(VT_ENABLED, 0) != 0;
3131 }
3132 bool Verify(flatbuffers::Verifier &verifier) const {
3133 return VerifyTableStart(verifier) &&
3134 VerifyField<uint8_t>(verifier, VT_ENABLED) &&
3135 verifier.EndTable();
3136 }
3137 };
3138
3139 struct NanConfigurationUpdateBuilder {
3140 typedef NanConfigurationUpdate Table;
3141 flatbuffers::FlatBufferBuilder &fbb_;
3142 flatbuffers::uoffset_t start_;
3143 void add_enabled(bool enabled) {
3144 fbb_.AddElement<uint8_t>(NanConfigurationUpdate::VT_ENABLED, static_cast<uint8_t>(enabled), 0);
3145 }
3146 explicit NanConfigurationUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3147 : fbb_(_fbb) {
3148 start_ = fbb_.StartTable();
3149 }
3150 NanConfigurationUpdateBuilder &operator=(const NanConfigurationUpdateBuilder &);
3151 flatbuffers::Offset<NanConfigurationUpdate> Finish() {
3152 const auto end = fbb_.EndTable(start_);
3153 auto o = flatbuffers::Offset<NanConfigurationUpdate>(end);
3154 return o;
3155 }
3156 };
3157
3158 inline flatbuffers::Offset<NanConfigurationUpdate> CreateNanConfigurationUpdate(
3159 flatbuffers::FlatBufferBuilder &_fbb,
3160 bool enabled = false) {
3161 NanConfigurationUpdateBuilder builder_(_fbb);
3162 builder_.add_enabled(enabled);
3163 return builder_.Finish();
3164 }
3165
3166 struct DebugConfiguration FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3167 typedef DebugConfigurationBuilder Builder;
3168 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3169 VT_HEALTH_MONITOR_FAILURE_CRASH = 4
3170 };
3171 bool health_monitor_failure_crash() const {
3172 return GetField<uint8_t>(VT_HEALTH_MONITOR_FAILURE_CRASH, 0) != 0;
3173 }
3174 bool Verify(flatbuffers::Verifier &verifier) const {
3175 return VerifyTableStart(verifier) &&
3176 VerifyField<uint8_t>(verifier, VT_HEALTH_MONITOR_FAILURE_CRASH) &&
3177 verifier.EndTable();
3178 }
3179 };
3180
3181 struct DebugConfigurationBuilder {
3182 typedef DebugConfiguration Table;
3183 flatbuffers::FlatBufferBuilder &fbb_;
3184 flatbuffers::uoffset_t start_;
3185 void add_health_monitor_failure_crash(bool health_monitor_failure_crash) {
3186 fbb_.AddElement<uint8_t>(DebugConfiguration::VT_HEALTH_MONITOR_FAILURE_CRASH, static_cast<uint8_t>(health_monitor_failure_crash), 0);
3187 }
3188 explicit DebugConfigurationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3189 : fbb_(_fbb) {
3190 start_ = fbb_.StartTable();
3191 }
3192 DebugConfigurationBuilder &operator=(const DebugConfigurationBuilder &);
3193 flatbuffers::Offset<DebugConfiguration> Finish() {
3194 const auto end = fbb_.EndTable(start_);
3195 auto o = flatbuffers::Offset<DebugConfiguration>(end);
3196 return o;
3197 }
3198 };
3199
3200 inline flatbuffers::Offset<DebugConfiguration> CreateDebugConfiguration(
3201 flatbuffers::FlatBufferBuilder &_fbb,
3202 bool health_monitor_failure_crash = false) {
3203 DebugConfigurationBuilder builder_(_fbb);
3204 builder_.add_health_monitor_failure_crash(health_monitor_failure_crash);
3205 return builder_.Finish();
3206 }
3207
3208 struct PulseRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3209 typedef PulseRequestBuilder Builder;
3210 bool Verify(flatbuffers::Verifier &verifier) const {
3211 return VerifyTableStart(verifier) &&
3212 verifier.EndTable();
3213 }
3214 };
3215
3216 struct PulseRequestBuilder {
3217 typedef PulseRequest Table;
3218 flatbuffers::FlatBufferBuilder &fbb_;
3219 flatbuffers::uoffset_t start_;
3220 explicit PulseRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3221 : fbb_(_fbb) {
3222 start_ = fbb_.StartTable();
3223 }
3224 PulseRequestBuilder &operator=(const PulseRequestBuilder &);
3225 flatbuffers::Offset<PulseRequest> Finish() {
3226 const auto end = fbb_.EndTable(start_);
3227 auto o = flatbuffers::Offset<PulseRequest>(end);
3228 return o;
3229 }
3230 };
3231
3232 inline flatbuffers::Offset<PulseRequest> CreatePulseRequest(
3233 flatbuffers::FlatBufferBuilder &_fbb) {
3234 PulseRequestBuilder builder_(_fbb);
3235 return builder_.Finish();
3236 }
3237
3238 struct PulseResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3239 typedef PulseResponseBuilder Builder;
3240 bool Verify(flatbuffers::Verifier &verifier) const {
3241 return VerifyTableStart(verifier) &&
3242 verifier.EndTable();
3243 }
3244 };
3245
3246 struct PulseResponseBuilder {
3247 typedef PulseResponse Table;
3248 flatbuffers::FlatBufferBuilder &fbb_;
3249 flatbuffers::uoffset_t start_;
3250 explicit PulseResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3251 : fbb_(_fbb) {
3252 start_ = fbb_.StartTable();
3253 }
3254 PulseResponseBuilder &operator=(const PulseResponseBuilder &);
3255 flatbuffers::Offset<PulseResponse> Finish() {
3256 const auto end = fbb_.EndTable(start_);
3257 auto o = flatbuffers::Offset<PulseResponse>(end);
3258 return o;
3259 }
3260 };
3261
3262 inline flatbuffers::Offset<PulseResponse> CreatePulseResponse(
3263 flatbuffers::FlatBufferBuilder &_fbb) {
3264 PulseResponseBuilder builder_(_fbb);
3265 return builder_.Finish();
3266 }
3267
3268 struct LeCocChannelInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3269 typedef LeCocChannelInfoBuilder Builder;
3270 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3271 VT_LOCALCID = 4,
3272 VT_REMOTECID = 6,
3273 VT_PSM = 8,
3274 VT_LOCALMTU = 10,
3275 VT_REMOTEMTU = 12,
3276 VT_LOCALMPS = 14,
3277 VT_REMOTEMPS = 16,
3278 VT_INITIALRXCREDITS = 18,
3279 VT_INITIALTXCREDITS = 20
3280 };
3281 int32_t localCid() const {
3282 return GetField<int32_t>(VT_LOCALCID, 0);
3283 }
3284 int32_t remoteCid() const {
3285 return GetField<int32_t>(VT_REMOTECID, 0);
3286 }
3287 int32_t psm() const {
3288 return GetField<int32_t>(VT_PSM, 0);
3289 }
3290 int32_t localMtu() const {
3291 return GetField<int32_t>(VT_LOCALMTU, 0);
3292 }
3293 int32_t remoteMtu() const {
3294 return GetField<int32_t>(VT_REMOTEMTU, 0);
3295 }
3296 int32_t localMps() const {
3297 return GetField<int32_t>(VT_LOCALMPS, 0);
3298 }
3299 int32_t remoteMps() const {
3300 return GetField<int32_t>(VT_REMOTEMPS, 0);
3301 }
3302 int32_t initialRxCredits() const {
3303 return GetField<int32_t>(VT_INITIALRXCREDITS, 0);
3304 }
3305 int32_t initialTxCredits() const {
3306 return GetField<int32_t>(VT_INITIALTXCREDITS, 0);
3307 }
3308 bool Verify(flatbuffers::Verifier &verifier) const {
3309 return VerifyTableStart(verifier) &&
3310 VerifyField<int32_t>(verifier, VT_LOCALCID) &&
3311 VerifyField<int32_t>(verifier, VT_REMOTECID) &&
3312 VerifyField<int32_t>(verifier, VT_PSM) &&
3313 VerifyField<int32_t>(verifier, VT_LOCALMTU) &&
3314 VerifyField<int32_t>(verifier, VT_REMOTEMTU) &&
3315 VerifyField<int32_t>(verifier, VT_LOCALMPS) &&
3316 VerifyField<int32_t>(verifier, VT_REMOTEMPS) &&
3317 VerifyField<int32_t>(verifier, VT_INITIALRXCREDITS) &&
3318 VerifyField<int32_t>(verifier, VT_INITIALTXCREDITS) &&
3319 verifier.EndTable();
3320 }
3321 };
3322
3323 struct LeCocChannelInfoBuilder {
3324 typedef LeCocChannelInfo Table;
3325 flatbuffers::FlatBufferBuilder &fbb_;
3326 flatbuffers::uoffset_t start_;
3327 void add_localCid(int32_t localCid) {
3328 fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_LOCALCID, localCid, 0);
3329 }
3330 void add_remoteCid(int32_t remoteCid) {
3331 fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_REMOTECID, remoteCid, 0);
3332 }
3333 void add_psm(int32_t psm) {
3334 fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_PSM, psm, 0);
3335 }
3336 void add_localMtu(int32_t localMtu) {
3337 fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_LOCALMTU, localMtu, 0);
3338 }
3339 void add_remoteMtu(int32_t remoteMtu) {
3340 fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_REMOTEMTU, remoteMtu, 0);
3341 }
3342 void add_localMps(int32_t localMps) {
3343 fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_LOCALMPS, localMps, 0);
3344 }
3345 void add_remoteMps(int32_t remoteMps) {
3346 fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_REMOTEMPS, remoteMps, 0);
3347 }
3348 void add_initialRxCredits(int32_t initialRxCredits) {
3349 fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_INITIALRXCREDITS, initialRxCredits, 0);
3350 }
3351 void add_initialTxCredits(int32_t initialTxCredits) {
3352 fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_INITIALTXCREDITS, initialTxCredits, 0);
3353 }
3354 explicit LeCocChannelInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3355 : fbb_(_fbb) {
3356 start_ = fbb_.StartTable();
3357 }
3358 LeCocChannelInfoBuilder &operator=(const LeCocChannelInfoBuilder &);
3359 flatbuffers::Offset<LeCocChannelInfo> Finish() {
3360 const auto end = fbb_.EndTable(start_);
3361 auto o = flatbuffers::Offset<LeCocChannelInfo>(end);
3362 return o;
3363 }
3364 };
3365
3366 inline flatbuffers::Offset<LeCocChannelInfo> CreateLeCocChannelInfo(
3367 flatbuffers::FlatBufferBuilder &_fbb,
3368 int32_t localCid = 0,
3369 int32_t remoteCid = 0,
3370 int32_t psm = 0,
3371 int32_t localMtu = 0,
3372 int32_t remoteMtu = 0,
3373 int32_t localMps = 0,
3374 int32_t remoteMps = 0,
3375 int32_t initialRxCredits = 0,
3376 int32_t initialTxCredits = 0) {
3377 LeCocChannelInfoBuilder builder_(_fbb);
3378 builder_.add_initialTxCredits(initialTxCredits);
3379 builder_.add_initialRxCredits(initialRxCredits);
3380 builder_.add_remoteMps(remoteMps);
3381 builder_.add_localMps(localMps);
3382 builder_.add_remoteMtu(remoteMtu);
3383 builder_.add_localMtu(localMtu);
3384 builder_.add_psm(psm);
3385 builder_.add_remoteCid(remoteCid);
3386 builder_.add_localCid(localCid);
3387 return builder_.Finish();
3388 }
3389
3390 struct BtSocketOpen FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3391 typedef BtSocketOpenBuilder Builder;
3392 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3393 VT_SOCKETID = 4,
3394 VT_NAME = 6,
3395 VT_ACLCONNECTIONHANDLE = 8,
3396 VT_CHANNELINFO_TYPE = 10,
3397 VT_CHANNELINFO = 12,
3398 VT_HUBID = 14,
3399 VT_ENDPOINTID = 16
3400 };
3401 int64_t socketId() const {
3402 return GetField<int64_t>(VT_SOCKETID, 0);
3403 }
3404 const flatbuffers::Vector<int8_t> *name() const {
3405 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_NAME);
3406 }
3407 int32_t aclConnectionHandle() const {
3408 return GetField<int32_t>(VT_ACLCONNECTIONHANDLE, 0);
3409 }
3410 chre::fbs::ChannelInfo channelInfo_type() const {
3411 return static_cast<chre::fbs::ChannelInfo>(GetField<uint8_t>(VT_CHANNELINFO_TYPE, 0));
3412 }
3413 const void *channelInfo() const {
3414 return GetPointer<const void *>(VT_CHANNELINFO);
3415 }
3416 template<typename T> const T *channelInfo_as() const;
3417 const chre::fbs::LeCocChannelInfo *channelInfo_as_LeCocChannelInfo() const {
3418 return channelInfo_type() == chre::fbs::ChannelInfo::LeCocChannelInfo ? static_cast<const chre::fbs::LeCocChannelInfo *>(channelInfo()) : nullptr;
3419 }
3420 int64_t hubId() const {
3421 return GetField<int64_t>(VT_HUBID, 0);
3422 }
3423 int64_t endpointId() const {
3424 return GetField<int64_t>(VT_ENDPOINTID, 0);
3425 }
3426 bool Verify(flatbuffers::Verifier &verifier) const {
3427 return VerifyTableStart(verifier) &&
3428 VerifyField<int64_t>(verifier, VT_SOCKETID) &&
3429 VerifyOffset(verifier, VT_NAME) &&
3430 verifier.VerifyVector(name()) &&
3431 VerifyField<int32_t>(verifier, VT_ACLCONNECTIONHANDLE) &&
3432 VerifyField<uint8_t>(verifier, VT_CHANNELINFO_TYPE) &&
3433 VerifyOffset(verifier, VT_CHANNELINFO) &&
3434 VerifyChannelInfo(verifier, channelInfo(), channelInfo_type()) &&
3435 VerifyField<int64_t>(verifier, VT_HUBID) &&
3436 VerifyField<int64_t>(verifier, VT_ENDPOINTID) &&
3437 verifier.EndTable();
3438 }
3439 };
3440
3441 template<> inline const chre::fbs::LeCocChannelInfo *BtSocketOpen::channelInfo_as<chre::fbs::LeCocChannelInfo>() const {
3442 return channelInfo_as_LeCocChannelInfo();
3443 }
3444
3445 struct BtSocketOpenBuilder {
3446 typedef BtSocketOpen Table;
3447 flatbuffers::FlatBufferBuilder &fbb_;
3448 flatbuffers::uoffset_t start_;
3449 void add_socketId(int64_t socketId) {
3450 fbb_.AddElement<int64_t>(BtSocketOpen::VT_SOCKETID, socketId, 0);
3451 }
3452 void add_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> name) {
3453 fbb_.AddOffset(BtSocketOpen::VT_NAME, name);
3454 }
3455 void add_aclConnectionHandle(int32_t aclConnectionHandle) {
3456 fbb_.AddElement<int32_t>(BtSocketOpen::VT_ACLCONNECTIONHANDLE, aclConnectionHandle, 0);
3457 }
3458 void add_channelInfo_type(chre::fbs::ChannelInfo channelInfo_type) {
3459 fbb_.AddElement<uint8_t>(BtSocketOpen::VT_CHANNELINFO_TYPE, static_cast<uint8_t>(channelInfo_type), 0);
3460 }
3461 void add_channelInfo(flatbuffers::Offset<void> channelInfo) {
3462 fbb_.AddOffset(BtSocketOpen::VT_CHANNELINFO, channelInfo);
3463 }
3464 void add_hubId(int64_t hubId) {
3465 fbb_.AddElement<int64_t>(BtSocketOpen::VT_HUBID, hubId, 0);
3466 }
3467 void add_endpointId(int64_t endpointId) {
3468 fbb_.AddElement<int64_t>(BtSocketOpen::VT_ENDPOINTID, endpointId, 0);
3469 }
3470 explicit BtSocketOpenBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3471 : fbb_(_fbb) {
3472 start_ = fbb_.StartTable();
3473 }
3474 BtSocketOpenBuilder &operator=(const BtSocketOpenBuilder &);
3475 flatbuffers::Offset<BtSocketOpen> Finish() {
3476 const auto end = fbb_.EndTable(start_);
3477 auto o = flatbuffers::Offset<BtSocketOpen>(end);
3478 return o;
3479 }
3480 };
3481
3482 inline flatbuffers::Offset<BtSocketOpen> CreateBtSocketOpen(
3483 flatbuffers::FlatBufferBuilder &_fbb,
3484 int64_t socketId = 0,
3485 flatbuffers::Offset<flatbuffers::Vector<int8_t>> name = 0,
3486 int32_t aclConnectionHandle = 0,
3487 chre::fbs::ChannelInfo channelInfo_type = chre::fbs::ChannelInfo::NONE,
3488 flatbuffers::Offset<void> channelInfo = 0,
3489 int64_t hubId = 0,
3490 int64_t endpointId = 0) {
3491 BtSocketOpenBuilder builder_(_fbb);
3492 builder_.add_endpointId(endpointId);
3493 builder_.add_hubId(hubId);
3494 builder_.add_socketId(socketId);
3495 builder_.add_channelInfo(channelInfo);
3496 builder_.add_aclConnectionHandle(aclConnectionHandle);
3497 builder_.add_name(name);
3498 builder_.add_channelInfo_type(channelInfo_type);
3499 return builder_.Finish();
3500 }
3501
3502 inline flatbuffers::Offset<BtSocketOpen> CreateBtSocketOpenDirect(
3503 flatbuffers::FlatBufferBuilder &_fbb,
3504 int64_t socketId = 0,
3505 const std::vector<int8_t> *name = nullptr,
3506 int32_t aclConnectionHandle = 0,
3507 chre::fbs::ChannelInfo channelInfo_type = chre::fbs::ChannelInfo::NONE,
3508 flatbuffers::Offset<void> channelInfo = 0,
3509 int64_t hubId = 0,
3510 int64_t endpointId = 0) {
3511 auto name__ = name ? _fbb.CreateVector<int8_t>(*name) : 0;
3512 return chre::fbs::CreateBtSocketOpen(
3513 _fbb,
3514 socketId,
3515 name__,
3516 aclConnectionHandle,
3517 channelInfo_type,
3518 channelInfo,
3519 hubId,
3520 endpointId);
3521 }
3522
3523 struct BtSocketOpenResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3524 typedef BtSocketOpenResponseBuilder Builder;
3525 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3526 VT_SOCKETID = 4,
3527 VT_STATUS = 6,
3528 VT_REASON = 8
3529 };
3530 int64_t socketId() const {
3531 return GetField<int64_t>(VT_SOCKETID, 0);
3532 }
3533 chre::fbs::BtSocketOpenStatus status() const {
3534 return static_cast<chre::fbs::BtSocketOpenStatus>(GetField<int8_t>(VT_STATUS, 0));
3535 }
3536 const flatbuffers::Vector<int8_t> *reason() const {
3537 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_REASON);
3538 }
3539 bool Verify(flatbuffers::Verifier &verifier) const {
3540 return VerifyTableStart(verifier) &&
3541 VerifyField<int64_t>(verifier, VT_SOCKETID) &&
3542 VerifyField<int8_t>(verifier, VT_STATUS) &&
3543 VerifyOffset(verifier, VT_REASON) &&
3544 verifier.VerifyVector(reason()) &&
3545 verifier.EndTable();
3546 }
3547 };
3548
3549 struct BtSocketOpenResponseBuilder {
3550 typedef BtSocketOpenResponse Table;
3551 flatbuffers::FlatBufferBuilder &fbb_;
3552 flatbuffers::uoffset_t start_;
3553 void add_socketId(int64_t socketId) {
3554 fbb_.AddElement<int64_t>(BtSocketOpenResponse::VT_SOCKETID, socketId, 0);
3555 }
3556 void add_status(chre::fbs::BtSocketOpenStatus status) {
3557 fbb_.AddElement<int8_t>(BtSocketOpenResponse::VT_STATUS, static_cast<int8_t>(status), 0);
3558 }
3559 void add_reason(flatbuffers::Offset<flatbuffers::Vector<int8_t>> reason) {
3560 fbb_.AddOffset(BtSocketOpenResponse::VT_REASON, reason);
3561 }
3562 explicit BtSocketOpenResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3563 : fbb_(_fbb) {
3564 start_ = fbb_.StartTable();
3565 }
3566 BtSocketOpenResponseBuilder &operator=(const BtSocketOpenResponseBuilder &);
3567 flatbuffers::Offset<BtSocketOpenResponse> Finish() {
3568 const auto end = fbb_.EndTable(start_);
3569 auto o = flatbuffers::Offset<BtSocketOpenResponse>(end);
3570 return o;
3571 }
3572 };
3573
3574 inline flatbuffers::Offset<BtSocketOpenResponse> CreateBtSocketOpenResponse(
3575 flatbuffers::FlatBufferBuilder &_fbb,
3576 int64_t socketId = 0,
3577 chre::fbs::BtSocketOpenStatus status = chre::fbs::BtSocketOpenStatus::SUCCESS,
3578 flatbuffers::Offset<flatbuffers::Vector<int8_t>> reason = 0) {
3579 BtSocketOpenResponseBuilder builder_(_fbb);
3580 builder_.add_socketId(socketId);
3581 builder_.add_reason(reason);
3582 builder_.add_status(status);
3583 return builder_.Finish();
3584 }
3585
3586 inline flatbuffers::Offset<BtSocketOpenResponse> CreateBtSocketOpenResponseDirect(
3587 flatbuffers::FlatBufferBuilder &_fbb,
3588 int64_t socketId = 0,
3589 chre::fbs::BtSocketOpenStatus status = chre::fbs::BtSocketOpenStatus::SUCCESS,
3590 const std::vector<int8_t> *reason = nullptr) {
3591 auto reason__ = reason ? _fbb.CreateVector<int8_t>(*reason) : 0;
3592 return chre::fbs::CreateBtSocketOpenResponse(
3593 _fbb,
3594 socketId,
3595 status,
3596 reason__);
3597 }
3598
3599 struct BtSocketClose FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3600 typedef BtSocketCloseBuilder Builder;
3601 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3602 VT_SOCKETID = 4,
3603 VT_REASON = 6
3604 };
3605 int64_t socketId() const {
3606 return GetField<int64_t>(VT_SOCKETID, 0);
3607 }
3608 const flatbuffers::Vector<int8_t> *reason() const {
3609 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_REASON);
3610 }
3611 bool Verify(flatbuffers::Verifier &verifier) const {
3612 return VerifyTableStart(verifier) &&
3613 VerifyField<int64_t>(verifier, VT_SOCKETID) &&
3614 VerifyOffset(verifier, VT_REASON) &&
3615 verifier.VerifyVector(reason()) &&
3616 verifier.EndTable();
3617 }
3618 };
3619
3620 struct BtSocketCloseBuilder {
3621 typedef BtSocketClose Table;
3622 flatbuffers::FlatBufferBuilder &fbb_;
3623 flatbuffers::uoffset_t start_;
3624 void add_socketId(int64_t socketId) {
3625 fbb_.AddElement<int64_t>(BtSocketClose::VT_SOCKETID, socketId, 0);
3626 }
3627 void add_reason(flatbuffers::Offset<flatbuffers::Vector<int8_t>> reason) {
3628 fbb_.AddOffset(BtSocketClose::VT_REASON, reason);
3629 }
3630 explicit BtSocketCloseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3631 : fbb_(_fbb) {
3632 start_ = fbb_.StartTable();
3633 }
3634 BtSocketCloseBuilder &operator=(const BtSocketCloseBuilder &);
3635 flatbuffers::Offset<BtSocketClose> Finish() {
3636 const auto end = fbb_.EndTable(start_);
3637 auto o = flatbuffers::Offset<BtSocketClose>(end);
3638 return o;
3639 }
3640 };
3641
3642 inline flatbuffers::Offset<BtSocketClose> CreateBtSocketClose(
3643 flatbuffers::FlatBufferBuilder &_fbb,
3644 int64_t socketId = 0,
3645 flatbuffers::Offset<flatbuffers::Vector<int8_t>> reason = 0) {
3646 BtSocketCloseBuilder builder_(_fbb);
3647 builder_.add_socketId(socketId);
3648 builder_.add_reason(reason);
3649 return builder_.Finish();
3650 }
3651
3652 inline flatbuffers::Offset<BtSocketClose> CreateBtSocketCloseDirect(
3653 flatbuffers::FlatBufferBuilder &_fbb,
3654 int64_t socketId = 0,
3655 const std::vector<int8_t> *reason = nullptr) {
3656 auto reason__ = reason ? _fbb.CreateVector<int8_t>(*reason) : 0;
3657 return chre::fbs::CreateBtSocketClose(
3658 _fbb,
3659 socketId,
3660 reason__);
3661 }
3662
3663 struct BtSocketCloseResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3664 typedef BtSocketCloseResponseBuilder Builder;
3665 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3666 VT_SOCKETID = 4
3667 };
3668 int64_t socketId() const {
3669 return GetField<int64_t>(VT_SOCKETID, 0);
3670 }
3671 bool Verify(flatbuffers::Verifier &verifier) const {
3672 return VerifyTableStart(verifier) &&
3673 VerifyField<int64_t>(verifier, VT_SOCKETID) &&
3674 verifier.EndTable();
3675 }
3676 };
3677
3678 struct BtSocketCloseResponseBuilder {
3679 typedef BtSocketCloseResponse Table;
3680 flatbuffers::FlatBufferBuilder &fbb_;
3681 flatbuffers::uoffset_t start_;
3682 void add_socketId(int64_t socketId) {
3683 fbb_.AddElement<int64_t>(BtSocketCloseResponse::VT_SOCKETID, socketId, 0);
3684 }
3685 explicit BtSocketCloseResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3686 : fbb_(_fbb) {
3687 start_ = fbb_.StartTable();
3688 }
3689 BtSocketCloseResponseBuilder &operator=(const BtSocketCloseResponseBuilder &);
3690 flatbuffers::Offset<BtSocketCloseResponse> Finish() {
3691 const auto end = fbb_.EndTable(start_);
3692 auto o = flatbuffers::Offset<BtSocketCloseResponse>(end);
3693 return o;
3694 }
3695 };
3696
3697 inline flatbuffers::Offset<BtSocketCloseResponse> CreateBtSocketCloseResponse(
3698 flatbuffers::FlatBufferBuilder &_fbb,
3699 int64_t socketId = 0) {
3700 BtSocketCloseResponseBuilder builder_(_fbb);
3701 builder_.add_socketId(socketId);
3702 return builder_.Finish();
3703 }
3704
3705 struct BtSocketCapabilitiesRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3706 typedef BtSocketCapabilitiesRequestBuilder Builder;
3707 bool Verify(flatbuffers::Verifier &verifier) const {
3708 return VerifyTableStart(verifier) &&
3709 verifier.EndTable();
3710 }
3711 };
3712
3713 struct BtSocketCapabilitiesRequestBuilder {
3714 typedef BtSocketCapabilitiesRequest Table;
3715 flatbuffers::FlatBufferBuilder &fbb_;
3716 flatbuffers::uoffset_t start_;
3717 explicit BtSocketCapabilitiesRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3718 : fbb_(_fbb) {
3719 start_ = fbb_.StartTable();
3720 }
3721 BtSocketCapabilitiesRequestBuilder &operator=(const BtSocketCapabilitiesRequestBuilder &);
3722 flatbuffers::Offset<BtSocketCapabilitiesRequest> Finish() {
3723 const auto end = fbb_.EndTable(start_);
3724 auto o = flatbuffers::Offset<BtSocketCapabilitiesRequest>(end);
3725 return o;
3726 }
3727 };
3728
3729 inline flatbuffers::Offset<BtSocketCapabilitiesRequest> CreateBtSocketCapabilitiesRequest(
3730 flatbuffers::FlatBufferBuilder &_fbb) {
3731 BtSocketCapabilitiesRequestBuilder builder_(_fbb);
3732 return builder_.Finish();
3733 }
3734
3735 struct BtSocketLeCocCapabilities FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3736 typedef BtSocketLeCocCapabilitiesBuilder Builder;
3737 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3738 VT_NUMBEROFSUPPORTEDSOCKETS = 4,
3739 VT_MTU = 6
3740 };
3741 int32_t numberOfSupportedSockets() const {
3742 return GetField<int32_t>(VT_NUMBEROFSUPPORTEDSOCKETS, 0);
3743 }
3744 int32_t mtu() const {
3745 return GetField<int32_t>(VT_MTU, 0);
3746 }
3747 bool Verify(flatbuffers::Verifier &verifier) const {
3748 return VerifyTableStart(verifier) &&
3749 VerifyField<int32_t>(verifier, VT_NUMBEROFSUPPORTEDSOCKETS) &&
3750 VerifyField<int32_t>(verifier, VT_MTU) &&
3751 verifier.EndTable();
3752 }
3753 };
3754
3755 struct BtSocketLeCocCapabilitiesBuilder {
3756 typedef BtSocketLeCocCapabilities Table;
3757 flatbuffers::FlatBufferBuilder &fbb_;
3758 flatbuffers::uoffset_t start_;
3759 void add_numberOfSupportedSockets(int32_t numberOfSupportedSockets) {
3760 fbb_.AddElement<int32_t>(BtSocketLeCocCapabilities::VT_NUMBEROFSUPPORTEDSOCKETS, numberOfSupportedSockets, 0);
3761 }
3762 void add_mtu(int32_t mtu) {
3763 fbb_.AddElement<int32_t>(BtSocketLeCocCapabilities::VT_MTU, mtu, 0);
3764 }
3765 explicit BtSocketLeCocCapabilitiesBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3766 : fbb_(_fbb) {
3767 start_ = fbb_.StartTable();
3768 }
3769 BtSocketLeCocCapabilitiesBuilder &operator=(const BtSocketLeCocCapabilitiesBuilder &);
3770 flatbuffers::Offset<BtSocketLeCocCapabilities> Finish() {
3771 const auto end = fbb_.EndTable(start_);
3772 auto o = flatbuffers::Offset<BtSocketLeCocCapabilities>(end);
3773 return o;
3774 }
3775 };
3776
3777 inline flatbuffers::Offset<BtSocketLeCocCapabilities> CreateBtSocketLeCocCapabilities(
3778 flatbuffers::FlatBufferBuilder &_fbb,
3779 int32_t numberOfSupportedSockets = 0,
3780 int32_t mtu = 0) {
3781 BtSocketLeCocCapabilitiesBuilder builder_(_fbb);
3782 builder_.add_mtu(mtu);
3783 builder_.add_numberOfSupportedSockets(numberOfSupportedSockets);
3784 return builder_.Finish();
3785 }
3786
3787 struct BtSocketRfcommCapabilities FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3788 typedef BtSocketRfcommCapabilitiesBuilder Builder;
3789 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3790 VT_NUMBEROFSUPPORTEDSOCKETS = 4,
3791 VT_MAXFRAMESIZE = 6
3792 };
3793 int32_t numberOfSupportedSockets() const {
3794 return GetField<int32_t>(VT_NUMBEROFSUPPORTEDSOCKETS, 0);
3795 }
3796 int32_t maxFrameSize() const {
3797 return GetField<int32_t>(VT_MAXFRAMESIZE, 0);
3798 }
3799 bool Verify(flatbuffers::Verifier &verifier) const {
3800 return VerifyTableStart(verifier) &&
3801 VerifyField<int32_t>(verifier, VT_NUMBEROFSUPPORTEDSOCKETS) &&
3802 VerifyField<int32_t>(verifier, VT_MAXFRAMESIZE) &&
3803 verifier.EndTable();
3804 }
3805 };
3806
3807 struct BtSocketRfcommCapabilitiesBuilder {
3808 typedef BtSocketRfcommCapabilities Table;
3809 flatbuffers::FlatBufferBuilder &fbb_;
3810 flatbuffers::uoffset_t start_;
3811 void add_numberOfSupportedSockets(int32_t numberOfSupportedSockets) {
3812 fbb_.AddElement<int32_t>(BtSocketRfcommCapabilities::VT_NUMBEROFSUPPORTEDSOCKETS, numberOfSupportedSockets, 0);
3813 }
3814 void add_maxFrameSize(int32_t maxFrameSize) {
3815 fbb_.AddElement<int32_t>(BtSocketRfcommCapabilities::VT_MAXFRAMESIZE, maxFrameSize, 0);
3816 }
3817 explicit BtSocketRfcommCapabilitiesBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3818 : fbb_(_fbb) {
3819 start_ = fbb_.StartTable();
3820 }
3821 BtSocketRfcommCapabilitiesBuilder &operator=(const BtSocketRfcommCapabilitiesBuilder &);
3822 flatbuffers::Offset<BtSocketRfcommCapabilities> Finish() {
3823 const auto end = fbb_.EndTable(start_);
3824 auto o = flatbuffers::Offset<BtSocketRfcommCapabilities>(end);
3825 return o;
3826 }
3827 };
3828
3829 inline flatbuffers::Offset<BtSocketRfcommCapabilities> CreateBtSocketRfcommCapabilities(
3830 flatbuffers::FlatBufferBuilder &_fbb,
3831 int32_t numberOfSupportedSockets = 0,
3832 int32_t maxFrameSize = 0) {
3833 BtSocketRfcommCapabilitiesBuilder builder_(_fbb);
3834 builder_.add_maxFrameSize(maxFrameSize);
3835 builder_.add_numberOfSupportedSockets(numberOfSupportedSockets);
3836 return builder_.Finish();
3837 }
3838
3839 struct BtSocketCapabilitiesResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3840 typedef BtSocketCapabilitiesResponseBuilder Builder;
3841 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3842 VT_LECOCCAPABILITIES = 4,
3843 VT_RFCOMMCAPABILITIES = 6
3844 };
3845 const chre::fbs::BtSocketLeCocCapabilities *leCocCapabilities() const {
3846 return GetPointer<const chre::fbs::BtSocketLeCocCapabilities *>(VT_LECOCCAPABILITIES);
3847 }
3848 const chre::fbs::BtSocketRfcommCapabilities *rfcommCapabilities() const {
3849 return GetPointer<const chre::fbs::BtSocketRfcommCapabilities *>(VT_RFCOMMCAPABILITIES);
3850 }
3851 bool Verify(flatbuffers::Verifier &verifier) const {
3852 return VerifyTableStart(verifier) &&
3853 VerifyOffset(verifier, VT_LECOCCAPABILITIES) &&
3854 verifier.VerifyTable(leCocCapabilities()) &&
3855 VerifyOffset(verifier, VT_RFCOMMCAPABILITIES) &&
3856 verifier.VerifyTable(rfcommCapabilities()) &&
3857 verifier.EndTable();
3858 }
3859 };
3860
3861 struct BtSocketCapabilitiesResponseBuilder {
3862 typedef BtSocketCapabilitiesResponse Table;
3863 flatbuffers::FlatBufferBuilder &fbb_;
3864 flatbuffers::uoffset_t start_;
3865 void add_leCocCapabilities(flatbuffers::Offset<chre::fbs::BtSocketLeCocCapabilities> leCocCapabilities) {
3866 fbb_.AddOffset(BtSocketCapabilitiesResponse::VT_LECOCCAPABILITIES, leCocCapabilities);
3867 }
3868 void add_rfcommCapabilities(flatbuffers::Offset<chre::fbs::BtSocketRfcommCapabilities> rfcommCapabilities) {
3869 fbb_.AddOffset(BtSocketCapabilitiesResponse::VT_RFCOMMCAPABILITIES, rfcommCapabilities);
3870 }
3871 explicit BtSocketCapabilitiesResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3872 : fbb_(_fbb) {
3873 start_ = fbb_.StartTable();
3874 }
3875 BtSocketCapabilitiesResponseBuilder &operator=(const BtSocketCapabilitiesResponseBuilder &);
3876 flatbuffers::Offset<BtSocketCapabilitiesResponse> Finish() {
3877 const auto end = fbb_.EndTable(start_);
3878 auto o = flatbuffers::Offset<BtSocketCapabilitiesResponse>(end);
3879 return o;
3880 }
3881 };
3882
3883 inline flatbuffers::Offset<BtSocketCapabilitiesResponse> CreateBtSocketCapabilitiesResponse(
3884 flatbuffers::FlatBufferBuilder &_fbb,
3885 flatbuffers::Offset<chre::fbs::BtSocketLeCocCapabilities> leCocCapabilities = 0,
3886 flatbuffers::Offset<chre::fbs::BtSocketRfcommCapabilities> rfcommCapabilities = 0) {
3887 BtSocketCapabilitiesResponseBuilder builder_(_fbb);
3888 builder_.add_rfcommCapabilities(rfcommCapabilities);
3889 builder_.add_leCocCapabilities(leCocCapabilities);
3890 return builder_.Finish();
3891 }
3892
3893 struct VendorHubInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3894 typedef VendorHubInfoBuilder Builder;
3895 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3896 VT_NAME = 4,
3897 VT_VERSION = 6,
3898 VT_EXTENDED_INFO = 8
3899 };
3900 /// The name of the hub. Nominally a UTF-8 string, but note that we're not
3901 /// using the built-in "string" data type from FlatBuffers here, because the
3902 /// generated C++ uses std::string which is not well-supported in CHRE.
3903 const flatbuffers::Vector<int8_t> *name() const {
3904 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_NAME);
3905 }
3906 /// Hub version
3907 uint32_t version() const {
3908 return GetField<uint32_t>(VT_VERSION, 0);
3909 }
3910 /// Additional vendor-defined data
3911 const flatbuffers::Vector<uint8_t> *extended_info() const {
3912 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_EXTENDED_INFO);
3913 }
3914 bool Verify(flatbuffers::Verifier &verifier) const {
3915 return VerifyTableStart(verifier) &&
3916 VerifyOffset(verifier, VT_NAME) &&
3917 verifier.VerifyVector(name()) &&
3918 VerifyField<uint32_t>(verifier, VT_VERSION) &&
3919 VerifyOffset(verifier, VT_EXTENDED_INFO) &&
3920 verifier.VerifyVector(extended_info()) &&
3921 verifier.EndTable();
3922 }
3923 };
3924
3925 struct VendorHubInfoBuilder {
3926 typedef VendorHubInfo Table;
3927 flatbuffers::FlatBufferBuilder &fbb_;
3928 flatbuffers::uoffset_t start_;
3929 void add_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> name) {
3930 fbb_.AddOffset(VendorHubInfo::VT_NAME, name);
3931 }
3932 void add_version(uint32_t version) {
3933 fbb_.AddElement<uint32_t>(VendorHubInfo::VT_VERSION, version, 0);
3934 }
3935 void add_extended_info(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> extended_info) {
3936 fbb_.AddOffset(VendorHubInfo::VT_EXTENDED_INFO, extended_info);
3937 }
3938 explicit VendorHubInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3939 : fbb_(_fbb) {
3940 start_ = fbb_.StartTable();
3941 }
3942 VendorHubInfoBuilder &operator=(const VendorHubInfoBuilder &);
3943 flatbuffers::Offset<VendorHubInfo> Finish() {
3944 const auto end = fbb_.EndTable(start_);
3945 auto o = flatbuffers::Offset<VendorHubInfo>(end);
3946 return o;
3947 }
3948 };
3949
3950 inline flatbuffers::Offset<VendorHubInfo> CreateVendorHubInfo(
3951 flatbuffers::FlatBufferBuilder &_fbb,
3952 flatbuffers::Offset<flatbuffers::Vector<int8_t>> name = 0,
3953 uint32_t version = 0,
3954 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> extended_info = 0) {
3955 VendorHubInfoBuilder builder_(_fbb);
3956 builder_.add_extended_info(extended_info);
3957 builder_.add_version(version);
3958 builder_.add_name(name);
3959 return builder_.Finish();
3960 }
3961
3962 inline flatbuffers::Offset<VendorHubInfo> CreateVendorHubInfoDirect(
3963 flatbuffers::FlatBufferBuilder &_fbb,
3964 const std::vector<int8_t> *name = nullptr,
3965 uint32_t version = 0,
3966 const std::vector<uint8_t> *extended_info = nullptr) {
3967 auto name__ = name ? _fbb.CreateVector<int8_t>(*name) : 0;
3968 auto extended_info__ = extended_info ? _fbb.CreateVector<uint8_t>(*extended_info) : 0;
3969 return chre::fbs::CreateVendorHubInfo(
3970 _fbb,
3971 name__,
3972 version,
3973 extended_info__);
3974 }
3975
3976 struct MessageHub FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3977 typedef MessageHubBuilder Builder;
3978 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
3979 VT_ID = 4,
3980 VT_DETAILS_TYPE = 6,
3981 VT_DETAILS = 8
3982 };
3983 /// The hub id. -1 is reserved and 0 is invalid. 0x416e64726f696400 represents
3984 /// the ContextHub service.
3985 int64_t id() const {
3986 return GetField<int64_t>(VT_ID, 0);
3987 }
3988 chre::fbs::MessageHubDetails details_type() const {
3989 return static_cast<chre::fbs::MessageHubDetails>(GetField<uint8_t>(VT_DETAILS_TYPE, 0));
3990 }
3991 /// Details of the message hub.
3992 const void *details() const {
3993 return GetPointer<const void *>(VT_DETAILS);
3994 }
3995 template<typename T> const T *details_as() const;
3996 const chre::fbs::HubInfoResponse *details_as_HubInfoResponse() const {
3997 return details_type() == chre::fbs::MessageHubDetails::HubInfoResponse ? static_cast<const chre::fbs::HubInfoResponse *>(details()) : nullptr;
3998 }
3999 const chre::fbs::VendorHubInfo *details_as_VendorHubInfo() const {
4000 return details_type() == chre::fbs::MessageHubDetails::VendorHubInfo ? static_cast<const chre::fbs::VendorHubInfo *>(details()) : nullptr;
4001 }
4002 bool Verify(flatbuffers::Verifier &verifier) const {
4003 return VerifyTableStart(verifier) &&
4004 VerifyField<int64_t>(verifier, VT_ID) &&
4005 VerifyField<uint8_t>(verifier, VT_DETAILS_TYPE) &&
4006 VerifyOffset(verifier, VT_DETAILS) &&
4007 VerifyMessageHubDetails(verifier, details(), details_type()) &&
4008 verifier.EndTable();
4009 }
4010 };
4011
4012 template<> inline const chre::fbs::HubInfoResponse *MessageHub::details_as<chre::fbs::HubInfoResponse>() const {
4013 return details_as_HubInfoResponse();
4014 }
4015
4016 template<> inline const chre::fbs::VendorHubInfo *MessageHub::details_as<chre::fbs::VendorHubInfo>() const {
4017 return details_as_VendorHubInfo();
4018 }
4019
4020 struct MessageHubBuilder {
4021 typedef MessageHub Table;
4022 flatbuffers::FlatBufferBuilder &fbb_;
4023 flatbuffers::uoffset_t start_;
4024 void add_id(int64_t id) {
4025 fbb_.AddElement<int64_t>(MessageHub::VT_ID, id, 0);
4026 }
4027 void add_details_type(chre::fbs::MessageHubDetails details_type) {
4028 fbb_.AddElement<uint8_t>(MessageHub::VT_DETAILS_TYPE, static_cast<uint8_t>(details_type), 0);
4029 }
4030 void add_details(flatbuffers::Offset<void> details) {
4031 fbb_.AddOffset(MessageHub::VT_DETAILS, details);
4032 }
4033 explicit MessageHubBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4034 : fbb_(_fbb) {
4035 start_ = fbb_.StartTable();
4036 }
4037 MessageHubBuilder &operator=(const MessageHubBuilder &);
4038 flatbuffers::Offset<MessageHub> Finish() {
4039 const auto end = fbb_.EndTable(start_);
4040 auto o = flatbuffers::Offset<MessageHub>(end);
4041 return o;
4042 }
4043 };
4044
4045 inline flatbuffers::Offset<MessageHub> CreateMessageHub(
4046 flatbuffers::FlatBufferBuilder &_fbb,
4047 int64_t id = 0,
4048 chre::fbs::MessageHubDetails details_type = chre::fbs::MessageHubDetails::NONE,
4049 flatbuffers::Offset<void> details = 0) {
4050 MessageHubBuilder builder_(_fbb);
4051 builder_.add_id(id);
4052 builder_.add_details(details);
4053 builder_.add_details_type(details_type);
4054 return builder_.Finish();
4055 }
4056
4057 struct RegisterMessageHub FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4058 typedef RegisterMessageHubBuilder Builder;
4059 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4060 VT_HUB = 4
4061 };
4062 const chre::fbs::MessageHub *hub() const {
4063 return GetPointer<const chre::fbs::MessageHub *>(VT_HUB);
4064 }
4065 bool Verify(flatbuffers::Verifier &verifier) const {
4066 return VerifyTableStart(verifier) &&
4067 VerifyOffset(verifier, VT_HUB) &&
4068 verifier.VerifyTable(hub()) &&
4069 verifier.EndTable();
4070 }
4071 };
4072
4073 struct RegisterMessageHubBuilder {
4074 typedef RegisterMessageHub Table;
4075 flatbuffers::FlatBufferBuilder &fbb_;
4076 flatbuffers::uoffset_t start_;
4077 void add_hub(flatbuffers::Offset<chre::fbs::MessageHub> hub) {
4078 fbb_.AddOffset(RegisterMessageHub::VT_HUB, hub);
4079 }
4080 explicit RegisterMessageHubBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4081 : fbb_(_fbb) {
4082 start_ = fbb_.StartTable();
4083 }
4084 RegisterMessageHubBuilder &operator=(const RegisterMessageHubBuilder &);
4085 flatbuffers::Offset<RegisterMessageHub> Finish() {
4086 const auto end = fbb_.EndTable(start_);
4087 auto o = flatbuffers::Offset<RegisterMessageHub>(end);
4088 return o;
4089 }
4090 };
4091
4092 inline flatbuffers::Offset<RegisterMessageHub> CreateRegisterMessageHub(
4093 flatbuffers::FlatBufferBuilder &_fbb,
4094 flatbuffers::Offset<chre::fbs::MessageHub> hub = 0) {
4095 RegisterMessageHubBuilder builder_(_fbb);
4096 builder_.add_hub(hub);
4097 return builder_.Finish();
4098 }
4099
4100 struct UnregisterMessageHub FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4101 typedef UnregisterMessageHubBuilder Builder;
4102 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4103 VT_ID = 4
4104 };
4105 int64_t id() const {
4106 return GetField<int64_t>(VT_ID, 0);
4107 }
4108 bool Verify(flatbuffers::Verifier &verifier) const {
4109 return VerifyTableStart(verifier) &&
4110 VerifyField<int64_t>(verifier, VT_ID) &&
4111 verifier.EndTable();
4112 }
4113 };
4114
4115 struct UnregisterMessageHubBuilder {
4116 typedef UnregisterMessageHub Table;
4117 flatbuffers::FlatBufferBuilder &fbb_;
4118 flatbuffers::uoffset_t start_;
4119 void add_id(int64_t id) {
4120 fbb_.AddElement<int64_t>(UnregisterMessageHub::VT_ID, id, 0);
4121 }
4122 explicit UnregisterMessageHubBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4123 : fbb_(_fbb) {
4124 start_ = fbb_.StartTable();
4125 }
4126 UnregisterMessageHubBuilder &operator=(const UnregisterMessageHubBuilder &);
4127 flatbuffers::Offset<UnregisterMessageHub> Finish() {
4128 const auto end = fbb_.EndTable(start_);
4129 auto o = flatbuffers::Offset<UnregisterMessageHub>(end);
4130 return o;
4131 }
4132 };
4133
4134 inline flatbuffers::Offset<UnregisterMessageHub> CreateUnregisterMessageHub(
4135 flatbuffers::FlatBufferBuilder &_fbb,
4136 int64_t id = 0) {
4137 UnregisterMessageHubBuilder builder_(_fbb);
4138 builder_.add_id(id);
4139 return builder_.Finish();
4140 }
4141
4142 struct EndpointId FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4143 typedef EndpointIdBuilder Builder;
4144 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4145 VT_HUBID = 4,
4146 VT_ID = 6
4147 };
4148 /// Id of the hub hosting the endpoint
4149 int64_t hubId() const {
4150 return GetField<int64_t>(VT_HUBID, 0);
4151 }
4152 /// The id of the endpoint scoped to the hub
4153 int64_t id() const {
4154 return GetField<int64_t>(VT_ID, 0);
4155 }
4156 bool Verify(flatbuffers::Verifier &verifier) const {
4157 return VerifyTableStart(verifier) &&
4158 VerifyField<int64_t>(verifier, VT_HUBID) &&
4159 VerifyField<int64_t>(verifier, VT_ID) &&
4160 verifier.EndTable();
4161 }
4162 };
4163
4164 struct EndpointIdBuilder {
4165 typedef EndpointId Table;
4166 flatbuffers::FlatBufferBuilder &fbb_;
4167 flatbuffers::uoffset_t start_;
4168 void add_hubId(int64_t hubId) {
4169 fbb_.AddElement<int64_t>(EndpointId::VT_HUBID, hubId, 0);
4170 }
4171 void add_id(int64_t id) {
4172 fbb_.AddElement<int64_t>(EndpointId::VT_ID, id, 0);
4173 }
4174 explicit EndpointIdBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4175 : fbb_(_fbb) {
4176 start_ = fbb_.StartTable();
4177 }
4178 EndpointIdBuilder &operator=(const EndpointIdBuilder &);
4179 flatbuffers::Offset<EndpointId> Finish() {
4180 const auto end = fbb_.EndTable(start_);
4181 auto o = flatbuffers::Offset<EndpointId>(end);
4182 return o;
4183 }
4184 };
4185
4186 inline flatbuffers::Offset<EndpointId> CreateEndpointId(
4187 flatbuffers::FlatBufferBuilder &_fbb,
4188 int64_t hubId = 0,
4189 int64_t id = 0) {
4190 EndpointIdBuilder builder_(_fbb);
4191 builder_.add_id(id);
4192 builder_.add_hubId(hubId);
4193 return builder_.Finish();
4194 }
4195
4196 struct Service FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4197 typedef ServiceBuilder Builder;
4198 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4199 VT_FORMAT = 4,
4200 VT_DESCRIPTOR = 6,
4201 VT_MAJOR_VERSION = 8,
4202 VT_MINOR_VERSION = 10
4203 };
4204 chre::fbs::RpcFormat format() const {
4205 return static_cast<chre::fbs::RpcFormat>(GetField<uint8_t>(VT_FORMAT, 0));
4206 }
4207 /// Service descriptor. Nominally a UTF-8 string, but note that we're not
4208 /// using the built-in "string" data type from FlatBuffers here, because the
4209 /// generated C++ uses std::string which is not well-supported in CHRE.
4210 const flatbuffers::Vector<int8_t> *descriptor() const {
4211 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_DESCRIPTOR);
4212 }
4213 /// Breaking changes should bump the major version.
4214 uint32_t major_version() const {
4215 return GetField<uint32_t>(VT_MAJOR_VERSION, 0);
4216 }
4217 /// Monotonically increasing minor version.
4218 uint32_t minor_version() const {
4219 return GetField<uint32_t>(VT_MINOR_VERSION, 0);
4220 }
4221 bool Verify(flatbuffers::Verifier &verifier) const {
4222 return VerifyTableStart(verifier) &&
4223 VerifyField<uint8_t>(verifier, VT_FORMAT) &&
4224 VerifyOffset(verifier, VT_DESCRIPTOR) &&
4225 verifier.VerifyVector(descriptor()) &&
4226 VerifyField<uint32_t>(verifier, VT_MAJOR_VERSION) &&
4227 VerifyField<uint32_t>(verifier, VT_MINOR_VERSION) &&
4228 verifier.EndTable();
4229 }
4230 };
4231
4232 struct ServiceBuilder {
4233 typedef Service Table;
4234 flatbuffers::FlatBufferBuilder &fbb_;
4235 flatbuffers::uoffset_t start_;
4236 void add_format(chre::fbs::RpcFormat format) {
4237 fbb_.AddElement<uint8_t>(Service::VT_FORMAT, static_cast<uint8_t>(format), 0);
4238 }
4239 void add_descriptor(flatbuffers::Offset<flatbuffers::Vector<int8_t>> descriptor) {
4240 fbb_.AddOffset(Service::VT_DESCRIPTOR, descriptor);
4241 }
4242 void add_major_version(uint32_t major_version) {
4243 fbb_.AddElement<uint32_t>(Service::VT_MAJOR_VERSION, major_version, 0);
4244 }
4245 void add_minor_version(uint32_t minor_version) {
4246 fbb_.AddElement<uint32_t>(Service::VT_MINOR_VERSION, minor_version, 0);
4247 }
4248 explicit ServiceBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4249 : fbb_(_fbb) {
4250 start_ = fbb_.StartTable();
4251 }
4252 ServiceBuilder &operator=(const ServiceBuilder &);
4253 flatbuffers::Offset<Service> Finish() {
4254 const auto end = fbb_.EndTable(start_);
4255 auto o = flatbuffers::Offset<Service>(end);
4256 return o;
4257 }
4258 };
4259
4260 inline flatbuffers::Offset<Service> CreateService(
4261 flatbuffers::FlatBufferBuilder &_fbb,
4262 chre::fbs::RpcFormat format = chre::fbs::RpcFormat::CUSTOM,
4263 flatbuffers::Offset<flatbuffers::Vector<int8_t>> descriptor = 0,
4264 uint32_t major_version = 0,
4265 uint32_t minor_version = 0) {
4266 ServiceBuilder builder_(_fbb);
4267 builder_.add_minor_version(minor_version);
4268 builder_.add_major_version(major_version);
4269 builder_.add_descriptor(descriptor);
4270 builder_.add_format(format);
4271 return builder_.Finish();
4272 }
4273
4274 inline flatbuffers::Offset<Service> CreateServiceDirect(
4275 flatbuffers::FlatBufferBuilder &_fbb,
4276 chre::fbs::RpcFormat format = chre::fbs::RpcFormat::CUSTOM,
4277 const std::vector<int8_t> *descriptor = nullptr,
4278 uint32_t major_version = 0,
4279 uint32_t minor_version = 0) {
4280 auto descriptor__ = descriptor ? _fbb.CreateVector<int8_t>(*descriptor) : 0;
4281 return chre::fbs::CreateService(
4282 _fbb,
4283 format,
4284 descriptor__,
4285 major_version,
4286 minor_version);
4287 }
4288
4289 struct EndpointInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4290 typedef EndpointInfoBuilder Builder;
4291 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4292 VT_ID = 4,
4293 VT_TYPE = 6,
4294 VT_NAME = 8,
4295 VT_VERSION = 10,
4296 VT_REQUIRED_PERMISSIONS = 12,
4297 VT_SERVICES = 14
4298 };
4299 const chre::fbs::EndpointId *id() const {
4300 return GetPointer<const chre::fbs::EndpointId *>(VT_ID);
4301 }
4302 chre::fbs::EndpointType type() const {
4303 return static_cast<chre::fbs::EndpointType>(GetField<uint8_t>(VT_TYPE, 0));
4304 }
4305 /// Endpoing name. Nominally a UTF-8 string, but note that we're not using
4306 /// the built-in "string" data type from FlatBuffers here, because the
4307 /// generated C++ uses std::string which is not well-supported in CHRE.
4308 const flatbuffers::Vector<int8_t> *name() const {
4309 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_NAME);
4310 }
4311 uint32_t version() const {
4312 return GetField<uint32_t>(VT_VERSION, 0);
4313 }
4314 /// Values from CHRE_MESSAGE_PERMISSION_*
4315 uint32_t required_permissions() const {
4316 return GetField<uint32_t>(VT_REQUIRED_PERMISSIONS, 0);
4317 }
4318 const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::Service>> *services() const {
4319 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::Service>> *>(VT_SERVICES);
4320 }
4321 bool Verify(flatbuffers::Verifier &verifier) const {
4322 return VerifyTableStart(verifier) &&
4323 VerifyOffset(verifier, VT_ID) &&
4324 verifier.VerifyTable(id()) &&
4325 VerifyField<uint8_t>(verifier, VT_TYPE) &&
4326 VerifyOffset(verifier, VT_NAME) &&
4327 verifier.VerifyVector(name()) &&
4328 VerifyField<uint32_t>(verifier, VT_VERSION) &&
4329 VerifyField<uint32_t>(verifier, VT_REQUIRED_PERMISSIONS) &&
4330 VerifyOffset(verifier, VT_SERVICES) &&
4331 verifier.VerifyVector(services()) &&
4332 verifier.VerifyVectorOfTables(services()) &&
4333 verifier.EndTable();
4334 }
4335 };
4336
4337 struct EndpointInfoBuilder {
4338 typedef EndpointInfo Table;
4339 flatbuffers::FlatBufferBuilder &fbb_;
4340 flatbuffers::uoffset_t start_;
4341 void add_id(flatbuffers::Offset<chre::fbs::EndpointId> id) {
4342 fbb_.AddOffset(EndpointInfo::VT_ID, id);
4343 }
4344 void add_type(chre::fbs::EndpointType type) {
4345 fbb_.AddElement<uint8_t>(EndpointInfo::VT_TYPE, static_cast<uint8_t>(type), 0);
4346 }
4347 void add_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> name) {
4348 fbb_.AddOffset(EndpointInfo::VT_NAME, name);
4349 }
4350 void add_version(uint32_t version) {
4351 fbb_.AddElement<uint32_t>(EndpointInfo::VT_VERSION, version, 0);
4352 }
4353 void add_required_permissions(uint32_t required_permissions) {
4354 fbb_.AddElement<uint32_t>(EndpointInfo::VT_REQUIRED_PERMISSIONS, required_permissions, 0);
4355 }
4356 void add_services(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::Service>>> services) {
4357 fbb_.AddOffset(EndpointInfo::VT_SERVICES, services);
4358 }
4359 explicit EndpointInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4360 : fbb_(_fbb) {
4361 start_ = fbb_.StartTable();
4362 }
4363 EndpointInfoBuilder &operator=(const EndpointInfoBuilder &);
4364 flatbuffers::Offset<EndpointInfo> Finish() {
4365 const auto end = fbb_.EndTable(start_);
4366 auto o = flatbuffers::Offset<EndpointInfo>(end);
4367 return o;
4368 }
4369 };
4370
4371 inline flatbuffers::Offset<EndpointInfo> CreateEndpointInfo(
4372 flatbuffers::FlatBufferBuilder &_fbb,
4373 flatbuffers::Offset<chre::fbs::EndpointId> id = 0,
4374 chre::fbs::EndpointType type = chre::fbs::EndpointType::INVALID,
4375 flatbuffers::Offset<flatbuffers::Vector<int8_t>> name = 0,
4376 uint32_t version = 0,
4377 uint32_t required_permissions = 0,
4378 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::Service>>> services = 0) {
4379 EndpointInfoBuilder builder_(_fbb);
4380 builder_.add_services(services);
4381 builder_.add_required_permissions(required_permissions);
4382 builder_.add_version(version);
4383 builder_.add_name(name);
4384 builder_.add_id(id);
4385 builder_.add_type(type);
4386 return builder_.Finish();
4387 }
4388
4389 inline flatbuffers::Offset<EndpointInfo> CreateEndpointInfoDirect(
4390 flatbuffers::FlatBufferBuilder &_fbb,
4391 flatbuffers::Offset<chre::fbs::EndpointId> id = 0,
4392 chre::fbs::EndpointType type = chre::fbs::EndpointType::INVALID,
4393 const std::vector<int8_t> *name = nullptr,
4394 uint32_t version = 0,
4395 uint32_t required_permissions = 0,
4396 const std::vector<flatbuffers::Offset<chre::fbs::Service>> *services = nullptr) {
4397 auto name__ = name ? _fbb.CreateVector<int8_t>(*name) : 0;
4398 auto services__ = services ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::Service>>(*services) : 0;
4399 return chre::fbs::CreateEndpointInfo(
4400 _fbb,
4401 id,
4402 type,
4403 name__,
4404 version,
4405 required_permissions,
4406 services__);
4407 }
4408
4409 struct RegisterEndpoint FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4410 typedef RegisterEndpointBuilder Builder;
4411 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4412 VT_ENDPOINT = 4
4413 };
4414 const chre::fbs::EndpointInfo *endpoint() const {
4415 return GetPointer<const chre::fbs::EndpointInfo *>(VT_ENDPOINT);
4416 }
4417 bool Verify(flatbuffers::Verifier &verifier) const {
4418 return VerifyTableStart(verifier) &&
4419 VerifyOffset(verifier, VT_ENDPOINT) &&
4420 verifier.VerifyTable(endpoint()) &&
4421 verifier.EndTable();
4422 }
4423 };
4424
4425 struct RegisterEndpointBuilder {
4426 typedef RegisterEndpoint Table;
4427 flatbuffers::FlatBufferBuilder &fbb_;
4428 flatbuffers::uoffset_t start_;
4429 void add_endpoint(flatbuffers::Offset<chre::fbs::EndpointInfo> endpoint) {
4430 fbb_.AddOffset(RegisterEndpoint::VT_ENDPOINT, endpoint);
4431 }
4432 explicit RegisterEndpointBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4433 : fbb_(_fbb) {
4434 start_ = fbb_.StartTable();
4435 }
4436 RegisterEndpointBuilder &operator=(const RegisterEndpointBuilder &);
4437 flatbuffers::Offset<RegisterEndpoint> Finish() {
4438 const auto end = fbb_.EndTable(start_);
4439 auto o = flatbuffers::Offset<RegisterEndpoint>(end);
4440 return o;
4441 }
4442 };
4443
4444 inline flatbuffers::Offset<RegisterEndpoint> CreateRegisterEndpoint(
4445 flatbuffers::FlatBufferBuilder &_fbb,
4446 flatbuffers::Offset<chre::fbs::EndpointInfo> endpoint = 0) {
4447 RegisterEndpointBuilder builder_(_fbb);
4448 builder_.add_endpoint(endpoint);
4449 return builder_.Finish();
4450 }
4451
4452 /// MessageRouter handles service inspection separately from endpoint inspection
4453 /// so these messages are required to send embedded endpoint information in
4454 /// pieces to the host. After RegisterEndpoint, the endpoint is only ready once
4455 /// an EndpointReady message is sent. After EndpointReady, AddServiceToEndpoint
4456 /// will be rejected.
4457 struct AddServiceToEndpoint FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4458 typedef AddServiceToEndpointBuilder Builder;
4459 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4460 VT_ENDPOINT = 4,
4461 VT_SERVICE = 6
4462 };
4463 const chre::fbs::EndpointId *endpoint() const {
4464 return GetPointer<const chre::fbs::EndpointId *>(VT_ENDPOINT);
4465 }
4466 const chre::fbs::Service *service() const {
4467 return GetPointer<const chre::fbs::Service *>(VT_SERVICE);
4468 }
4469 bool Verify(flatbuffers::Verifier &verifier) const {
4470 return VerifyTableStart(verifier) &&
4471 VerifyOffset(verifier, VT_ENDPOINT) &&
4472 verifier.VerifyTable(endpoint()) &&
4473 VerifyOffset(verifier, VT_SERVICE) &&
4474 verifier.VerifyTable(service()) &&
4475 verifier.EndTable();
4476 }
4477 };
4478
4479 struct AddServiceToEndpointBuilder {
4480 typedef AddServiceToEndpoint Table;
4481 flatbuffers::FlatBufferBuilder &fbb_;
4482 flatbuffers::uoffset_t start_;
4483 void add_endpoint(flatbuffers::Offset<chre::fbs::EndpointId> endpoint) {
4484 fbb_.AddOffset(AddServiceToEndpoint::VT_ENDPOINT, endpoint);
4485 }
4486 void add_service(flatbuffers::Offset<chre::fbs::Service> service) {
4487 fbb_.AddOffset(AddServiceToEndpoint::VT_SERVICE, service);
4488 }
4489 explicit AddServiceToEndpointBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4490 : fbb_(_fbb) {
4491 start_ = fbb_.StartTable();
4492 }
4493 AddServiceToEndpointBuilder &operator=(const AddServiceToEndpointBuilder &);
4494 flatbuffers::Offset<AddServiceToEndpoint> Finish() {
4495 const auto end = fbb_.EndTable(start_);
4496 auto o = flatbuffers::Offset<AddServiceToEndpoint>(end);
4497 return o;
4498 }
4499 };
4500
4501 inline flatbuffers::Offset<AddServiceToEndpoint> CreateAddServiceToEndpoint(
4502 flatbuffers::FlatBufferBuilder &_fbb,
4503 flatbuffers::Offset<chre::fbs::EndpointId> endpoint = 0,
4504 flatbuffers::Offset<chre::fbs::Service> service = 0) {
4505 AddServiceToEndpointBuilder builder_(_fbb);
4506 builder_.add_service(service);
4507 builder_.add_endpoint(endpoint);
4508 return builder_.Finish();
4509 }
4510
4511 struct EndpointReady FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4512 typedef EndpointReadyBuilder Builder;
4513 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4514 VT_ENDPOINT = 4
4515 };
4516 const chre::fbs::EndpointId *endpoint() const {
4517 return GetPointer<const chre::fbs::EndpointId *>(VT_ENDPOINT);
4518 }
4519 bool Verify(flatbuffers::Verifier &verifier) const {
4520 return VerifyTableStart(verifier) &&
4521 VerifyOffset(verifier, VT_ENDPOINT) &&
4522 verifier.VerifyTable(endpoint()) &&
4523 verifier.EndTable();
4524 }
4525 };
4526
4527 struct EndpointReadyBuilder {
4528 typedef EndpointReady Table;
4529 flatbuffers::FlatBufferBuilder &fbb_;
4530 flatbuffers::uoffset_t start_;
4531 void add_endpoint(flatbuffers::Offset<chre::fbs::EndpointId> endpoint) {
4532 fbb_.AddOffset(EndpointReady::VT_ENDPOINT, endpoint);
4533 }
4534 explicit EndpointReadyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4535 : fbb_(_fbb) {
4536 start_ = fbb_.StartTable();
4537 }
4538 EndpointReadyBuilder &operator=(const EndpointReadyBuilder &);
4539 flatbuffers::Offset<EndpointReady> Finish() {
4540 const auto end = fbb_.EndTable(start_);
4541 auto o = flatbuffers::Offset<EndpointReady>(end);
4542 return o;
4543 }
4544 };
4545
4546 inline flatbuffers::Offset<EndpointReady> CreateEndpointReady(
4547 flatbuffers::FlatBufferBuilder &_fbb,
4548 flatbuffers::Offset<chre::fbs::EndpointId> endpoint = 0) {
4549 EndpointReadyBuilder builder_(_fbb);
4550 builder_.add_endpoint(endpoint);
4551 return builder_.Finish();
4552 }
4553
4554 struct UnregisterEndpoint FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4555 typedef UnregisterEndpointBuilder Builder;
4556 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4557 VT_ENDPOINT = 4
4558 };
4559 const chre::fbs::EndpointId *endpoint() const {
4560 return GetPointer<const chre::fbs::EndpointId *>(VT_ENDPOINT);
4561 }
4562 bool Verify(flatbuffers::Verifier &verifier) const {
4563 return VerifyTableStart(verifier) &&
4564 VerifyOffset(verifier, VT_ENDPOINT) &&
4565 verifier.VerifyTable(endpoint()) &&
4566 verifier.EndTable();
4567 }
4568 };
4569
4570 struct UnregisterEndpointBuilder {
4571 typedef UnregisterEndpoint Table;
4572 flatbuffers::FlatBufferBuilder &fbb_;
4573 flatbuffers::uoffset_t start_;
4574 void add_endpoint(flatbuffers::Offset<chre::fbs::EndpointId> endpoint) {
4575 fbb_.AddOffset(UnregisterEndpoint::VT_ENDPOINT, endpoint);
4576 }
4577 explicit UnregisterEndpointBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4578 : fbb_(_fbb) {
4579 start_ = fbb_.StartTable();
4580 }
4581 UnregisterEndpointBuilder &operator=(const UnregisterEndpointBuilder &);
4582 flatbuffers::Offset<UnregisterEndpoint> Finish() {
4583 const auto end = fbb_.EndTable(start_);
4584 auto o = flatbuffers::Offset<UnregisterEndpoint>(end);
4585 return o;
4586 }
4587 };
4588
4589 inline flatbuffers::Offset<UnregisterEndpoint> CreateUnregisterEndpoint(
4590 flatbuffers::FlatBufferBuilder &_fbb,
4591 flatbuffers::Offset<chre::fbs::EndpointId> endpoint = 0) {
4592 UnregisterEndpointBuilder builder_(_fbb);
4593 builder_.add_endpoint(endpoint);
4594 return builder_.Finish();
4595 }
4596
4597 /// HAL->CHRE, indicates the HAL is coming up
4598 struct GetMessageHubsAndEndpointsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4599 typedef GetMessageHubsAndEndpointsRequestBuilder Builder;
4600 bool Verify(flatbuffers::Verifier &verifier) const {
4601 return VerifyTableStart(verifier) &&
4602 verifier.EndTable();
4603 }
4604 };
4605
4606 struct GetMessageHubsAndEndpointsRequestBuilder {
4607 typedef GetMessageHubsAndEndpointsRequest Table;
4608 flatbuffers::FlatBufferBuilder &fbb_;
4609 flatbuffers::uoffset_t start_;
4610 explicit GetMessageHubsAndEndpointsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4611 : fbb_(_fbb) {
4612 start_ = fbb_.StartTable();
4613 }
4614 GetMessageHubsAndEndpointsRequestBuilder &operator=(const GetMessageHubsAndEndpointsRequestBuilder &);
4615 flatbuffers::Offset<GetMessageHubsAndEndpointsRequest> Finish() {
4616 const auto end = fbb_.EndTable(start_);
4617 auto o = flatbuffers::Offset<GetMessageHubsAndEndpointsRequest>(end);
4618 return o;
4619 }
4620 };
4621
4622 inline flatbuffers::Offset<GetMessageHubsAndEndpointsRequest> CreateGetMessageHubsAndEndpointsRequest(
4623 flatbuffers::FlatBufferBuilder &_fbb) {
4624 GetMessageHubsAndEndpointsRequestBuilder builder_(_fbb);
4625 return builder_.Finish();
4626 }
4627
4628 struct GetMessageHubsAndEndpointsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4629 typedef GetMessageHubsAndEndpointsResponseBuilder Builder;
4630 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4631 VT_HUBS = 4,
4632 VT_ENDPOINTS = 6
4633 };
4634 const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MessageHub>> *hubs() const {
4635 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MessageHub>> *>(VT_HUBS);
4636 }
4637 const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::EndpointInfo>> *endpoints() const {
4638 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::EndpointInfo>> *>(VT_ENDPOINTS);
4639 }
4640 bool Verify(flatbuffers::Verifier &verifier) const {
4641 return VerifyTableStart(verifier) &&
4642 VerifyOffset(verifier, VT_HUBS) &&
4643 verifier.VerifyVector(hubs()) &&
4644 verifier.VerifyVectorOfTables(hubs()) &&
4645 VerifyOffset(verifier, VT_ENDPOINTS) &&
4646 verifier.VerifyVector(endpoints()) &&
4647 verifier.VerifyVectorOfTables(endpoints()) &&
4648 verifier.EndTable();
4649 }
4650 };
4651
4652 struct GetMessageHubsAndEndpointsResponseBuilder {
4653 typedef GetMessageHubsAndEndpointsResponse Table;
4654 flatbuffers::FlatBufferBuilder &fbb_;
4655 flatbuffers::uoffset_t start_;
4656 void add_hubs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MessageHub>>> hubs) {
4657 fbb_.AddOffset(GetMessageHubsAndEndpointsResponse::VT_HUBS, hubs);
4658 }
4659 void add_endpoints(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::EndpointInfo>>> endpoints) {
4660 fbb_.AddOffset(GetMessageHubsAndEndpointsResponse::VT_ENDPOINTS, endpoints);
4661 }
4662 explicit GetMessageHubsAndEndpointsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4663 : fbb_(_fbb) {
4664 start_ = fbb_.StartTable();
4665 }
4666 GetMessageHubsAndEndpointsResponseBuilder &operator=(const GetMessageHubsAndEndpointsResponseBuilder &);
4667 flatbuffers::Offset<GetMessageHubsAndEndpointsResponse> Finish() {
4668 const auto end = fbb_.EndTable(start_);
4669 auto o = flatbuffers::Offset<GetMessageHubsAndEndpointsResponse>(end);
4670 return o;
4671 }
4672 };
4673
4674 inline flatbuffers::Offset<GetMessageHubsAndEndpointsResponse> CreateGetMessageHubsAndEndpointsResponse(
4675 flatbuffers::FlatBufferBuilder &_fbb,
4676 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MessageHub>>> hubs = 0,
4677 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::EndpointInfo>>> endpoints = 0) {
4678 GetMessageHubsAndEndpointsResponseBuilder builder_(_fbb);
4679 builder_.add_endpoints(endpoints);
4680 builder_.add_hubs(hubs);
4681 return builder_.Finish();
4682 }
4683
4684 inline flatbuffers::Offset<GetMessageHubsAndEndpointsResponse> CreateGetMessageHubsAndEndpointsResponseDirect(
4685 flatbuffers::FlatBufferBuilder &_fbb,
4686 const std::vector<flatbuffers::Offset<chre::fbs::MessageHub>> *hubs = nullptr,
4687 const std::vector<flatbuffers::Offset<chre::fbs::EndpointInfo>> *endpoints = nullptr) {
4688 auto hubs__ = hubs ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::MessageHub>>(*hubs) : 0;
4689 auto endpoints__ = endpoints ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::EndpointInfo>>(*endpoints) : 0;
4690 return chre::fbs::CreateGetMessageHubsAndEndpointsResponse(
4691 _fbb,
4692 hubs__,
4693 endpoints__);
4694 }
4695
4696 struct OpenEndpointSessionRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4697 typedef OpenEndpointSessionRequestBuilder Builder;
4698 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4699 VT_HOST_HUB_ID = 4,
4700 VT_SESSION_ID = 6,
4701 VT_FROMENDPOINT = 8,
4702 VT_TOENDPOINT = 10,
4703 VT_SERVICEDESCRIPTOR = 12
4704 };
4705 int64_t host_hub_id() const {
4706 return GetField<int64_t>(VT_HOST_HUB_ID, 0);
4707 }
4708 uint16_t session_id() const {
4709 return GetField<uint16_t>(VT_SESSION_ID, 0);
4710 }
4711 const chre::fbs::EndpointId *fromEndpoint() const {
4712 return GetPointer<const chre::fbs::EndpointId *>(VT_FROMENDPOINT);
4713 }
4714 const chre::fbs::EndpointId *toEndpoint() const {
4715 return GetPointer<const chre::fbs::EndpointId *>(VT_TOENDPOINT);
4716 }
4717 /// If present, describes the service definition used over the session
4718 const flatbuffers::Vector<int8_t> *serviceDescriptor() const {
4719 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_SERVICEDESCRIPTOR);
4720 }
4721 bool Verify(flatbuffers::Verifier &verifier) const {
4722 return VerifyTableStart(verifier) &&
4723 VerifyField<int64_t>(verifier, VT_HOST_HUB_ID) &&
4724 VerifyField<uint16_t>(verifier, VT_SESSION_ID) &&
4725 VerifyOffset(verifier, VT_FROMENDPOINT) &&
4726 verifier.VerifyTable(fromEndpoint()) &&
4727 VerifyOffset(verifier, VT_TOENDPOINT) &&
4728 verifier.VerifyTable(toEndpoint()) &&
4729 VerifyOffset(verifier, VT_SERVICEDESCRIPTOR) &&
4730 verifier.VerifyVector(serviceDescriptor()) &&
4731 verifier.EndTable();
4732 }
4733 };
4734
4735 struct OpenEndpointSessionRequestBuilder {
4736 typedef OpenEndpointSessionRequest Table;
4737 flatbuffers::FlatBufferBuilder &fbb_;
4738 flatbuffers::uoffset_t start_;
4739 void add_host_hub_id(int64_t host_hub_id) {
4740 fbb_.AddElement<int64_t>(OpenEndpointSessionRequest::VT_HOST_HUB_ID, host_hub_id, 0);
4741 }
4742 void add_session_id(uint16_t session_id) {
4743 fbb_.AddElement<uint16_t>(OpenEndpointSessionRequest::VT_SESSION_ID, session_id, 0);
4744 }
4745 void add_fromEndpoint(flatbuffers::Offset<chre::fbs::EndpointId> fromEndpoint) {
4746 fbb_.AddOffset(OpenEndpointSessionRequest::VT_FROMENDPOINT, fromEndpoint);
4747 }
4748 void add_toEndpoint(flatbuffers::Offset<chre::fbs::EndpointId> toEndpoint) {
4749 fbb_.AddOffset(OpenEndpointSessionRequest::VT_TOENDPOINT, toEndpoint);
4750 }
4751 void add_serviceDescriptor(flatbuffers::Offset<flatbuffers::Vector<int8_t>> serviceDescriptor) {
4752 fbb_.AddOffset(OpenEndpointSessionRequest::VT_SERVICEDESCRIPTOR, serviceDescriptor);
4753 }
4754 explicit OpenEndpointSessionRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4755 : fbb_(_fbb) {
4756 start_ = fbb_.StartTable();
4757 }
4758 OpenEndpointSessionRequestBuilder &operator=(const OpenEndpointSessionRequestBuilder &);
4759 flatbuffers::Offset<OpenEndpointSessionRequest> Finish() {
4760 const auto end = fbb_.EndTable(start_);
4761 auto o = flatbuffers::Offset<OpenEndpointSessionRequest>(end);
4762 return o;
4763 }
4764 };
4765
4766 inline flatbuffers::Offset<OpenEndpointSessionRequest> CreateOpenEndpointSessionRequest(
4767 flatbuffers::FlatBufferBuilder &_fbb,
4768 int64_t host_hub_id = 0,
4769 uint16_t session_id = 0,
4770 flatbuffers::Offset<chre::fbs::EndpointId> fromEndpoint = 0,
4771 flatbuffers::Offset<chre::fbs::EndpointId> toEndpoint = 0,
4772 flatbuffers::Offset<flatbuffers::Vector<int8_t>> serviceDescriptor = 0) {
4773 OpenEndpointSessionRequestBuilder builder_(_fbb);
4774 builder_.add_host_hub_id(host_hub_id);
4775 builder_.add_serviceDescriptor(serviceDescriptor);
4776 builder_.add_toEndpoint(toEndpoint);
4777 builder_.add_fromEndpoint(fromEndpoint);
4778 builder_.add_session_id(session_id);
4779 return builder_.Finish();
4780 }
4781
4782 inline flatbuffers::Offset<OpenEndpointSessionRequest> CreateOpenEndpointSessionRequestDirect(
4783 flatbuffers::FlatBufferBuilder &_fbb,
4784 int64_t host_hub_id = 0,
4785 uint16_t session_id = 0,
4786 flatbuffers::Offset<chre::fbs::EndpointId> fromEndpoint = 0,
4787 flatbuffers::Offset<chre::fbs::EndpointId> toEndpoint = 0,
4788 const std::vector<int8_t> *serviceDescriptor = nullptr) {
4789 auto serviceDescriptor__ = serviceDescriptor ? _fbb.CreateVector<int8_t>(*serviceDescriptor) : 0;
4790 return chre::fbs::CreateOpenEndpointSessionRequest(
4791 _fbb,
4792 host_hub_id,
4793 session_id,
4794 fromEndpoint,
4795 toEndpoint,
4796 serviceDescriptor__);
4797 }
4798
4799 struct EndpointSessionOpened FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4800 typedef EndpointSessionOpenedBuilder Builder;
4801 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4802 VT_HOST_HUB_ID = 4,
4803 VT_SESSION_ID = 6
4804 };
4805 int64_t host_hub_id() const {
4806 return GetField<int64_t>(VT_HOST_HUB_ID, 0);
4807 }
4808 uint16_t session_id() const {
4809 return GetField<uint16_t>(VT_SESSION_ID, 0);
4810 }
4811 bool Verify(flatbuffers::Verifier &verifier) const {
4812 return VerifyTableStart(verifier) &&
4813 VerifyField<int64_t>(verifier, VT_HOST_HUB_ID) &&
4814 VerifyField<uint16_t>(verifier, VT_SESSION_ID) &&
4815 verifier.EndTable();
4816 }
4817 };
4818
4819 struct EndpointSessionOpenedBuilder {
4820 typedef EndpointSessionOpened Table;
4821 flatbuffers::FlatBufferBuilder &fbb_;
4822 flatbuffers::uoffset_t start_;
4823 void add_host_hub_id(int64_t host_hub_id) {
4824 fbb_.AddElement<int64_t>(EndpointSessionOpened::VT_HOST_HUB_ID, host_hub_id, 0);
4825 }
4826 void add_session_id(uint16_t session_id) {
4827 fbb_.AddElement<uint16_t>(EndpointSessionOpened::VT_SESSION_ID, session_id, 0);
4828 }
4829 explicit EndpointSessionOpenedBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4830 : fbb_(_fbb) {
4831 start_ = fbb_.StartTable();
4832 }
4833 EndpointSessionOpenedBuilder &operator=(const EndpointSessionOpenedBuilder &);
4834 flatbuffers::Offset<EndpointSessionOpened> Finish() {
4835 const auto end = fbb_.EndTable(start_);
4836 auto o = flatbuffers::Offset<EndpointSessionOpened>(end);
4837 return o;
4838 }
4839 };
4840
4841 inline flatbuffers::Offset<EndpointSessionOpened> CreateEndpointSessionOpened(
4842 flatbuffers::FlatBufferBuilder &_fbb,
4843 int64_t host_hub_id = 0,
4844 uint16_t session_id = 0) {
4845 EndpointSessionOpenedBuilder builder_(_fbb);
4846 builder_.add_host_hub_id(host_hub_id);
4847 builder_.add_session_id(session_id);
4848 return builder_.Finish();
4849 }
4850
4851 struct EndpointSessionClosed FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4852 typedef EndpointSessionClosedBuilder Builder;
4853 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4854 VT_HOST_HUB_ID = 4,
4855 VT_SESSION_ID = 6,
4856 VT_REASON = 8
4857 };
4858 int64_t host_hub_id() const {
4859 return GetField<int64_t>(VT_HOST_HUB_ID, 0);
4860 }
4861 uint16_t session_id() const {
4862 return GetField<uint16_t>(VT_SESSION_ID, 0);
4863 }
4864 chre::fbs::Reason reason() const {
4865 return static_cast<chre::fbs::Reason>(GetField<uint8_t>(VT_REASON, 0));
4866 }
4867 bool Verify(flatbuffers::Verifier &verifier) const {
4868 return VerifyTableStart(verifier) &&
4869 VerifyField<int64_t>(verifier, VT_HOST_HUB_ID) &&
4870 VerifyField<uint16_t>(verifier, VT_SESSION_ID) &&
4871 VerifyField<uint8_t>(verifier, VT_REASON) &&
4872 verifier.EndTable();
4873 }
4874 };
4875
4876 struct EndpointSessionClosedBuilder {
4877 typedef EndpointSessionClosed Table;
4878 flatbuffers::FlatBufferBuilder &fbb_;
4879 flatbuffers::uoffset_t start_;
4880 void add_host_hub_id(int64_t host_hub_id) {
4881 fbb_.AddElement<int64_t>(EndpointSessionClosed::VT_HOST_HUB_ID, host_hub_id, 0);
4882 }
4883 void add_session_id(uint16_t session_id) {
4884 fbb_.AddElement<uint16_t>(EndpointSessionClosed::VT_SESSION_ID, session_id, 0);
4885 }
4886 void add_reason(chre::fbs::Reason reason) {
4887 fbb_.AddElement<uint8_t>(EndpointSessionClosed::VT_REASON, static_cast<uint8_t>(reason), 0);
4888 }
4889 explicit EndpointSessionClosedBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4890 : fbb_(_fbb) {
4891 start_ = fbb_.StartTable();
4892 }
4893 EndpointSessionClosedBuilder &operator=(const EndpointSessionClosedBuilder &);
4894 flatbuffers::Offset<EndpointSessionClosed> Finish() {
4895 const auto end = fbb_.EndTable(start_);
4896 auto o = flatbuffers::Offset<EndpointSessionClosed>(end);
4897 return o;
4898 }
4899 };
4900
4901 inline flatbuffers::Offset<EndpointSessionClosed> CreateEndpointSessionClosed(
4902 flatbuffers::FlatBufferBuilder &_fbb,
4903 int64_t host_hub_id = 0,
4904 uint16_t session_id = 0,
4905 chre::fbs::Reason reason = chre::fbs::Reason::UNSPECIFIED) {
4906 EndpointSessionClosedBuilder builder_(_fbb);
4907 builder_.add_host_hub_id(host_hub_id);
4908 builder_.add_session_id(session_id);
4909 builder_.add_reason(reason);
4910 return builder_.Finish();
4911 }
4912
4913 struct EndpointSessionMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4914 typedef EndpointSessionMessageBuilder Builder;
4915 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4916 VT_HOST_HUB_ID = 4,
4917 VT_SESSION_ID = 6,
4918 VT_TYPE = 8,
4919 VT_PERMISSIONS = 10,
4920 VT_DATA = 12,
4921 VT_FLAGS = 14,
4922 VT_SEQUENCE_NUMBER = 16
4923 };
4924 int64_t host_hub_id() const {
4925 return GetField<int64_t>(VT_HOST_HUB_ID, 0);
4926 }
4927 /// Id of session this message is being sent within
4928 uint16_t session_id() const {
4929 return GetField<uint16_t>(VT_SESSION_ID, 0);
4930 }
4931 /// Type of the message, specific to the Session protocol
4932 uint32_t type() const {
4933 return GetField<uint32_t>(VT_TYPE, 0);
4934 }
4935 /// Values from CHRE_MESSAGE_PERMISSION_*. Permissions required to read the
4936 /// message.
4937 uint32_t permissions() const {
4938 return GetField<uint32_t>(VT_PERMISSIONS, 0);
4939 }
4940 const flatbuffers::Vector<uint8_t> *data() const {
4941 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
4942 }
4943 /// Bitmask of additional flags applied to the message:
4944 /// - 0x1: Message delivery status required within 1s
4945 uint32_t flags() const {
4946 return GetField<uint32_t>(VT_FLAGS, 0);
4947 }
4948 uint32_t sequence_number() const {
4949 return GetField<uint32_t>(VT_SEQUENCE_NUMBER, 0);
4950 }
4951 bool Verify(flatbuffers::Verifier &verifier) const {
4952 return VerifyTableStart(verifier) &&
4953 VerifyField<int64_t>(verifier, VT_HOST_HUB_ID) &&
4954 VerifyField<uint16_t>(verifier, VT_SESSION_ID) &&
4955 VerifyField<uint32_t>(verifier, VT_TYPE) &&
4956 VerifyField<uint32_t>(verifier, VT_PERMISSIONS) &&
4957 VerifyOffset(verifier, VT_DATA) &&
4958 verifier.VerifyVector(data()) &&
4959 VerifyField<uint32_t>(verifier, VT_FLAGS) &&
4960 VerifyField<uint32_t>(verifier, VT_SEQUENCE_NUMBER) &&
4961 verifier.EndTable();
4962 }
4963 };
4964
4965 struct EndpointSessionMessageBuilder {
4966 typedef EndpointSessionMessage Table;
4967 flatbuffers::FlatBufferBuilder &fbb_;
4968 flatbuffers::uoffset_t start_;
4969 void add_host_hub_id(int64_t host_hub_id) {
4970 fbb_.AddElement<int64_t>(EndpointSessionMessage::VT_HOST_HUB_ID, host_hub_id, 0);
4971 }
4972 void add_session_id(uint16_t session_id) {
4973 fbb_.AddElement<uint16_t>(EndpointSessionMessage::VT_SESSION_ID, session_id, 0);
4974 }
4975 void add_type(uint32_t type) {
4976 fbb_.AddElement<uint32_t>(EndpointSessionMessage::VT_TYPE, type, 0);
4977 }
4978 void add_permissions(uint32_t permissions) {
4979 fbb_.AddElement<uint32_t>(EndpointSessionMessage::VT_PERMISSIONS, permissions, 0);
4980 }
4981 void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
4982 fbb_.AddOffset(EndpointSessionMessage::VT_DATA, data);
4983 }
4984 void add_flags(uint32_t flags) {
4985 fbb_.AddElement<uint32_t>(EndpointSessionMessage::VT_FLAGS, flags, 0);
4986 }
4987 void add_sequence_number(uint32_t sequence_number) {
4988 fbb_.AddElement<uint32_t>(EndpointSessionMessage::VT_SEQUENCE_NUMBER, sequence_number, 0);
4989 }
4990 explicit EndpointSessionMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
4991 : fbb_(_fbb) {
4992 start_ = fbb_.StartTable();
4993 }
4994 EndpointSessionMessageBuilder &operator=(const EndpointSessionMessageBuilder &);
4995 flatbuffers::Offset<EndpointSessionMessage> Finish() {
4996 const auto end = fbb_.EndTable(start_);
4997 auto o = flatbuffers::Offset<EndpointSessionMessage>(end);
4998 return o;
4999 }
5000 };
5001
5002 inline flatbuffers::Offset<EndpointSessionMessage> CreateEndpointSessionMessage(
5003 flatbuffers::FlatBufferBuilder &_fbb,
5004 int64_t host_hub_id = 0,
5005 uint16_t session_id = 0,
5006 uint32_t type = 0,
5007 uint32_t permissions = 0,
5008 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0,
5009 uint32_t flags = 0,
5010 uint32_t sequence_number = 0) {
5011 EndpointSessionMessageBuilder builder_(_fbb);
5012 builder_.add_host_hub_id(host_hub_id);
5013 builder_.add_sequence_number(sequence_number);
5014 builder_.add_flags(flags);
5015 builder_.add_data(data);
5016 builder_.add_permissions(permissions);
5017 builder_.add_type(type);
5018 builder_.add_session_id(session_id);
5019 return builder_.Finish();
5020 }
5021
5022 inline flatbuffers::Offset<EndpointSessionMessage> CreateEndpointSessionMessageDirect(
5023 flatbuffers::FlatBufferBuilder &_fbb,
5024 int64_t host_hub_id = 0,
5025 uint16_t session_id = 0,
5026 uint32_t type = 0,
5027 uint32_t permissions = 0,
5028 const std::vector<uint8_t> *data = nullptr,
5029 uint32_t flags = 0,
5030 uint32_t sequence_number = 0) {
5031 auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
5032 return chre::fbs::CreateEndpointSessionMessage(
5033 _fbb,
5034 host_hub_id,
5035 session_id,
5036 type,
5037 permissions,
5038 data__,
5039 flags,
5040 sequence_number);
5041 }
5042
5043 struct EndpointSessionMessageDeliveryStatus FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5044 typedef EndpointSessionMessageDeliveryStatusBuilder Builder;
5045 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5046 VT_HOST_HUB_ID = 4,
5047 VT_SESSION_ID = 6,
5048 VT_STATUS = 8
5049 };
5050 int64_t host_hub_id() const {
5051 return GetField<int64_t>(VT_HOST_HUB_ID, 0);
5052 }
5053 /// Id of session the message was sent within
5054 uint16_t session_id() const {
5055 return GetField<uint16_t>(VT_SESSION_ID, 0);
5056 }
5057 const chre::fbs::MessageDeliveryStatus *status() const {
5058 return GetPointer<const chre::fbs::MessageDeliveryStatus *>(VT_STATUS);
5059 }
5060 bool Verify(flatbuffers::Verifier &verifier) const {
5061 return VerifyTableStart(verifier) &&
5062 VerifyField<int64_t>(verifier, VT_HOST_HUB_ID) &&
5063 VerifyField<uint16_t>(verifier, VT_SESSION_ID) &&
5064 VerifyOffset(verifier, VT_STATUS) &&
5065 verifier.VerifyTable(status()) &&
5066 verifier.EndTable();
5067 }
5068 };
5069
5070 struct EndpointSessionMessageDeliveryStatusBuilder {
5071 typedef EndpointSessionMessageDeliveryStatus Table;
5072 flatbuffers::FlatBufferBuilder &fbb_;
5073 flatbuffers::uoffset_t start_;
5074 void add_host_hub_id(int64_t host_hub_id) {
5075 fbb_.AddElement<int64_t>(EndpointSessionMessageDeliveryStatus::VT_HOST_HUB_ID, host_hub_id, 0);
5076 }
5077 void add_session_id(uint16_t session_id) {
5078 fbb_.AddElement<uint16_t>(EndpointSessionMessageDeliveryStatus::VT_SESSION_ID, session_id, 0);
5079 }
5080 void add_status(flatbuffers::Offset<chre::fbs::MessageDeliveryStatus> status) {
5081 fbb_.AddOffset(EndpointSessionMessageDeliveryStatus::VT_STATUS, status);
5082 }
5083 explicit EndpointSessionMessageDeliveryStatusBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5084 : fbb_(_fbb) {
5085 start_ = fbb_.StartTable();
5086 }
5087 EndpointSessionMessageDeliveryStatusBuilder &operator=(const EndpointSessionMessageDeliveryStatusBuilder &);
5088 flatbuffers::Offset<EndpointSessionMessageDeliveryStatus> Finish() {
5089 const auto end = fbb_.EndTable(start_);
5090 auto o = flatbuffers::Offset<EndpointSessionMessageDeliveryStatus>(end);
5091 return o;
5092 }
5093 };
5094
5095 inline flatbuffers::Offset<EndpointSessionMessageDeliveryStatus> CreateEndpointSessionMessageDeliveryStatus(
5096 flatbuffers::FlatBufferBuilder &_fbb,
5097 int64_t host_hub_id = 0,
5098 uint16_t session_id = 0,
5099 flatbuffers::Offset<chre::fbs::MessageDeliveryStatus> status = 0) {
5100 EndpointSessionMessageDeliveryStatusBuilder builder_(_fbb);
5101 builder_.add_host_hub_id(host_hub_id);
5102 builder_.add_status(status);
5103 builder_.add_session_id(session_id);
5104 return builder_.Finish();
5105 }
5106
5107 /// The top-level container that encapsulates all possible messages. Note that
5108 /// per FlatBuffers requirements, we can't use a union as the top-level
5109 /// structure (root type), so we must wrap it in a table.
5110 struct MessageContainer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5111 typedef MessageContainerBuilder Builder;
5112 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5113 VT_MESSAGE_TYPE = 4,
5114 VT_MESSAGE = 6,
5115 VT_HOST_ADDR = 8
5116 };
5117 chre::fbs::ChreMessage message_type() const {
5118 return static_cast<chre::fbs::ChreMessage>(GetField<uint8_t>(VT_MESSAGE_TYPE, 0));
5119 }
5120 const void *message() const {
5121 return GetPointer<const void *>(VT_MESSAGE);
5122 }
5123 template<typename T> const T *message_as() const;
5124 const chre::fbs::NanoappMessage *message_as_NanoappMessage() const {
5125 return message_type() == chre::fbs::ChreMessage::NanoappMessage ? static_cast<const chre::fbs::NanoappMessage *>(message()) : nullptr;
5126 }
5127 const chre::fbs::HubInfoRequest *message_as_HubInfoRequest() const {
5128 return message_type() == chre::fbs::ChreMessage::HubInfoRequest ? static_cast<const chre::fbs::HubInfoRequest *>(message()) : nullptr;
5129 }
5130 const chre::fbs::HubInfoResponse *message_as_HubInfoResponse() const {
5131 return message_type() == chre::fbs::ChreMessage::HubInfoResponse ? static_cast<const chre::fbs::HubInfoResponse *>(message()) : nullptr;
5132 }
5133 const chre::fbs::NanoappListRequest *message_as_NanoappListRequest() const {
5134 return message_type() == chre::fbs::ChreMessage::NanoappListRequest ? static_cast<const chre::fbs::NanoappListRequest *>(message()) : nullptr;
5135 }
5136 const chre::fbs::NanoappListResponse *message_as_NanoappListResponse() const {
5137 return message_type() == chre::fbs::ChreMessage::NanoappListResponse ? static_cast<const chre::fbs::NanoappListResponse *>(message()) : nullptr;
5138 }
5139 const chre::fbs::LoadNanoappRequest *message_as_LoadNanoappRequest() const {
5140 return message_type() == chre::fbs::ChreMessage::LoadNanoappRequest ? static_cast<const chre::fbs::LoadNanoappRequest *>(message()) : nullptr;
5141 }
5142 const chre::fbs::LoadNanoappResponse *message_as_LoadNanoappResponse() const {
5143 return message_type() == chre::fbs::ChreMessage::LoadNanoappResponse ? static_cast<const chre::fbs::LoadNanoappResponse *>(message()) : nullptr;
5144 }
5145 const chre::fbs::UnloadNanoappRequest *message_as_UnloadNanoappRequest() const {
5146 return message_type() == chre::fbs::ChreMessage::UnloadNanoappRequest ? static_cast<const chre::fbs::UnloadNanoappRequest *>(message()) : nullptr;
5147 }
5148 const chre::fbs::UnloadNanoappResponse *message_as_UnloadNanoappResponse() const {
5149 return message_type() == chre::fbs::ChreMessage::UnloadNanoappResponse ? static_cast<const chre::fbs::UnloadNanoappResponse *>(message()) : nullptr;
5150 }
5151 const chre::fbs::LogMessage *message_as_LogMessage() const {
5152 return message_type() == chre::fbs::ChreMessage::LogMessage ? static_cast<const chre::fbs::LogMessage *>(message()) : nullptr;
5153 }
5154 const chre::fbs::TimeSyncMessage *message_as_TimeSyncMessage() const {
5155 return message_type() == chre::fbs::ChreMessage::TimeSyncMessage ? static_cast<const chre::fbs::TimeSyncMessage *>(message()) : nullptr;
5156 }
5157 const chre::fbs::DebugDumpRequest *message_as_DebugDumpRequest() const {
5158 return message_type() == chre::fbs::ChreMessage::DebugDumpRequest ? static_cast<const chre::fbs::DebugDumpRequest *>(message()) : nullptr;
5159 }
5160 const chre::fbs::DebugDumpData *message_as_DebugDumpData() const {
5161 return message_type() == chre::fbs::ChreMessage::DebugDumpData ? static_cast<const chre::fbs::DebugDumpData *>(message()) : nullptr;
5162 }
5163 const chre::fbs::DebugDumpResponse *message_as_DebugDumpResponse() const {
5164 return message_type() == chre::fbs::ChreMessage::DebugDumpResponse ? static_cast<const chre::fbs::DebugDumpResponse *>(message()) : nullptr;
5165 }
5166 const chre::fbs::TimeSyncRequest *message_as_TimeSyncRequest() const {
5167 return message_type() == chre::fbs::ChreMessage::TimeSyncRequest ? static_cast<const chre::fbs::TimeSyncRequest *>(message()) : nullptr;
5168 }
5169 const chre::fbs::LowPowerMicAccessRequest *message_as_LowPowerMicAccessRequest() const {
5170 return message_type() == chre::fbs::ChreMessage::LowPowerMicAccessRequest ? static_cast<const chre::fbs::LowPowerMicAccessRequest *>(message()) : nullptr;
5171 }
5172 const chre::fbs::LowPowerMicAccessRelease *message_as_LowPowerMicAccessRelease() const {
5173 return message_type() == chre::fbs::ChreMessage::LowPowerMicAccessRelease ? static_cast<const chre::fbs::LowPowerMicAccessRelease *>(message()) : nullptr;
5174 }
5175 const chre::fbs::SettingChangeMessage *message_as_SettingChangeMessage() const {
5176 return message_type() == chre::fbs::ChreMessage::SettingChangeMessage ? static_cast<const chre::fbs::SettingChangeMessage *>(message()) : nullptr;
5177 }
5178 const chre::fbs::LogMessageV2 *message_as_LogMessageV2() const {
5179 return message_type() == chre::fbs::ChreMessage::LogMessageV2 ? static_cast<const chre::fbs::LogMessageV2 *>(message()) : nullptr;
5180 }
5181 const chre::fbs::SelfTestRequest *message_as_SelfTestRequest() const {
5182 return message_type() == chre::fbs::ChreMessage::SelfTestRequest ? static_cast<const chre::fbs::SelfTestRequest *>(message()) : nullptr;
5183 }
5184 const chre::fbs::SelfTestResponse *message_as_SelfTestResponse() const {
5185 return message_type() == chre::fbs::ChreMessage::SelfTestResponse ? static_cast<const chre::fbs::SelfTestResponse *>(message()) : nullptr;
5186 }
5187 const chre::fbs::HostEndpointConnected *message_as_HostEndpointConnected() const {
5188 return message_type() == chre::fbs::ChreMessage::HostEndpointConnected ? static_cast<const chre::fbs::HostEndpointConnected *>(message()) : nullptr;
5189 }
5190 const chre::fbs::HostEndpointDisconnected *message_as_HostEndpointDisconnected() const {
5191 return message_type() == chre::fbs::ChreMessage::HostEndpointDisconnected ? static_cast<const chre::fbs::HostEndpointDisconnected *>(message()) : nullptr;
5192 }
5193 const chre::fbs::MetricLog *message_as_MetricLog() const {
5194 return message_type() == chre::fbs::ChreMessage::MetricLog ? static_cast<const chre::fbs::MetricLog *>(message()) : nullptr;
5195 }
5196 const chre::fbs::BatchedMetricLog *message_as_BatchedMetricLog() const {
5197 return message_type() == chre::fbs::ChreMessage::BatchedMetricLog ? static_cast<const chre::fbs::BatchedMetricLog *>(message()) : nullptr;
5198 }
5199 const chre::fbs::NanConfigurationRequest *message_as_NanConfigurationRequest() const {
5200 return message_type() == chre::fbs::ChreMessage::NanConfigurationRequest ? static_cast<const chre::fbs::NanConfigurationRequest *>(message()) : nullptr;
5201 }
5202 const chre::fbs::NanConfigurationUpdate *message_as_NanConfigurationUpdate() const {
5203 return message_type() == chre::fbs::ChreMessage::NanConfigurationUpdate ? static_cast<const chre::fbs::NanConfigurationUpdate *>(message()) : nullptr;
5204 }
5205 const chre::fbs::DebugConfiguration *message_as_DebugConfiguration() const {
5206 return message_type() == chre::fbs::ChreMessage::DebugConfiguration ? static_cast<const chre::fbs::DebugConfiguration *>(message()) : nullptr;
5207 }
5208 const chre::fbs::PulseRequest *message_as_PulseRequest() const {
5209 return message_type() == chre::fbs::ChreMessage::PulseRequest ? static_cast<const chre::fbs::PulseRequest *>(message()) : nullptr;
5210 }
5211 const chre::fbs::PulseResponse *message_as_PulseResponse() const {
5212 return message_type() == chre::fbs::ChreMessage::PulseResponse ? static_cast<const chre::fbs::PulseResponse *>(message()) : nullptr;
5213 }
5214 const chre::fbs::NanoappTokenDatabaseInfo *message_as_NanoappTokenDatabaseInfo() const {
5215 return message_type() == chre::fbs::ChreMessage::NanoappTokenDatabaseInfo ? static_cast<const chre::fbs::NanoappTokenDatabaseInfo *>(message()) : nullptr;
5216 }
5217 const chre::fbs::MessageDeliveryStatus *message_as_MessageDeliveryStatus() const {
5218 return message_type() == chre::fbs::ChreMessage::MessageDeliveryStatus ? static_cast<const chre::fbs::MessageDeliveryStatus *>(message()) : nullptr;
5219 }
5220 const chre::fbs::BtSocketOpen *message_as_BtSocketOpen() const {
5221 return message_type() == chre::fbs::ChreMessage::BtSocketOpen ? static_cast<const chre::fbs::BtSocketOpen *>(message()) : nullptr;
5222 }
5223 const chre::fbs::BtSocketOpenResponse *message_as_BtSocketOpenResponse() const {
5224 return message_type() == chre::fbs::ChreMessage::BtSocketOpenResponse ? static_cast<const chre::fbs::BtSocketOpenResponse *>(message()) : nullptr;
5225 }
5226 const chre::fbs::BtSocketClose *message_as_BtSocketClose() const {
5227 return message_type() == chre::fbs::ChreMessage::BtSocketClose ? static_cast<const chre::fbs::BtSocketClose *>(message()) : nullptr;
5228 }
5229 const chre::fbs::BtSocketCloseResponse *message_as_BtSocketCloseResponse() const {
5230 return message_type() == chre::fbs::ChreMessage::BtSocketCloseResponse ? static_cast<const chre::fbs::BtSocketCloseResponse *>(message()) : nullptr;
5231 }
5232 const chre::fbs::GetMessageHubsAndEndpointsRequest *message_as_GetMessageHubsAndEndpointsRequest() const {
5233 return message_type() == chre::fbs::ChreMessage::GetMessageHubsAndEndpointsRequest ? static_cast<const chre::fbs::GetMessageHubsAndEndpointsRequest *>(message()) : nullptr;
5234 }
5235 const chre::fbs::GetMessageHubsAndEndpointsResponse *message_as_GetMessageHubsAndEndpointsResponse() const {
5236 return message_type() == chre::fbs::ChreMessage::GetMessageHubsAndEndpointsResponse ? static_cast<const chre::fbs::GetMessageHubsAndEndpointsResponse *>(message()) : nullptr;
5237 }
5238 const chre::fbs::RegisterMessageHub *message_as_RegisterMessageHub() const {
5239 return message_type() == chre::fbs::ChreMessage::RegisterMessageHub ? static_cast<const chre::fbs::RegisterMessageHub *>(message()) : nullptr;
5240 }
5241 const chre::fbs::UnregisterMessageHub *message_as_UnregisterMessageHub() const {
5242 return message_type() == chre::fbs::ChreMessage::UnregisterMessageHub ? static_cast<const chre::fbs::UnregisterMessageHub *>(message()) : nullptr;
5243 }
5244 const chre::fbs::RegisterEndpoint *message_as_RegisterEndpoint() const {
5245 return message_type() == chre::fbs::ChreMessage::RegisterEndpoint ? static_cast<const chre::fbs::RegisterEndpoint *>(message()) : nullptr;
5246 }
5247 const chre::fbs::UnregisterEndpoint *message_as_UnregisterEndpoint() const {
5248 return message_type() == chre::fbs::ChreMessage::UnregisterEndpoint ? static_cast<const chre::fbs::UnregisterEndpoint *>(message()) : nullptr;
5249 }
5250 const chre::fbs::OpenEndpointSessionRequest *message_as_OpenEndpointSessionRequest() const {
5251 return message_type() == chre::fbs::ChreMessage::OpenEndpointSessionRequest ? static_cast<const chre::fbs::OpenEndpointSessionRequest *>(message()) : nullptr;
5252 }
5253 const chre::fbs::EndpointSessionOpened *message_as_EndpointSessionOpened() const {
5254 return message_type() == chre::fbs::ChreMessage::EndpointSessionOpened ? static_cast<const chre::fbs::EndpointSessionOpened *>(message()) : nullptr;
5255 }
5256 const chre::fbs::EndpointSessionClosed *message_as_EndpointSessionClosed() const {
5257 return message_type() == chre::fbs::ChreMessage::EndpointSessionClosed ? static_cast<const chre::fbs::EndpointSessionClosed *>(message()) : nullptr;
5258 }
5259 const chre::fbs::EndpointSessionMessage *message_as_EndpointSessionMessage() const {
5260 return message_type() == chre::fbs::ChreMessage::EndpointSessionMessage ? static_cast<const chre::fbs::EndpointSessionMessage *>(message()) : nullptr;
5261 }
5262 const chre::fbs::EndpointSessionMessageDeliveryStatus *message_as_EndpointSessionMessageDeliveryStatus() const {
5263 return message_type() == chre::fbs::ChreMessage::EndpointSessionMessageDeliveryStatus ? static_cast<const chre::fbs::EndpointSessionMessageDeliveryStatus *>(message()) : nullptr;
5264 }
5265 const chre::fbs::BtSocketCapabilitiesRequest *message_as_BtSocketCapabilitiesRequest() const {
5266 return message_type() == chre::fbs::ChreMessage::BtSocketCapabilitiesRequest ? static_cast<const chre::fbs::BtSocketCapabilitiesRequest *>(message()) : nullptr;
5267 }
5268 const chre::fbs::BtSocketCapabilitiesResponse *message_as_BtSocketCapabilitiesResponse() const {
5269 return message_type() == chre::fbs::ChreMessage::BtSocketCapabilitiesResponse ? static_cast<const chre::fbs::BtSocketCapabilitiesResponse *>(message()) : nullptr;
5270 }
5271 const chre::fbs::AddServiceToEndpoint *message_as_AddServiceToEndpoint() const {
5272 return message_type() == chre::fbs::ChreMessage::AddServiceToEndpoint ? static_cast<const chre::fbs::AddServiceToEndpoint *>(message()) : nullptr;
5273 }
5274 const chre::fbs::EndpointReady *message_as_EndpointReady() const {
5275 return message_type() == chre::fbs::ChreMessage::EndpointReady ? static_cast<const chre::fbs::EndpointReady *>(message()) : nullptr;
5276 }
5277 /// The originating or destination client ID on the host side, used to direct
5278 /// responses only to the client that sent the request. Although initially
5279 /// populated by the requesting client, this is enforced to be the correct
5280 /// value by the entity guarding access to CHRE.
5281 /// This is wrapped in a struct to ensure that it is always included when
5282 /// encoding the message, so it can be mutated by the host daemon.
5283 const chre::fbs::HostAddress *host_addr() const {
5284 return GetStruct<const chre::fbs::HostAddress *>(VT_HOST_ADDR);
5285 }
5286 bool Verify(flatbuffers::Verifier &verifier) const {
5287 return VerifyTableStart(verifier) &&
5288 VerifyField<uint8_t>(verifier, VT_MESSAGE_TYPE) &&
5289 VerifyOffsetRequired(verifier, VT_MESSAGE) &&
5290 VerifyChreMessage(verifier, message(), message_type()) &&
5291 VerifyFieldRequired<chre::fbs::HostAddress>(verifier, VT_HOST_ADDR) &&
5292 verifier.EndTable();
5293 }
5294 };
5295
5296 template<> inline const chre::fbs::NanoappMessage *MessageContainer::message_as<chre::fbs::NanoappMessage>() const {
5297 return message_as_NanoappMessage();
5298 }
5299
5300 template<> inline const chre::fbs::HubInfoRequest *MessageContainer::message_as<chre::fbs::HubInfoRequest>() const {
5301 return message_as_HubInfoRequest();
5302 }
5303
5304 template<> inline const chre::fbs::HubInfoResponse *MessageContainer::message_as<chre::fbs::HubInfoResponse>() const {
5305 return message_as_HubInfoResponse();
5306 }
5307
5308 template<> inline const chre::fbs::NanoappListRequest *MessageContainer::message_as<chre::fbs::NanoappListRequest>() const {
5309 return message_as_NanoappListRequest();
5310 }
5311
5312 template<> inline const chre::fbs::NanoappListResponse *MessageContainer::message_as<chre::fbs::NanoappListResponse>() const {
5313 return message_as_NanoappListResponse();
5314 }
5315
5316 template<> inline const chre::fbs::LoadNanoappRequest *MessageContainer::message_as<chre::fbs::LoadNanoappRequest>() const {
5317 return message_as_LoadNanoappRequest();
5318 }
5319
5320 template<> inline const chre::fbs::LoadNanoappResponse *MessageContainer::message_as<chre::fbs::LoadNanoappResponse>() const {
5321 return message_as_LoadNanoappResponse();
5322 }
5323
5324 template<> inline const chre::fbs::UnloadNanoappRequest *MessageContainer::message_as<chre::fbs::UnloadNanoappRequest>() const {
5325 return message_as_UnloadNanoappRequest();
5326 }
5327
5328 template<> inline const chre::fbs::UnloadNanoappResponse *MessageContainer::message_as<chre::fbs::UnloadNanoappResponse>() const {
5329 return message_as_UnloadNanoappResponse();
5330 }
5331
5332 template<> inline const chre::fbs::LogMessage *MessageContainer::message_as<chre::fbs::LogMessage>() const {
5333 return message_as_LogMessage();
5334 }
5335
5336 template<> inline const chre::fbs::TimeSyncMessage *MessageContainer::message_as<chre::fbs::TimeSyncMessage>() const {
5337 return message_as_TimeSyncMessage();
5338 }
5339
5340 template<> inline const chre::fbs::DebugDumpRequest *MessageContainer::message_as<chre::fbs::DebugDumpRequest>() const {
5341 return message_as_DebugDumpRequest();
5342 }
5343
5344 template<> inline const chre::fbs::DebugDumpData *MessageContainer::message_as<chre::fbs::DebugDumpData>() const {
5345 return message_as_DebugDumpData();
5346 }
5347
5348 template<> inline const chre::fbs::DebugDumpResponse *MessageContainer::message_as<chre::fbs::DebugDumpResponse>() const {
5349 return message_as_DebugDumpResponse();
5350 }
5351
5352 template<> inline const chre::fbs::TimeSyncRequest *MessageContainer::message_as<chre::fbs::TimeSyncRequest>() const {
5353 return message_as_TimeSyncRequest();
5354 }
5355
5356 template<> inline const chre::fbs::LowPowerMicAccessRequest *MessageContainer::message_as<chre::fbs::LowPowerMicAccessRequest>() const {
5357 return message_as_LowPowerMicAccessRequest();
5358 }
5359
5360 template<> inline const chre::fbs::LowPowerMicAccessRelease *MessageContainer::message_as<chre::fbs::LowPowerMicAccessRelease>() const {
5361 return message_as_LowPowerMicAccessRelease();
5362 }
5363
5364 template<> inline const chre::fbs::SettingChangeMessage *MessageContainer::message_as<chre::fbs::SettingChangeMessage>() const {
5365 return message_as_SettingChangeMessage();
5366 }
5367
5368 template<> inline const chre::fbs::LogMessageV2 *MessageContainer::message_as<chre::fbs::LogMessageV2>() const {
5369 return message_as_LogMessageV2();
5370 }
5371
5372 template<> inline const chre::fbs::SelfTestRequest *MessageContainer::message_as<chre::fbs::SelfTestRequest>() const {
5373 return message_as_SelfTestRequest();
5374 }
5375
5376 template<> inline const chre::fbs::SelfTestResponse *MessageContainer::message_as<chre::fbs::SelfTestResponse>() const {
5377 return message_as_SelfTestResponse();
5378 }
5379
5380 template<> inline const chre::fbs::HostEndpointConnected *MessageContainer::message_as<chre::fbs::HostEndpointConnected>() const {
5381 return message_as_HostEndpointConnected();
5382 }
5383
5384 template<> inline const chre::fbs::HostEndpointDisconnected *MessageContainer::message_as<chre::fbs::HostEndpointDisconnected>() const {
5385 return message_as_HostEndpointDisconnected();
5386 }
5387
5388 template<> inline const chre::fbs::MetricLog *MessageContainer::message_as<chre::fbs::MetricLog>() const {
5389 return message_as_MetricLog();
5390 }
5391
5392 template<> inline const chre::fbs::BatchedMetricLog *MessageContainer::message_as<chre::fbs::BatchedMetricLog>() const {
5393 return message_as_BatchedMetricLog();
5394 }
5395
5396 template<> inline const chre::fbs::NanConfigurationRequest *MessageContainer::message_as<chre::fbs::NanConfigurationRequest>() const {
5397 return message_as_NanConfigurationRequest();
5398 }
5399
5400 template<> inline const chre::fbs::NanConfigurationUpdate *MessageContainer::message_as<chre::fbs::NanConfigurationUpdate>() const {
5401 return message_as_NanConfigurationUpdate();
5402 }
5403
5404 template<> inline const chre::fbs::DebugConfiguration *MessageContainer::message_as<chre::fbs::DebugConfiguration>() const {
5405 return message_as_DebugConfiguration();
5406 }
5407
5408 template<> inline const chre::fbs::PulseRequest *MessageContainer::message_as<chre::fbs::PulseRequest>() const {
5409 return message_as_PulseRequest();
5410 }
5411
5412 template<> inline const chre::fbs::PulseResponse *MessageContainer::message_as<chre::fbs::PulseResponse>() const {
5413 return message_as_PulseResponse();
5414 }
5415
5416 template<> inline const chre::fbs::NanoappTokenDatabaseInfo *MessageContainer::message_as<chre::fbs::NanoappTokenDatabaseInfo>() const {
5417 return message_as_NanoappTokenDatabaseInfo();
5418 }
5419
5420 template<> inline const chre::fbs::MessageDeliveryStatus *MessageContainer::message_as<chre::fbs::MessageDeliveryStatus>() const {
5421 return message_as_MessageDeliveryStatus();
5422 }
5423
5424 template<> inline const chre::fbs::BtSocketOpen *MessageContainer::message_as<chre::fbs::BtSocketOpen>() const {
5425 return message_as_BtSocketOpen();
5426 }
5427
5428 template<> inline const chre::fbs::BtSocketOpenResponse *MessageContainer::message_as<chre::fbs::BtSocketOpenResponse>() const {
5429 return message_as_BtSocketOpenResponse();
5430 }
5431
5432 template<> inline const chre::fbs::BtSocketClose *MessageContainer::message_as<chre::fbs::BtSocketClose>() const {
5433 return message_as_BtSocketClose();
5434 }
5435
5436 template<> inline const chre::fbs::BtSocketCloseResponse *MessageContainer::message_as<chre::fbs::BtSocketCloseResponse>() const {
5437 return message_as_BtSocketCloseResponse();
5438 }
5439
5440 template<> inline const chre::fbs::GetMessageHubsAndEndpointsRequest *MessageContainer::message_as<chre::fbs::GetMessageHubsAndEndpointsRequest>() const {
5441 return message_as_GetMessageHubsAndEndpointsRequest();
5442 }
5443
5444 template<> inline const chre::fbs::GetMessageHubsAndEndpointsResponse *MessageContainer::message_as<chre::fbs::GetMessageHubsAndEndpointsResponse>() const {
5445 return message_as_GetMessageHubsAndEndpointsResponse();
5446 }
5447
5448 template<> inline const chre::fbs::RegisterMessageHub *MessageContainer::message_as<chre::fbs::RegisterMessageHub>() const {
5449 return message_as_RegisterMessageHub();
5450 }
5451
5452 template<> inline const chre::fbs::UnregisterMessageHub *MessageContainer::message_as<chre::fbs::UnregisterMessageHub>() const {
5453 return message_as_UnregisterMessageHub();
5454 }
5455
5456 template<> inline const chre::fbs::RegisterEndpoint *MessageContainer::message_as<chre::fbs::RegisterEndpoint>() const {
5457 return message_as_RegisterEndpoint();
5458 }
5459
5460 template<> inline const chre::fbs::UnregisterEndpoint *MessageContainer::message_as<chre::fbs::UnregisterEndpoint>() const {
5461 return message_as_UnregisterEndpoint();
5462 }
5463
5464 template<> inline const chre::fbs::OpenEndpointSessionRequest *MessageContainer::message_as<chre::fbs::OpenEndpointSessionRequest>() const {
5465 return message_as_OpenEndpointSessionRequest();
5466 }
5467
5468 template<> inline const chre::fbs::EndpointSessionOpened *MessageContainer::message_as<chre::fbs::EndpointSessionOpened>() const {
5469 return message_as_EndpointSessionOpened();
5470 }
5471
5472 template<> inline const chre::fbs::EndpointSessionClosed *MessageContainer::message_as<chre::fbs::EndpointSessionClosed>() const {
5473 return message_as_EndpointSessionClosed();
5474 }
5475
5476 template<> inline const chre::fbs::EndpointSessionMessage *MessageContainer::message_as<chre::fbs::EndpointSessionMessage>() const {
5477 return message_as_EndpointSessionMessage();
5478 }
5479
5480 template<> inline const chre::fbs::EndpointSessionMessageDeliveryStatus *MessageContainer::message_as<chre::fbs::EndpointSessionMessageDeliveryStatus>() const {
5481 return message_as_EndpointSessionMessageDeliveryStatus();
5482 }
5483
5484 template<> inline const chre::fbs::BtSocketCapabilitiesRequest *MessageContainer::message_as<chre::fbs::BtSocketCapabilitiesRequest>() const {
5485 return message_as_BtSocketCapabilitiesRequest();
5486 }
5487
5488 template<> inline const chre::fbs::BtSocketCapabilitiesResponse *MessageContainer::message_as<chre::fbs::BtSocketCapabilitiesResponse>() const {
5489 return message_as_BtSocketCapabilitiesResponse();
5490 }
5491
5492 template<> inline const chre::fbs::AddServiceToEndpoint *MessageContainer::message_as<chre::fbs::AddServiceToEndpoint>() const {
5493 return message_as_AddServiceToEndpoint();
5494 }
5495
5496 template<> inline const chre::fbs::EndpointReady *MessageContainer::message_as<chre::fbs::EndpointReady>() const {
5497 return message_as_EndpointReady();
5498 }
5499
5500 struct MessageContainerBuilder {
5501 typedef MessageContainer Table;
5502 flatbuffers::FlatBufferBuilder &fbb_;
5503 flatbuffers::uoffset_t start_;
5504 void add_message_type(chre::fbs::ChreMessage message_type) {
5505 fbb_.AddElement<uint8_t>(MessageContainer::VT_MESSAGE_TYPE, static_cast<uint8_t>(message_type), 0);
5506 }
5507 void add_message(flatbuffers::Offset<void> message) {
5508 fbb_.AddOffset(MessageContainer::VT_MESSAGE, message);
5509 }
5510 void add_host_addr(const chre::fbs::HostAddress *host_addr) {
5511 fbb_.AddStruct(MessageContainer::VT_HOST_ADDR, host_addr);
5512 }
5513 explicit MessageContainerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
5514 : fbb_(_fbb) {
5515 start_ = fbb_.StartTable();
5516 }
5517 MessageContainerBuilder &operator=(const MessageContainerBuilder &);
5518 flatbuffers::Offset<MessageContainer> Finish() {
5519 const auto end = fbb_.EndTable(start_);
5520 auto o = flatbuffers::Offset<MessageContainer>(end);
5521 fbb_.Required(o, MessageContainer::VT_MESSAGE);
5522 fbb_.Required(o, MessageContainer::VT_HOST_ADDR);
5523 return o;
5524 }
5525 };
5526
5527 inline flatbuffers::Offset<MessageContainer> CreateMessageContainer(
5528 flatbuffers::FlatBufferBuilder &_fbb,
5529 chre::fbs::ChreMessage message_type = chre::fbs::ChreMessage::NONE,
5530 flatbuffers::Offset<void> message = 0,
5531 const chre::fbs::HostAddress *host_addr = 0) {
5532 MessageContainerBuilder builder_(_fbb);
5533 builder_.add_host_addr(host_addr);
5534 builder_.add_message(message);
5535 builder_.add_message_type(message_type);
5536 return builder_.Finish();
5537 }
5538
5539 inline bool VerifyChannelInfo(flatbuffers::Verifier &verifier, const void *obj, ChannelInfo type) {
5540 switch (type) {
5541 case ChannelInfo::NONE: {
5542 return true;
5543 }
5544 case ChannelInfo::LeCocChannelInfo: {
5545 auto ptr = reinterpret_cast<const chre::fbs::LeCocChannelInfo *>(obj);
5546 return verifier.VerifyTable(ptr);
5547 }
5548 default: return true;
5549 }
5550 }
5551
5552 inline bool VerifyChannelInfoVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
5553 if (!values || !types) return !values && !types;
5554 if (values->size() != types->size()) return false;
5555 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
5556 if (!VerifyChannelInfo(
5557 verifier, values->Get(i), types->GetEnum<ChannelInfo>(i))) {
5558 return false;
5559 }
5560 }
5561 return true;
5562 }
5563
5564 inline bool VerifyMessageHubDetails(flatbuffers::Verifier &verifier, const void *obj, MessageHubDetails type) {
5565 switch (type) {
5566 case MessageHubDetails::NONE: {
5567 return true;
5568 }
5569 case MessageHubDetails::HubInfoResponse: {
5570 auto ptr = reinterpret_cast<const chre::fbs::HubInfoResponse *>(obj);
5571 return verifier.VerifyTable(ptr);
5572 }
5573 case MessageHubDetails::VendorHubInfo: {
5574 auto ptr = reinterpret_cast<const chre::fbs::VendorHubInfo *>(obj);
5575 return verifier.VerifyTable(ptr);
5576 }
5577 default: return true;
5578 }
5579 }
5580
5581 inline bool VerifyMessageHubDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
5582 if (!values || !types) return !values && !types;
5583 if (values->size() != types->size()) return false;
5584 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
5585 if (!VerifyMessageHubDetails(
5586 verifier, values->Get(i), types->GetEnum<MessageHubDetails>(i))) {
5587 return false;
5588 }
5589 }
5590 return true;
5591 }
5592
5593 inline bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type) {
5594 switch (type) {
5595 case ChreMessage::NONE: {
5596 return true;
5597 }
5598 case ChreMessage::NanoappMessage: {
5599 auto ptr = reinterpret_cast<const chre::fbs::NanoappMessage *>(obj);
5600 return verifier.VerifyTable(ptr);
5601 }
5602 case ChreMessage::HubInfoRequest: {
5603 auto ptr = reinterpret_cast<const chre::fbs::HubInfoRequest *>(obj);
5604 return verifier.VerifyTable(ptr);
5605 }
5606 case ChreMessage::HubInfoResponse: {
5607 auto ptr = reinterpret_cast<const chre::fbs::HubInfoResponse *>(obj);
5608 return verifier.VerifyTable(ptr);
5609 }
5610 case ChreMessage::NanoappListRequest: {
5611 auto ptr = reinterpret_cast<const chre::fbs::NanoappListRequest *>(obj);
5612 return verifier.VerifyTable(ptr);
5613 }
5614 case ChreMessage::NanoappListResponse: {
5615 auto ptr = reinterpret_cast<const chre::fbs::NanoappListResponse *>(obj);
5616 return verifier.VerifyTable(ptr);
5617 }
5618 case ChreMessage::LoadNanoappRequest: {
5619 auto ptr = reinterpret_cast<const chre::fbs::LoadNanoappRequest *>(obj);
5620 return verifier.VerifyTable(ptr);
5621 }
5622 case ChreMessage::LoadNanoappResponse: {
5623 auto ptr = reinterpret_cast<const chre::fbs::LoadNanoappResponse *>(obj);
5624 return verifier.VerifyTable(ptr);
5625 }
5626 case ChreMessage::UnloadNanoappRequest: {
5627 auto ptr = reinterpret_cast<const chre::fbs::UnloadNanoappRequest *>(obj);
5628 return verifier.VerifyTable(ptr);
5629 }
5630 case ChreMessage::UnloadNanoappResponse: {
5631 auto ptr = reinterpret_cast<const chre::fbs::UnloadNanoappResponse *>(obj);
5632 return verifier.VerifyTable(ptr);
5633 }
5634 case ChreMessage::LogMessage: {
5635 auto ptr = reinterpret_cast<const chre::fbs::LogMessage *>(obj);
5636 return verifier.VerifyTable(ptr);
5637 }
5638 case ChreMessage::TimeSyncMessage: {
5639 auto ptr = reinterpret_cast<const chre::fbs::TimeSyncMessage *>(obj);
5640 return verifier.VerifyTable(ptr);
5641 }
5642 case ChreMessage::DebugDumpRequest: {
5643 auto ptr = reinterpret_cast<const chre::fbs::DebugDumpRequest *>(obj);
5644 return verifier.VerifyTable(ptr);
5645 }
5646 case ChreMessage::DebugDumpData: {
5647 auto ptr = reinterpret_cast<const chre::fbs::DebugDumpData *>(obj);
5648 return verifier.VerifyTable(ptr);
5649 }
5650 case ChreMessage::DebugDumpResponse: {
5651 auto ptr = reinterpret_cast<const chre::fbs::DebugDumpResponse *>(obj);
5652 return verifier.VerifyTable(ptr);
5653 }
5654 case ChreMessage::TimeSyncRequest: {
5655 auto ptr = reinterpret_cast<const chre::fbs::TimeSyncRequest *>(obj);
5656 return verifier.VerifyTable(ptr);
5657 }
5658 case ChreMessage::LowPowerMicAccessRequest: {
5659 auto ptr = reinterpret_cast<const chre::fbs::LowPowerMicAccessRequest *>(obj);
5660 return verifier.VerifyTable(ptr);
5661 }
5662 case ChreMessage::LowPowerMicAccessRelease: {
5663 auto ptr = reinterpret_cast<const chre::fbs::LowPowerMicAccessRelease *>(obj);
5664 return verifier.VerifyTable(ptr);
5665 }
5666 case ChreMessage::SettingChangeMessage: {
5667 auto ptr = reinterpret_cast<const chre::fbs::SettingChangeMessage *>(obj);
5668 return verifier.VerifyTable(ptr);
5669 }
5670 case ChreMessage::LogMessageV2: {
5671 auto ptr = reinterpret_cast<const chre::fbs::LogMessageV2 *>(obj);
5672 return verifier.VerifyTable(ptr);
5673 }
5674 case ChreMessage::SelfTestRequest: {
5675 auto ptr = reinterpret_cast<const chre::fbs::SelfTestRequest *>(obj);
5676 return verifier.VerifyTable(ptr);
5677 }
5678 case ChreMessage::SelfTestResponse: {
5679 auto ptr = reinterpret_cast<const chre::fbs::SelfTestResponse *>(obj);
5680 return verifier.VerifyTable(ptr);
5681 }
5682 case ChreMessage::HostEndpointConnected: {
5683 auto ptr = reinterpret_cast<const chre::fbs::HostEndpointConnected *>(obj);
5684 return verifier.VerifyTable(ptr);
5685 }
5686 case ChreMessage::HostEndpointDisconnected: {
5687 auto ptr = reinterpret_cast<const chre::fbs::HostEndpointDisconnected *>(obj);
5688 return verifier.VerifyTable(ptr);
5689 }
5690 case ChreMessage::MetricLog: {
5691 auto ptr = reinterpret_cast<const chre::fbs::MetricLog *>(obj);
5692 return verifier.VerifyTable(ptr);
5693 }
5694 case ChreMessage::BatchedMetricLog: {
5695 auto ptr = reinterpret_cast<const chre::fbs::BatchedMetricLog *>(obj);
5696 return verifier.VerifyTable(ptr);
5697 }
5698 case ChreMessage::NanConfigurationRequest: {
5699 auto ptr = reinterpret_cast<const chre::fbs::NanConfigurationRequest *>(obj);
5700 return verifier.VerifyTable(ptr);
5701 }
5702 case ChreMessage::NanConfigurationUpdate: {
5703 auto ptr = reinterpret_cast<const chre::fbs::NanConfigurationUpdate *>(obj);
5704 return verifier.VerifyTable(ptr);
5705 }
5706 case ChreMessage::DebugConfiguration: {
5707 auto ptr = reinterpret_cast<const chre::fbs::DebugConfiguration *>(obj);
5708 return verifier.VerifyTable(ptr);
5709 }
5710 case ChreMessage::PulseRequest: {
5711 auto ptr = reinterpret_cast<const chre::fbs::PulseRequest *>(obj);
5712 return verifier.VerifyTable(ptr);
5713 }
5714 case ChreMessage::PulseResponse: {
5715 auto ptr = reinterpret_cast<const chre::fbs::PulseResponse *>(obj);
5716 return verifier.VerifyTable(ptr);
5717 }
5718 case ChreMessage::NanoappTokenDatabaseInfo: {
5719 auto ptr = reinterpret_cast<const chre::fbs::NanoappTokenDatabaseInfo *>(obj);
5720 return verifier.VerifyTable(ptr);
5721 }
5722 case ChreMessage::MessageDeliveryStatus: {
5723 auto ptr = reinterpret_cast<const chre::fbs::MessageDeliveryStatus *>(obj);
5724 return verifier.VerifyTable(ptr);
5725 }
5726 case ChreMessage::BtSocketOpen: {
5727 auto ptr = reinterpret_cast<const chre::fbs::BtSocketOpen *>(obj);
5728 return verifier.VerifyTable(ptr);
5729 }
5730 case ChreMessage::BtSocketOpenResponse: {
5731 auto ptr = reinterpret_cast<const chre::fbs::BtSocketOpenResponse *>(obj);
5732 return verifier.VerifyTable(ptr);
5733 }
5734 case ChreMessage::BtSocketClose: {
5735 auto ptr = reinterpret_cast<const chre::fbs::BtSocketClose *>(obj);
5736 return verifier.VerifyTable(ptr);
5737 }
5738 case ChreMessage::BtSocketCloseResponse: {
5739 auto ptr = reinterpret_cast<const chre::fbs::BtSocketCloseResponse *>(obj);
5740 return verifier.VerifyTable(ptr);
5741 }
5742 case ChreMessage::GetMessageHubsAndEndpointsRequest: {
5743 auto ptr = reinterpret_cast<const chre::fbs::GetMessageHubsAndEndpointsRequest *>(obj);
5744 return verifier.VerifyTable(ptr);
5745 }
5746 case ChreMessage::GetMessageHubsAndEndpointsResponse: {
5747 auto ptr = reinterpret_cast<const chre::fbs::GetMessageHubsAndEndpointsResponse *>(obj);
5748 return verifier.VerifyTable(ptr);
5749 }
5750 case ChreMessage::RegisterMessageHub: {
5751 auto ptr = reinterpret_cast<const chre::fbs::RegisterMessageHub *>(obj);
5752 return verifier.VerifyTable(ptr);
5753 }
5754 case ChreMessage::UnregisterMessageHub: {
5755 auto ptr = reinterpret_cast<const chre::fbs::UnregisterMessageHub *>(obj);
5756 return verifier.VerifyTable(ptr);
5757 }
5758 case ChreMessage::RegisterEndpoint: {
5759 auto ptr = reinterpret_cast<const chre::fbs::RegisterEndpoint *>(obj);
5760 return verifier.VerifyTable(ptr);
5761 }
5762 case ChreMessage::UnregisterEndpoint: {
5763 auto ptr = reinterpret_cast<const chre::fbs::UnregisterEndpoint *>(obj);
5764 return verifier.VerifyTable(ptr);
5765 }
5766 case ChreMessage::OpenEndpointSessionRequest: {
5767 auto ptr = reinterpret_cast<const chre::fbs::OpenEndpointSessionRequest *>(obj);
5768 return verifier.VerifyTable(ptr);
5769 }
5770 case ChreMessage::EndpointSessionOpened: {
5771 auto ptr = reinterpret_cast<const chre::fbs::EndpointSessionOpened *>(obj);
5772 return verifier.VerifyTable(ptr);
5773 }
5774 case ChreMessage::EndpointSessionClosed: {
5775 auto ptr = reinterpret_cast<const chre::fbs::EndpointSessionClosed *>(obj);
5776 return verifier.VerifyTable(ptr);
5777 }
5778 case ChreMessage::EndpointSessionMessage: {
5779 auto ptr = reinterpret_cast<const chre::fbs::EndpointSessionMessage *>(obj);
5780 return verifier.VerifyTable(ptr);
5781 }
5782 case ChreMessage::EndpointSessionMessageDeliveryStatus: {
5783 auto ptr = reinterpret_cast<const chre::fbs::EndpointSessionMessageDeliveryStatus *>(obj);
5784 return verifier.VerifyTable(ptr);
5785 }
5786 case ChreMessage::BtSocketCapabilitiesRequest: {
5787 auto ptr = reinterpret_cast<const chre::fbs::BtSocketCapabilitiesRequest *>(obj);
5788 return verifier.VerifyTable(ptr);
5789 }
5790 case ChreMessage::BtSocketCapabilitiesResponse: {
5791 auto ptr = reinterpret_cast<const chre::fbs::BtSocketCapabilitiesResponse *>(obj);
5792 return verifier.VerifyTable(ptr);
5793 }
5794 case ChreMessage::AddServiceToEndpoint: {
5795 auto ptr = reinterpret_cast<const chre::fbs::AddServiceToEndpoint *>(obj);
5796 return verifier.VerifyTable(ptr);
5797 }
5798 case ChreMessage::EndpointReady: {
5799 auto ptr = reinterpret_cast<const chre::fbs::EndpointReady *>(obj);
5800 return verifier.VerifyTable(ptr);
5801 }
5802 default: return true;
5803 }
5804 }
5805
5806 inline bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
5807 if (!values || !types) return !values && !types;
5808 if (values->size() != types->size()) return false;
5809 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
5810 if (!VerifyChreMessage(
5811 verifier, values->Get(i), types->GetEnum<ChreMessage>(i))) {
5812 return false;
5813 }
5814 }
5815 return true;
5816 }
5817
5818 inline const chre::fbs::MessageContainer *GetMessageContainer(const void *buf) {
5819 return flatbuffers::GetRoot<chre::fbs::MessageContainer>(buf);
5820 }
5821
5822 inline const chre::fbs::MessageContainer *GetSizePrefixedMessageContainer(const void *buf) {
5823 return flatbuffers::GetSizePrefixedRoot<chre::fbs::MessageContainer>(buf);
5824 }
5825
5826 inline bool VerifyMessageContainerBuffer(
5827 flatbuffers::Verifier &verifier) {
5828 return verifier.VerifyBuffer<chre::fbs::MessageContainer>(nullptr);
5829 }
5830
5831 inline bool VerifySizePrefixedMessageContainerBuffer(
5832 flatbuffers::Verifier &verifier) {
5833 return verifier.VerifySizePrefixedBuffer<chre::fbs::MessageContainer>(nullptr);
5834 }
5835
5836 inline void FinishMessageContainerBuffer(
5837 flatbuffers::FlatBufferBuilder &fbb,
5838 flatbuffers::Offset<chre::fbs::MessageContainer> root) {
5839 fbb.Finish(root);
5840 }
5841
5842 inline void FinishSizePrefixedMessageContainerBuffer(
5843 flatbuffers::FlatBufferBuilder &fbb,
5844 flatbuffers::Offset<chre::fbs::MessageContainer> root) {
5845 fbb.FinishSizePrefixed(root);
5846 }
5847
5848 } // namespace fbs
5849 } // namespace chre
5850
5851 #endif // FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_
5852