1 // automatically generated by the FlatBuffers compiler, do not modify
2
3
4 #ifndef FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_
5 #define FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_
6
7 #include "flatbuffers/flatbuffers.h"
8
9 namespace chre {
10 namespace fbs {
11
12 struct NanoappMessage;
13 struct NanoappMessageBuilder;
14
15 struct HubInfoRequest;
16 struct HubInfoRequestBuilder;
17
18 struct HubInfoResponse;
19 struct HubInfoResponseBuilder;
20
21 struct NanoappListRequest;
22 struct NanoappListRequestBuilder;
23
24 struct NanoappListEntry;
25 struct NanoappListEntryBuilder;
26
27 struct NanoappListResponse;
28 struct NanoappListResponseBuilder;
29
30 struct LoadNanoappRequest;
31 struct LoadNanoappRequestBuilder;
32
33 struct LoadNanoappResponse;
34 struct LoadNanoappResponseBuilder;
35
36 struct UnloadNanoappRequest;
37 struct UnloadNanoappRequestBuilder;
38
39 struct UnloadNanoappResponse;
40 struct UnloadNanoappResponseBuilder;
41
42 struct LogMessage;
43 struct LogMessageBuilder;
44
45 struct TimeSyncMessage;
46 struct TimeSyncMessageBuilder;
47
48 struct DebugDumpRequest;
49 struct DebugDumpRequestBuilder;
50
51 struct DebugDumpData;
52 struct DebugDumpDataBuilder;
53
54 struct DebugDumpResponse;
55 struct DebugDumpResponseBuilder;
56
57 struct TimeSyncRequest;
58 struct TimeSyncRequestBuilder;
59
60 struct LowPowerMicAccessRequest;
61 struct LowPowerMicAccessRequestBuilder;
62
63 struct LowPowerMicAccessRelease;
64 struct LowPowerMicAccessReleaseBuilder;
65
66 struct SettingChangeMessage;
67 struct SettingChangeMessageBuilder;
68
69 struct HostAddress;
70
71 struct MessageContainer;
72 struct MessageContainerBuilder;
73
74 /// An enum describing the setting type.
75 enum class Setting : int8_t {
76 LOCATION = 0,
77 MIN = LOCATION,
78 MAX = LOCATION
79 };
80
EnumValuesSetting()81 inline const Setting (&EnumValuesSetting())[1] {
82 static const Setting values[] = {
83 Setting::LOCATION
84 };
85 return values;
86 }
87
EnumNamesSetting()88 inline const char * const *EnumNamesSetting() {
89 static const char * const names[2] = {
90 "LOCATION",
91 nullptr
92 };
93 return names;
94 }
95
EnumNameSetting(Setting e)96 inline const char *EnumNameSetting(Setting e) {
97 if (flatbuffers::IsOutRange(e, Setting::LOCATION, Setting::LOCATION)) return "";
98 const size_t index = static_cast<size_t>(e);
99 return EnumNamesSetting()[index];
100 }
101
102 /// An enum describing the state of a setting.
103 enum class SettingState : int8_t {
104 DISABLED = 0,
105 ENABLED = 1,
106 MIN = DISABLED,
107 MAX = ENABLED
108 };
109
EnumValuesSettingState()110 inline const SettingState (&EnumValuesSettingState())[2] {
111 static const SettingState values[] = {
112 SettingState::DISABLED,
113 SettingState::ENABLED
114 };
115 return values;
116 }
117
EnumNamesSettingState()118 inline const char * const *EnumNamesSettingState() {
119 static const char * const names[3] = {
120 "DISABLED",
121 "ENABLED",
122 nullptr
123 };
124 return names;
125 }
126
EnumNameSettingState(SettingState e)127 inline const char *EnumNameSettingState(SettingState e) {
128 if (flatbuffers::IsOutRange(e, SettingState::DISABLED, SettingState::ENABLED)) return "";
129 const size_t index = static_cast<size_t>(e);
130 return EnumNamesSettingState()[index];
131 }
132
133 /// A union that joins together all possible messages. Note that in FlatBuffers,
134 /// unions have an implicit type
135 enum class ChreMessage : uint8_t {
136 NONE = 0,
137 NanoappMessage = 1,
138 HubInfoRequest = 2,
139 HubInfoResponse = 3,
140 NanoappListRequest = 4,
141 NanoappListResponse = 5,
142 LoadNanoappRequest = 6,
143 LoadNanoappResponse = 7,
144 UnloadNanoappRequest = 8,
145 UnloadNanoappResponse = 9,
146 LogMessage = 10,
147 TimeSyncMessage = 11,
148 DebugDumpRequest = 12,
149 DebugDumpData = 13,
150 DebugDumpResponse = 14,
151 TimeSyncRequest = 15,
152 LowPowerMicAccessRequest = 16,
153 LowPowerMicAccessRelease = 17,
154 SettingChangeMessage = 18,
155 MIN = NONE,
156 MAX = SettingChangeMessage
157 };
158
EnumValuesChreMessage()159 inline const ChreMessage (&EnumValuesChreMessage())[19] {
160 static const ChreMessage values[] = {
161 ChreMessage::NONE,
162 ChreMessage::NanoappMessage,
163 ChreMessage::HubInfoRequest,
164 ChreMessage::HubInfoResponse,
165 ChreMessage::NanoappListRequest,
166 ChreMessage::NanoappListResponse,
167 ChreMessage::LoadNanoappRequest,
168 ChreMessage::LoadNanoappResponse,
169 ChreMessage::UnloadNanoappRequest,
170 ChreMessage::UnloadNanoappResponse,
171 ChreMessage::LogMessage,
172 ChreMessage::TimeSyncMessage,
173 ChreMessage::DebugDumpRequest,
174 ChreMessage::DebugDumpData,
175 ChreMessage::DebugDumpResponse,
176 ChreMessage::TimeSyncRequest,
177 ChreMessage::LowPowerMicAccessRequest,
178 ChreMessage::LowPowerMicAccessRelease,
179 ChreMessage::SettingChangeMessage
180 };
181 return values;
182 }
183
EnumNamesChreMessage()184 inline const char * const *EnumNamesChreMessage() {
185 static const char * const names[20] = {
186 "NONE",
187 "NanoappMessage",
188 "HubInfoRequest",
189 "HubInfoResponse",
190 "NanoappListRequest",
191 "NanoappListResponse",
192 "LoadNanoappRequest",
193 "LoadNanoappResponse",
194 "UnloadNanoappRequest",
195 "UnloadNanoappResponse",
196 "LogMessage",
197 "TimeSyncMessage",
198 "DebugDumpRequest",
199 "DebugDumpData",
200 "DebugDumpResponse",
201 "TimeSyncRequest",
202 "LowPowerMicAccessRequest",
203 "LowPowerMicAccessRelease",
204 "SettingChangeMessage",
205 nullptr
206 };
207 return names;
208 }
209
EnumNameChreMessage(ChreMessage e)210 inline const char *EnumNameChreMessage(ChreMessage e) {
211 if (flatbuffers::IsOutRange(e, ChreMessage::NONE, ChreMessage::SettingChangeMessage)) return "";
212 const size_t index = static_cast<size_t>(e);
213 return EnumNamesChreMessage()[index];
214 }
215
216 template<typename T> struct ChreMessageTraits {
217 static const ChreMessage enum_value = ChreMessage::NONE;
218 };
219
220 template<> struct ChreMessageTraits<chre::fbs::NanoappMessage> {
221 static const ChreMessage enum_value = ChreMessage::NanoappMessage;
222 };
223
224 template<> struct ChreMessageTraits<chre::fbs::HubInfoRequest> {
225 static const ChreMessage enum_value = ChreMessage::HubInfoRequest;
226 };
227
228 template<> struct ChreMessageTraits<chre::fbs::HubInfoResponse> {
229 static const ChreMessage enum_value = ChreMessage::HubInfoResponse;
230 };
231
232 template<> struct ChreMessageTraits<chre::fbs::NanoappListRequest> {
233 static const ChreMessage enum_value = ChreMessage::NanoappListRequest;
234 };
235
236 template<> struct ChreMessageTraits<chre::fbs::NanoappListResponse> {
237 static const ChreMessage enum_value = ChreMessage::NanoappListResponse;
238 };
239
240 template<> struct ChreMessageTraits<chre::fbs::LoadNanoappRequest> {
241 static const ChreMessage enum_value = ChreMessage::LoadNanoappRequest;
242 };
243
244 template<> struct ChreMessageTraits<chre::fbs::LoadNanoappResponse> {
245 static const ChreMessage enum_value = ChreMessage::LoadNanoappResponse;
246 };
247
248 template<> struct ChreMessageTraits<chre::fbs::UnloadNanoappRequest> {
249 static const ChreMessage enum_value = ChreMessage::UnloadNanoappRequest;
250 };
251
252 template<> struct ChreMessageTraits<chre::fbs::UnloadNanoappResponse> {
253 static const ChreMessage enum_value = ChreMessage::UnloadNanoappResponse;
254 };
255
256 template<> struct ChreMessageTraits<chre::fbs::LogMessage> {
257 static const ChreMessage enum_value = ChreMessage::LogMessage;
258 };
259
260 template<> struct ChreMessageTraits<chre::fbs::TimeSyncMessage> {
261 static const ChreMessage enum_value = ChreMessage::TimeSyncMessage;
262 };
263
264 template<> struct ChreMessageTraits<chre::fbs::DebugDumpRequest> {
265 static const ChreMessage enum_value = ChreMessage::DebugDumpRequest;
266 };
267
268 template<> struct ChreMessageTraits<chre::fbs::DebugDumpData> {
269 static const ChreMessage enum_value = ChreMessage::DebugDumpData;
270 };
271
272 template<> struct ChreMessageTraits<chre::fbs::DebugDumpResponse> {
273 static const ChreMessage enum_value = ChreMessage::DebugDumpResponse;
274 };
275
276 template<> struct ChreMessageTraits<chre::fbs::TimeSyncRequest> {
277 static const ChreMessage enum_value = ChreMessage::TimeSyncRequest;
278 };
279
280 template<> struct ChreMessageTraits<chre::fbs::LowPowerMicAccessRequest> {
281 static const ChreMessage enum_value = ChreMessage::LowPowerMicAccessRequest;
282 };
283
284 template<> struct ChreMessageTraits<chre::fbs::LowPowerMicAccessRelease> {
285 static const ChreMessage enum_value = ChreMessage::LowPowerMicAccessRelease;
286 };
287
288 template<> struct ChreMessageTraits<chre::fbs::SettingChangeMessage> {
289 static const ChreMessage enum_value = ChreMessage::SettingChangeMessage;
290 };
291
292 bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type);
293 bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
294
295 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) HostAddress FLATBUFFERS_FINAL_CLASS {
296 private:
297 uint16_t client_id_;
298
299 public:
300 HostAddress() {
301 memset(static_cast<void *>(this), 0, sizeof(HostAddress));
302 }
303 HostAddress(uint16_t _client_id)
304 : client_id_(flatbuffers::EndianScalar(_client_id)) {
305 }
306 uint16_t client_id() const {
307 return flatbuffers::EndianScalar(client_id_);
308 }
309 };
310 FLATBUFFERS_STRUCT_END(HostAddress, 2);
311
312 /// Represents a message sent to/from a nanoapp from/to a client on the host
313 struct NanoappMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
314 typedef NanoappMessageBuilder Builder;
315 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
316 VT_APP_ID = 4,
317 VT_MESSAGE_TYPE = 6,
318 VT_HOST_ENDPOINT = 8,
319 VT_MESSAGE = 10
320 };
321 uint64_t app_id() const {
322 return GetField<uint64_t>(VT_APP_ID, 0);
323 }
324 uint32_t message_type() const {
325 return GetField<uint32_t>(VT_MESSAGE_TYPE, 0);
326 }
327 /// Identifies the host-side endpoint on the host that sent or should receive
328 /// this message. The default value is a special value defined in the HAL and
329 /// elsewhere that indicates that the endpoint is unspecified.
330 uint16_t host_endpoint() const {
331 return GetField<uint16_t>(VT_HOST_ENDPOINT, 65534);
332 }
333 /// Vector containing arbitrary application-specific message data
334 const flatbuffers::Vector<uint8_t> *message() const {
335 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MESSAGE);
336 }
337 bool Verify(flatbuffers::Verifier &verifier) const {
338 return VerifyTableStart(verifier) &&
339 VerifyField<uint64_t>(verifier, VT_APP_ID) &&
340 VerifyField<uint32_t>(verifier, VT_MESSAGE_TYPE) &&
341 VerifyField<uint16_t>(verifier, VT_HOST_ENDPOINT) &&
342 VerifyOffsetRequired(verifier, VT_MESSAGE) &&
343 verifier.VerifyVector(message()) &&
344 verifier.EndTable();
345 }
346 };
347
348 struct NanoappMessageBuilder {
349 typedef NanoappMessage Table;
350 flatbuffers::FlatBufferBuilder &fbb_;
351 flatbuffers::uoffset_t start_;
352 void add_app_id(uint64_t app_id) {
353 fbb_.AddElement<uint64_t>(NanoappMessage::VT_APP_ID, app_id, 0);
354 }
355 void add_message_type(uint32_t message_type) {
356 fbb_.AddElement<uint32_t>(NanoappMessage::VT_MESSAGE_TYPE, message_type, 0);
357 }
358 void add_host_endpoint(uint16_t host_endpoint) {
359 fbb_.AddElement<uint16_t>(NanoappMessage::VT_HOST_ENDPOINT, host_endpoint, 65534);
360 }
361 void add_message(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message) {
362 fbb_.AddOffset(NanoappMessage::VT_MESSAGE, message);
363 }
364 explicit NanoappMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
365 : fbb_(_fbb) {
366 start_ = fbb_.StartTable();
367 }
368 NanoappMessageBuilder &operator=(const NanoappMessageBuilder &);
369 flatbuffers::Offset<NanoappMessage> Finish() {
370 const auto end = fbb_.EndTable(start_);
371 auto o = flatbuffers::Offset<NanoappMessage>(end);
372 fbb_.Required(o, NanoappMessage::VT_MESSAGE);
373 return o;
374 }
375 };
376
377 inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessage(
378 flatbuffers::FlatBufferBuilder &_fbb,
379 uint64_t app_id = 0,
380 uint32_t message_type = 0,
381 uint16_t host_endpoint = 65534,
382 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message = 0) {
383 NanoappMessageBuilder builder_(_fbb);
384 builder_.add_app_id(app_id);
385 builder_.add_message(message);
386 builder_.add_message_type(message_type);
387 builder_.add_host_endpoint(host_endpoint);
388 return builder_.Finish();
389 }
390
391 inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessageDirect(
392 flatbuffers::FlatBufferBuilder &_fbb,
393 uint64_t app_id = 0,
394 uint32_t message_type = 0,
395 uint16_t host_endpoint = 65534,
396 const std::vector<uint8_t> *message = nullptr) {
397 auto message__ = message ? _fbb.CreateVector<uint8_t>(*message) : 0;
398 return chre::fbs::CreateNanoappMessage(
399 _fbb,
400 app_id,
401 message_type,
402 host_endpoint,
403 message__);
404 }
405
406 struct HubInfoRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
407 typedef HubInfoRequestBuilder Builder;
408 bool Verify(flatbuffers::Verifier &verifier) const {
409 return VerifyTableStart(verifier) &&
410 verifier.EndTable();
411 }
412 };
413
414 struct HubInfoRequestBuilder {
415 typedef HubInfoRequest Table;
416 flatbuffers::FlatBufferBuilder &fbb_;
417 flatbuffers::uoffset_t start_;
418 explicit HubInfoRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
419 : fbb_(_fbb) {
420 start_ = fbb_.StartTable();
421 }
422 HubInfoRequestBuilder &operator=(const HubInfoRequestBuilder &);
423 flatbuffers::Offset<HubInfoRequest> Finish() {
424 const auto end = fbb_.EndTable(start_);
425 auto o = flatbuffers::Offset<HubInfoRequest>(end);
426 return o;
427 }
428 };
429
430 inline flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest(
431 flatbuffers::FlatBufferBuilder &_fbb) {
432 HubInfoRequestBuilder builder_(_fbb);
433 return builder_.Finish();
434 }
435
436 struct HubInfoResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
437 typedef HubInfoResponseBuilder Builder;
438 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
439 VT_NAME = 4,
440 VT_VENDOR = 6,
441 VT_TOOLCHAIN = 8,
442 VT_PLATFORM_VERSION = 10,
443 VT_TOOLCHAIN_VERSION = 12,
444 VT_PEAK_MIPS = 14,
445 VT_STOPPED_POWER = 16,
446 VT_SLEEP_POWER = 18,
447 VT_PEAK_POWER = 20,
448 VT_MAX_MSG_LEN = 22,
449 VT_PLATFORM_ID = 24,
450 VT_CHRE_PLATFORM_VERSION = 26
451 };
452 /// The name of the hub. Nominally a UTF-8 string, but note that we're not
453 /// using the built-in "string" data type from FlatBuffers here, because the
454 /// generated C++ uses std::string which is not well-supported in CHRE. This
455 /// applies for vendor and toolchain as well.
456 const flatbuffers::Vector<int8_t> *name() const {
457 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_NAME);
458 }
459 const flatbuffers::Vector<int8_t> *vendor() const {
460 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_VENDOR);
461 }
462 const flatbuffers::Vector<int8_t> *toolchain() const {
463 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_TOOLCHAIN);
464 }
465 /// Legacy platform version reported in the HAL; semantics not strictly
466 /// defined
467 uint32_t platform_version() const {
468 return GetField<uint32_t>(VT_PLATFORM_VERSION, 0);
469 }
470 /// Toolchain version reported in the HAL; semantics not strictly defined
471 uint32_t toolchain_version() const {
472 return GetField<uint32_t>(VT_TOOLCHAIN_VERSION, 0);
473 }
474 float peak_mips() const {
475 return GetField<float>(VT_PEAK_MIPS, 0.0f);
476 }
477 float stopped_power() const {
478 return GetField<float>(VT_STOPPED_POWER, 0.0f);
479 }
480 float sleep_power() const {
481 return GetField<float>(VT_SLEEP_POWER, 0.0f);
482 }
483 float peak_power() const {
484 return GetField<float>(VT_PEAK_POWER, 0.0f);
485 }
486 /// Maximum size message that can be sent to a nanoapp
487 uint32_t max_msg_len() const {
488 return GetField<uint32_t>(VT_MAX_MSG_LEN, 0);
489 }
490 /// @see chreGetPlatformId()
491 uint64_t platform_id() const {
492 return GetField<uint64_t>(VT_PLATFORM_ID, 0);
493 }
494 /// @see chreGetVersion()
495 uint32_t chre_platform_version() const {
496 return GetField<uint32_t>(VT_CHRE_PLATFORM_VERSION, 0);
497 }
498 bool Verify(flatbuffers::Verifier &verifier) const {
499 return VerifyTableStart(verifier) &&
500 VerifyOffset(verifier, VT_NAME) &&
501 verifier.VerifyVector(name()) &&
502 VerifyOffset(verifier, VT_VENDOR) &&
503 verifier.VerifyVector(vendor()) &&
504 VerifyOffset(verifier, VT_TOOLCHAIN) &&
505 verifier.VerifyVector(toolchain()) &&
506 VerifyField<uint32_t>(verifier, VT_PLATFORM_VERSION) &&
507 VerifyField<uint32_t>(verifier, VT_TOOLCHAIN_VERSION) &&
508 VerifyField<float>(verifier, VT_PEAK_MIPS) &&
509 VerifyField<float>(verifier, VT_STOPPED_POWER) &&
510 VerifyField<float>(verifier, VT_SLEEP_POWER) &&
511 VerifyField<float>(verifier, VT_PEAK_POWER) &&
512 VerifyField<uint32_t>(verifier, VT_MAX_MSG_LEN) &&
513 VerifyField<uint64_t>(verifier, VT_PLATFORM_ID) &&
514 VerifyField<uint32_t>(verifier, VT_CHRE_PLATFORM_VERSION) &&
515 verifier.EndTable();
516 }
517 };
518
519 struct HubInfoResponseBuilder {
520 typedef HubInfoResponse Table;
521 flatbuffers::FlatBufferBuilder &fbb_;
522 flatbuffers::uoffset_t start_;
523 void add_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> name) {
524 fbb_.AddOffset(HubInfoResponse::VT_NAME, name);
525 }
526 void add_vendor(flatbuffers::Offset<flatbuffers::Vector<int8_t>> vendor) {
527 fbb_.AddOffset(HubInfoResponse::VT_VENDOR, vendor);
528 }
529 void add_toolchain(flatbuffers::Offset<flatbuffers::Vector<int8_t>> toolchain) {
530 fbb_.AddOffset(HubInfoResponse::VT_TOOLCHAIN, toolchain);
531 }
532 void add_platform_version(uint32_t platform_version) {
533 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_PLATFORM_VERSION, platform_version, 0);
534 }
535 void add_toolchain_version(uint32_t toolchain_version) {
536 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_TOOLCHAIN_VERSION, toolchain_version, 0);
537 }
538 void add_peak_mips(float peak_mips) {
539 fbb_.AddElement<float>(HubInfoResponse::VT_PEAK_MIPS, peak_mips, 0.0f);
540 }
541 void add_stopped_power(float stopped_power) {
542 fbb_.AddElement<float>(HubInfoResponse::VT_STOPPED_POWER, stopped_power, 0.0f);
543 }
544 void add_sleep_power(float sleep_power) {
545 fbb_.AddElement<float>(HubInfoResponse::VT_SLEEP_POWER, sleep_power, 0.0f);
546 }
547 void add_peak_power(float peak_power) {
548 fbb_.AddElement<float>(HubInfoResponse::VT_PEAK_POWER, peak_power, 0.0f);
549 }
550 void add_max_msg_len(uint32_t max_msg_len) {
551 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_MAX_MSG_LEN, max_msg_len, 0);
552 }
553 void add_platform_id(uint64_t platform_id) {
554 fbb_.AddElement<uint64_t>(HubInfoResponse::VT_PLATFORM_ID, platform_id, 0);
555 }
556 void add_chre_platform_version(uint32_t chre_platform_version) {
557 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_CHRE_PLATFORM_VERSION, chre_platform_version, 0);
558 }
559 explicit HubInfoResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
560 : fbb_(_fbb) {
561 start_ = fbb_.StartTable();
562 }
563 HubInfoResponseBuilder &operator=(const HubInfoResponseBuilder &);
564 flatbuffers::Offset<HubInfoResponse> Finish() {
565 const auto end = fbb_.EndTable(start_);
566 auto o = flatbuffers::Offset<HubInfoResponse>(end);
567 return o;
568 }
569 };
570
571 inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponse(
572 flatbuffers::FlatBufferBuilder &_fbb,
573 flatbuffers::Offset<flatbuffers::Vector<int8_t>> name = 0,
574 flatbuffers::Offset<flatbuffers::Vector<int8_t>> vendor = 0,
575 flatbuffers::Offset<flatbuffers::Vector<int8_t>> toolchain = 0,
576 uint32_t platform_version = 0,
577 uint32_t toolchain_version = 0,
578 float peak_mips = 0.0f,
579 float stopped_power = 0.0f,
580 float sleep_power = 0.0f,
581 float peak_power = 0.0f,
582 uint32_t max_msg_len = 0,
583 uint64_t platform_id = 0,
584 uint32_t chre_platform_version = 0) {
585 HubInfoResponseBuilder builder_(_fbb);
586 builder_.add_platform_id(platform_id);
587 builder_.add_chre_platform_version(chre_platform_version);
588 builder_.add_max_msg_len(max_msg_len);
589 builder_.add_peak_power(peak_power);
590 builder_.add_sleep_power(sleep_power);
591 builder_.add_stopped_power(stopped_power);
592 builder_.add_peak_mips(peak_mips);
593 builder_.add_toolchain_version(toolchain_version);
594 builder_.add_platform_version(platform_version);
595 builder_.add_toolchain(toolchain);
596 builder_.add_vendor(vendor);
597 builder_.add_name(name);
598 return builder_.Finish();
599 }
600
601 inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponseDirect(
602 flatbuffers::FlatBufferBuilder &_fbb,
603 const std::vector<int8_t> *name = nullptr,
604 const std::vector<int8_t> *vendor = nullptr,
605 const std::vector<int8_t> *toolchain = nullptr,
606 uint32_t platform_version = 0,
607 uint32_t toolchain_version = 0,
608 float peak_mips = 0.0f,
609 float stopped_power = 0.0f,
610 float sleep_power = 0.0f,
611 float peak_power = 0.0f,
612 uint32_t max_msg_len = 0,
613 uint64_t platform_id = 0,
614 uint32_t chre_platform_version = 0) {
615 auto name__ = name ? _fbb.CreateVector<int8_t>(*name) : 0;
616 auto vendor__ = vendor ? _fbb.CreateVector<int8_t>(*vendor) : 0;
617 auto toolchain__ = toolchain ? _fbb.CreateVector<int8_t>(*toolchain) : 0;
618 return chre::fbs::CreateHubInfoResponse(
619 _fbb,
620 name__,
621 vendor__,
622 toolchain__,
623 platform_version,
624 toolchain_version,
625 peak_mips,
626 stopped_power,
627 sleep_power,
628 peak_power,
629 max_msg_len,
630 platform_id,
631 chre_platform_version);
632 }
633
634 struct NanoappListRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
635 typedef NanoappListRequestBuilder Builder;
636 bool Verify(flatbuffers::Verifier &verifier) const {
637 return VerifyTableStart(verifier) &&
638 verifier.EndTable();
639 }
640 };
641
642 struct NanoappListRequestBuilder {
643 typedef NanoappListRequest Table;
644 flatbuffers::FlatBufferBuilder &fbb_;
645 flatbuffers::uoffset_t start_;
646 explicit NanoappListRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
647 : fbb_(_fbb) {
648 start_ = fbb_.StartTable();
649 }
650 NanoappListRequestBuilder &operator=(const NanoappListRequestBuilder &);
651 flatbuffers::Offset<NanoappListRequest> Finish() {
652 const auto end = fbb_.EndTable(start_);
653 auto o = flatbuffers::Offset<NanoappListRequest>(end);
654 return o;
655 }
656 };
657
658 inline flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest(
659 flatbuffers::FlatBufferBuilder &_fbb) {
660 NanoappListRequestBuilder builder_(_fbb);
661 return builder_.Finish();
662 }
663
664 struct NanoappListEntry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
665 typedef NanoappListEntryBuilder Builder;
666 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
667 VT_APP_ID = 4,
668 VT_VERSION = 6,
669 VT_ENABLED = 8,
670 VT_IS_SYSTEM = 10
671 };
672 uint64_t app_id() const {
673 return GetField<uint64_t>(VT_APP_ID, 0);
674 }
675 uint32_t version() const {
676 return GetField<uint32_t>(VT_VERSION, 0);
677 }
678 bool enabled() const {
679 return GetField<uint8_t>(VT_ENABLED, 1) != 0;
680 }
681 /// Whether the nanoapp is a pre-loaded "system" nanoapp, i.e. one that should
682 /// not show up in the list of nanoapps in the context hub HAL. System
683 /// nanoapps are typically used to leverage CHRE for some device functionality
684 /// and do not interact via the context hub HAL.
685 bool is_system() const {
686 return GetField<uint8_t>(VT_IS_SYSTEM, 0) != 0;
687 }
688 bool Verify(flatbuffers::Verifier &verifier) const {
689 return VerifyTableStart(verifier) &&
690 VerifyField<uint64_t>(verifier, VT_APP_ID) &&
691 VerifyField<uint32_t>(verifier, VT_VERSION) &&
692 VerifyField<uint8_t>(verifier, VT_ENABLED) &&
693 VerifyField<uint8_t>(verifier, VT_IS_SYSTEM) &&
694 verifier.EndTable();
695 }
696 };
697
698 struct NanoappListEntryBuilder {
699 typedef NanoappListEntry Table;
700 flatbuffers::FlatBufferBuilder &fbb_;
701 flatbuffers::uoffset_t start_;
702 void add_app_id(uint64_t app_id) {
703 fbb_.AddElement<uint64_t>(NanoappListEntry::VT_APP_ID, app_id, 0);
704 }
705 void add_version(uint32_t version) {
706 fbb_.AddElement<uint32_t>(NanoappListEntry::VT_VERSION, version, 0);
707 }
708 void add_enabled(bool enabled) {
709 fbb_.AddElement<uint8_t>(NanoappListEntry::VT_ENABLED, static_cast<uint8_t>(enabled), 1);
710 }
711 void add_is_system(bool is_system) {
712 fbb_.AddElement<uint8_t>(NanoappListEntry::VT_IS_SYSTEM, static_cast<uint8_t>(is_system), 0);
713 }
714 explicit NanoappListEntryBuilder(flatbuffers::FlatBufferBuilder &_fbb)
715 : fbb_(_fbb) {
716 start_ = fbb_.StartTable();
717 }
718 NanoappListEntryBuilder &operator=(const NanoappListEntryBuilder &);
719 flatbuffers::Offset<NanoappListEntry> Finish() {
720 const auto end = fbb_.EndTable(start_);
721 auto o = flatbuffers::Offset<NanoappListEntry>(end);
722 return o;
723 }
724 };
725
726 inline flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntry(
727 flatbuffers::FlatBufferBuilder &_fbb,
728 uint64_t app_id = 0,
729 uint32_t version = 0,
730 bool enabled = true,
731 bool is_system = false) {
732 NanoappListEntryBuilder builder_(_fbb);
733 builder_.add_app_id(app_id);
734 builder_.add_version(version);
735 builder_.add_is_system(is_system);
736 builder_.add_enabled(enabled);
737 return builder_.Finish();
738 }
739
740 struct NanoappListResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
741 typedef NanoappListResponseBuilder Builder;
742 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
743 VT_NANOAPPS = 4
744 };
745 const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>> *nanoapps() const {
746 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>> *>(VT_NANOAPPS);
747 }
748 bool Verify(flatbuffers::Verifier &verifier) const {
749 return VerifyTableStart(verifier) &&
750 VerifyOffsetRequired(verifier, VT_NANOAPPS) &&
751 verifier.VerifyVector(nanoapps()) &&
752 verifier.VerifyVectorOfTables(nanoapps()) &&
753 verifier.EndTable();
754 }
755 };
756
757 struct NanoappListResponseBuilder {
758 typedef NanoappListResponse Table;
759 flatbuffers::FlatBufferBuilder &fbb_;
760 flatbuffers::uoffset_t start_;
761 void add_nanoapps(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>>> nanoapps) {
762 fbb_.AddOffset(NanoappListResponse::VT_NANOAPPS, nanoapps);
763 }
764 explicit NanoappListResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
765 : fbb_(_fbb) {
766 start_ = fbb_.StartTable();
767 }
768 NanoappListResponseBuilder &operator=(const NanoappListResponseBuilder &);
769 flatbuffers::Offset<NanoappListResponse> Finish() {
770 const auto end = fbb_.EndTable(start_);
771 auto o = flatbuffers::Offset<NanoappListResponse>(end);
772 fbb_.Required(o, NanoappListResponse::VT_NANOAPPS);
773 return o;
774 }
775 };
776
777 inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse(
778 flatbuffers::FlatBufferBuilder &_fbb,
779 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>>> nanoapps = 0) {
780 NanoappListResponseBuilder builder_(_fbb);
781 builder_.add_nanoapps(nanoapps);
782 return builder_.Finish();
783 }
784
785 inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponseDirect(
786 flatbuffers::FlatBufferBuilder &_fbb,
787 const std::vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>> *nanoapps = nullptr) {
788 auto nanoapps__ = nanoapps ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::NanoappListEntry>>(*nanoapps) : 0;
789 return chre::fbs::CreateNanoappListResponse(
790 _fbb,
791 nanoapps__);
792 }
793
794 /// Represents a request for loading a nanoapp.
795 /// The nanaopp can either be requested to be loaded via a file or via a buffer.
796 /// For loading via a file, the following steps will be taken:
797 /// 1. The loader sends a LoadNanoappRequest message to CHRE. app_binary must
798 /// be set for legacy purposes, but should be empty. Additionally,
799 /// fragment_id and total_app_size are unused in this request. The loading
800 /// that happens as part of this request is serialized, but asynchronous
801 /// meaning that load requests will be processed in the order they are sent
802 /// but multiple requests can be outstanding at any given time.
803 /// 2. CHRE stores the filename and waits until its event loop is able to
804 /// process the request.
805 /// 3. Once ready, the nanoapp will be loaded from the file specified in the
806 /// original request and will send a callback indicating the
807 /// completion/failure of the request.
808 /// For loading via a buffer, loading may optionally be fragmented into multiple
809 /// sequential requests, which will follow the following steps:
810 /// 1. The loader sends a LoadNanoappRequest message to CHRE. If the request
811 /// is fragmented, then the fields fragment_id and total_app_size must
812 /// be defined. Once the first fragment is sent to CHRE, all subsequent
813 /// fragments must be delivered before a new LoadNanoappRequest can be
814 /// issued. If a new request is received while a current request has
815 /// outstanding fragments, the current request will be overridden with the
816 /// new one.
817 /// 2. CHRE preallocates the required amount of memory, and loads app_binary,
818 /// appending to already loaded fragments as appropriate.
819 /// 3. If the request is fragmented, then the requestor must sequentially send
820 /// multiple LoadNanoappRequest with incremental nanoapp binary fragments.
821 /// CHRE will respond with LoadNanoappResponse for each request. For
822 /// requests starting from the second fragment, all fields except
823 /// fragment_id and app_binary should be ignored by CHRE.
824 ///
825 /// Once the LoadNanoappRepsonse for the last fragment is received
826 /// by the HAL, the HAL client will receive a callback indicating the
827 /// completion/failure of a load request.
828 ///
829 /// If any request fragment is lost, then the entire load request will be
830 /// considered to have failed. If the request times out (e.g. the requestor
831 /// process crashes), then the load request will be cancelled at CHRE and fail.
832 struct LoadNanoappRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
833 typedef LoadNanoappRequestBuilder Builder;
834 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
835 VT_TRANSACTION_ID = 4,
836 VT_APP_ID = 6,
837 VT_APP_VERSION = 8,
838 VT_TARGET_API_VERSION = 10,
839 VT_APP_BINARY = 12,
840 VT_FRAGMENT_ID = 14,
841 VT_TOTAL_APP_SIZE = 16,
842 VT_APP_BINARY_FILE_NAME = 18
843 };
844 uint32_t transaction_id() const {
845 return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
846 }
847 uint64_t app_id() const {
848 return GetField<uint64_t>(VT_APP_ID, 0);
849 }
850 uint32_t app_version() const {
851 return GetField<uint32_t>(VT_APP_VERSION, 0);
852 }
853 uint32_t target_api_version() const {
854 return GetField<uint32_t>(VT_TARGET_API_VERSION, 0);
855 }
856 const flatbuffers::Vector<uint8_t> *app_binary() const {
857 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_APP_BINARY);
858 }
859 /// Fields that are relevant for fragmented loading
860 /// The framgent count starts at 1 and should end at the total number of
861 /// fragments. For clients that do not support fragmented loading, the
862 /// default behavior should be to assume one fragment.
863 uint32_t fragment_id() const {
864 return GetField<uint32_t>(VT_FRAGMENT_ID, 0);
865 }
866 uint32_t total_app_size() const {
867 return GetField<uint32_t>(VT_TOTAL_APP_SIZE, 0);
868 }
869 /// Null-terminated ASCII string containing the file name that contains the
870 /// app binary to be loaded.
871 const flatbuffers::Vector<int8_t> *app_binary_file_name() const {
872 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_APP_BINARY_FILE_NAME);
873 }
874 bool Verify(flatbuffers::Verifier &verifier) const {
875 return VerifyTableStart(verifier) &&
876 VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
877 VerifyField<uint64_t>(verifier, VT_APP_ID) &&
878 VerifyField<uint32_t>(verifier, VT_APP_VERSION) &&
879 VerifyField<uint32_t>(verifier, VT_TARGET_API_VERSION) &&
880 VerifyOffsetRequired(verifier, VT_APP_BINARY) &&
881 verifier.VerifyVector(app_binary()) &&
882 VerifyField<uint32_t>(verifier, VT_FRAGMENT_ID) &&
883 VerifyField<uint32_t>(verifier, VT_TOTAL_APP_SIZE) &&
884 VerifyOffset(verifier, VT_APP_BINARY_FILE_NAME) &&
885 verifier.VerifyVector(app_binary_file_name()) &&
886 verifier.EndTable();
887 }
888 };
889
890 struct LoadNanoappRequestBuilder {
891 typedef LoadNanoappRequest Table;
892 flatbuffers::FlatBufferBuilder &fbb_;
893 flatbuffers::uoffset_t start_;
894 void add_transaction_id(uint32_t transaction_id) {
895 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TRANSACTION_ID, transaction_id, 0);
896 }
897 void add_app_id(uint64_t app_id) {
898 fbb_.AddElement<uint64_t>(LoadNanoappRequest::VT_APP_ID, app_id, 0);
899 }
900 void add_app_version(uint32_t app_version) {
901 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_APP_VERSION, app_version, 0);
902 }
903 void add_target_api_version(uint32_t target_api_version) {
904 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TARGET_API_VERSION, target_api_version, 0);
905 }
906 void add_app_binary(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary) {
907 fbb_.AddOffset(LoadNanoappRequest::VT_APP_BINARY, app_binary);
908 }
909 void add_fragment_id(uint32_t fragment_id) {
910 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_FRAGMENT_ID, fragment_id, 0);
911 }
912 void add_total_app_size(uint32_t total_app_size) {
913 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TOTAL_APP_SIZE, total_app_size, 0);
914 }
915 void add_app_binary_file_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> app_binary_file_name) {
916 fbb_.AddOffset(LoadNanoappRequest::VT_APP_BINARY_FILE_NAME, app_binary_file_name);
917 }
918 explicit LoadNanoappRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
919 : fbb_(_fbb) {
920 start_ = fbb_.StartTable();
921 }
922 LoadNanoappRequestBuilder &operator=(const LoadNanoappRequestBuilder &);
923 flatbuffers::Offset<LoadNanoappRequest> Finish() {
924 const auto end = fbb_.EndTable(start_);
925 auto o = flatbuffers::Offset<LoadNanoappRequest>(end);
926 fbb_.Required(o, LoadNanoappRequest::VT_APP_BINARY);
927 return o;
928 }
929 };
930
931 inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest(
932 flatbuffers::FlatBufferBuilder &_fbb,
933 uint32_t transaction_id = 0,
934 uint64_t app_id = 0,
935 uint32_t app_version = 0,
936 uint32_t target_api_version = 0,
937 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary = 0,
938 uint32_t fragment_id = 0,
939 uint32_t total_app_size = 0,
940 flatbuffers::Offset<flatbuffers::Vector<int8_t>> app_binary_file_name = 0) {
941 LoadNanoappRequestBuilder builder_(_fbb);
942 builder_.add_app_id(app_id);
943 builder_.add_app_binary_file_name(app_binary_file_name);
944 builder_.add_total_app_size(total_app_size);
945 builder_.add_fragment_id(fragment_id);
946 builder_.add_app_binary(app_binary);
947 builder_.add_target_api_version(target_api_version);
948 builder_.add_app_version(app_version);
949 builder_.add_transaction_id(transaction_id);
950 return builder_.Finish();
951 }
952
953 inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequestDirect(
954 flatbuffers::FlatBufferBuilder &_fbb,
955 uint32_t transaction_id = 0,
956 uint64_t app_id = 0,
957 uint32_t app_version = 0,
958 uint32_t target_api_version = 0,
959 const std::vector<uint8_t> *app_binary = nullptr,
960 uint32_t fragment_id = 0,
961 uint32_t total_app_size = 0,
962 const std::vector<int8_t> *app_binary_file_name = nullptr) {
963 auto app_binary__ = app_binary ? _fbb.CreateVector<uint8_t>(*app_binary) : 0;
964 auto app_binary_file_name__ = app_binary_file_name ? _fbb.CreateVector<int8_t>(*app_binary_file_name) : 0;
965 return chre::fbs::CreateLoadNanoappRequest(
966 _fbb,
967 transaction_id,
968 app_id,
969 app_version,
970 target_api_version,
971 app_binary__,
972 fragment_id,
973 total_app_size,
974 app_binary_file_name__);
975 }
976
977 struct LoadNanoappResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
978 typedef LoadNanoappResponseBuilder Builder;
979 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
980 VT_TRANSACTION_ID = 4,
981 VT_SUCCESS = 6,
982 VT_FRAGMENT_ID = 8
983 };
984 uint32_t transaction_id() const {
985 return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
986 }
987 /// Denotes whether a load request succeeded or failed.
988 /// If any fragment of a load request fails, the entire load request for
989 /// the same transaction will fail.
990 bool success() const {
991 return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
992 }
993 /// The fragment count of the load reponse is for.
994 uint32_t fragment_id() const {
995 return GetField<uint32_t>(VT_FRAGMENT_ID, 0);
996 }
997 bool Verify(flatbuffers::Verifier &verifier) const {
998 return VerifyTableStart(verifier) &&
999 VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
1000 VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
1001 VerifyField<uint32_t>(verifier, VT_FRAGMENT_ID) &&
1002 verifier.EndTable();
1003 }
1004 };
1005
1006 struct LoadNanoappResponseBuilder {
1007 typedef LoadNanoappResponse Table;
1008 flatbuffers::FlatBufferBuilder &fbb_;
1009 flatbuffers::uoffset_t start_;
1010 void add_transaction_id(uint32_t transaction_id) {
1011 fbb_.AddElement<uint32_t>(LoadNanoappResponse::VT_TRANSACTION_ID, transaction_id, 0);
1012 }
1013 void add_success(bool success) {
1014 fbb_.AddElement<uint8_t>(LoadNanoappResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0);
1015 }
1016 void add_fragment_id(uint32_t fragment_id) {
1017 fbb_.AddElement<uint32_t>(LoadNanoappResponse::VT_FRAGMENT_ID, fragment_id, 0);
1018 }
1019 explicit LoadNanoappResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1020 : fbb_(_fbb) {
1021 start_ = fbb_.StartTable();
1022 }
1023 LoadNanoappResponseBuilder &operator=(const LoadNanoappResponseBuilder &);
1024 flatbuffers::Offset<LoadNanoappResponse> Finish() {
1025 const auto end = fbb_.EndTable(start_);
1026 auto o = flatbuffers::Offset<LoadNanoappResponse>(end);
1027 return o;
1028 }
1029 };
1030
1031 inline flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse(
1032 flatbuffers::FlatBufferBuilder &_fbb,
1033 uint32_t transaction_id = 0,
1034 bool success = false,
1035 uint32_t fragment_id = 0) {
1036 LoadNanoappResponseBuilder builder_(_fbb);
1037 builder_.add_fragment_id(fragment_id);
1038 builder_.add_transaction_id(transaction_id);
1039 builder_.add_success(success);
1040 return builder_.Finish();
1041 }
1042
1043 struct UnloadNanoappRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1044 typedef UnloadNanoappRequestBuilder Builder;
1045 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1046 VT_TRANSACTION_ID = 4,
1047 VT_APP_ID = 6,
1048 VT_ALLOW_SYSTEM_NANOAPP_UNLOAD = 8
1049 };
1050 uint32_t transaction_id() const {
1051 return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
1052 }
1053 uint64_t app_id() const {
1054 return GetField<uint64_t>(VT_APP_ID, 0);
1055 }
1056 /// Set to true to allow this request to unload nanoapps identified as "system
1057 /// nanoapps", i.e. ones with is_system set to true in NanoappListResponse.
1058 bool allow_system_nanoapp_unload() const {
1059 return GetField<uint8_t>(VT_ALLOW_SYSTEM_NANOAPP_UNLOAD, 0) != 0;
1060 }
1061 bool Verify(flatbuffers::Verifier &verifier) const {
1062 return VerifyTableStart(verifier) &&
1063 VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
1064 VerifyField<uint64_t>(verifier, VT_APP_ID) &&
1065 VerifyField<uint8_t>(verifier, VT_ALLOW_SYSTEM_NANOAPP_UNLOAD) &&
1066 verifier.EndTable();
1067 }
1068 };
1069
1070 struct UnloadNanoappRequestBuilder {
1071 typedef UnloadNanoappRequest Table;
1072 flatbuffers::FlatBufferBuilder &fbb_;
1073 flatbuffers::uoffset_t start_;
1074 void add_transaction_id(uint32_t transaction_id) {
1075 fbb_.AddElement<uint32_t>(UnloadNanoappRequest::VT_TRANSACTION_ID, transaction_id, 0);
1076 }
1077 void add_app_id(uint64_t app_id) {
1078 fbb_.AddElement<uint64_t>(UnloadNanoappRequest::VT_APP_ID, app_id, 0);
1079 }
1080 void add_allow_system_nanoapp_unload(bool allow_system_nanoapp_unload) {
1081 fbb_.AddElement<uint8_t>(UnloadNanoappRequest::VT_ALLOW_SYSTEM_NANOAPP_UNLOAD, static_cast<uint8_t>(allow_system_nanoapp_unload), 0);
1082 }
1083 explicit UnloadNanoappRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1084 : fbb_(_fbb) {
1085 start_ = fbb_.StartTable();
1086 }
1087 UnloadNanoappRequestBuilder &operator=(const UnloadNanoappRequestBuilder &);
1088 flatbuffers::Offset<UnloadNanoappRequest> Finish() {
1089 const auto end = fbb_.EndTable(start_);
1090 auto o = flatbuffers::Offset<UnloadNanoappRequest>(end);
1091 return o;
1092 }
1093 };
1094
1095 inline flatbuffers::Offset<UnloadNanoappRequest> CreateUnloadNanoappRequest(
1096 flatbuffers::FlatBufferBuilder &_fbb,
1097 uint32_t transaction_id = 0,
1098 uint64_t app_id = 0,
1099 bool allow_system_nanoapp_unload = false) {
1100 UnloadNanoappRequestBuilder builder_(_fbb);
1101 builder_.add_app_id(app_id);
1102 builder_.add_transaction_id(transaction_id);
1103 builder_.add_allow_system_nanoapp_unload(allow_system_nanoapp_unload);
1104 return builder_.Finish();
1105 }
1106
1107 struct UnloadNanoappResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1108 typedef UnloadNanoappResponseBuilder Builder;
1109 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1110 VT_TRANSACTION_ID = 4,
1111 VT_SUCCESS = 6
1112 };
1113 uint32_t transaction_id() const {
1114 return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
1115 }
1116 bool success() const {
1117 return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
1118 }
1119 bool Verify(flatbuffers::Verifier &verifier) const {
1120 return VerifyTableStart(verifier) &&
1121 VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
1122 VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
1123 verifier.EndTable();
1124 }
1125 };
1126
1127 struct UnloadNanoappResponseBuilder {
1128 typedef UnloadNanoappResponse Table;
1129 flatbuffers::FlatBufferBuilder &fbb_;
1130 flatbuffers::uoffset_t start_;
1131 void add_transaction_id(uint32_t transaction_id) {
1132 fbb_.AddElement<uint32_t>(UnloadNanoappResponse::VT_TRANSACTION_ID, transaction_id, 0);
1133 }
1134 void add_success(bool success) {
1135 fbb_.AddElement<uint8_t>(UnloadNanoappResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0);
1136 }
1137 explicit UnloadNanoappResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1138 : fbb_(_fbb) {
1139 start_ = fbb_.StartTable();
1140 }
1141 UnloadNanoappResponseBuilder &operator=(const UnloadNanoappResponseBuilder &);
1142 flatbuffers::Offset<UnloadNanoappResponse> Finish() {
1143 const auto end = fbb_.EndTable(start_);
1144 auto o = flatbuffers::Offset<UnloadNanoappResponse>(end);
1145 return o;
1146 }
1147 };
1148
1149 inline flatbuffers::Offset<UnloadNanoappResponse> CreateUnloadNanoappResponse(
1150 flatbuffers::FlatBufferBuilder &_fbb,
1151 uint32_t transaction_id = 0,
1152 bool success = false) {
1153 UnloadNanoappResponseBuilder builder_(_fbb);
1154 builder_.add_transaction_id(transaction_id);
1155 builder_.add_success(success);
1156 return builder_.Finish();
1157 }
1158
1159 /// Represents log messages from CHRE.
1160 struct LogMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1161 typedef LogMessageBuilder Builder;
1162 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1163 VT_BUFFER = 4
1164 };
1165 /// A buffer containing formatted log data. A flat array is used here to avoid
1166 /// overhead in serializing and deserializing. The format is as follows:
1167 ///
1168 /// uint8_t - log level (1 = error, 2 = warning,
1169 /// 3 = info, 4 = debug)
1170 /// uint64_t, little-endian - timestamp in nanoseconds
1171 /// char[] - message to log
1172 /// char, \0 - null-terminator
1173 ///
1174 /// This pattern repeats until the end of the buffer for multiple log
1175 /// messages. The last byte will always be a null-terminator. There are no
1176 /// padding bytes between these fields. Treat this like a packed struct and be
1177 /// cautious with unaligned access when reading/writing this buffer.
1178 const flatbuffers::Vector<int8_t> *buffer() const {
1179 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_BUFFER);
1180 }
1181 bool Verify(flatbuffers::Verifier &verifier) const {
1182 return VerifyTableStart(verifier) &&
1183 VerifyOffset(verifier, VT_BUFFER) &&
1184 verifier.VerifyVector(buffer()) &&
1185 verifier.EndTable();
1186 }
1187 };
1188
1189 struct LogMessageBuilder {
1190 typedef LogMessage Table;
1191 flatbuffers::FlatBufferBuilder &fbb_;
1192 flatbuffers::uoffset_t start_;
1193 void add_buffer(flatbuffers::Offset<flatbuffers::Vector<int8_t>> buffer) {
1194 fbb_.AddOffset(LogMessage::VT_BUFFER, buffer);
1195 }
1196 explicit LogMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1197 : fbb_(_fbb) {
1198 start_ = fbb_.StartTable();
1199 }
1200 LogMessageBuilder &operator=(const LogMessageBuilder &);
1201 flatbuffers::Offset<LogMessage> Finish() {
1202 const auto end = fbb_.EndTable(start_);
1203 auto o = flatbuffers::Offset<LogMessage>(end);
1204 return o;
1205 }
1206 };
1207
1208 inline flatbuffers::Offset<LogMessage> CreateLogMessage(
1209 flatbuffers::FlatBufferBuilder &_fbb,
1210 flatbuffers::Offset<flatbuffers::Vector<int8_t>> buffer = 0) {
1211 LogMessageBuilder builder_(_fbb);
1212 builder_.add_buffer(buffer);
1213 return builder_.Finish();
1214 }
1215
1216 inline flatbuffers::Offset<LogMessage> CreateLogMessageDirect(
1217 flatbuffers::FlatBufferBuilder &_fbb,
1218 const std::vector<int8_t> *buffer = nullptr) {
1219 auto buffer__ = buffer ? _fbb.CreateVector<int8_t>(*buffer) : 0;
1220 return chre::fbs::CreateLogMessage(
1221 _fbb,
1222 buffer__);
1223 }
1224
1225 /// Represents a message sent to CHRE to indicate AP timestamp for time sync
1226 struct TimeSyncMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1227 typedef TimeSyncMessageBuilder Builder;
1228 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1229 VT_OFFSET = 4
1230 };
1231 /// Offset between AP and CHRE timestamp
1232 int64_t offset() const {
1233 return GetField<int64_t>(VT_OFFSET, 0);
1234 }
1235 bool Verify(flatbuffers::Verifier &verifier) const {
1236 return VerifyTableStart(verifier) &&
1237 VerifyField<int64_t>(verifier, VT_OFFSET) &&
1238 verifier.EndTable();
1239 }
1240 };
1241
1242 struct TimeSyncMessageBuilder {
1243 typedef TimeSyncMessage Table;
1244 flatbuffers::FlatBufferBuilder &fbb_;
1245 flatbuffers::uoffset_t start_;
1246 void add_offset(int64_t offset) {
1247 fbb_.AddElement<int64_t>(TimeSyncMessage::VT_OFFSET, offset, 0);
1248 }
1249 explicit TimeSyncMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1250 : fbb_(_fbb) {
1251 start_ = fbb_.StartTable();
1252 }
1253 TimeSyncMessageBuilder &operator=(const TimeSyncMessageBuilder &);
1254 flatbuffers::Offset<TimeSyncMessage> Finish() {
1255 const auto end = fbb_.EndTable(start_);
1256 auto o = flatbuffers::Offset<TimeSyncMessage>(end);
1257 return o;
1258 }
1259 };
1260
1261 inline flatbuffers::Offset<TimeSyncMessage> CreateTimeSyncMessage(
1262 flatbuffers::FlatBufferBuilder &_fbb,
1263 int64_t offset = 0) {
1264 TimeSyncMessageBuilder builder_(_fbb);
1265 builder_.add_offset(offset);
1266 return builder_.Finish();
1267 }
1268
1269 /// A request to gather and return debugging information. Only one debug dump
1270 /// session can be active at a time. Upon accepting a request, zero or more
1271 /// DebugDumpData messages are generated, followed by a DebugDumpResponse
1272 /// indicating the completion of the operation.
1273 struct DebugDumpRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1274 typedef DebugDumpRequestBuilder Builder;
1275 bool Verify(flatbuffers::Verifier &verifier) const {
1276 return VerifyTableStart(verifier) &&
1277 verifier.EndTable();
1278 }
1279 };
1280
1281 struct DebugDumpRequestBuilder {
1282 typedef DebugDumpRequest Table;
1283 flatbuffers::FlatBufferBuilder &fbb_;
1284 flatbuffers::uoffset_t start_;
1285 explicit DebugDumpRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1286 : fbb_(_fbb) {
1287 start_ = fbb_.StartTable();
1288 }
1289 DebugDumpRequestBuilder &operator=(const DebugDumpRequestBuilder &);
1290 flatbuffers::Offset<DebugDumpRequest> Finish() {
1291 const auto end = fbb_.EndTable(start_);
1292 auto o = flatbuffers::Offset<DebugDumpRequest>(end);
1293 return o;
1294 }
1295 };
1296
1297 inline flatbuffers::Offset<DebugDumpRequest> CreateDebugDumpRequest(
1298 flatbuffers::FlatBufferBuilder &_fbb) {
1299 DebugDumpRequestBuilder builder_(_fbb);
1300 return builder_.Finish();
1301 }
1302
1303 struct DebugDumpData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1304 typedef DebugDumpDataBuilder Builder;
1305 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1306 VT_DEBUG_STR = 4
1307 };
1308 /// Null-terminated ASCII string containing debugging information
1309 const flatbuffers::Vector<int8_t> *debug_str() const {
1310 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_DEBUG_STR);
1311 }
1312 bool Verify(flatbuffers::Verifier &verifier) const {
1313 return VerifyTableStart(verifier) &&
1314 VerifyOffset(verifier, VT_DEBUG_STR) &&
1315 verifier.VerifyVector(debug_str()) &&
1316 verifier.EndTable();
1317 }
1318 };
1319
1320 struct DebugDumpDataBuilder {
1321 typedef DebugDumpData Table;
1322 flatbuffers::FlatBufferBuilder &fbb_;
1323 flatbuffers::uoffset_t start_;
1324 void add_debug_str(flatbuffers::Offset<flatbuffers::Vector<int8_t>> debug_str) {
1325 fbb_.AddOffset(DebugDumpData::VT_DEBUG_STR, debug_str);
1326 }
1327 explicit DebugDumpDataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1328 : fbb_(_fbb) {
1329 start_ = fbb_.StartTable();
1330 }
1331 DebugDumpDataBuilder &operator=(const DebugDumpDataBuilder &);
1332 flatbuffers::Offset<DebugDumpData> Finish() {
1333 const auto end = fbb_.EndTable(start_);
1334 auto o = flatbuffers::Offset<DebugDumpData>(end);
1335 return o;
1336 }
1337 };
1338
1339 inline flatbuffers::Offset<DebugDumpData> CreateDebugDumpData(
1340 flatbuffers::FlatBufferBuilder &_fbb,
1341 flatbuffers::Offset<flatbuffers::Vector<int8_t>> debug_str = 0) {
1342 DebugDumpDataBuilder builder_(_fbb);
1343 builder_.add_debug_str(debug_str);
1344 return builder_.Finish();
1345 }
1346
1347 inline flatbuffers::Offset<DebugDumpData> CreateDebugDumpDataDirect(
1348 flatbuffers::FlatBufferBuilder &_fbb,
1349 const std::vector<int8_t> *debug_str = nullptr) {
1350 auto debug_str__ = debug_str ? _fbb.CreateVector<int8_t>(*debug_str) : 0;
1351 return chre::fbs::CreateDebugDumpData(
1352 _fbb,
1353 debug_str__);
1354 }
1355
1356 struct DebugDumpResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1357 typedef DebugDumpResponseBuilder Builder;
1358 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1359 VT_SUCCESS = 4,
1360 VT_DATA_COUNT = 6
1361 };
1362 /// true if the request was accepted and a dump was performed, false if it was
1363 /// rejected or failed to complete for some reason
1364 bool success() const {
1365 return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
1366 }
1367 /// The number of DebugDumpData messages sent in this session
1368 uint32_t data_count() const {
1369 return GetField<uint32_t>(VT_DATA_COUNT, 0);
1370 }
1371 bool Verify(flatbuffers::Verifier &verifier) const {
1372 return VerifyTableStart(verifier) &&
1373 VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
1374 VerifyField<uint32_t>(verifier, VT_DATA_COUNT) &&
1375 verifier.EndTable();
1376 }
1377 };
1378
1379 struct DebugDumpResponseBuilder {
1380 typedef DebugDumpResponse Table;
1381 flatbuffers::FlatBufferBuilder &fbb_;
1382 flatbuffers::uoffset_t start_;
1383 void add_success(bool success) {
1384 fbb_.AddElement<uint8_t>(DebugDumpResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0);
1385 }
1386 void add_data_count(uint32_t data_count) {
1387 fbb_.AddElement<uint32_t>(DebugDumpResponse::VT_DATA_COUNT, data_count, 0);
1388 }
1389 explicit DebugDumpResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1390 : fbb_(_fbb) {
1391 start_ = fbb_.StartTable();
1392 }
1393 DebugDumpResponseBuilder &operator=(const DebugDumpResponseBuilder &);
1394 flatbuffers::Offset<DebugDumpResponse> Finish() {
1395 const auto end = fbb_.EndTable(start_);
1396 auto o = flatbuffers::Offset<DebugDumpResponse>(end);
1397 return o;
1398 }
1399 };
1400
1401 inline flatbuffers::Offset<DebugDumpResponse> CreateDebugDumpResponse(
1402 flatbuffers::FlatBufferBuilder &_fbb,
1403 bool success = false,
1404 uint32_t data_count = 0) {
1405 DebugDumpResponseBuilder builder_(_fbb);
1406 builder_.add_data_count(data_count);
1407 builder_.add_success(success);
1408 return builder_.Finish();
1409 }
1410
1411 /// A request from CHRE for host to initiate a time sync message
1412 /// (system feature, platform-specific - not all platforms necessarily use this)
1413 struct TimeSyncRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1414 typedef TimeSyncRequestBuilder Builder;
1415 bool Verify(flatbuffers::Verifier &verifier) const {
1416 return VerifyTableStart(verifier) &&
1417 verifier.EndTable();
1418 }
1419 };
1420
1421 struct TimeSyncRequestBuilder {
1422 typedef TimeSyncRequest Table;
1423 flatbuffers::FlatBufferBuilder &fbb_;
1424 flatbuffers::uoffset_t start_;
1425 explicit TimeSyncRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1426 : fbb_(_fbb) {
1427 start_ = fbb_.StartTable();
1428 }
1429 TimeSyncRequestBuilder &operator=(const TimeSyncRequestBuilder &);
1430 flatbuffers::Offset<TimeSyncRequest> Finish() {
1431 const auto end = fbb_.EndTable(start_);
1432 auto o = flatbuffers::Offset<TimeSyncRequest>(end);
1433 return o;
1434 }
1435 };
1436
1437 inline flatbuffers::Offset<TimeSyncRequest> CreateTimeSyncRequest(
1438 flatbuffers::FlatBufferBuilder &_fbb) {
1439 TimeSyncRequestBuilder builder_(_fbb);
1440 return builder_.Finish();
1441 }
1442
1443 /// Request from CHRE to enable direct access to data from the low-power
1444 /// microphone. On some systems, coordination via the AP (e.g. with
1445 /// SoundTrigger HAL) is needed to ensure this capability is powered up when
1446 /// CHRE needs it. The host does not send a response.
1447 struct LowPowerMicAccessRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1448 typedef LowPowerMicAccessRequestBuilder Builder;
1449 bool Verify(flatbuffers::Verifier &verifier) const {
1450 return VerifyTableStart(verifier) &&
1451 verifier.EndTable();
1452 }
1453 };
1454
1455 struct LowPowerMicAccessRequestBuilder {
1456 typedef LowPowerMicAccessRequest Table;
1457 flatbuffers::FlatBufferBuilder &fbb_;
1458 flatbuffers::uoffset_t start_;
1459 explicit LowPowerMicAccessRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1460 : fbb_(_fbb) {
1461 start_ = fbb_.StartTable();
1462 }
1463 LowPowerMicAccessRequestBuilder &operator=(const LowPowerMicAccessRequestBuilder &);
1464 flatbuffers::Offset<LowPowerMicAccessRequest> Finish() {
1465 const auto end = fbb_.EndTable(start_);
1466 auto o = flatbuffers::Offset<LowPowerMicAccessRequest>(end);
1467 return o;
1468 }
1469 };
1470
1471 inline flatbuffers::Offset<LowPowerMicAccessRequest> CreateLowPowerMicAccessRequest(
1472 flatbuffers::FlatBufferBuilder &_fbb) {
1473 LowPowerMicAccessRequestBuilder builder_(_fbb);
1474 return builder_.Finish();
1475 }
1476
1477 /// Notification from CHRE that it no longer needs direct access to low-power
1478 /// microphone data.
1479 struct LowPowerMicAccessRelease FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1480 typedef LowPowerMicAccessReleaseBuilder Builder;
1481 bool Verify(flatbuffers::Verifier &verifier) const {
1482 return VerifyTableStart(verifier) &&
1483 verifier.EndTable();
1484 }
1485 };
1486
1487 struct LowPowerMicAccessReleaseBuilder {
1488 typedef LowPowerMicAccessRelease Table;
1489 flatbuffers::FlatBufferBuilder &fbb_;
1490 flatbuffers::uoffset_t start_;
1491 explicit LowPowerMicAccessReleaseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1492 : fbb_(_fbb) {
1493 start_ = fbb_.StartTable();
1494 }
1495 LowPowerMicAccessReleaseBuilder &operator=(const LowPowerMicAccessReleaseBuilder &);
1496 flatbuffers::Offset<LowPowerMicAccessRelease> Finish() {
1497 const auto end = fbb_.EndTable(start_);
1498 auto o = flatbuffers::Offset<LowPowerMicAccessRelease>(end);
1499 return o;
1500 }
1501 };
1502
1503 inline flatbuffers::Offset<LowPowerMicAccessRelease> CreateLowPowerMicAccessRelease(
1504 flatbuffers::FlatBufferBuilder &_fbb) {
1505 LowPowerMicAccessReleaseBuilder builder_(_fbb);
1506 return builder_.Finish();
1507 }
1508
1509 /// Notification from the host that a system setting has changed
1510 struct SettingChangeMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1511 typedef SettingChangeMessageBuilder Builder;
1512 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1513 VT_SETTING = 4,
1514 VT_STATE = 6
1515 };
1516 /// The setting that has changed
1517 chre::fbs::Setting setting() const {
1518 return static_cast<chre::fbs::Setting>(GetField<int8_t>(VT_SETTING, 0));
1519 }
1520 /// The new setting value
1521 chre::fbs::SettingState state() const {
1522 return static_cast<chre::fbs::SettingState>(GetField<int8_t>(VT_STATE, 0));
1523 }
1524 bool Verify(flatbuffers::Verifier &verifier) const {
1525 return VerifyTableStart(verifier) &&
1526 VerifyField<int8_t>(verifier, VT_SETTING) &&
1527 VerifyField<int8_t>(verifier, VT_STATE) &&
1528 verifier.EndTable();
1529 }
1530 };
1531
1532 struct SettingChangeMessageBuilder {
1533 typedef SettingChangeMessage Table;
1534 flatbuffers::FlatBufferBuilder &fbb_;
1535 flatbuffers::uoffset_t start_;
1536 void add_setting(chre::fbs::Setting setting) {
1537 fbb_.AddElement<int8_t>(SettingChangeMessage::VT_SETTING, static_cast<int8_t>(setting), 0);
1538 }
1539 void add_state(chre::fbs::SettingState state) {
1540 fbb_.AddElement<int8_t>(SettingChangeMessage::VT_STATE, static_cast<int8_t>(state), 0);
1541 }
1542 explicit SettingChangeMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1543 : fbb_(_fbb) {
1544 start_ = fbb_.StartTable();
1545 }
1546 SettingChangeMessageBuilder &operator=(const SettingChangeMessageBuilder &);
1547 flatbuffers::Offset<SettingChangeMessage> Finish() {
1548 const auto end = fbb_.EndTable(start_);
1549 auto o = flatbuffers::Offset<SettingChangeMessage>(end);
1550 return o;
1551 }
1552 };
1553
1554 inline flatbuffers::Offset<SettingChangeMessage> CreateSettingChangeMessage(
1555 flatbuffers::FlatBufferBuilder &_fbb,
1556 chre::fbs::Setting setting = chre::fbs::Setting::LOCATION,
1557 chre::fbs::SettingState state = chre::fbs::SettingState::DISABLED) {
1558 SettingChangeMessageBuilder builder_(_fbb);
1559 builder_.add_state(state);
1560 builder_.add_setting(setting);
1561 return builder_.Finish();
1562 }
1563
1564 /// The top-level container that encapsulates all possible messages. Note that
1565 /// per FlatBuffers requirements, we can't use a union as the top-level
1566 /// structure (root type), so we must wrap it in a table.
1567 struct MessageContainer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1568 typedef MessageContainerBuilder Builder;
1569 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1570 VT_MESSAGE_TYPE = 4,
1571 VT_MESSAGE = 6,
1572 VT_HOST_ADDR = 8
1573 };
1574 chre::fbs::ChreMessage message_type() const {
1575 return static_cast<chre::fbs::ChreMessage>(GetField<uint8_t>(VT_MESSAGE_TYPE, 0));
1576 }
1577 const void *message() const {
1578 return GetPointer<const void *>(VT_MESSAGE);
1579 }
1580 template<typename T> const T *message_as() const;
1581 const chre::fbs::NanoappMessage *message_as_NanoappMessage() const {
1582 return message_type() == chre::fbs::ChreMessage::NanoappMessage ? static_cast<const chre::fbs::NanoappMessage *>(message()) : nullptr;
1583 }
1584 const chre::fbs::HubInfoRequest *message_as_HubInfoRequest() const {
1585 return message_type() == chre::fbs::ChreMessage::HubInfoRequest ? static_cast<const chre::fbs::HubInfoRequest *>(message()) : nullptr;
1586 }
1587 const chre::fbs::HubInfoResponse *message_as_HubInfoResponse() const {
1588 return message_type() == chre::fbs::ChreMessage::HubInfoResponse ? static_cast<const chre::fbs::HubInfoResponse *>(message()) : nullptr;
1589 }
1590 const chre::fbs::NanoappListRequest *message_as_NanoappListRequest() const {
1591 return message_type() == chre::fbs::ChreMessage::NanoappListRequest ? static_cast<const chre::fbs::NanoappListRequest *>(message()) : nullptr;
1592 }
1593 const chre::fbs::NanoappListResponse *message_as_NanoappListResponse() const {
1594 return message_type() == chre::fbs::ChreMessage::NanoappListResponse ? static_cast<const chre::fbs::NanoappListResponse *>(message()) : nullptr;
1595 }
1596 const chre::fbs::LoadNanoappRequest *message_as_LoadNanoappRequest() const {
1597 return message_type() == chre::fbs::ChreMessage::LoadNanoappRequest ? static_cast<const chre::fbs::LoadNanoappRequest *>(message()) : nullptr;
1598 }
1599 const chre::fbs::LoadNanoappResponse *message_as_LoadNanoappResponse() const {
1600 return message_type() == chre::fbs::ChreMessage::LoadNanoappResponse ? static_cast<const chre::fbs::LoadNanoappResponse *>(message()) : nullptr;
1601 }
1602 const chre::fbs::UnloadNanoappRequest *message_as_UnloadNanoappRequest() const {
1603 return message_type() == chre::fbs::ChreMessage::UnloadNanoappRequest ? static_cast<const chre::fbs::UnloadNanoappRequest *>(message()) : nullptr;
1604 }
1605 const chre::fbs::UnloadNanoappResponse *message_as_UnloadNanoappResponse() const {
1606 return message_type() == chre::fbs::ChreMessage::UnloadNanoappResponse ? static_cast<const chre::fbs::UnloadNanoappResponse *>(message()) : nullptr;
1607 }
1608 const chre::fbs::LogMessage *message_as_LogMessage() const {
1609 return message_type() == chre::fbs::ChreMessage::LogMessage ? static_cast<const chre::fbs::LogMessage *>(message()) : nullptr;
1610 }
1611 const chre::fbs::TimeSyncMessage *message_as_TimeSyncMessage() const {
1612 return message_type() == chre::fbs::ChreMessage::TimeSyncMessage ? static_cast<const chre::fbs::TimeSyncMessage *>(message()) : nullptr;
1613 }
1614 const chre::fbs::DebugDumpRequest *message_as_DebugDumpRequest() const {
1615 return message_type() == chre::fbs::ChreMessage::DebugDumpRequest ? static_cast<const chre::fbs::DebugDumpRequest *>(message()) : nullptr;
1616 }
1617 const chre::fbs::DebugDumpData *message_as_DebugDumpData() const {
1618 return message_type() == chre::fbs::ChreMessage::DebugDumpData ? static_cast<const chre::fbs::DebugDumpData *>(message()) : nullptr;
1619 }
1620 const chre::fbs::DebugDumpResponse *message_as_DebugDumpResponse() const {
1621 return message_type() == chre::fbs::ChreMessage::DebugDumpResponse ? static_cast<const chre::fbs::DebugDumpResponse *>(message()) : nullptr;
1622 }
1623 const chre::fbs::TimeSyncRequest *message_as_TimeSyncRequest() const {
1624 return message_type() == chre::fbs::ChreMessage::TimeSyncRequest ? static_cast<const chre::fbs::TimeSyncRequest *>(message()) : nullptr;
1625 }
1626 const chre::fbs::LowPowerMicAccessRequest *message_as_LowPowerMicAccessRequest() const {
1627 return message_type() == chre::fbs::ChreMessage::LowPowerMicAccessRequest ? static_cast<const chre::fbs::LowPowerMicAccessRequest *>(message()) : nullptr;
1628 }
1629 const chre::fbs::LowPowerMicAccessRelease *message_as_LowPowerMicAccessRelease() const {
1630 return message_type() == chre::fbs::ChreMessage::LowPowerMicAccessRelease ? static_cast<const chre::fbs::LowPowerMicAccessRelease *>(message()) : nullptr;
1631 }
1632 const chre::fbs::SettingChangeMessage *message_as_SettingChangeMessage() const {
1633 return message_type() == chre::fbs::ChreMessage::SettingChangeMessage ? static_cast<const chre::fbs::SettingChangeMessage *>(message()) : nullptr;
1634 }
1635 /// The originating or destination client ID on the host side, used to direct
1636 /// responses only to the client that sent the request. Although initially
1637 /// populated by the requesting client, this is enforced to be the correct
1638 /// value by the entity guarding access to CHRE.
1639 /// This is wrapped in a struct to ensure that it is always included when
1640 /// encoding the message, so it can be mutated by the host daemon.
1641 const chre::fbs::HostAddress *host_addr() const {
1642 return GetStruct<const chre::fbs::HostAddress *>(VT_HOST_ADDR);
1643 }
1644 bool Verify(flatbuffers::Verifier &verifier) const {
1645 return VerifyTableStart(verifier) &&
1646 VerifyField<uint8_t>(verifier, VT_MESSAGE_TYPE) &&
1647 VerifyOffsetRequired(verifier, VT_MESSAGE) &&
1648 VerifyChreMessage(verifier, message(), message_type()) &&
1649 VerifyFieldRequired<chre::fbs::HostAddress>(verifier, VT_HOST_ADDR) &&
1650 verifier.EndTable();
1651 }
1652 };
1653
1654 template<> inline const chre::fbs::NanoappMessage *MessageContainer::message_as<chre::fbs::NanoappMessage>() const {
1655 return message_as_NanoappMessage();
1656 }
1657
1658 template<> inline const chre::fbs::HubInfoRequest *MessageContainer::message_as<chre::fbs::HubInfoRequest>() const {
1659 return message_as_HubInfoRequest();
1660 }
1661
1662 template<> inline const chre::fbs::HubInfoResponse *MessageContainer::message_as<chre::fbs::HubInfoResponse>() const {
1663 return message_as_HubInfoResponse();
1664 }
1665
1666 template<> inline const chre::fbs::NanoappListRequest *MessageContainer::message_as<chre::fbs::NanoappListRequest>() const {
1667 return message_as_NanoappListRequest();
1668 }
1669
1670 template<> inline const chre::fbs::NanoappListResponse *MessageContainer::message_as<chre::fbs::NanoappListResponse>() const {
1671 return message_as_NanoappListResponse();
1672 }
1673
1674 template<> inline const chre::fbs::LoadNanoappRequest *MessageContainer::message_as<chre::fbs::LoadNanoappRequest>() const {
1675 return message_as_LoadNanoappRequest();
1676 }
1677
1678 template<> inline const chre::fbs::LoadNanoappResponse *MessageContainer::message_as<chre::fbs::LoadNanoappResponse>() const {
1679 return message_as_LoadNanoappResponse();
1680 }
1681
1682 template<> inline const chre::fbs::UnloadNanoappRequest *MessageContainer::message_as<chre::fbs::UnloadNanoappRequest>() const {
1683 return message_as_UnloadNanoappRequest();
1684 }
1685
1686 template<> inline const chre::fbs::UnloadNanoappResponse *MessageContainer::message_as<chre::fbs::UnloadNanoappResponse>() const {
1687 return message_as_UnloadNanoappResponse();
1688 }
1689
1690 template<> inline const chre::fbs::LogMessage *MessageContainer::message_as<chre::fbs::LogMessage>() const {
1691 return message_as_LogMessage();
1692 }
1693
1694 template<> inline const chre::fbs::TimeSyncMessage *MessageContainer::message_as<chre::fbs::TimeSyncMessage>() const {
1695 return message_as_TimeSyncMessage();
1696 }
1697
1698 template<> inline const chre::fbs::DebugDumpRequest *MessageContainer::message_as<chre::fbs::DebugDumpRequest>() const {
1699 return message_as_DebugDumpRequest();
1700 }
1701
1702 template<> inline const chre::fbs::DebugDumpData *MessageContainer::message_as<chre::fbs::DebugDumpData>() const {
1703 return message_as_DebugDumpData();
1704 }
1705
1706 template<> inline const chre::fbs::DebugDumpResponse *MessageContainer::message_as<chre::fbs::DebugDumpResponse>() const {
1707 return message_as_DebugDumpResponse();
1708 }
1709
1710 template<> inline const chre::fbs::TimeSyncRequest *MessageContainer::message_as<chre::fbs::TimeSyncRequest>() const {
1711 return message_as_TimeSyncRequest();
1712 }
1713
1714 template<> inline const chre::fbs::LowPowerMicAccessRequest *MessageContainer::message_as<chre::fbs::LowPowerMicAccessRequest>() const {
1715 return message_as_LowPowerMicAccessRequest();
1716 }
1717
1718 template<> inline const chre::fbs::LowPowerMicAccessRelease *MessageContainer::message_as<chre::fbs::LowPowerMicAccessRelease>() const {
1719 return message_as_LowPowerMicAccessRelease();
1720 }
1721
1722 template<> inline const chre::fbs::SettingChangeMessage *MessageContainer::message_as<chre::fbs::SettingChangeMessage>() const {
1723 return message_as_SettingChangeMessage();
1724 }
1725
1726 struct MessageContainerBuilder {
1727 typedef MessageContainer Table;
1728 flatbuffers::FlatBufferBuilder &fbb_;
1729 flatbuffers::uoffset_t start_;
1730 void add_message_type(chre::fbs::ChreMessage message_type) {
1731 fbb_.AddElement<uint8_t>(MessageContainer::VT_MESSAGE_TYPE, static_cast<uint8_t>(message_type), 0);
1732 }
1733 void add_message(flatbuffers::Offset<void> message) {
1734 fbb_.AddOffset(MessageContainer::VT_MESSAGE, message);
1735 }
1736 void add_host_addr(const chre::fbs::HostAddress *host_addr) {
1737 fbb_.AddStruct(MessageContainer::VT_HOST_ADDR, host_addr);
1738 }
1739 explicit MessageContainerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1740 : fbb_(_fbb) {
1741 start_ = fbb_.StartTable();
1742 }
1743 MessageContainerBuilder &operator=(const MessageContainerBuilder &);
1744 flatbuffers::Offset<MessageContainer> Finish() {
1745 const auto end = fbb_.EndTable(start_);
1746 auto o = flatbuffers::Offset<MessageContainer>(end);
1747 fbb_.Required(o, MessageContainer::VT_MESSAGE);
1748 fbb_.Required(o, MessageContainer::VT_HOST_ADDR);
1749 return o;
1750 }
1751 };
1752
1753 inline flatbuffers::Offset<MessageContainer> CreateMessageContainer(
1754 flatbuffers::FlatBufferBuilder &_fbb,
1755 chre::fbs::ChreMessage message_type = chre::fbs::ChreMessage::NONE,
1756 flatbuffers::Offset<void> message = 0,
1757 const chre::fbs::HostAddress *host_addr = 0) {
1758 MessageContainerBuilder builder_(_fbb);
1759 builder_.add_host_addr(host_addr);
1760 builder_.add_message(message);
1761 builder_.add_message_type(message_type);
1762 return builder_.Finish();
1763 }
1764
1765 inline bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type) {
1766 switch (type) {
1767 case ChreMessage::NONE: {
1768 return true;
1769 }
1770 case ChreMessage::NanoappMessage: {
1771 auto ptr = reinterpret_cast<const chre::fbs::NanoappMessage *>(obj);
1772 return verifier.VerifyTable(ptr);
1773 }
1774 case ChreMessage::HubInfoRequest: {
1775 auto ptr = reinterpret_cast<const chre::fbs::HubInfoRequest *>(obj);
1776 return verifier.VerifyTable(ptr);
1777 }
1778 case ChreMessage::HubInfoResponse: {
1779 auto ptr = reinterpret_cast<const chre::fbs::HubInfoResponse *>(obj);
1780 return verifier.VerifyTable(ptr);
1781 }
1782 case ChreMessage::NanoappListRequest: {
1783 auto ptr = reinterpret_cast<const chre::fbs::NanoappListRequest *>(obj);
1784 return verifier.VerifyTable(ptr);
1785 }
1786 case ChreMessage::NanoappListResponse: {
1787 auto ptr = reinterpret_cast<const chre::fbs::NanoappListResponse *>(obj);
1788 return verifier.VerifyTable(ptr);
1789 }
1790 case ChreMessage::LoadNanoappRequest: {
1791 auto ptr = reinterpret_cast<const chre::fbs::LoadNanoappRequest *>(obj);
1792 return verifier.VerifyTable(ptr);
1793 }
1794 case ChreMessage::LoadNanoappResponse: {
1795 auto ptr = reinterpret_cast<const chre::fbs::LoadNanoappResponse *>(obj);
1796 return verifier.VerifyTable(ptr);
1797 }
1798 case ChreMessage::UnloadNanoappRequest: {
1799 auto ptr = reinterpret_cast<const chre::fbs::UnloadNanoappRequest *>(obj);
1800 return verifier.VerifyTable(ptr);
1801 }
1802 case ChreMessage::UnloadNanoappResponse: {
1803 auto ptr = reinterpret_cast<const chre::fbs::UnloadNanoappResponse *>(obj);
1804 return verifier.VerifyTable(ptr);
1805 }
1806 case ChreMessage::LogMessage: {
1807 auto ptr = reinterpret_cast<const chre::fbs::LogMessage *>(obj);
1808 return verifier.VerifyTable(ptr);
1809 }
1810 case ChreMessage::TimeSyncMessage: {
1811 auto ptr = reinterpret_cast<const chre::fbs::TimeSyncMessage *>(obj);
1812 return verifier.VerifyTable(ptr);
1813 }
1814 case ChreMessage::DebugDumpRequest: {
1815 auto ptr = reinterpret_cast<const chre::fbs::DebugDumpRequest *>(obj);
1816 return verifier.VerifyTable(ptr);
1817 }
1818 case ChreMessage::DebugDumpData: {
1819 auto ptr = reinterpret_cast<const chre::fbs::DebugDumpData *>(obj);
1820 return verifier.VerifyTable(ptr);
1821 }
1822 case ChreMessage::DebugDumpResponse: {
1823 auto ptr = reinterpret_cast<const chre::fbs::DebugDumpResponse *>(obj);
1824 return verifier.VerifyTable(ptr);
1825 }
1826 case ChreMessage::TimeSyncRequest: {
1827 auto ptr = reinterpret_cast<const chre::fbs::TimeSyncRequest *>(obj);
1828 return verifier.VerifyTable(ptr);
1829 }
1830 case ChreMessage::LowPowerMicAccessRequest: {
1831 auto ptr = reinterpret_cast<const chre::fbs::LowPowerMicAccessRequest *>(obj);
1832 return verifier.VerifyTable(ptr);
1833 }
1834 case ChreMessage::LowPowerMicAccessRelease: {
1835 auto ptr = reinterpret_cast<const chre::fbs::LowPowerMicAccessRelease *>(obj);
1836 return verifier.VerifyTable(ptr);
1837 }
1838 case ChreMessage::SettingChangeMessage: {
1839 auto ptr = reinterpret_cast<const chre::fbs::SettingChangeMessage *>(obj);
1840 return verifier.VerifyTable(ptr);
1841 }
1842 default: return true;
1843 }
1844 }
1845
1846 inline bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
1847 if (!values || !types) return !values && !types;
1848 if (values->size() != types->size()) return false;
1849 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
1850 if (!VerifyChreMessage(
1851 verifier, values->Get(i), types->GetEnum<ChreMessage>(i))) {
1852 return false;
1853 }
1854 }
1855 return true;
1856 }
1857
1858 inline const chre::fbs::MessageContainer *GetMessageContainer(const void *buf) {
1859 return flatbuffers::GetRoot<chre::fbs::MessageContainer>(buf);
1860 }
1861
1862 inline const chre::fbs::MessageContainer *GetSizePrefixedMessageContainer(const void *buf) {
1863 return flatbuffers::GetSizePrefixedRoot<chre::fbs::MessageContainer>(buf);
1864 }
1865
1866 inline bool VerifyMessageContainerBuffer(
1867 flatbuffers::Verifier &verifier) {
1868 return verifier.VerifyBuffer<chre::fbs::MessageContainer>(nullptr);
1869 }
1870
1871 inline bool VerifySizePrefixedMessageContainerBuffer(
1872 flatbuffers::Verifier &verifier) {
1873 return verifier.VerifySizePrefixedBuffer<chre::fbs::MessageContainer>(nullptr);
1874 }
1875
1876 inline void FinishMessageContainerBuffer(
1877 flatbuffers::FlatBufferBuilder &fbb,
1878 flatbuffers::Offset<chre::fbs::MessageContainer> root) {
1879 fbb.Finish(root);
1880 }
1881
1882 inline void FinishSizePrefixedMessageContainerBuffer(
1883 flatbuffers::FlatBufferBuilder &fbb,
1884 flatbuffers::Offset<chre::fbs::MessageContainer> root) {
1885 fbb.FinishSizePrefixed(root);
1886 }
1887
1888 } // namespace fbs
1889 } // namespace chre
1890
1891 #endif // FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_
1892