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
9namespace chre {
10namespace fbs {
11
12struct NanoappMessage;
13
14struct HubInfoRequest;
15
16struct HubInfoResponse;
17
18struct NanoappListRequest;
19
20struct NanoappListEntry;
21
22struct NanoappListResponse;
23
24struct LoadNanoappRequest;
25
26struct LoadNanoappResponse;
27
28struct HostAddress;
29
30struct MessageContainer;
31
32/// A union that joins together all possible messages. Note that in FlatBuffers,
33/// unions have an implicit type
34enum 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
47inline 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
62inline const char *EnumNameChreMessage(ChreMessage e) {
63  const size_t index = static_cast<int>(e);
64  return EnumNamesChreMessage()[index];
65}
66
67template<typename T> struct ChreMessageTraits {
68  static const ChreMessage enum_value = ChreMessage::NONE;
69};
70
71template<> struct ChreMessageTraits<NanoappMessage> {
72  static const ChreMessage enum_value = ChreMessage::NanoappMessage;
73};
74
75template<> struct ChreMessageTraits<HubInfoRequest> {
76  static const ChreMessage enum_value = ChreMessage::HubInfoRequest;
77};
78
79template<> struct ChreMessageTraits<HubInfoResponse> {
80  static const ChreMessage enum_value = ChreMessage::HubInfoResponse;
81};
82
83template<> struct ChreMessageTraits<NanoappListRequest> {
84  static const ChreMessage enum_value = ChreMessage::NanoappListRequest;
85};
86
87template<> struct ChreMessageTraits<NanoappListResponse> {
88  static const ChreMessage enum_value = ChreMessage::NanoappListResponse;
89};
90
91template<> struct ChreMessageTraits<LoadNanoappRequest> {
92  static const ChreMessage enum_value = ChreMessage::LoadNanoappRequest;
93};
94
95template<> struct ChreMessageTraits<LoadNanoappResponse> {
96  static const ChreMessage enum_value = ChreMessage::LoadNanoappResponse;
97};
98
99bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type);
100bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
101
102MANUALLY_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};
120STRUCT_END(HostAddress, 2);
121
122/// Represents a message sent to/from a nanoapp from/to a client on the host
123struct 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
157struct 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
185inline 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
199inline 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
213struct HubInfoRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
214  bool Verify(flatbuffers::Verifier &verifier) const {
215    return VerifyTableStart(verifier) &&
216           verifier.EndTable();
217  }
218};
219
220struct 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
235inline flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest(
236    flatbuffers::FlatBufferBuilder &_fbb) {
237  HubInfoRequestBuilder builder_(_fbb);
238  return builder_.Finish();
239}
240
241struct 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
323struct 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
374inline 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
404inline 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
434struct NanoappListRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
435  bool Verify(flatbuffers::Verifier &verifier) const {
436    return VerifyTableStart(verifier) &&
437           verifier.EndTable();
438  }
439};
440
441struct 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
456inline flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest(
457    flatbuffers::FlatBufferBuilder &_fbb) {
458  NanoappListRequestBuilder builder_(_fbb);
459  return builder_.Finish();
460}
461
462struct 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
495struct 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
522inline 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
536struct 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
552struct 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
571inline 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
579inline 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
587struct 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
622struct 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
653inline 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
669inline 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
685struct 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
704struct 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
725inline 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.
738struct 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
769struct 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
795inline 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
807inline 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
844inline 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
855inline const chre::fbs::MessageContainer *GetMessageContainer(const void *buf) {
856  return flatbuffers::GetRoot<chre::fbs::MessageContainer>(buf);
857}
858
859inline bool VerifyMessageContainerBuffer(
860    flatbuffers::Verifier &verifier) {
861  return verifier.VerifyBuffer<chre::fbs::MessageContainer>(nullptr);
862}
863
864inline 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