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