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
14 struct HubInfoRequest;
15
16 struct HubInfoResponse;
17
18 struct NanoappListRequest;
19
20 struct NanoappListEntry;
21
22 struct NanoappListResponse;
23
24 struct LoadNanoappRequest;
25
26 struct LoadNanoappResponse;
27
28 struct HostAddress;
29
30 struct MessageContainer;
31
32 /// A union that joins together all possible messages. Note that in FlatBuffers,
33 /// unions have an implicit type
34 enum class ChreMessage : uint8_t {
35 NONE = 0,
36 NanoappMessage = 1,
37 HubInfoRequest = 2,
38 HubInfoResponse = 3,
39 NanoappListRequest = 4,
40 NanoappListResponse = 5,
41 LoadNanoappRequest = 6,
42 LoadNanoappResponse = 7,
43 MIN = NONE,
44 MAX = LoadNanoappResponse
45 };
46
EnumNamesChreMessage()47 inline const char **EnumNamesChreMessage() {
48 static const char *names[] = {
49 "NONE",
50 "NanoappMessage",
51 "HubInfoRequest",
52 "HubInfoResponse",
53 "NanoappListRequest",
54 "NanoappListResponse",
55 "LoadNanoappRequest",
56 "LoadNanoappResponse",
57 nullptr
58 };
59 return names;
60 }
61
EnumNameChreMessage(ChreMessage e)62 inline const char *EnumNameChreMessage(ChreMessage e) {
63 const size_t index = static_cast<int>(e);
64 return EnumNamesChreMessage()[index];
65 }
66
67 template<typename T> struct ChreMessageTraits {
68 static const ChreMessage enum_value = ChreMessage::NONE;
69 };
70
71 template<> struct ChreMessageTraits<NanoappMessage> {
72 static const ChreMessage enum_value = ChreMessage::NanoappMessage;
73 };
74
75 template<> struct ChreMessageTraits<HubInfoRequest> {
76 static const ChreMessage enum_value = ChreMessage::HubInfoRequest;
77 };
78
79 template<> struct ChreMessageTraits<HubInfoResponse> {
80 static const ChreMessage enum_value = ChreMessage::HubInfoResponse;
81 };
82
83 template<> struct ChreMessageTraits<NanoappListRequest> {
84 static const ChreMessage enum_value = ChreMessage::NanoappListRequest;
85 };
86
87 template<> struct ChreMessageTraits<NanoappListResponse> {
88 static const ChreMessage enum_value = ChreMessage::NanoappListResponse;
89 };
90
91 template<> struct ChreMessageTraits<LoadNanoappRequest> {
92 static const ChreMessage enum_value = ChreMessage::LoadNanoappRequest;
93 };
94
95 template<> struct ChreMessageTraits<LoadNanoappResponse> {
96 static const ChreMessage enum_value = ChreMessage::LoadNanoappResponse;
97 };
98
99 bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type);
100 bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
101
102 MANUALLY_ALIGNED_STRUCT(2) HostAddress FLATBUFFERS_FINAL_CLASS {
103 private:
104 uint16_t client_id_;
105
106 public:
107 HostAddress() {
108 memset(this, 0, sizeof(HostAddress));
109 }
110 HostAddress(const HostAddress &_o) {
111 memcpy(this, &_o, sizeof(HostAddress));
112 }
113 HostAddress(uint16_t _client_id)
114 : client_id_(flatbuffers::EndianScalar(_client_id)) {
115 }
116 uint16_t client_id() const {
117 return flatbuffers::EndianScalar(client_id_);
118 }
119 };
120 STRUCT_END(HostAddress, 2);
121
122 /// Represents a message sent to/from a nanoapp from/to a client on the host
123 struct NanoappMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
124 enum {
125 VT_APP_ID = 4,
126 VT_MESSAGE_TYPE = 6,
127 VT_HOST_ENDPOINT = 8,
128 VT_MESSAGE = 10
129 };
130 uint64_t app_id() const {
131 return GetField<uint64_t>(VT_APP_ID, 0);
132 }
133 uint32_t message_type() const {
134 return GetField<uint32_t>(VT_MESSAGE_TYPE, 0);
135 }
136 /// Identifies the host-side endpoint on the host that sent or should receive
137 /// this message. The default value is a special value defined in the HAL and
138 /// elsewhere that indicates that the endpoint is unspecified.
139 uint16_t host_endpoint() const {
140 return GetField<uint16_t>(VT_HOST_ENDPOINT, 65534);
141 }
142 /// Vector containing arbitrary application-specific message data
143 const flatbuffers::Vector<uint8_t> *message() const {
144 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MESSAGE);
145 }
146 bool Verify(flatbuffers::Verifier &verifier) const {
147 return VerifyTableStart(verifier) &&
148 VerifyField<uint64_t>(verifier, VT_APP_ID) &&
149 VerifyField<uint32_t>(verifier, VT_MESSAGE_TYPE) &&
150 VerifyField<uint16_t>(verifier, VT_HOST_ENDPOINT) &&
151 VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_MESSAGE) &&
152 verifier.Verify(message()) &&
153 verifier.EndTable();
154 }
155 };
156
157 struct NanoappMessageBuilder {
158 flatbuffers::FlatBufferBuilder &fbb_;
159 flatbuffers::uoffset_t start_;
160 void add_app_id(uint64_t app_id) {
161 fbb_.AddElement<uint64_t>(NanoappMessage::VT_APP_ID, app_id, 0);
162 }
163 void add_message_type(uint32_t message_type) {
164 fbb_.AddElement<uint32_t>(NanoappMessage::VT_MESSAGE_TYPE, message_type, 0);
165 }
166 void add_host_endpoint(uint16_t host_endpoint) {
167 fbb_.AddElement<uint16_t>(NanoappMessage::VT_HOST_ENDPOINT, host_endpoint, 65534);
168 }
169 void add_message(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message) {
170 fbb_.AddOffset(NanoappMessage::VT_MESSAGE, message);
171 }
172 NanoappMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
173 : fbb_(_fbb) {
174 start_ = fbb_.StartTable();
175 }
176 NanoappMessageBuilder &operator=(const NanoappMessageBuilder &);
177 flatbuffers::Offset<NanoappMessage> Finish() {
178 const auto end = fbb_.EndTable(start_, 4);
179 auto o = flatbuffers::Offset<NanoappMessage>(end);
180 fbb_.Required(o, NanoappMessage::VT_MESSAGE);
181 return o;
182 }
183 };
184
185 inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessage(
186 flatbuffers::FlatBufferBuilder &_fbb,
187 uint64_t app_id = 0,
188 uint32_t message_type = 0,
189 uint16_t host_endpoint = 65534,
190 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message = 0) {
191 NanoappMessageBuilder builder_(_fbb);
192 builder_.add_app_id(app_id);
193 builder_.add_message(message);
194 builder_.add_message_type(message_type);
195 builder_.add_host_endpoint(host_endpoint);
196 return builder_.Finish();
197 }
198
199 inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessageDirect(
200 flatbuffers::FlatBufferBuilder &_fbb,
201 uint64_t app_id = 0,
202 uint32_t message_type = 0,
203 uint16_t host_endpoint = 65534,
204 const std::vector<uint8_t> *message = nullptr) {
205 return chre::fbs::CreateNanoappMessage(
206 _fbb,
207 app_id,
208 message_type,
209 host_endpoint,
210 message ? _fbb.CreateVector<uint8_t>(*message) : 0);
211 }
212
213 struct HubInfoRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
214 bool Verify(flatbuffers::Verifier &verifier) const {
215 return VerifyTableStart(verifier) &&
216 verifier.EndTable();
217 }
218 };
219
220 struct HubInfoRequestBuilder {
221 flatbuffers::FlatBufferBuilder &fbb_;
222 flatbuffers::uoffset_t start_;
223 HubInfoRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
224 : fbb_(_fbb) {
225 start_ = fbb_.StartTable();
226 }
227 HubInfoRequestBuilder &operator=(const HubInfoRequestBuilder &);
228 flatbuffers::Offset<HubInfoRequest> Finish() {
229 const auto end = fbb_.EndTable(start_, 0);
230 auto o = flatbuffers::Offset<HubInfoRequest>(end);
231 return o;
232 }
233 };
234
235 inline flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest(
236 flatbuffers::FlatBufferBuilder &_fbb) {
237 HubInfoRequestBuilder builder_(_fbb);
238 return builder_.Finish();
239 }
240
241 struct HubInfoResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
242 enum {
243 VT_NAME = 4,
244 VT_VENDOR = 6,
245 VT_TOOLCHAIN = 8,
246 VT_PLATFORM_VERSION = 10,
247 VT_TOOLCHAIN_VERSION = 12,
248 VT_PEAK_MIPS = 14,
249 VT_STOPPED_POWER = 16,
250 VT_SLEEP_POWER = 18,
251 VT_PEAK_POWER = 20,
252 VT_MAX_MSG_LEN = 22,
253 VT_PLATFORM_ID = 24,
254 VT_CHRE_PLATFORM_VERSION = 26
255 };
256 /// The name of the hub. Nominally a UTF-8 string, but note that we're not
257 /// using the built-in "string" data type from FlatBuffers here, because the
258 /// generated C++ uses std::string which is not well-supported in CHRE. This
259 /// applies for vendor and toolchain as well.
260 const flatbuffers::Vector<int8_t> *name() const {
261 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_NAME);
262 }
263 const flatbuffers::Vector<int8_t> *vendor() const {
264 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_VENDOR);
265 }
266 const flatbuffers::Vector<int8_t> *toolchain() const {
267 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_TOOLCHAIN);
268 }
269 /// Legacy platform version reported in the HAL; semantics not strictly
270 /// defined
271 uint32_t platform_version() const {
272 return GetField<uint32_t>(VT_PLATFORM_VERSION, 0);
273 }
274 /// Toolchain version reported in the HAL; semantics not strictly defined
275 uint32_t toolchain_version() const {
276 return GetField<uint32_t>(VT_TOOLCHAIN_VERSION, 0);
277 }
278 float peak_mips() const {
279 return GetField<float>(VT_PEAK_MIPS, 0.0f);
280 }
281 float stopped_power() const {
282 return GetField<float>(VT_STOPPED_POWER, 0.0f);
283 }
284 float sleep_power() const {
285 return GetField<float>(VT_SLEEP_POWER, 0.0f);
286 }
287 float peak_power() const {
288 return GetField<float>(VT_PEAK_POWER, 0.0f);
289 }
290 /// Maximum size message that can be sent to a nanoapp
291 uint32_t max_msg_len() const {
292 return GetField<uint32_t>(VT_MAX_MSG_LEN, 0);
293 }
294 /// @see chreGetPlatformId()
295 uint64_t platform_id() const {
296 return GetField<uint64_t>(VT_PLATFORM_ID, 0);
297 }
298 /// @see chreGetVersion()
299 uint32_t chre_platform_version() const {
300 return GetField<uint32_t>(VT_CHRE_PLATFORM_VERSION, 0);
301 }
302 bool Verify(flatbuffers::Verifier &verifier) const {
303 return VerifyTableStart(verifier) &&
304 VerifyField<flatbuffers::uoffset_t>(verifier, VT_NAME) &&
305 verifier.Verify(name()) &&
306 VerifyField<flatbuffers::uoffset_t>(verifier, VT_VENDOR) &&
307 verifier.Verify(vendor()) &&
308 VerifyField<flatbuffers::uoffset_t>(verifier, VT_TOOLCHAIN) &&
309 verifier.Verify(toolchain()) &&
310 VerifyField<uint32_t>(verifier, VT_PLATFORM_VERSION) &&
311 VerifyField<uint32_t>(verifier, VT_TOOLCHAIN_VERSION) &&
312 VerifyField<float>(verifier, VT_PEAK_MIPS) &&
313 VerifyField<float>(verifier, VT_STOPPED_POWER) &&
314 VerifyField<float>(verifier, VT_SLEEP_POWER) &&
315 VerifyField<float>(verifier, VT_PEAK_POWER) &&
316 VerifyField<uint32_t>(verifier, VT_MAX_MSG_LEN) &&
317 VerifyField<uint64_t>(verifier, VT_PLATFORM_ID) &&
318 VerifyField<uint32_t>(verifier, VT_CHRE_PLATFORM_VERSION) &&
319 verifier.EndTable();
320 }
321 };
322
323 struct HubInfoResponseBuilder {
324 flatbuffers::FlatBufferBuilder &fbb_;
325 flatbuffers::uoffset_t start_;
326 void add_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> name) {
327 fbb_.AddOffset(HubInfoResponse::VT_NAME, name);
328 }
329 void add_vendor(flatbuffers::Offset<flatbuffers::Vector<int8_t>> vendor) {
330 fbb_.AddOffset(HubInfoResponse::VT_VENDOR, vendor);
331 }
332 void add_toolchain(flatbuffers::Offset<flatbuffers::Vector<int8_t>> toolchain) {
333 fbb_.AddOffset(HubInfoResponse::VT_TOOLCHAIN, toolchain);
334 }
335 void add_platform_version(uint32_t platform_version) {
336 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_PLATFORM_VERSION, platform_version, 0);
337 }
338 void add_toolchain_version(uint32_t toolchain_version) {
339 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_TOOLCHAIN_VERSION, toolchain_version, 0);
340 }
341 void add_peak_mips(float peak_mips) {
342 fbb_.AddElement<float>(HubInfoResponse::VT_PEAK_MIPS, peak_mips, 0.0f);
343 }
344 void add_stopped_power(float stopped_power) {
345 fbb_.AddElement<float>(HubInfoResponse::VT_STOPPED_POWER, stopped_power, 0.0f);
346 }
347 void add_sleep_power(float sleep_power) {
348 fbb_.AddElement<float>(HubInfoResponse::VT_SLEEP_POWER, sleep_power, 0.0f);
349 }
350 void add_peak_power(float peak_power) {
351 fbb_.AddElement<float>(HubInfoResponse::VT_PEAK_POWER, peak_power, 0.0f);
352 }
353 void add_max_msg_len(uint32_t max_msg_len) {
354 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_MAX_MSG_LEN, max_msg_len, 0);
355 }
356 void add_platform_id(uint64_t platform_id) {
357 fbb_.AddElement<uint64_t>(HubInfoResponse::VT_PLATFORM_ID, platform_id, 0);
358 }
359 void add_chre_platform_version(uint32_t chre_platform_version) {
360 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_CHRE_PLATFORM_VERSION, chre_platform_version, 0);
361 }
362 HubInfoResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
363 : fbb_(_fbb) {
364 start_ = fbb_.StartTable();
365 }
366 HubInfoResponseBuilder &operator=(const HubInfoResponseBuilder &);
367 flatbuffers::Offset<HubInfoResponse> Finish() {
368 const auto end = fbb_.EndTable(start_, 12);
369 auto o = flatbuffers::Offset<HubInfoResponse>(end);
370 return o;
371 }
372 };
373
374 inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponse(
375 flatbuffers::FlatBufferBuilder &_fbb,
376 flatbuffers::Offset<flatbuffers::Vector<int8_t>> name = 0,
377 flatbuffers::Offset<flatbuffers::Vector<int8_t>> vendor = 0,
378 flatbuffers::Offset<flatbuffers::Vector<int8_t>> toolchain = 0,
379 uint32_t platform_version = 0,
380 uint32_t toolchain_version = 0,
381 float peak_mips = 0.0f,
382 float stopped_power = 0.0f,
383 float sleep_power = 0.0f,
384 float peak_power = 0.0f,
385 uint32_t max_msg_len = 0,
386 uint64_t platform_id = 0,
387 uint32_t chre_platform_version = 0) {
388 HubInfoResponseBuilder builder_(_fbb);
389 builder_.add_platform_id(platform_id);
390 builder_.add_chre_platform_version(chre_platform_version);
391 builder_.add_max_msg_len(max_msg_len);
392 builder_.add_peak_power(peak_power);
393 builder_.add_sleep_power(sleep_power);
394 builder_.add_stopped_power(stopped_power);
395 builder_.add_peak_mips(peak_mips);
396 builder_.add_toolchain_version(toolchain_version);
397 builder_.add_platform_version(platform_version);
398 builder_.add_toolchain(toolchain);
399 builder_.add_vendor(vendor);
400 builder_.add_name(name);
401 return builder_.Finish();
402 }
403
404 inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponseDirect(
405 flatbuffers::FlatBufferBuilder &_fbb,
406 const std::vector<int8_t> *name = nullptr,
407 const std::vector<int8_t> *vendor = nullptr,
408 const std::vector<int8_t> *toolchain = nullptr,
409 uint32_t platform_version = 0,
410 uint32_t toolchain_version = 0,
411 float peak_mips = 0.0f,
412 float stopped_power = 0.0f,
413 float sleep_power = 0.0f,
414 float peak_power = 0.0f,
415 uint32_t max_msg_len = 0,
416 uint64_t platform_id = 0,
417 uint32_t chre_platform_version = 0) {
418 return chre::fbs::CreateHubInfoResponse(
419 _fbb,
420 name ? _fbb.CreateVector<int8_t>(*name) : 0,
421 vendor ? _fbb.CreateVector<int8_t>(*vendor) : 0,
422 toolchain ? _fbb.CreateVector<int8_t>(*toolchain) : 0,
423 platform_version,
424 toolchain_version,
425 peak_mips,
426 stopped_power,
427 sleep_power,
428 peak_power,
429 max_msg_len,
430 platform_id,
431 chre_platform_version);
432 }
433
434 struct NanoappListRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
435 bool Verify(flatbuffers::Verifier &verifier) const {
436 return VerifyTableStart(verifier) &&
437 verifier.EndTable();
438 }
439 };
440
441 struct NanoappListRequestBuilder {
442 flatbuffers::FlatBufferBuilder &fbb_;
443 flatbuffers::uoffset_t start_;
444 NanoappListRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
445 : fbb_(_fbb) {
446 start_ = fbb_.StartTable();
447 }
448 NanoappListRequestBuilder &operator=(const NanoappListRequestBuilder &);
449 flatbuffers::Offset<NanoappListRequest> Finish() {
450 const auto end = fbb_.EndTable(start_, 0);
451 auto o = flatbuffers::Offset<NanoappListRequest>(end);
452 return o;
453 }
454 };
455
456 inline flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest(
457 flatbuffers::FlatBufferBuilder &_fbb) {
458 NanoappListRequestBuilder builder_(_fbb);
459 return builder_.Finish();
460 }
461
462 struct NanoappListEntry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
463 enum {
464 VT_APP_ID = 4,
465 VT_VERSION = 6,
466 VT_ENABLED = 8,
467 VT_IS_SYSTEM = 10
468 };
469 uint64_t app_id() const {
470 return GetField<uint64_t>(VT_APP_ID, 0);
471 }
472 uint32_t version() const {
473 return GetField<uint32_t>(VT_VERSION, 0);
474 }
475 bool enabled() const {
476 return GetField<uint8_t>(VT_ENABLED, 1) != 0;
477 }
478 /// Whether the nanoapp is a pre-loaded "system" nanoapp, i.e. one that should
479 /// not show up in the list of nanoapps in the context hub HAL. System
480 /// nanoapps are typically used to leverage CHRE for some device functionality
481 /// and do not interact via the context hub HAL.
482 bool is_system() const {
483 return GetField<uint8_t>(VT_IS_SYSTEM, 0) != 0;
484 }
485 bool Verify(flatbuffers::Verifier &verifier) const {
486 return VerifyTableStart(verifier) &&
487 VerifyField<uint64_t>(verifier, VT_APP_ID) &&
488 VerifyField<uint32_t>(verifier, VT_VERSION) &&
489 VerifyField<uint8_t>(verifier, VT_ENABLED) &&
490 VerifyField<uint8_t>(verifier, VT_IS_SYSTEM) &&
491 verifier.EndTable();
492 }
493 };
494
495 struct NanoappListEntryBuilder {
496 flatbuffers::FlatBufferBuilder &fbb_;
497 flatbuffers::uoffset_t start_;
498 void add_app_id(uint64_t app_id) {
499 fbb_.AddElement<uint64_t>(NanoappListEntry::VT_APP_ID, app_id, 0);
500 }
501 void add_version(uint32_t version) {
502 fbb_.AddElement<uint32_t>(NanoappListEntry::VT_VERSION, version, 0);
503 }
504 void add_enabled(bool enabled) {
505 fbb_.AddElement<uint8_t>(NanoappListEntry::VT_ENABLED, static_cast<uint8_t>(enabled), 1);
506 }
507 void add_is_system(bool is_system) {
508 fbb_.AddElement<uint8_t>(NanoappListEntry::VT_IS_SYSTEM, static_cast<uint8_t>(is_system), 0);
509 }
510 NanoappListEntryBuilder(flatbuffers::FlatBufferBuilder &_fbb)
511 : fbb_(_fbb) {
512 start_ = fbb_.StartTable();
513 }
514 NanoappListEntryBuilder &operator=(const NanoappListEntryBuilder &);
515 flatbuffers::Offset<NanoappListEntry> Finish() {
516 const auto end = fbb_.EndTable(start_, 4);
517 auto o = flatbuffers::Offset<NanoappListEntry>(end);
518 return o;
519 }
520 };
521
522 inline flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntry(
523 flatbuffers::FlatBufferBuilder &_fbb,
524 uint64_t app_id = 0,
525 uint32_t version = 0,
526 bool enabled = true,
527 bool is_system = false) {
528 NanoappListEntryBuilder builder_(_fbb);
529 builder_.add_app_id(app_id);
530 builder_.add_version(version);
531 builder_.add_is_system(is_system);
532 builder_.add_enabled(enabled);
533 return builder_.Finish();
534 }
535
536 struct NanoappListResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
537 enum {
538 VT_NANOAPPS = 4
539 };
540 const flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>> *nanoapps() const {
541 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>> *>(VT_NANOAPPS);
542 }
543 bool Verify(flatbuffers::Verifier &verifier) const {
544 return VerifyTableStart(verifier) &&
545 VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_NANOAPPS) &&
546 verifier.Verify(nanoapps()) &&
547 verifier.VerifyVectorOfTables(nanoapps()) &&
548 verifier.EndTable();
549 }
550 };
551
552 struct NanoappListResponseBuilder {
553 flatbuffers::FlatBufferBuilder &fbb_;
554 flatbuffers::uoffset_t start_;
555 void add_nanoapps(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>>> nanoapps) {
556 fbb_.AddOffset(NanoappListResponse::VT_NANOAPPS, nanoapps);
557 }
558 NanoappListResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
559 : fbb_(_fbb) {
560 start_ = fbb_.StartTable();
561 }
562 NanoappListResponseBuilder &operator=(const NanoappListResponseBuilder &);
563 flatbuffers::Offset<NanoappListResponse> Finish() {
564 const auto end = fbb_.EndTable(start_, 1);
565 auto o = flatbuffers::Offset<NanoappListResponse>(end);
566 fbb_.Required(o, NanoappListResponse::VT_NANOAPPS);
567 return o;
568 }
569 };
570
571 inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse(
572 flatbuffers::FlatBufferBuilder &_fbb,
573 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>>> nanoapps = 0) {
574 NanoappListResponseBuilder builder_(_fbb);
575 builder_.add_nanoapps(nanoapps);
576 return builder_.Finish();
577 }
578
579 inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponseDirect(
580 flatbuffers::FlatBufferBuilder &_fbb,
581 const std::vector<flatbuffers::Offset<NanoappListEntry>> *nanoapps = nullptr) {
582 return chre::fbs::CreateNanoappListResponse(
583 _fbb,
584 nanoapps ? _fbb.CreateVector<flatbuffers::Offset<NanoappListEntry>>(*nanoapps) : 0);
585 }
586
587 struct LoadNanoappRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
588 enum {
589 VT_TRANSACTION_ID = 4,
590 VT_APP_ID = 6,
591 VT_APP_VERSION = 8,
592 VT_TARGET_API_VERSION = 10,
593 VT_APP_BINARY = 12
594 };
595 uint32_t transaction_id() const {
596 return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
597 }
598 uint64_t app_id() const {
599 return GetField<uint64_t>(VT_APP_ID, 0);
600 }
601 uint32_t app_version() const {
602 return GetField<uint32_t>(VT_APP_VERSION, 0);
603 }
604 uint32_t target_api_version() const {
605 return GetField<uint32_t>(VT_TARGET_API_VERSION, 0);
606 }
607 const flatbuffers::Vector<uint8_t> *app_binary() const {
608 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_APP_BINARY);
609 }
610 bool Verify(flatbuffers::Verifier &verifier) const {
611 return VerifyTableStart(verifier) &&
612 VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
613 VerifyField<uint64_t>(verifier, VT_APP_ID) &&
614 VerifyField<uint32_t>(verifier, VT_APP_VERSION) &&
615 VerifyField<uint32_t>(verifier, VT_TARGET_API_VERSION) &&
616 VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_APP_BINARY) &&
617 verifier.Verify(app_binary()) &&
618 verifier.EndTable();
619 }
620 };
621
622 struct LoadNanoappRequestBuilder {
623 flatbuffers::FlatBufferBuilder &fbb_;
624 flatbuffers::uoffset_t start_;
625 void add_transaction_id(uint32_t transaction_id) {
626 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TRANSACTION_ID, transaction_id, 0);
627 }
628 void add_app_id(uint64_t app_id) {
629 fbb_.AddElement<uint64_t>(LoadNanoappRequest::VT_APP_ID, app_id, 0);
630 }
631 void add_app_version(uint32_t app_version) {
632 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_APP_VERSION, app_version, 0);
633 }
634 void add_target_api_version(uint32_t target_api_version) {
635 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TARGET_API_VERSION, target_api_version, 0);
636 }
637 void add_app_binary(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary) {
638 fbb_.AddOffset(LoadNanoappRequest::VT_APP_BINARY, app_binary);
639 }
640 LoadNanoappRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
641 : fbb_(_fbb) {
642 start_ = fbb_.StartTable();
643 }
644 LoadNanoappRequestBuilder &operator=(const LoadNanoappRequestBuilder &);
645 flatbuffers::Offset<LoadNanoappRequest> Finish() {
646 const auto end = fbb_.EndTable(start_, 5);
647 auto o = flatbuffers::Offset<LoadNanoappRequest>(end);
648 fbb_.Required(o, LoadNanoappRequest::VT_APP_BINARY);
649 return o;
650 }
651 };
652
653 inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest(
654 flatbuffers::FlatBufferBuilder &_fbb,
655 uint32_t transaction_id = 0,
656 uint64_t app_id = 0,
657 uint32_t app_version = 0,
658 uint32_t target_api_version = 0,
659 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary = 0) {
660 LoadNanoappRequestBuilder builder_(_fbb);
661 builder_.add_app_id(app_id);
662 builder_.add_app_binary(app_binary);
663 builder_.add_target_api_version(target_api_version);
664 builder_.add_app_version(app_version);
665 builder_.add_transaction_id(transaction_id);
666 return builder_.Finish();
667 }
668
669 inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequestDirect(
670 flatbuffers::FlatBufferBuilder &_fbb,
671 uint32_t transaction_id = 0,
672 uint64_t app_id = 0,
673 uint32_t app_version = 0,
674 uint32_t target_api_version = 0,
675 const std::vector<uint8_t> *app_binary = nullptr) {
676 return chre::fbs::CreateLoadNanoappRequest(
677 _fbb,
678 transaction_id,
679 app_id,
680 app_version,
681 target_api_version,
682 app_binary ? _fbb.CreateVector<uint8_t>(*app_binary) : 0);
683 }
684
685 struct LoadNanoappResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
686 enum {
687 VT_TRANSACTION_ID = 4,
688 VT_SUCCESS = 6
689 };
690 uint32_t transaction_id() const {
691 return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
692 }
693 bool success() const {
694 return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
695 }
696 bool Verify(flatbuffers::Verifier &verifier) const {
697 return VerifyTableStart(verifier) &&
698 VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
699 VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
700 verifier.EndTable();
701 }
702 };
703
704 struct LoadNanoappResponseBuilder {
705 flatbuffers::FlatBufferBuilder &fbb_;
706 flatbuffers::uoffset_t start_;
707 void add_transaction_id(uint32_t transaction_id) {
708 fbb_.AddElement<uint32_t>(LoadNanoappResponse::VT_TRANSACTION_ID, transaction_id, 0);
709 }
710 void add_success(bool success) {
711 fbb_.AddElement<uint8_t>(LoadNanoappResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0);
712 }
713 LoadNanoappResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
714 : fbb_(_fbb) {
715 start_ = fbb_.StartTable();
716 }
717 LoadNanoappResponseBuilder &operator=(const LoadNanoappResponseBuilder &);
718 flatbuffers::Offset<LoadNanoappResponse> Finish() {
719 const auto end = fbb_.EndTable(start_, 2);
720 auto o = flatbuffers::Offset<LoadNanoappResponse>(end);
721 return o;
722 }
723 };
724
725 inline flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse(
726 flatbuffers::FlatBufferBuilder &_fbb,
727 uint32_t transaction_id = 0,
728 bool success = false) {
729 LoadNanoappResponseBuilder builder_(_fbb);
730 builder_.add_transaction_id(transaction_id);
731 builder_.add_success(success);
732 return builder_.Finish();
733 }
734
735 /// The top-level container that encapsulates all possible messages. Note that
736 /// per FlatBuffers requirements, we can't use a union as the top-level structure
737 /// (root type), so we must wrap it in a table.
738 struct MessageContainer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
739 enum {
740 VT_MESSAGE_TYPE = 4,
741 VT_MESSAGE = 6,
742 VT_HOST_ADDR = 8
743 };
744 ChreMessage message_type() const {
745 return static_cast<ChreMessage>(GetField<uint8_t>(VT_MESSAGE_TYPE, 0));
746 }
747 const void *message() const {
748 return GetPointer<const void *>(VT_MESSAGE);
749 }
750 /// The originating or destination client ID on the host side, used to direct
751 /// responses only to the client that sent the request. Although initially
752 /// populated by the requesting client, this is enforced to be the correct
753 /// value by the entity guarding access to CHRE.
754 /// This is wrapped in a struct to ensure that it is always included when
755 /// encoding the message, so it can be mutated by the host daemon.
756 const HostAddress *host_addr() const {
757 return GetStruct<const HostAddress *>(VT_HOST_ADDR);
758 }
759 bool Verify(flatbuffers::Verifier &verifier) const {
760 return VerifyTableStart(verifier) &&
761 VerifyField<uint8_t>(verifier, VT_MESSAGE_TYPE) &&
762 VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_MESSAGE) &&
763 VerifyChreMessage(verifier, message(), message_type()) &&
764 VerifyFieldRequired<HostAddress>(verifier, VT_HOST_ADDR) &&
765 verifier.EndTable();
766 }
767 };
768
769 struct MessageContainerBuilder {
770 flatbuffers::FlatBufferBuilder &fbb_;
771 flatbuffers::uoffset_t start_;
772 void add_message_type(ChreMessage message_type) {
773 fbb_.AddElement<uint8_t>(MessageContainer::VT_MESSAGE_TYPE, static_cast<uint8_t>(message_type), 0);
774 }
775 void add_message(flatbuffers::Offset<void> message) {
776 fbb_.AddOffset(MessageContainer::VT_MESSAGE, message);
777 }
778 void add_host_addr(const HostAddress *host_addr) {
779 fbb_.AddStruct(MessageContainer::VT_HOST_ADDR, host_addr);
780 }
781 MessageContainerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
782 : fbb_(_fbb) {
783 start_ = fbb_.StartTable();
784 }
785 MessageContainerBuilder &operator=(const MessageContainerBuilder &);
786 flatbuffers::Offset<MessageContainer> Finish() {
787 const auto end = fbb_.EndTable(start_, 3);
788 auto o = flatbuffers::Offset<MessageContainer>(end);
789 fbb_.Required(o, MessageContainer::VT_MESSAGE);
790 fbb_.Required(o, MessageContainer::VT_HOST_ADDR);
791 return o;
792 }
793 };
794
795 inline flatbuffers::Offset<MessageContainer> CreateMessageContainer(
796 flatbuffers::FlatBufferBuilder &_fbb,
797 ChreMessage message_type = ChreMessage::NONE,
798 flatbuffers::Offset<void> message = 0,
799 const HostAddress *host_addr = 0) {
800 MessageContainerBuilder builder_(_fbb);
801 builder_.add_host_addr(host_addr);
802 builder_.add_message(message);
803 builder_.add_message_type(message_type);
804 return builder_.Finish();
805 }
806
807 inline bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type) {
808 switch (type) {
809 case ChreMessage::NONE: {
810 return true;
811 }
812 case ChreMessage::NanoappMessage: {
813 auto ptr = reinterpret_cast<const NanoappMessage *>(obj);
814 return verifier.VerifyTable(ptr);
815 }
816 case ChreMessage::HubInfoRequest: {
817 auto ptr = reinterpret_cast<const HubInfoRequest *>(obj);
818 return verifier.VerifyTable(ptr);
819 }
820 case ChreMessage::HubInfoResponse: {
821 auto ptr = reinterpret_cast<const HubInfoResponse *>(obj);
822 return verifier.VerifyTable(ptr);
823 }
824 case ChreMessage::NanoappListRequest: {
825 auto ptr = reinterpret_cast<const NanoappListRequest *>(obj);
826 return verifier.VerifyTable(ptr);
827 }
828 case ChreMessage::NanoappListResponse: {
829 auto ptr = reinterpret_cast<const NanoappListResponse *>(obj);
830 return verifier.VerifyTable(ptr);
831 }
832 case ChreMessage::LoadNanoappRequest: {
833 auto ptr = reinterpret_cast<const LoadNanoappRequest *>(obj);
834 return verifier.VerifyTable(ptr);
835 }
836 case ChreMessage::LoadNanoappResponse: {
837 auto ptr = reinterpret_cast<const LoadNanoappResponse *>(obj);
838 return verifier.VerifyTable(ptr);
839 }
840 default: return false;
841 }
842 }
843
844 inline bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
845 if (values->size() != types->size()) return false;
846 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
847 if (!VerifyChreMessage(
848 verifier, values->Get(i), types->GetEnum<ChreMessage>(i))) {
849 return false;
850 }
851 }
852 return true;
853 }
854
855 inline const chre::fbs::MessageContainer *GetMessageContainer(const void *buf) {
856 return flatbuffers::GetRoot<chre::fbs::MessageContainer>(buf);
857 }
858
859 inline bool VerifyMessageContainerBuffer(
860 flatbuffers::Verifier &verifier) {
861 return verifier.VerifyBuffer<chre::fbs::MessageContainer>(nullptr);
862 }
863
864 inline void FinishMessageContainerBuffer(
865 flatbuffers::FlatBufferBuilder &fbb,
866 flatbuffers::Offset<chre::fbs::MessageContainer> root) {
867 fbb.Finish(root);
868 }
869
870 } // namespace fbs
871 } // namespace chre
872
873 #endif // FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_
874