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