1 // automatically generated by the FlatBuffers compiler, do not modify 2 3 4 #ifndef FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_ 5 #define FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_ 6 7 #include "flatbuffers/flatbuffers.h" 8 9 namespace chre { 10 namespace fbs { 11 12 struct NanoappMessage; 13 struct NanoappMessageT; 14 15 struct HubInfoRequest; 16 struct HubInfoRequestT; 17 18 struct HubInfoResponse; 19 struct HubInfoResponseT; 20 21 struct NanoappListRequest; 22 struct NanoappListRequestT; 23 24 struct NanoappListEntry; 25 struct NanoappListEntryT; 26 27 struct NanoappListResponse; 28 struct NanoappListResponseT; 29 30 struct LoadNanoappRequest; 31 struct LoadNanoappRequestT; 32 33 struct LoadNanoappResponse; 34 struct LoadNanoappResponseT; 35 36 struct UnloadNanoappRequest; 37 struct UnloadNanoappRequestT; 38 39 struct UnloadNanoappResponse; 40 struct UnloadNanoappResponseT; 41 42 struct LogMessage; 43 struct LogMessageT; 44 45 struct TimeSyncMessage; 46 struct TimeSyncMessageT; 47 48 struct DebugDumpRequest; 49 struct DebugDumpRequestT; 50 51 struct DebugDumpData; 52 struct DebugDumpDataT; 53 54 struct DebugDumpResponse; 55 struct DebugDumpResponseT; 56 57 struct TimeSyncRequest; 58 struct TimeSyncRequestT; 59 60 struct LowPowerMicAccessRequest; 61 struct LowPowerMicAccessRequestT; 62 63 struct LowPowerMicAccessRelease; 64 struct LowPowerMicAccessReleaseT; 65 66 struct HostAddress; 67 68 struct MessageContainer; 69 struct MessageContainerT; 70 71 /// A union that joins together all possible messages. Note that in FlatBuffers, 72 /// unions have an implicit type 73 enum class ChreMessage : uint8_t { 74 NONE = 0, 75 NanoappMessage = 1, 76 HubInfoRequest = 2, 77 HubInfoResponse = 3, 78 NanoappListRequest = 4, 79 NanoappListResponse = 5, 80 LoadNanoappRequest = 6, 81 LoadNanoappResponse = 7, 82 UnloadNanoappRequest = 8, 83 UnloadNanoappResponse = 9, 84 LogMessage = 10, 85 TimeSyncMessage = 11, 86 DebugDumpRequest = 12, 87 DebugDumpData = 13, 88 DebugDumpResponse = 14, 89 TimeSyncRequest = 15, 90 LowPowerMicAccessRequest = 16, 91 LowPowerMicAccessRelease = 17, 92 MIN = NONE, 93 MAX = LowPowerMicAccessRelease 94 }; 95 96 inline const char **EnumNamesChreMessage() { 97 static const char *names[] = { 98 "NONE", 99 "NanoappMessage", 100 "HubInfoRequest", 101 "HubInfoResponse", 102 "NanoappListRequest", 103 "NanoappListResponse", 104 "LoadNanoappRequest", 105 "LoadNanoappResponse", 106 "UnloadNanoappRequest", 107 "UnloadNanoappResponse", 108 "LogMessage", 109 "TimeSyncMessage", 110 "DebugDumpRequest", 111 "DebugDumpData", 112 "DebugDumpResponse", 113 "TimeSyncRequest", 114 "LowPowerMicAccessRequest", 115 "LowPowerMicAccessRelease", 116 nullptr 117 }; 118 return names; 119 } 120 121 inline const char *EnumNameChreMessage(ChreMessage e) { 122 const size_t index = static_cast<int>(e); 123 return EnumNamesChreMessage()[index]; 124 } 125 126 template<typename T> struct ChreMessageTraits { 127 static const ChreMessage enum_value = ChreMessage::NONE; 128 }; 129 130 template<> struct ChreMessageTraits<NanoappMessage> { 131 static const ChreMessage enum_value = ChreMessage::NanoappMessage; 132 }; 133 134 template<> struct ChreMessageTraits<HubInfoRequest> { 135 static const ChreMessage enum_value = ChreMessage::HubInfoRequest; 136 }; 137 138 template<> struct ChreMessageTraits<HubInfoResponse> { 139 static const ChreMessage enum_value = ChreMessage::HubInfoResponse; 140 }; 141 142 template<> struct ChreMessageTraits<NanoappListRequest> { 143 static const ChreMessage enum_value = ChreMessage::NanoappListRequest; 144 }; 145 146 template<> struct ChreMessageTraits<NanoappListResponse> { 147 static const ChreMessage enum_value = ChreMessage::NanoappListResponse; 148 }; 149 150 template<> struct ChreMessageTraits<LoadNanoappRequest> { 151 static const ChreMessage enum_value = ChreMessage::LoadNanoappRequest; 152 }; 153 154 template<> struct ChreMessageTraits<LoadNanoappResponse> { 155 static const ChreMessage enum_value = ChreMessage::LoadNanoappResponse; 156 }; 157 158 template<> struct ChreMessageTraits<UnloadNanoappRequest> { 159 static const ChreMessage enum_value = ChreMessage::UnloadNanoappRequest; 160 }; 161 162 template<> struct ChreMessageTraits<UnloadNanoappResponse> { 163 static const ChreMessage enum_value = ChreMessage::UnloadNanoappResponse; 164 }; 165 166 template<> struct ChreMessageTraits<LogMessage> { 167 static const ChreMessage enum_value = ChreMessage::LogMessage; 168 }; 169 170 template<> struct ChreMessageTraits<TimeSyncMessage> { 171 static const ChreMessage enum_value = ChreMessage::TimeSyncMessage; 172 }; 173 174 template<> struct ChreMessageTraits<DebugDumpRequest> { 175 static const ChreMessage enum_value = ChreMessage::DebugDumpRequest; 176 }; 177 178 template<> struct ChreMessageTraits<DebugDumpData> { 179 static const ChreMessage enum_value = ChreMessage::DebugDumpData; 180 }; 181 182 template<> struct ChreMessageTraits<DebugDumpResponse> { 183 static const ChreMessage enum_value = ChreMessage::DebugDumpResponse; 184 }; 185 186 template<> struct ChreMessageTraits<TimeSyncRequest> { 187 static const ChreMessage enum_value = ChreMessage::TimeSyncRequest; 188 }; 189 190 template<> struct ChreMessageTraits<LowPowerMicAccessRequest> { 191 static const ChreMessage enum_value = ChreMessage::LowPowerMicAccessRequest; 192 }; 193 194 template<> struct ChreMessageTraits<LowPowerMicAccessRelease> { 195 static const ChreMessage enum_value = ChreMessage::LowPowerMicAccessRelease; 196 }; 197 198 struct ChreMessageUnion { 199 ChreMessage type; 200 flatbuffers::NativeTable *table; 201 202 ChreMessageUnion() : type(ChreMessage::NONE), table(nullptr) {} 203 ChreMessageUnion(ChreMessageUnion&& u): 204 type(std::move(u.type)), table(std::move(u.table)) {} 205 ChreMessageUnion(const ChreMessageUnion &); 206 ChreMessageUnion &operator=(const ChreMessageUnion &); 207 ~ChreMessageUnion() { Reset(); } 208 209 void Reset(); 210 211 template <typename T> 212 void Set(T&& value) { 213 Reset(); 214 type = ChreMessageTraits<typename T::TableType>::enum_value; 215 if (type != ChreMessage::NONE) { 216 table = new T(std::forward<T>(value)); 217 } 218 } 219 220 static flatbuffers::NativeTable *UnPack(const void *obj, ChreMessage type, const flatbuffers::resolver_function_t *resolver); 221 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; 222 223 NanoappMessageT *AsNanoappMessage() { 224 return type == ChreMessage::NanoappMessage ? 225 reinterpret_cast<NanoappMessageT *>(table) : nullptr; 226 } 227 HubInfoRequestT *AsHubInfoRequest() { 228 return type == ChreMessage::HubInfoRequest ? 229 reinterpret_cast<HubInfoRequestT *>(table) : nullptr; 230 } 231 HubInfoResponseT *AsHubInfoResponse() { 232 return type == ChreMessage::HubInfoResponse ? 233 reinterpret_cast<HubInfoResponseT *>(table) : nullptr; 234 } 235 NanoappListRequestT *AsNanoappListRequest() { 236 return type == ChreMessage::NanoappListRequest ? 237 reinterpret_cast<NanoappListRequestT *>(table) : nullptr; 238 } 239 NanoappListResponseT *AsNanoappListResponse() { 240 return type == ChreMessage::NanoappListResponse ? 241 reinterpret_cast<NanoappListResponseT *>(table) : nullptr; 242 } 243 LoadNanoappRequestT *AsLoadNanoappRequest() { 244 return type == ChreMessage::LoadNanoappRequest ? 245 reinterpret_cast<LoadNanoappRequestT *>(table) : nullptr; 246 } 247 LoadNanoappResponseT *AsLoadNanoappResponse() { 248 return type == ChreMessage::LoadNanoappResponse ? 249 reinterpret_cast<LoadNanoappResponseT *>(table) : nullptr; 250 } 251 UnloadNanoappRequestT *AsUnloadNanoappRequest() { 252 return type == ChreMessage::UnloadNanoappRequest ? 253 reinterpret_cast<UnloadNanoappRequestT *>(table) : nullptr; 254 } 255 UnloadNanoappResponseT *AsUnloadNanoappResponse() { 256 return type == ChreMessage::UnloadNanoappResponse ? 257 reinterpret_cast<UnloadNanoappResponseT *>(table) : nullptr; 258 } 259 LogMessageT *AsLogMessage() { 260 return type == ChreMessage::LogMessage ? 261 reinterpret_cast<LogMessageT *>(table) : nullptr; 262 } 263 TimeSyncMessageT *AsTimeSyncMessage() { 264 return type == ChreMessage::TimeSyncMessage ? 265 reinterpret_cast<TimeSyncMessageT *>(table) : nullptr; 266 } 267 DebugDumpRequestT *AsDebugDumpRequest() { 268 return type == ChreMessage::DebugDumpRequest ? 269 reinterpret_cast<DebugDumpRequestT *>(table) : nullptr; 270 } 271 DebugDumpDataT *AsDebugDumpData() { 272 return type == ChreMessage::DebugDumpData ? 273 reinterpret_cast<DebugDumpDataT *>(table) : nullptr; 274 } 275 DebugDumpResponseT *AsDebugDumpResponse() { 276 return type == ChreMessage::DebugDumpResponse ? 277 reinterpret_cast<DebugDumpResponseT *>(table) : nullptr; 278 } 279 TimeSyncRequestT *AsTimeSyncRequest() { 280 return type == ChreMessage::TimeSyncRequest ? 281 reinterpret_cast<TimeSyncRequestT *>(table) : nullptr; 282 } 283 LowPowerMicAccessRequestT *AsLowPowerMicAccessRequest() { 284 return type == ChreMessage::LowPowerMicAccessRequest ? 285 reinterpret_cast<LowPowerMicAccessRequestT *>(table) : nullptr; 286 } 287 LowPowerMicAccessReleaseT *AsLowPowerMicAccessRelease() { 288 return type == ChreMessage::LowPowerMicAccessRelease ? 289 reinterpret_cast<LowPowerMicAccessReleaseT *>(table) : nullptr; 290 } 291 }; 292 293 bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type); 294 bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types); 295 296 MANUALLY_ALIGNED_STRUCT(2) HostAddress FLATBUFFERS_FINAL_CLASS { 297 private: 298 uint16_t client_id_; 299 300 public: 301 HostAddress() { 302 memset(this, 0, sizeof(HostAddress)); 303 } 304 HostAddress(const HostAddress &_o) { 305 memcpy(this, &_o, sizeof(HostAddress)); 306 } 307 HostAddress(uint16_t _client_id) 308 : client_id_(flatbuffers::EndianScalar(_client_id)) { 309 } 310 uint16_t client_id() const { 311 return flatbuffers::EndianScalar(client_id_); 312 } 313 void mutate_client_id(uint16_t _client_id) { 314 flatbuffers::WriteScalar(&client_id_, _client_id); 315 } 316 }; 317 STRUCT_END(HostAddress, 2); 318 319 struct NanoappMessageT : public flatbuffers::NativeTable { 320 typedef NanoappMessage TableType; 321 uint64_t app_id; 322 uint32_t message_type; 323 uint16_t host_endpoint; 324 std::vector<uint8_t> message; 325 NanoappMessageT() 326 : app_id(0), 327 message_type(0), 328 host_endpoint(65534) { 329 } 330 }; 331 332 /// Represents a message sent to/from a nanoapp from/to a client on the host 333 struct NanoappMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 334 typedef NanoappMessageT NativeTableType; 335 enum { 336 VT_APP_ID = 4, 337 VT_MESSAGE_TYPE = 6, 338 VT_HOST_ENDPOINT = 8, 339 VT_MESSAGE = 10 340 }; 341 uint64_t app_id() const { 342 return GetField<uint64_t>(VT_APP_ID, 0); 343 } 344 bool mutate_app_id(uint64_t _app_id) { 345 return SetField(VT_APP_ID, _app_id); 346 } 347 uint32_t message_type() const { 348 return GetField<uint32_t>(VT_MESSAGE_TYPE, 0); 349 } 350 bool mutate_message_type(uint32_t _message_type) { 351 return SetField(VT_MESSAGE_TYPE, _message_type); 352 } 353 /// Identifies the host-side endpoint on the host that sent or should receive 354 /// this message. The default value is a special value defined in the HAL and 355 /// elsewhere that indicates that the endpoint is unspecified. 356 uint16_t host_endpoint() const { 357 return GetField<uint16_t>(VT_HOST_ENDPOINT, 65534); 358 } 359 bool mutate_host_endpoint(uint16_t _host_endpoint) { 360 return SetField(VT_HOST_ENDPOINT, _host_endpoint); 361 } 362 /// Vector containing arbitrary application-specific message data 363 const flatbuffers::Vector<uint8_t> *message() const { 364 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MESSAGE); 365 } 366 flatbuffers::Vector<uint8_t> *mutable_message() { 367 return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_MESSAGE); 368 } 369 bool Verify(flatbuffers::Verifier &verifier) const { 370 return VerifyTableStart(verifier) && 371 VerifyField<uint64_t>(verifier, VT_APP_ID) && 372 VerifyField<uint32_t>(verifier, VT_MESSAGE_TYPE) && 373 VerifyField<uint16_t>(verifier, VT_HOST_ENDPOINT) && 374 VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_MESSAGE) && 375 verifier.Verify(message()) && 376 verifier.EndTable(); 377 } 378 NanoappMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 379 void UnPackTo(NanoappMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 380 static flatbuffers::Offset<NanoappMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 381 }; 382 383 struct NanoappMessageBuilder { 384 flatbuffers::FlatBufferBuilder &fbb_; 385 flatbuffers::uoffset_t start_; 386 void add_app_id(uint64_t app_id) { 387 fbb_.AddElement<uint64_t>(NanoappMessage::VT_APP_ID, app_id, 0); 388 } 389 void add_message_type(uint32_t message_type) { 390 fbb_.AddElement<uint32_t>(NanoappMessage::VT_MESSAGE_TYPE, message_type, 0); 391 } 392 void add_host_endpoint(uint16_t host_endpoint) { 393 fbb_.AddElement<uint16_t>(NanoappMessage::VT_HOST_ENDPOINT, host_endpoint, 65534); 394 } 395 void add_message(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message) { 396 fbb_.AddOffset(NanoappMessage::VT_MESSAGE, message); 397 } 398 NanoappMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) 399 : fbb_(_fbb) { 400 start_ = fbb_.StartTable(); 401 } 402 NanoappMessageBuilder &operator=(const NanoappMessageBuilder &); 403 flatbuffers::Offset<NanoappMessage> Finish() { 404 const auto end = fbb_.EndTable(start_, 4); 405 auto o = flatbuffers::Offset<NanoappMessage>(end); 406 fbb_.Required(o, NanoappMessage::VT_MESSAGE); 407 return o; 408 } 409 }; 410 411 inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessage( 412 flatbuffers::FlatBufferBuilder &_fbb, 413 uint64_t app_id = 0, 414 uint32_t message_type = 0, 415 uint16_t host_endpoint = 65534, 416 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message = 0) { 417 NanoappMessageBuilder builder_(_fbb); 418 builder_.add_app_id(app_id); 419 builder_.add_message(message); 420 builder_.add_message_type(message_type); 421 builder_.add_host_endpoint(host_endpoint); 422 return builder_.Finish(); 423 } 424 425 inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessageDirect( 426 flatbuffers::FlatBufferBuilder &_fbb, 427 uint64_t app_id = 0, 428 uint32_t message_type = 0, 429 uint16_t host_endpoint = 65534, 430 const std::vector<uint8_t> *message = nullptr) { 431 return chre::fbs::CreateNanoappMessage( 432 _fbb, 433 app_id, 434 message_type, 435 host_endpoint, 436 message ? _fbb.CreateVector<uint8_t>(*message) : 0); 437 } 438 439 flatbuffers::Offset<NanoappMessage> CreateNanoappMessage(flatbuffers::FlatBufferBuilder &_fbb, const NanoappMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 440 441 struct HubInfoRequestT : public flatbuffers::NativeTable { 442 typedef HubInfoRequest TableType; 443 HubInfoRequestT() { 444 } 445 }; 446 447 struct HubInfoRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 448 typedef HubInfoRequestT NativeTableType; 449 bool Verify(flatbuffers::Verifier &verifier) const { 450 return VerifyTableStart(verifier) && 451 verifier.EndTable(); 452 } 453 HubInfoRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 454 void UnPackTo(HubInfoRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 455 static flatbuffers::Offset<HubInfoRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 456 }; 457 458 struct HubInfoRequestBuilder { 459 flatbuffers::FlatBufferBuilder &fbb_; 460 flatbuffers::uoffset_t start_; 461 HubInfoRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) 462 : fbb_(_fbb) { 463 start_ = fbb_.StartTable(); 464 } 465 HubInfoRequestBuilder &operator=(const HubInfoRequestBuilder &); 466 flatbuffers::Offset<HubInfoRequest> Finish() { 467 const auto end = fbb_.EndTable(start_, 0); 468 auto o = flatbuffers::Offset<HubInfoRequest>(end); 469 return o; 470 } 471 }; 472 473 inline flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest( 474 flatbuffers::FlatBufferBuilder &_fbb) { 475 HubInfoRequestBuilder builder_(_fbb); 476 return builder_.Finish(); 477 } 478 479 flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 480 481 struct HubInfoResponseT : public flatbuffers::NativeTable { 482 typedef HubInfoResponse TableType; 483 std::vector<int8_t> name; 484 std::vector<int8_t> vendor; 485 std::vector<int8_t> toolchain; 486 uint32_t platform_version; 487 uint32_t toolchain_version; 488 float peak_mips; 489 float stopped_power; 490 float sleep_power; 491 float peak_power; 492 uint32_t max_msg_len; 493 uint64_t platform_id; 494 uint32_t chre_platform_version; 495 HubInfoResponseT() 496 : platform_version(0), 497 toolchain_version(0), 498 peak_mips(0.0f), 499 stopped_power(0.0f), 500 sleep_power(0.0f), 501 peak_power(0.0f), 502 max_msg_len(0), 503 platform_id(0), 504 chre_platform_version(0) { 505 } 506 }; 507 508 struct HubInfoResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 509 typedef HubInfoResponseT NativeTableType; 510 enum { 511 VT_NAME = 4, 512 VT_VENDOR = 6, 513 VT_TOOLCHAIN = 8, 514 VT_PLATFORM_VERSION = 10, 515 VT_TOOLCHAIN_VERSION = 12, 516 VT_PEAK_MIPS = 14, 517 VT_STOPPED_POWER = 16, 518 VT_SLEEP_POWER = 18, 519 VT_PEAK_POWER = 20, 520 VT_MAX_MSG_LEN = 22, 521 VT_PLATFORM_ID = 24, 522 VT_CHRE_PLATFORM_VERSION = 26 523 }; 524 /// The name of the hub. Nominally a UTF-8 string, but note that we're not 525 /// using the built-in "string" data type from FlatBuffers here, because the 526 /// generated C++ uses std::string which is not well-supported in CHRE. This 527 /// applies for vendor and toolchain as well. 528 const flatbuffers::Vector<int8_t> *name() const { 529 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_NAME); 530 } 531 flatbuffers::Vector<int8_t> *mutable_name() { 532 return GetPointer<flatbuffers::Vector<int8_t> *>(VT_NAME); 533 } 534 const flatbuffers::Vector<int8_t> *vendor() const { 535 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_VENDOR); 536 } 537 flatbuffers::Vector<int8_t> *mutable_vendor() { 538 return GetPointer<flatbuffers::Vector<int8_t> *>(VT_VENDOR); 539 } 540 const flatbuffers::Vector<int8_t> *toolchain() const { 541 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_TOOLCHAIN); 542 } 543 flatbuffers::Vector<int8_t> *mutable_toolchain() { 544 return GetPointer<flatbuffers::Vector<int8_t> *>(VT_TOOLCHAIN); 545 } 546 /// Legacy platform version reported in the HAL; semantics not strictly 547 /// defined 548 uint32_t platform_version() const { 549 return GetField<uint32_t>(VT_PLATFORM_VERSION, 0); 550 } 551 bool mutate_platform_version(uint32_t _platform_version) { 552 return SetField(VT_PLATFORM_VERSION, _platform_version); 553 } 554 /// Toolchain version reported in the HAL; semantics not strictly defined 555 uint32_t toolchain_version() const { 556 return GetField<uint32_t>(VT_TOOLCHAIN_VERSION, 0); 557 } 558 bool mutate_toolchain_version(uint32_t _toolchain_version) { 559 return SetField(VT_TOOLCHAIN_VERSION, _toolchain_version); 560 } 561 float peak_mips() const { 562 return GetField<float>(VT_PEAK_MIPS, 0.0f); 563 } 564 bool mutate_peak_mips(float _peak_mips) { 565 return SetField(VT_PEAK_MIPS, _peak_mips); 566 } 567 float stopped_power() const { 568 return GetField<float>(VT_STOPPED_POWER, 0.0f); 569 } 570 bool mutate_stopped_power(float _stopped_power) { 571 return SetField(VT_STOPPED_POWER, _stopped_power); 572 } 573 float sleep_power() const { 574 return GetField<float>(VT_SLEEP_POWER, 0.0f); 575 } 576 bool mutate_sleep_power(float _sleep_power) { 577 return SetField(VT_SLEEP_POWER, _sleep_power); 578 } 579 float peak_power() const { 580 return GetField<float>(VT_PEAK_POWER, 0.0f); 581 } 582 bool mutate_peak_power(float _peak_power) { 583 return SetField(VT_PEAK_POWER, _peak_power); 584 } 585 /// Maximum size message that can be sent to a nanoapp 586 uint32_t max_msg_len() const { 587 return GetField<uint32_t>(VT_MAX_MSG_LEN, 0); 588 } 589 bool mutate_max_msg_len(uint32_t _max_msg_len) { 590 return SetField(VT_MAX_MSG_LEN, _max_msg_len); 591 } 592 /// @see chreGetPlatformId() 593 uint64_t platform_id() const { 594 return GetField<uint64_t>(VT_PLATFORM_ID, 0); 595 } 596 bool mutate_platform_id(uint64_t _platform_id) { 597 return SetField(VT_PLATFORM_ID, _platform_id); 598 } 599 /// @see chreGetVersion() 600 uint32_t chre_platform_version() const { 601 return GetField<uint32_t>(VT_CHRE_PLATFORM_VERSION, 0); 602 } 603 bool mutate_chre_platform_version(uint32_t _chre_platform_version) { 604 return SetField(VT_CHRE_PLATFORM_VERSION, _chre_platform_version); 605 } 606 bool Verify(flatbuffers::Verifier &verifier) const { 607 return VerifyTableStart(verifier) && 608 VerifyField<flatbuffers::uoffset_t>(verifier, VT_NAME) && 609 verifier.Verify(name()) && 610 VerifyField<flatbuffers::uoffset_t>(verifier, VT_VENDOR) && 611 verifier.Verify(vendor()) && 612 VerifyField<flatbuffers::uoffset_t>(verifier, VT_TOOLCHAIN) && 613 verifier.Verify(toolchain()) && 614 VerifyField<uint32_t>(verifier, VT_PLATFORM_VERSION) && 615 VerifyField<uint32_t>(verifier, VT_TOOLCHAIN_VERSION) && 616 VerifyField<float>(verifier, VT_PEAK_MIPS) && 617 VerifyField<float>(verifier, VT_STOPPED_POWER) && 618 VerifyField<float>(verifier, VT_SLEEP_POWER) && 619 VerifyField<float>(verifier, VT_PEAK_POWER) && 620 VerifyField<uint32_t>(verifier, VT_MAX_MSG_LEN) && 621 VerifyField<uint64_t>(verifier, VT_PLATFORM_ID) && 622 VerifyField<uint32_t>(verifier, VT_CHRE_PLATFORM_VERSION) && 623 verifier.EndTable(); 624 } 625 HubInfoResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 626 void UnPackTo(HubInfoResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 627 static flatbuffers::Offset<HubInfoResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 628 }; 629 630 struct HubInfoResponseBuilder { 631 flatbuffers::FlatBufferBuilder &fbb_; 632 flatbuffers::uoffset_t start_; 633 void add_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> name) { 634 fbb_.AddOffset(HubInfoResponse::VT_NAME, name); 635 } 636 void add_vendor(flatbuffers::Offset<flatbuffers::Vector<int8_t>> vendor) { 637 fbb_.AddOffset(HubInfoResponse::VT_VENDOR, vendor); 638 } 639 void add_toolchain(flatbuffers::Offset<flatbuffers::Vector<int8_t>> toolchain) { 640 fbb_.AddOffset(HubInfoResponse::VT_TOOLCHAIN, toolchain); 641 } 642 void add_platform_version(uint32_t platform_version) { 643 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_PLATFORM_VERSION, platform_version, 0); 644 } 645 void add_toolchain_version(uint32_t toolchain_version) { 646 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_TOOLCHAIN_VERSION, toolchain_version, 0); 647 } 648 void add_peak_mips(float peak_mips) { 649 fbb_.AddElement<float>(HubInfoResponse::VT_PEAK_MIPS, peak_mips, 0.0f); 650 } 651 void add_stopped_power(float stopped_power) { 652 fbb_.AddElement<float>(HubInfoResponse::VT_STOPPED_POWER, stopped_power, 0.0f); 653 } 654 void add_sleep_power(float sleep_power) { 655 fbb_.AddElement<float>(HubInfoResponse::VT_SLEEP_POWER, sleep_power, 0.0f); 656 } 657 void add_peak_power(float peak_power) { 658 fbb_.AddElement<float>(HubInfoResponse::VT_PEAK_POWER, peak_power, 0.0f); 659 } 660 void add_max_msg_len(uint32_t max_msg_len) { 661 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_MAX_MSG_LEN, max_msg_len, 0); 662 } 663 void add_platform_id(uint64_t platform_id) { 664 fbb_.AddElement<uint64_t>(HubInfoResponse::VT_PLATFORM_ID, platform_id, 0); 665 } 666 void add_chre_platform_version(uint32_t chre_platform_version) { 667 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_CHRE_PLATFORM_VERSION, chre_platform_version, 0); 668 } 669 HubInfoResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) 670 : fbb_(_fbb) { 671 start_ = fbb_.StartTable(); 672 } 673 HubInfoResponseBuilder &operator=(const HubInfoResponseBuilder &); 674 flatbuffers::Offset<HubInfoResponse> Finish() { 675 const auto end = fbb_.EndTable(start_, 12); 676 auto o = flatbuffers::Offset<HubInfoResponse>(end); 677 return o; 678 } 679 }; 680 681 inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponse( 682 flatbuffers::FlatBufferBuilder &_fbb, 683 flatbuffers::Offset<flatbuffers::Vector<int8_t>> name = 0, 684 flatbuffers::Offset<flatbuffers::Vector<int8_t>> vendor = 0, 685 flatbuffers::Offset<flatbuffers::Vector<int8_t>> toolchain = 0, 686 uint32_t platform_version = 0, 687 uint32_t toolchain_version = 0, 688 float peak_mips = 0.0f, 689 float stopped_power = 0.0f, 690 float sleep_power = 0.0f, 691 float peak_power = 0.0f, 692 uint32_t max_msg_len = 0, 693 uint64_t platform_id = 0, 694 uint32_t chre_platform_version = 0) { 695 HubInfoResponseBuilder builder_(_fbb); 696 builder_.add_platform_id(platform_id); 697 builder_.add_chre_platform_version(chre_platform_version); 698 builder_.add_max_msg_len(max_msg_len); 699 builder_.add_peak_power(peak_power); 700 builder_.add_sleep_power(sleep_power); 701 builder_.add_stopped_power(stopped_power); 702 builder_.add_peak_mips(peak_mips); 703 builder_.add_toolchain_version(toolchain_version); 704 builder_.add_platform_version(platform_version); 705 builder_.add_toolchain(toolchain); 706 builder_.add_vendor(vendor); 707 builder_.add_name(name); 708 return builder_.Finish(); 709 } 710 711 inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponseDirect( 712 flatbuffers::FlatBufferBuilder &_fbb, 713 const std::vector<int8_t> *name = nullptr, 714 const std::vector<int8_t> *vendor = nullptr, 715 const std::vector<int8_t> *toolchain = nullptr, 716 uint32_t platform_version = 0, 717 uint32_t toolchain_version = 0, 718 float peak_mips = 0.0f, 719 float stopped_power = 0.0f, 720 float sleep_power = 0.0f, 721 float peak_power = 0.0f, 722 uint32_t max_msg_len = 0, 723 uint64_t platform_id = 0, 724 uint32_t chre_platform_version = 0) { 725 return chre::fbs::CreateHubInfoResponse( 726 _fbb, 727 name ? _fbb.CreateVector<int8_t>(*name) : 0, 728 vendor ? _fbb.CreateVector<int8_t>(*vendor) : 0, 729 toolchain ? _fbb.CreateVector<int8_t>(*toolchain) : 0, 730 platform_version, 731 toolchain_version, 732 peak_mips, 733 stopped_power, 734 sleep_power, 735 peak_power, 736 max_msg_len, 737 platform_id, 738 chre_platform_version); 739 } 740 741 flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponse(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 742 743 struct NanoappListRequestT : public flatbuffers::NativeTable { 744 typedef NanoappListRequest TableType; 745 NanoappListRequestT() { 746 } 747 }; 748 749 struct NanoappListRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 750 typedef NanoappListRequestT NativeTableType; 751 bool Verify(flatbuffers::Verifier &verifier) const { 752 return VerifyTableStart(verifier) && 753 verifier.EndTable(); 754 } 755 NanoappListRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 756 void UnPackTo(NanoappListRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 757 static flatbuffers::Offset<NanoappListRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 758 }; 759 760 struct NanoappListRequestBuilder { 761 flatbuffers::FlatBufferBuilder &fbb_; 762 flatbuffers::uoffset_t start_; 763 NanoappListRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) 764 : fbb_(_fbb) { 765 start_ = fbb_.StartTable(); 766 } 767 NanoappListRequestBuilder &operator=(const NanoappListRequestBuilder &); 768 flatbuffers::Offset<NanoappListRequest> Finish() { 769 const auto end = fbb_.EndTable(start_, 0); 770 auto o = flatbuffers::Offset<NanoappListRequest>(end); 771 return o; 772 } 773 }; 774 775 inline flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest( 776 flatbuffers::FlatBufferBuilder &_fbb) { 777 NanoappListRequestBuilder builder_(_fbb); 778 return builder_.Finish(); 779 } 780 781 flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 782 783 struct NanoappListEntryT : public flatbuffers::NativeTable { 784 typedef NanoappListEntry TableType; 785 uint64_t app_id; 786 uint32_t version; 787 bool enabled; 788 bool is_system; 789 NanoappListEntryT() 790 : app_id(0), 791 version(0), 792 enabled(true), 793 is_system(false) { 794 } 795 }; 796 797 struct NanoappListEntry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 798 typedef NanoappListEntryT NativeTableType; 799 enum { 800 VT_APP_ID = 4, 801 VT_VERSION = 6, 802 VT_ENABLED = 8, 803 VT_IS_SYSTEM = 10 804 }; 805 uint64_t app_id() const { 806 return GetField<uint64_t>(VT_APP_ID, 0); 807 } 808 bool mutate_app_id(uint64_t _app_id) { 809 return SetField(VT_APP_ID, _app_id); 810 } 811 uint32_t version() const { 812 return GetField<uint32_t>(VT_VERSION, 0); 813 } 814 bool mutate_version(uint32_t _version) { 815 return SetField(VT_VERSION, _version); 816 } 817 bool enabled() const { 818 return GetField<uint8_t>(VT_ENABLED, 1) != 0; 819 } 820 bool mutate_enabled(bool _enabled) { 821 return SetField(VT_ENABLED, static_cast<uint8_t>(_enabled)); 822 } 823 /// Whether the nanoapp is a pre-loaded "system" nanoapp, i.e. one that should 824 /// not show up in the list of nanoapps in the context hub HAL. System 825 /// nanoapps are typically used to leverage CHRE for some device functionality 826 /// and do not interact via the context hub HAL. 827 bool is_system() const { 828 return GetField<uint8_t>(VT_IS_SYSTEM, 0) != 0; 829 } 830 bool mutate_is_system(bool _is_system) { 831 return SetField(VT_IS_SYSTEM, static_cast<uint8_t>(_is_system)); 832 } 833 bool Verify(flatbuffers::Verifier &verifier) const { 834 return VerifyTableStart(verifier) && 835 VerifyField<uint64_t>(verifier, VT_APP_ID) && 836 VerifyField<uint32_t>(verifier, VT_VERSION) && 837 VerifyField<uint8_t>(verifier, VT_ENABLED) && 838 VerifyField<uint8_t>(verifier, VT_IS_SYSTEM) && 839 verifier.EndTable(); 840 } 841 NanoappListEntryT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 842 void UnPackTo(NanoappListEntryT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 843 static flatbuffers::Offset<NanoappListEntry> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListEntryT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 844 }; 845 846 struct NanoappListEntryBuilder { 847 flatbuffers::FlatBufferBuilder &fbb_; 848 flatbuffers::uoffset_t start_; 849 void add_app_id(uint64_t app_id) { 850 fbb_.AddElement<uint64_t>(NanoappListEntry::VT_APP_ID, app_id, 0); 851 } 852 void add_version(uint32_t version) { 853 fbb_.AddElement<uint32_t>(NanoappListEntry::VT_VERSION, version, 0); 854 } 855 void add_enabled(bool enabled) { 856 fbb_.AddElement<uint8_t>(NanoappListEntry::VT_ENABLED, static_cast<uint8_t>(enabled), 1); 857 } 858 void add_is_system(bool is_system) { 859 fbb_.AddElement<uint8_t>(NanoappListEntry::VT_IS_SYSTEM, static_cast<uint8_t>(is_system), 0); 860 } 861 NanoappListEntryBuilder(flatbuffers::FlatBufferBuilder &_fbb) 862 : fbb_(_fbb) { 863 start_ = fbb_.StartTable(); 864 } 865 NanoappListEntryBuilder &operator=(const NanoappListEntryBuilder &); 866 flatbuffers::Offset<NanoappListEntry> Finish() { 867 const auto end = fbb_.EndTable(start_, 4); 868 auto o = flatbuffers::Offset<NanoappListEntry>(end); 869 return o; 870 } 871 }; 872 873 inline flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntry( 874 flatbuffers::FlatBufferBuilder &_fbb, 875 uint64_t app_id = 0, 876 uint32_t version = 0, 877 bool enabled = true, 878 bool is_system = false) { 879 NanoappListEntryBuilder builder_(_fbb); 880 builder_.add_app_id(app_id); 881 builder_.add_version(version); 882 builder_.add_is_system(is_system); 883 builder_.add_enabled(enabled); 884 return builder_.Finish(); 885 } 886 887 flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntry(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListEntryT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 888 889 struct NanoappListResponseT : public flatbuffers::NativeTable { 890 typedef NanoappListResponse TableType; 891 std::vector<std::unique_ptr<NanoappListEntryT>> nanoapps; 892 NanoappListResponseT() { 893 } 894 }; 895 896 struct NanoappListResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 897 typedef NanoappListResponseT NativeTableType; 898 enum { 899 VT_NANOAPPS = 4 900 }; 901 const flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>> *nanoapps() const { 902 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>> *>(VT_NANOAPPS); 903 } 904 flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>> *mutable_nanoapps() { 905 return GetPointer<flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>> *>(VT_NANOAPPS); 906 } 907 bool Verify(flatbuffers::Verifier &verifier) const { 908 return VerifyTableStart(verifier) && 909 VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_NANOAPPS) && 910 verifier.Verify(nanoapps()) && 911 verifier.VerifyVectorOfTables(nanoapps()) && 912 verifier.EndTable(); 913 } 914 NanoappListResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 915 void UnPackTo(NanoappListResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 916 static flatbuffers::Offset<NanoappListResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 917 }; 918 919 struct NanoappListResponseBuilder { 920 flatbuffers::FlatBufferBuilder &fbb_; 921 flatbuffers::uoffset_t start_; 922 void add_nanoapps(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>>> nanoapps) { 923 fbb_.AddOffset(NanoappListResponse::VT_NANOAPPS, nanoapps); 924 } 925 NanoappListResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) 926 : fbb_(_fbb) { 927 start_ = fbb_.StartTable(); 928 } 929 NanoappListResponseBuilder &operator=(const NanoappListResponseBuilder &); 930 flatbuffers::Offset<NanoappListResponse> Finish() { 931 const auto end = fbb_.EndTable(start_, 1); 932 auto o = flatbuffers::Offset<NanoappListResponse>(end); 933 fbb_.Required(o, NanoappListResponse::VT_NANOAPPS); 934 return o; 935 } 936 }; 937 938 inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse( 939 flatbuffers::FlatBufferBuilder &_fbb, 940 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>>> nanoapps = 0) { 941 NanoappListResponseBuilder builder_(_fbb); 942 builder_.add_nanoapps(nanoapps); 943 return builder_.Finish(); 944 } 945 946 inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponseDirect( 947 flatbuffers::FlatBufferBuilder &_fbb, 948 const std::vector<flatbuffers::Offset<NanoappListEntry>> *nanoapps = nullptr) { 949 return chre::fbs::CreateNanoappListResponse( 950 _fbb, 951 nanoapps ? _fbb.CreateVector<flatbuffers::Offset<NanoappListEntry>>(*nanoapps) : 0); 952 } 953 954 flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 955 956 struct LoadNanoappRequestT : public flatbuffers::NativeTable { 957 typedef LoadNanoappRequest TableType; 958 uint32_t transaction_id; 959 uint64_t app_id; 960 uint32_t app_version; 961 uint32_t target_api_version; 962 std::vector<uint8_t> app_binary; 963 uint32_t fragment_id; 964 uint32_t total_app_size; 965 LoadNanoappRequestT() 966 : transaction_id(0), 967 app_id(0), 968 app_version(0), 969 target_api_version(0), 970 fragment_id(0), 971 total_app_size(0) { 972 } 973 }; 974 975 /// Represents a request for loading a nanoapp. 976 /// The loading may optionally be fragmented into multiple sequential requests, 977 /// which will follow the following steps: 978 /// 1. The loader sends a LoadNanoappRequest message to CHRE. If the request 979 /// is fragmented, then the fields fragment_id and total_app_size must 980 /// be defined. Parallel loading for the different clients is supported. 981 /// If there is already a pending request for the client, the pending request 982 /// will abort and fail, and the new request will be started. 983 /// 2. CHRE preallocates the required amount of memory, and loads app_binary, 984 /// appending to already loaded fragments as appropriate. 985 /// 3. If the request is fragmented, then the requestor must sequentially send 986 /// multiple LoadNanoappRequest with incremental nanoapp binary fragments. 987 /// CHRE will respond with LoadNanoappResponse for each request. For 988 /// requests starting from the second fragment, all fields except 989 /// fragment_id and app_binary should be ignored by CHRE. 990 /// 991 /// Once the LoadNanoappRepsonse for the last fragment is received 992 /// by the HAL, the HAL client will receive a callback indicating the 993 /// completion/failure of a load request. 994 /// 995 /// If any request fragment is lost, then the entire load request will be 996 /// considered to have failed. If the request times out (e.g. the requestor 997 /// process crashes), then the load request will be cancelled at CHRE and fail. 998 struct LoadNanoappRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 999 typedef LoadNanoappRequestT NativeTableType; 1000 enum { 1001 VT_TRANSACTION_ID = 4, 1002 VT_APP_ID = 6, 1003 VT_APP_VERSION = 8, 1004 VT_TARGET_API_VERSION = 10, 1005 VT_APP_BINARY = 12, 1006 VT_FRAGMENT_ID = 14, 1007 VT_TOTAL_APP_SIZE = 16 1008 }; 1009 uint32_t transaction_id() const { 1010 return GetField<uint32_t>(VT_TRANSACTION_ID, 0); 1011 } 1012 bool mutate_transaction_id(uint32_t _transaction_id) { 1013 return SetField(VT_TRANSACTION_ID, _transaction_id); 1014 } 1015 uint64_t app_id() const { 1016 return GetField<uint64_t>(VT_APP_ID, 0); 1017 } 1018 bool mutate_app_id(uint64_t _app_id) { 1019 return SetField(VT_APP_ID, _app_id); 1020 } 1021 uint32_t app_version() const { 1022 return GetField<uint32_t>(VT_APP_VERSION, 0); 1023 } 1024 bool mutate_app_version(uint32_t _app_version) { 1025 return SetField(VT_APP_VERSION, _app_version); 1026 } 1027 uint32_t target_api_version() const { 1028 return GetField<uint32_t>(VT_TARGET_API_VERSION, 0); 1029 } 1030 bool mutate_target_api_version(uint32_t _target_api_version) { 1031 return SetField(VT_TARGET_API_VERSION, _target_api_version); 1032 } 1033 const flatbuffers::Vector<uint8_t> *app_binary() const { 1034 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_APP_BINARY); 1035 } 1036 flatbuffers::Vector<uint8_t> *mutable_app_binary() { 1037 return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_APP_BINARY); 1038 } 1039 /// Fields that are relevant for fragmented loading 1040 /// The framgent count starts at 1 and should end at the total number of 1041 /// fragments. For clients that do not support fragmented loading, the 1042 /// default behavior should be to assume one fragment. 1043 uint32_t fragment_id() const { 1044 return GetField<uint32_t>(VT_FRAGMENT_ID, 0); 1045 } 1046 bool mutate_fragment_id(uint32_t _fragment_id) { 1047 return SetField(VT_FRAGMENT_ID, _fragment_id); 1048 } 1049 uint32_t total_app_size() const { 1050 return GetField<uint32_t>(VT_TOTAL_APP_SIZE, 0); 1051 } 1052 bool mutate_total_app_size(uint32_t _total_app_size) { 1053 return SetField(VT_TOTAL_APP_SIZE, _total_app_size); 1054 } 1055 bool Verify(flatbuffers::Verifier &verifier) const { 1056 return VerifyTableStart(verifier) && 1057 VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) && 1058 VerifyField<uint64_t>(verifier, VT_APP_ID) && 1059 VerifyField<uint32_t>(verifier, VT_APP_VERSION) && 1060 VerifyField<uint32_t>(verifier, VT_TARGET_API_VERSION) && 1061 VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_APP_BINARY) && 1062 verifier.Verify(app_binary()) && 1063 VerifyField<uint32_t>(verifier, VT_FRAGMENT_ID) && 1064 VerifyField<uint32_t>(verifier, VT_TOTAL_APP_SIZE) && 1065 verifier.EndTable(); 1066 } 1067 LoadNanoappRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1068 void UnPackTo(LoadNanoappRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1069 static flatbuffers::Offset<LoadNanoappRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1070 }; 1071 1072 struct LoadNanoappRequestBuilder { 1073 flatbuffers::FlatBufferBuilder &fbb_; 1074 flatbuffers::uoffset_t start_; 1075 void add_transaction_id(uint32_t transaction_id) { 1076 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TRANSACTION_ID, transaction_id, 0); 1077 } 1078 void add_app_id(uint64_t app_id) { 1079 fbb_.AddElement<uint64_t>(LoadNanoappRequest::VT_APP_ID, app_id, 0); 1080 } 1081 void add_app_version(uint32_t app_version) { 1082 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_APP_VERSION, app_version, 0); 1083 } 1084 void add_target_api_version(uint32_t target_api_version) { 1085 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TARGET_API_VERSION, target_api_version, 0); 1086 } 1087 void add_app_binary(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary) { 1088 fbb_.AddOffset(LoadNanoappRequest::VT_APP_BINARY, app_binary); 1089 } 1090 void add_fragment_id(uint32_t fragment_id) { 1091 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_FRAGMENT_ID, fragment_id, 0); 1092 } 1093 void add_total_app_size(uint32_t total_app_size) { 1094 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TOTAL_APP_SIZE, total_app_size, 0); 1095 } 1096 LoadNanoappRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) 1097 : fbb_(_fbb) { 1098 start_ = fbb_.StartTable(); 1099 } 1100 LoadNanoappRequestBuilder &operator=(const LoadNanoappRequestBuilder &); 1101 flatbuffers::Offset<LoadNanoappRequest> Finish() { 1102 const auto end = fbb_.EndTable(start_, 7); 1103 auto o = flatbuffers::Offset<LoadNanoappRequest>(end); 1104 fbb_.Required(o, LoadNanoappRequest::VT_APP_BINARY); 1105 return o; 1106 } 1107 }; 1108 1109 inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest( 1110 flatbuffers::FlatBufferBuilder &_fbb, 1111 uint32_t transaction_id = 0, 1112 uint64_t app_id = 0, 1113 uint32_t app_version = 0, 1114 uint32_t target_api_version = 0, 1115 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary = 0, 1116 uint32_t fragment_id = 0, 1117 uint32_t total_app_size = 0) { 1118 LoadNanoappRequestBuilder builder_(_fbb); 1119 builder_.add_app_id(app_id); 1120 builder_.add_total_app_size(total_app_size); 1121 builder_.add_fragment_id(fragment_id); 1122 builder_.add_app_binary(app_binary); 1123 builder_.add_target_api_version(target_api_version); 1124 builder_.add_app_version(app_version); 1125 builder_.add_transaction_id(transaction_id); 1126 return builder_.Finish(); 1127 } 1128 1129 inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequestDirect( 1130 flatbuffers::FlatBufferBuilder &_fbb, 1131 uint32_t transaction_id = 0, 1132 uint64_t app_id = 0, 1133 uint32_t app_version = 0, 1134 uint32_t target_api_version = 0, 1135 const std::vector<uint8_t> *app_binary = nullptr, 1136 uint32_t fragment_id = 0, 1137 uint32_t total_app_size = 0) { 1138 return chre::fbs::CreateLoadNanoappRequest( 1139 _fbb, 1140 transaction_id, 1141 app_id, 1142 app_version, 1143 target_api_version, 1144 app_binary ? _fbb.CreateVector<uint8_t>(*app_binary) : 0, 1145 fragment_id, 1146 total_app_size); 1147 } 1148 1149 flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1150 1151 struct LoadNanoappResponseT : public flatbuffers::NativeTable { 1152 typedef LoadNanoappResponse TableType; 1153 uint32_t transaction_id; 1154 bool success; 1155 uint32_t fragment_id; 1156 LoadNanoappResponseT() 1157 : transaction_id(0), 1158 success(false), 1159 fragment_id(0) { 1160 } 1161 }; 1162 1163 struct LoadNanoappResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 1164 typedef LoadNanoappResponseT NativeTableType; 1165 enum { 1166 VT_TRANSACTION_ID = 4, 1167 VT_SUCCESS = 6, 1168 VT_FRAGMENT_ID = 8 1169 }; 1170 uint32_t transaction_id() const { 1171 return GetField<uint32_t>(VT_TRANSACTION_ID, 0); 1172 } 1173 bool mutate_transaction_id(uint32_t _transaction_id) { 1174 return SetField(VT_TRANSACTION_ID, _transaction_id); 1175 } 1176 /// Denotes whether a load request succeeded or failed. 1177 /// If any fragment of a load request fails, the entire load request for 1178 /// the same transaction will fail. 1179 bool success() const { 1180 return GetField<uint8_t>(VT_SUCCESS, 0) != 0; 1181 } 1182 bool mutate_success(bool _success) { 1183 return SetField(VT_SUCCESS, static_cast<uint8_t>(_success)); 1184 } 1185 /// The fragment count of the load reponse is for. 1186 uint32_t fragment_id() const { 1187 return GetField<uint32_t>(VT_FRAGMENT_ID, 0); 1188 } 1189 bool mutate_fragment_id(uint32_t _fragment_id) { 1190 return SetField(VT_FRAGMENT_ID, _fragment_id); 1191 } 1192 bool Verify(flatbuffers::Verifier &verifier) const { 1193 return VerifyTableStart(verifier) && 1194 VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) && 1195 VerifyField<uint8_t>(verifier, VT_SUCCESS) && 1196 VerifyField<uint32_t>(verifier, VT_FRAGMENT_ID) && 1197 verifier.EndTable(); 1198 } 1199 LoadNanoappResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1200 void UnPackTo(LoadNanoappResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1201 static flatbuffers::Offset<LoadNanoappResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1202 }; 1203 1204 struct LoadNanoappResponseBuilder { 1205 flatbuffers::FlatBufferBuilder &fbb_; 1206 flatbuffers::uoffset_t start_; 1207 void add_transaction_id(uint32_t transaction_id) { 1208 fbb_.AddElement<uint32_t>(LoadNanoappResponse::VT_TRANSACTION_ID, transaction_id, 0); 1209 } 1210 void add_success(bool success) { 1211 fbb_.AddElement<uint8_t>(LoadNanoappResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0); 1212 } 1213 void add_fragment_id(uint32_t fragment_id) { 1214 fbb_.AddElement<uint32_t>(LoadNanoappResponse::VT_FRAGMENT_ID, fragment_id, 0); 1215 } 1216 LoadNanoappResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) 1217 : fbb_(_fbb) { 1218 start_ = fbb_.StartTable(); 1219 } 1220 LoadNanoappResponseBuilder &operator=(const LoadNanoappResponseBuilder &); 1221 flatbuffers::Offset<LoadNanoappResponse> Finish() { 1222 const auto end = fbb_.EndTable(start_, 3); 1223 auto o = flatbuffers::Offset<LoadNanoappResponse>(end); 1224 return o; 1225 } 1226 }; 1227 1228 inline flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse( 1229 flatbuffers::FlatBufferBuilder &_fbb, 1230 uint32_t transaction_id = 0, 1231 bool success = false, 1232 uint32_t fragment_id = 0) { 1233 LoadNanoappResponseBuilder builder_(_fbb); 1234 builder_.add_fragment_id(fragment_id); 1235 builder_.add_transaction_id(transaction_id); 1236 builder_.add_success(success); 1237 return builder_.Finish(); 1238 } 1239 1240 flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1241 1242 struct UnloadNanoappRequestT : public flatbuffers::NativeTable { 1243 typedef UnloadNanoappRequest TableType; 1244 uint32_t transaction_id; 1245 uint64_t app_id; 1246 bool allow_system_nanoapp_unload; 1247 UnloadNanoappRequestT() 1248 : transaction_id(0), 1249 app_id(0), 1250 allow_system_nanoapp_unload(false) { 1251 } 1252 }; 1253 1254 struct UnloadNanoappRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 1255 typedef UnloadNanoappRequestT NativeTableType; 1256 enum { 1257 VT_TRANSACTION_ID = 4, 1258 VT_APP_ID = 6, 1259 VT_ALLOW_SYSTEM_NANOAPP_UNLOAD = 8 1260 }; 1261 uint32_t transaction_id() const { 1262 return GetField<uint32_t>(VT_TRANSACTION_ID, 0); 1263 } 1264 bool mutate_transaction_id(uint32_t _transaction_id) { 1265 return SetField(VT_TRANSACTION_ID, _transaction_id); 1266 } 1267 uint64_t app_id() const { 1268 return GetField<uint64_t>(VT_APP_ID, 0); 1269 } 1270 bool mutate_app_id(uint64_t _app_id) { 1271 return SetField(VT_APP_ID, _app_id); 1272 } 1273 /// Set to true to allow this request to unload nanoapps identified as "system 1274 /// nanoapps", i.e. ones with is_system set to true in NanoappListResponse. 1275 bool allow_system_nanoapp_unload() const { 1276 return GetField<uint8_t>(VT_ALLOW_SYSTEM_NANOAPP_UNLOAD, 0) != 0; 1277 } 1278 bool mutate_allow_system_nanoapp_unload(bool _allow_system_nanoapp_unload) { 1279 return SetField(VT_ALLOW_SYSTEM_NANOAPP_UNLOAD, static_cast<uint8_t>(_allow_system_nanoapp_unload)); 1280 } 1281 bool Verify(flatbuffers::Verifier &verifier) const { 1282 return VerifyTableStart(verifier) && 1283 VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) && 1284 VerifyField<uint64_t>(verifier, VT_APP_ID) && 1285 VerifyField<uint8_t>(verifier, VT_ALLOW_SYSTEM_NANOAPP_UNLOAD) && 1286 verifier.EndTable(); 1287 } 1288 UnloadNanoappRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1289 void UnPackTo(UnloadNanoappRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1290 static flatbuffers::Offset<UnloadNanoappRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1291 }; 1292 1293 struct UnloadNanoappRequestBuilder { 1294 flatbuffers::FlatBufferBuilder &fbb_; 1295 flatbuffers::uoffset_t start_; 1296 void add_transaction_id(uint32_t transaction_id) { 1297 fbb_.AddElement<uint32_t>(UnloadNanoappRequest::VT_TRANSACTION_ID, transaction_id, 0); 1298 } 1299 void add_app_id(uint64_t app_id) { 1300 fbb_.AddElement<uint64_t>(UnloadNanoappRequest::VT_APP_ID, app_id, 0); 1301 } 1302 void add_allow_system_nanoapp_unload(bool allow_system_nanoapp_unload) { 1303 fbb_.AddElement<uint8_t>(UnloadNanoappRequest::VT_ALLOW_SYSTEM_NANOAPP_UNLOAD, static_cast<uint8_t>(allow_system_nanoapp_unload), 0); 1304 } 1305 UnloadNanoappRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) 1306 : fbb_(_fbb) { 1307 start_ = fbb_.StartTable(); 1308 } 1309 UnloadNanoappRequestBuilder &operator=(const UnloadNanoappRequestBuilder &); 1310 flatbuffers::Offset<UnloadNanoappRequest> Finish() { 1311 const auto end = fbb_.EndTable(start_, 3); 1312 auto o = flatbuffers::Offset<UnloadNanoappRequest>(end); 1313 return o; 1314 } 1315 }; 1316 1317 inline flatbuffers::Offset<UnloadNanoappRequest> CreateUnloadNanoappRequest( 1318 flatbuffers::FlatBufferBuilder &_fbb, 1319 uint32_t transaction_id = 0, 1320 uint64_t app_id = 0, 1321 bool allow_system_nanoapp_unload = false) { 1322 UnloadNanoappRequestBuilder builder_(_fbb); 1323 builder_.add_app_id(app_id); 1324 builder_.add_transaction_id(transaction_id); 1325 builder_.add_allow_system_nanoapp_unload(allow_system_nanoapp_unload); 1326 return builder_.Finish(); 1327 } 1328 1329 flatbuffers::Offset<UnloadNanoappRequest> CreateUnloadNanoappRequest(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1330 1331 struct UnloadNanoappResponseT : public flatbuffers::NativeTable { 1332 typedef UnloadNanoappResponse TableType; 1333 uint32_t transaction_id; 1334 bool success; 1335 UnloadNanoappResponseT() 1336 : transaction_id(0), 1337 success(false) { 1338 } 1339 }; 1340 1341 struct UnloadNanoappResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 1342 typedef UnloadNanoappResponseT NativeTableType; 1343 enum { 1344 VT_TRANSACTION_ID = 4, 1345 VT_SUCCESS = 6 1346 }; 1347 uint32_t transaction_id() const { 1348 return GetField<uint32_t>(VT_TRANSACTION_ID, 0); 1349 } 1350 bool mutate_transaction_id(uint32_t _transaction_id) { 1351 return SetField(VT_TRANSACTION_ID, _transaction_id); 1352 } 1353 bool success() const { 1354 return GetField<uint8_t>(VT_SUCCESS, 0) != 0; 1355 } 1356 bool mutate_success(bool _success) { 1357 return SetField(VT_SUCCESS, static_cast<uint8_t>(_success)); 1358 } 1359 bool Verify(flatbuffers::Verifier &verifier) const { 1360 return VerifyTableStart(verifier) && 1361 VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) && 1362 VerifyField<uint8_t>(verifier, VT_SUCCESS) && 1363 verifier.EndTable(); 1364 } 1365 UnloadNanoappResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1366 void UnPackTo(UnloadNanoappResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1367 static flatbuffers::Offset<UnloadNanoappResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1368 }; 1369 1370 struct UnloadNanoappResponseBuilder { 1371 flatbuffers::FlatBufferBuilder &fbb_; 1372 flatbuffers::uoffset_t start_; 1373 void add_transaction_id(uint32_t transaction_id) { 1374 fbb_.AddElement<uint32_t>(UnloadNanoappResponse::VT_TRANSACTION_ID, transaction_id, 0); 1375 } 1376 void add_success(bool success) { 1377 fbb_.AddElement<uint8_t>(UnloadNanoappResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0); 1378 } 1379 UnloadNanoappResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) 1380 : fbb_(_fbb) { 1381 start_ = fbb_.StartTable(); 1382 } 1383 UnloadNanoappResponseBuilder &operator=(const UnloadNanoappResponseBuilder &); 1384 flatbuffers::Offset<UnloadNanoappResponse> Finish() { 1385 const auto end = fbb_.EndTable(start_, 2); 1386 auto o = flatbuffers::Offset<UnloadNanoappResponse>(end); 1387 return o; 1388 } 1389 }; 1390 1391 inline flatbuffers::Offset<UnloadNanoappResponse> CreateUnloadNanoappResponse( 1392 flatbuffers::FlatBufferBuilder &_fbb, 1393 uint32_t transaction_id = 0, 1394 bool success = false) { 1395 UnloadNanoappResponseBuilder builder_(_fbb); 1396 builder_.add_transaction_id(transaction_id); 1397 builder_.add_success(success); 1398 return builder_.Finish(); 1399 } 1400 1401 flatbuffers::Offset<UnloadNanoappResponse> CreateUnloadNanoappResponse(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1402 1403 struct LogMessageT : public flatbuffers::NativeTable { 1404 typedef LogMessage TableType; 1405 std::vector<int8_t> buffer; 1406 LogMessageT() { 1407 } 1408 }; 1409 1410 /// Represents log messages from CHRE. 1411 struct LogMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 1412 typedef LogMessageT NativeTableType; 1413 enum { 1414 VT_BUFFER = 4 1415 }; 1416 /// A buffer containing formatted log data. A flat array is used here to avoid 1417 /// overhead in serializing and deserializing. The format is as follows: 1418 /// 1419 /// uint8_t - log level (1 = error, 2 = warning, 1420 /// 3 = info, 4 = debug) 1421 /// uint64_t, little-endian - timestamp in nanoseconds 1422 /// char[] - message to log 1423 /// char, \0 - null-terminator 1424 /// 1425 /// This pattern repeats until the end of the buffer for multiple log 1426 /// messages. The last byte will always be a null-terminator. There are no 1427 /// padding bytes between these fields. Treat this like a packed struct and be 1428 /// cautious with unaligned access when reading/writing this buffer. 1429 const flatbuffers::Vector<int8_t> *buffer() const { 1430 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_BUFFER); 1431 } 1432 flatbuffers::Vector<int8_t> *mutable_buffer() { 1433 return GetPointer<flatbuffers::Vector<int8_t> *>(VT_BUFFER); 1434 } 1435 bool Verify(flatbuffers::Verifier &verifier) const { 1436 return VerifyTableStart(verifier) && 1437 VerifyField<flatbuffers::uoffset_t>(verifier, VT_BUFFER) && 1438 verifier.Verify(buffer()) && 1439 verifier.EndTable(); 1440 } 1441 LogMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1442 void UnPackTo(LogMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1443 static flatbuffers::Offset<LogMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1444 }; 1445 1446 struct LogMessageBuilder { 1447 flatbuffers::FlatBufferBuilder &fbb_; 1448 flatbuffers::uoffset_t start_; 1449 void add_buffer(flatbuffers::Offset<flatbuffers::Vector<int8_t>> buffer) { 1450 fbb_.AddOffset(LogMessage::VT_BUFFER, buffer); 1451 } 1452 LogMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) 1453 : fbb_(_fbb) { 1454 start_ = fbb_.StartTable(); 1455 } 1456 LogMessageBuilder &operator=(const LogMessageBuilder &); 1457 flatbuffers::Offset<LogMessage> Finish() { 1458 const auto end = fbb_.EndTable(start_, 1); 1459 auto o = flatbuffers::Offset<LogMessage>(end); 1460 return o; 1461 } 1462 }; 1463 1464 inline flatbuffers::Offset<LogMessage> CreateLogMessage( 1465 flatbuffers::FlatBufferBuilder &_fbb, 1466 flatbuffers::Offset<flatbuffers::Vector<int8_t>> buffer = 0) { 1467 LogMessageBuilder builder_(_fbb); 1468 builder_.add_buffer(buffer); 1469 return builder_.Finish(); 1470 } 1471 1472 inline flatbuffers::Offset<LogMessage> CreateLogMessageDirect( 1473 flatbuffers::FlatBufferBuilder &_fbb, 1474 const std::vector<int8_t> *buffer = nullptr) { 1475 return chre::fbs::CreateLogMessage( 1476 _fbb, 1477 buffer ? _fbb.CreateVector<int8_t>(*buffer) : 0); 1478 } 1479 1480 flatbuffers::Offset<LogMessage> CreateLogMessage(flatbuffers::FlatBufferBuilder &_fbb, const LogMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1481 1482 struct TimeSyncMessageT : public flatbuffers::NativeTable { 1483 typedef TimeSyncMessage TableType; 1484 int64_t offset; 1485 TimeSyncMessageT() 1486 : offset(0) { 1487 } 1488 }; 1489 1490 /// Represents a message sent to CHRE to indicate AP timestamp for time sync 1491 struct TimeSyncMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 1492 typedef TimeSyncMessageT NativeTableType; 1493 enum { 1494 VT_OFFSET = 4 1495 }; 1496 /// Offset between AP and CHRE timestamp 1497 int64_t offset() const { 1498 return GetField<int64_t>(VT_OFFSET, 0); 1499 } 1500 bool mutate_offset(int64_t _offset) { 1501 return SetField(VT_OFFSET, _offset); 1502 } 1503 bool Verify(flatbuffers::Verifier &verifier) const { 1504 return VerifyTableStart(verifier) && 1505 VerifyField<int64_t>(verifier, VT_OFFSET) && 1506 verifier.EndTable(); 1507 } 1508 TimeSyncMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1509 void UnPackTo(TimeSyncMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1510 static flatbuffers::Offset<TimeSyncMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TimeSyncMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1511 }; 1512 1513 struct TimeSyncMessageBuilder { 1514 flatbuffers::FlatBufferBuilder &fbb_; 1515 flatbuffers::uoffset_t start_; 1516 void add_offset(int64_t offset) { 1517 fbb_.AddElement<int64_t>(TimeSyncMessage::VT_OFFSET, offset, 0); 1518 } 1519 TimeSyncMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) 1520 : fbb_(_fbb) { 1521 start_ = fbb_.StartTable(); 1522 } 1523 TimeSyncMessageBuilder &operator=(const TimeSyncMessageBuilder &); 1524 flatbuffers::Offset<TimeSyncMessage> Finish() { 1525 const auto end = fbb_.EndTable(start_, 1); 1526 auto o = flatbuffers::Offset<TimeSyncMessage>(end); 1527 return o; 1528 } 1529 }; 1530 1531 inline flatbuffers::Offset<TimeSyncMessage> CreateTimeSyncMessage( 1532 flatbuffers::FlatBufferBuilder &_fbb, 1533 int64_t offset = 0) { 1534 TimeSyncMessageBuilder builder_(_fbb); 1535 builder_.add_offset(offset); 1536 return builder_.Finish(); 1537 } 1538 1539 flatbuffers::Offset<TimeSyncMessage> CreateTimeSyncMessage(flatbuffers::FlatBufferBuilder &_fbb, const TimeSyncMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1540 1541 struct DebugDumpRequestT : public flatbuffers::NativeTable { 1542 typedef DebugDumpRequest TableType; 1543 DebugDumpRequestT() { 1544 } 1545 }; 1546 1547 /// A request to gather and return debugging information. Only one debug dump 1548 /// session can be active at a time. Upon accepting a request, zero or more 1549 /// DebugDumpData messages are generated, followed by a DebugDumpResponse 1550 /// indicating the completion of the operation. 1551 struct DebugDumpRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 1552 typedef DebugDumpRequestT NativeTableType; 1553 bool Verify(flatbuffers::Verifier &verifier) const { 1554 return VerifyTableStart(verifier) && 1555 verifier.EndTable(); 1556 } 1557 DebugDumpRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1558 void UnPackTo(DebugDumpRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1559 static flatbuffers::Offset<DebugDumpRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1560 }; 1561 1562 struct DebugDumpRequestBuilder { 1563 flatbuffers::FlatBufferBuilder &fbb_; 1564 flatbuffers::uoffset_t start_; 1565 DebugDumpRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) 1566 : fbb_(_fbb) { 1567 start_ = fbb_.StartTable(); 1568 } 1569 DebugDumpRequestBuilder &operator=(const DebugDumpRequestBuilder &); 1570 flatbuffers::Offset<DebugDumpRequest> Finish() { 1571 const auto end = fbb_.EndTable(start_, 0); 1572 auto o = flatbuffers::Offset<DebugDumpRequest>(end); 1573 return o; 1574 } 1575 }; 1576 1577 inline flatbuffers::Offset<DebugDumpRequest> CreateDebugDumpRequest( 1578 flatbuffers::FlatBufferBuilder &_fbb) { 1579 DebugDumpRequestBuilder builder_(_fbb); 1580 return builder_.Finish(); 1581 } 1582 1583 flatbuffers::Offset<DebugDumpRequest> CreateDebugDumpRequest(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1584 1585 struct DebugDumpDataT : public flatbuffers::NativeTable { 1586 typedef DebugDumpData TableType; 1587 std::vector<int8_t> debug_str; 1588 DebugDumpDataT() { 1589 } 1590 }; 1591 1592 struct DebugDumpData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 1593 typedef DebugDumpDataT NativeTableType; 1594 enum { 1595 VT_DEBUG_STR = 4 1596 }; 1597 /// Null-terminated ASCII string containing debugging information 1598 const flatbuffers::Vector<int8_t> *debug_str() const { 1599 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_DEBUG_STR); 1600 } 1601 flatbuffers::Vector<int8_t> *mutable_debug_str() { 1602 return GetPointer<flatbuffers::Vector<int8_t> *>(VT_DEBUG_STR); 1603 } 1604 bool Verify(flatbuffers::Verifier &verifier) const { 1605 return VerifyTableStart(verifier) && 1606 VerifyField<flatbuffers::uoffset_t>(verifier, VT_DEBUG_STR) && 1607 verifier.Verify(debug_str()) && 1608 verifier.EndTable(); 1609 } 1610 DebugDumpDataT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1611 void UnPackTo(DebugDumpDataT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1612 static flatbuffers::Offset<DebugDumpData> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpDataT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1613 }; 1614 1615 struct DebugDumpDataBuilder { 1616 flatbuffers::FlatBufferBuilder &fbb_; 1617 flatbuffers::uoffset_t start_; 1618 void add_debug_str(flatbuffers::Offset<flatbuffers::Vector<int8_t>> debug_str) { 1619 fbb_.AddOffset(DebugDumpData::VT_DEBUG_STR, debug_str); 1620 } 1621 DebugDumpDataBuilder(flatbuffers::FlatBufferBuilder &_fbb) 1622 : fbb_(_fbb) { 1623 start_ = fbb_.StartTable(); 1624 } 1625 DebugDumpDataBuilder &operator=(const DebugDumpDataBuilder &); 1626 flatbuffers::Offset<DebugDumpData> Finish() { 1627 const auto end = fbb_.EndTable(start_, 1); 1628 auto o = flatbuffers::Offset<DebugDumpData>(end); 1629 return o; 1630 } 1631 }; 1632 1633 inline flatbuffers::Offset<DebugDumpData> CreateDebugDumpData( 1634 flatbuffers::FlatBufferBuilder &_fbb, 1635 flatbuffers::Offset<flatbuffers::Vector<int8_t>> debug_str = 0) { 1636 DebugDumpDataBuilder builder_(_fbb); 1637 builder_.add_debug_str(debug_str); 1638 return builder_.Finish(); 1639 } 1640 1641 inline flatbuffers::Offset<DebugDumpData> CreateDebugDumpDataDirect( 1642 flatbuffers::FlatBufferBuilder &_fbb, 1643 const std::vector<int8_t> *debug_str = nullptr) { 1644 return chre::fbs::CreateDebugDumpData( 1645 _fbb, 1646 debug_str ? _fbb.CreateVector<int8_t>(*debug_str) : 0); 1647 } 1648 1649 flatbuffers::Offset<DebugDumpData> CreateDebugDumpData(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpDataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1650 1651 struct DebugDumpResponseT : public flatbuffers::NativeTable { 1652 typedef DebugDumpResponse TableType; 1653 bool success; 1654 uint32_t data_count; 1655 DebugDumpResponseT() 1656 : success(false), 1657 data_count(0) { 1658 } 1659 }; 1660 1661 struct DebugDumpResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 1662 typedef DebugDumpResponseT NativeTableType; 1663 enum { 1664 VT_SUCCESS = 4, 1665 VT_DATA_COUNT = 6 1666 }; 1667 /// true if the request was accepted and a dump was performed, false if it was 1668 /// rejected or failed to complete for some reason 1669 bool success() const { 1670 return GetField<uint8_t>(VT_SUCCESS, 0) != 0; 1671 } 1672 bool mutate_success(bool _success) { 1673 return SetField(VT_SUCCESS, static_cast<uint8_t>(_success)); 1674 } 1675 /// The number of DebugDumpData messages sent in this session 1676 uint32_t data_count() const { 1677 return GetField<uint32_t>(VT_DATA_COUNT, 0); 1678 } 1679 bool mutate_data_count(uint32_t _data_count) { 1680 return SetField(VT_DATA_COUNT, _data_count); 1681 } 1682 bool Verify(flatbuffers::Verifier &verifier) const { 1683 return VerifyTableStart(verifier) && 1684 VerifyField<uint8_t>(verifier, VT_SUCCESS) && 1685 VerifyField<uint32_t>(verifier, VT_DATA_COUNT) && 1686 verifier.EndTable(); 1687 } 1688 DebugDumpResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1689 void UnPackTo(DebugDumpResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1690 static flatbuffers::Offset<DebugDumpResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1691 }; 1692 1693 struct DebugDumpResponseBuilder { 1694 flatbuffers::FlatBufferBuilder &fbb_; 1695 flatbuffers::uoffset_t start_; 1696 void add_success(bool success) { 1697 fbb_.AddElement<uint8_t>(DebugDumpResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0); 1698 } 1699 void add_data_count(uint32_t data_count) { 1700 fbb_.AddElement<uint32_t>(DebugDumpResponse::VT_DATA_COUNT, data_count, 0); 1701 } 1702 DebugDumpResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) 1703 : fbb_(_fbb) { 1704 start_ = fbb_.StartTable(); 1705 } 1706 DebugDumpResponseBuilder &operator=(const DebugDumpResponseBuilder &); 1707 flatbuffers::Offset<DebugDumpResponse> Finish() { 1708 const auto end = fbb_.EndTable(start_, 2); 1709 auto o = flatbuffers::Offset<DebugDumpResponse>(end); 1710 return o; 1711 } 1712 }; 1713 1714 inline flatbuffers::Offset<DebugDumpResponse> CreateDebugDumpResponse( 1715 flatbuffers::FlatBufferBuilder &_fbb, 1716 bool success = false, 1717 uint32_t data_count = 0) { 1718 DebugDumpResponseBuilder builder_(_fbb); 1719 builder_.add_data_count(data_count); 1720 builder_.add_success(success); 1721 return builder_.Finish(); 1722 } 1723 1724 flatbuffers::Offset<DebugDumpResponse> CreateDebugDumpResponse(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1725 1726 struct TimeSyncRequestT : public flatbuffers::NativeTable { 1727 typedef TimeSyncRequest TableType; 1728 TimeSyncRequestT() { 1729 } 1730 }; 1731 1732 /// A request from CHRE for host to initiate a time sync message 1733 /// (system feature, platform-specific - not all platforms necessarily use this) 1734 struct TimeSyncRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 1735 typedef TimeSyncRequestT NativeTableType; 1736 bool Verify(flatbuffers::Verifier &verifier) const { 1737 return VerifyTableStart(verifier) && 1738 verifier.EndTable(); 1739 } 1740 TimeSyncRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1741 void UnPackTo(TimeSyncRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1742 static flatbuffers::Offset<TimeSyncRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TimeSyncRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1743 }; 1744 1745 struct TimeSyncRequestBuilder { 1746 flatbuffers::FlatBufferBuilder &fbb_; 1747 flatbuffers::uoffset_t start_; 1748 TimeSyncRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) 1749 : fbb_(_fbb) { 1750 start_ = fbb_.StartTable(); 1751 } 1752 TimeSyncRequestBuilder &operator=(const TimeSyncRequestBuilder &); 1753 flatbuffers::Offset<TimeSyncRequest> Finish() { 1754 const auto end = fbb_.EndTable(start_, 0); 1755 auto o = flatbuffers::Offset<TimeSyncRequest>(end); 1756 return o; 1757 } 1758 }; 1759 1760 inline flatbuffers::Offset<TimeSyncRequest> CreateTimeSyncRequest( 1761 flatbuffers::FlatBufferBuilder &_fbb) { 1762 TimeSyncRequestBuilder builder_(_fbb); 1763 return builder_.Finish(); 1764 } 1765 1766 flatbuffers::Offset<TimeSyncRequest> CreateTimeSyncRequest(flatbuffers::FlatBufferBuilder &_fbb, const TimeSyncRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1767 1768 struct LowPowerMicAccessRequestT : public flatbuffers::NativeTable { 1769 typedef LowPowerMicAccessRequest TableType; 1770 LowPowerMicAccessRequestT() { 1771 } 1772 }; 1773 1774 /// Request from CHRE to enable direct access to data from the low-power 1775 /// microphone. On some systems, coordination via the AP (e.g. with 1776 /// SoundTrigger HAL) is needed to ensure this capability is powered up when 1777 /// CHRE needs it. The host does not send a response. 1778 struct LowPowerMicAccessRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 1779 typedef LowPowerMicAccessRequestT NativeTableType; 1780 bool Verify(flatbuffers::Verifier &verifier) const { 1781 return VerifyTableStart(verifier) && 1782 verifier.EndTable(); 1783 } 1784 LowPowerMicAccessRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1785 void UnPackTo(LowPowerMicAccessRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1786 static flatbuffers::Offset<LowPowerMicAccessRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LowPowerMicAccessRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1787 }; 1788 1789 struct LowPowerMicAccessRequestBuilder { 1790 flatbuffers::FlatBufferBuilder &fbb_; 1791 flatbuffers::uoffset_t start_; 1792 LowPowerMicAccessRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) 1793 : fbb_(_fbb) { 1794 start_ = fbb_.StartTable(); 1795 } 1796 LowPowerMicAccessRequestBuilder &operator=(const LowPowerMicAccessRequestBuilder &); 1797 flatbuffers::Offset<LowPowerMicAccessRequest> Finish() { 1798 const auto end = fbb_.EndTable(start_, 0); 1799 auto o = flatbuffers::Offset<LowPowerMicAccessRequest>(end); 1800 return o; 1801 } 1802 }; 1803 1804 inline flatbuffers::Offset<LowPowerMicAccessRequest> CreateLowPowerMicAccessRequest( 1805 flatbuffers::FlatBufferBuilder &_fbb) { 1806 LowPowerMicAccessRequestBuilder builder_(_fbb); 1807 return builder_.Finish(); 1808 } 1809 1810 flatbuffers::Offset<LowPowerMicAccessRequest> CreateLowPowerMicAccessRequest(flatbuffers::FlatBufferBuilder &_fbb, const LowPowerMicAccessRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1811 1812 struct LowPowerMicAccessReleaseT : public flatbuffers::NativeTable { 1813 typedef LowPowerMicAccessRelease TableType; 1814 LowPowerMicAccessReleaseT() { 1815 } 1816 }; 1817 1818 /// Notification from CHRE that it no longer needs direct access to low-power 1819 /// microphone data. 1820 struct LowPowerMicAccessRelease FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 1821 typedef LowPowerMicAccessReleaseT NativeTableType; 1822 bool Verify(flatbuffers::Verifier &verifier) const { 1823 return VerifyTableStart(verifier) && 1824 verifier.EndTable(); 1825 } 1826 LowPowerMicAccessReleaseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1827 void UnPackTo(LowPowerMicAccessReleaseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1828 static flatbuffers::Offset<LowPowerMicAccessRelease> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LowPowerMicAccessReleaseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1829 }; 1830 1831 struct LowPowerMicAccessReleaseBuilder { 1832 flatbuffers::FlatBufferBuilder &fbb_; 1833 flatbuffers::uoffset_t start_; 1834 LowPowerMicAccessReleaseBuilder(flatbuffers::FlatBufferBuilder &_fbb) 1835 : fbb_(_fbb) { 1836 start_ = fbb_.StartTable(); 1837 } 1838 LowPowerMicAccessReleaseBuilder &operator=(const LowPowerMicAccessReleaseBuilder &); 1839 flatbuffers::Offset<LowPowerMicAccessRelease> Finish() { 1840 const auto end = fbb_.EndTable(start_, 0); 1841 auto o = flatbuffers::Offset<LowPowerMicAccessRelease>(end); 1842 return o; 1843 } 1844 }; 1845 1846 inline flatbuffers::Offset<LowPowerMicAccessRelease> CreateLowPowerMicAccessRelease( 1847 flatbuffers::FlatBufferBuilder &_fbb) { 1848 LowPowerMicAccessReleaseBuilder builder_(_fbb); 1849 return builder_.Finish(); 1850 } 1851 1852 flatbuffers::Offset<LowPowerMicAccessRelease> CreateLowPowerMicAccessRelease(flatbuffers::FlatBufferBuilder &_fbb, const LowPowerMicAccessReleaseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1853 1854 struct MessageContainerT : public flatbuffers::NativeTable { 1855 typedef MessageContainer TableType; 1856 ChreMessageUnion message; 1857 std::unique_ptr<HostAddress> host_addr; 1858 MessageContainerT() { 1859 } 1860 }; 1861 1862 /// The top-level container that encapsulates all possible messages. Note that 1863 /// per FlatBuffers requirements, we can't use a union as the top-level 1864 /// structure (root type), so we must wrap it in a table. 1865 struct MessageContainer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 1866 typedef MessageContainerT NativeTableType; 1867 enum { 1868 VT_MESSAGE_TYPE = 4, 1869 VT_MESSAGE = 6, 1870 VT_HOST_ADDR = 8 1871 }; 1872 ChreMessage message_type() const { 1873 return static_cast<ChreMessage>(GetField<uint8_t>(VT_MESSAGE_TYPE, 0)); 1874 } 1875 bool mutate_message_type(ChreMessage _message_type) { 1876 return SetField(VT_MESSAGE_TYPE, static_cast<uint8_t>(_message_type)); 1877 } 1878 const void *message() const { 1879 return GetPointer<const void *>(VT_MESSAGE); 1880 } 1881 void *mutable_message() { 1882 return GetPointer<void *>(VT_MESSAGE); 1883 } 1884 /// The originating or destination client ID on the host side, used to direct 1885 /// responses only to the client that sent the request. Although initially 1886 /// populated by the requesting client, this is enforced to be the correct 1887 /// value by the entity guarding access to CHRE. 1888 /// This is wrapped in a struct to ensure that it is always included when 1889 /// encoding the message, so it can be mutated by the host daemon. 1890 const HostAddress *host_addr() const { 1891 return GetStruct<const HostAddress *>(VT_HOST_ADDR); 1892 } 1893 HostAddress *mutable_host_addr() { 1894 return GetStruct<HostAddress *>(VT_HOST_ADDR); 1895 } 1896 bool Verify(flatbuffers::Verifier &verifier) const { 1897 return VerifyTableStart(verifier) && 1898 VerifyField<uint8_t>(verifier, VT_MESSAGE_TYPE) && 1899 VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_MESSAGE) && 1900 VerifyChreMessage(verifier, message(), message_type()) && 1901 VerifyFieldRequired<HostAddress>(verifier, VT_HOST_ADDR) && 1902 verifier.EndTable(); 1903 } 1904 MessageContainerT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1905 void UnPackTo(MessageContainerT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1906 static flatbuffers::Offset<MessageContainer> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1907 }; 1908 1909 struct MessageContainerBuilder { 1910 flatbuffers::FlatBufferBuilder &fbb_; 1911 flatbuffers::uoffset_t start_; 1912 void add_message_type(ChreMessage message_type) { 1913 fbb_.AddElement<uint8_t>(MessageContainer::VT_MESSAGE_TYPE, static_cast<uint8_t>(message_type), 0); 1914 } 1915 void add_message(flatbuffers::Offset<void> message) { 1916 fbb_.AddOffset(MessageContainer::VT_MESSAGE, message); 1917 } 1918 void add_host_addr(const HostAddress *host_addr) { 1919 fbb_.AddStruct(MessageContainer::VT_HOST_ADDR, host_addr); 1920 } 1921 MessageContainerBuilder(flatbuffers::FlatBufferBuilder &_fbb) 1922 : fbb_(_fbb) { 1923 start_ = fbb_.StartTable(); 1924 } 1925 MessageContainerBuilder &operator=(const MessageContainerBuilder &); 1926 flatbuffers::Offset<MessageContainer> Finish() { 1927 const auto end = fbb_.EndTable(start_, 3); 1928 auto o = flatbuffers::Offset<MessageContainer>(end); 1929 fbb_.Required(o, MessageContainer::VT_MESSAGE); 1930 fbb_.Required(o, MessageContainer::VT_HOST_ADDR); 1931 return o; 1932 } 1933 }; 1934 1935 inline flatbuffers::Offset<MessageContainer> CreateMessageContainer( 1936 flatbuffers::FlatBufferBuilder &_fbb, 1937 ChreMessage message_type = ChreMessage::NONE, 1938 flatbuffers::Offset<void> message = 0, 1939 const HostAddress *host_addr = 0) { 1940 MessageContainerBuilder builder_(_fbb); 1941 builder_.add_host_addr(host_addr); 1942 builder_.add_message(message); 1943 builder_.add_message_type(message_type); 1944 return builder_.Finish(); 1945 } 1946 1947 flatbuffers::Offset<MessageContainer> CreateMessageContainer(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1948 1949 inline NanoappMessageT *NanoappMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 1950 auto _o = new NanoappMessageT(); 1951 UnPackTo(_o, _resolver); 1952 return _o; 1953 } 1954 1955 inline void NanoappMessage::UnPackTo(NanoappMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const { 1956 (void)_o; 1957 (void)_resolver; 1958 { auto _e = app_id(); _o->app_id = _e; }; 1959 { auto _e = message_type(); _o->message_type = _e; }; 1960 { auto _e = host_endpoint(); _o->host_endpoint = _e; }; 1961 { auto _e = message(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->message.push_back(_e->Get(_i)); } }; 1962 } 1963 1964 inline flatbuffers::Offset<NanoappMessage> NanoappMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 1965 return CreateNanoappMessage(_fbb, _o, _rehasher); 1966 } 1967 1968 inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessage(flatbuffers::FlatBufferBuilder &_fbb, const NanoappMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 1969 (void)_rehasher; 1970 (void)_o; 1971 auto _app_id = _o->app_id; 1972 auto _message_type = _o->message_type; 1973 auto _host_endpoint = _o->host_endpoint; 1974 auto _message = _fbb.CreateVector(_o->message); 1975 return chre::fbs::CreateNanoappMessage( 1976 _fbb, 1977 _app_id, 1978 _message_type, 1979 _host_endpoint, 1980 _message); 1981 } 1982 1983 inline HubInfoRequestT *HubInfoRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 1984 auto _o = new HubInfoRequestT(); 1985 UnPackTo(_o, _resolver); 1986 return _o; 1987 } 1988 1989 inline void HubInfoRequest::UnPackTo(HubInfoRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const { 1990 (void)_o; 1991 (void)_resolver; 1992 } 1993 1994 inline flatbuffers::Offset<HubInfoRequest> HubInfoRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 1995 return CreateHubInfoRequest(_fbb, _o, _rehasher); 1996 } 1997 1998 inline flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 1999 (void)_rehasher; 2000 (void)_o; 2001 return chre::fbs::CreateHubInfoRequest( 2002 _fbb); 2003 } 2004 2005 inline HubInfoResponseT *HubInfoResponse::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2006 auto _o = new HubInfoResponseT(); 2007 UnPackTo(_o, _resolver); 2008 return _o; 2009 } 2010 2011 inline void HubInfoResponse::UnPackTo(HubInfoResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2012 (void)_o; 2013 (void)_resolver; 2014 { auto _e = name(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->name.push_back(_e->Get(_i)); } }; 2015 { auto _e = vendor(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vendor.push_back(_e->Get(_i)); } }; 2016 { auto _e = toolchain(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->toolchain.push_back(_e->Get(_i)); } }; 2017 { auto _e = platform_version(); _o->platform_version = _e; }; 2018 { auto _e = toolchain_version(); _o->toolchain_version = _e; }; 2019 { auto _e = peak_mips(); _o->peak_mips = _e; }; 2020 { auto _e = stopped_power(); _o->stopped_power = _e; }; 2021 { auto _e = sleep_power(); _o->sleep_power = _e; }; 2022 { auto _e = peak_power(); _o->peak_power = _e; }; 2023 { auto _e = max_msg_len(); _o->max_msg_len = _e; }; 2024 { auto _e = platform_id(); _o->platform_id = _e; }; 2025 { auto _e = chre_platform_version(); _o->chre_platform_version = _e; }; 2026 } 2027 2028 inline flatbuffers::Offset<HubInfoResponse> HubInfoResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2029 return CreateHubInfoResponse(_fbb, _o, _rehasher); 2030 } 2031 2032 inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponse(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2033 (void)_rehasher; 2034 (void)_o; 2035 auto _name = _o->name.size() ? _fbb.CreateVector(_o->name) : 0; 2036 auto _vendor = _o->vendor.size() ? _fbb.CreateVector(_o->vendor) : 0; 2037 auto _toolchain = _o->toolchain.size() ? _fbb.CreateVector(_o->toolchain) : 0; 2038 auto _platform_version = _o->platform_version; 2039 auto _toolchain_version = _o->toolchain_version; 2040 auto _peak_mips = _o->peak_mips; 2041 auto _stopped_power = _o->stopped_power; 2042 auto _sleep_power = _o->sleep_power; 2043 auto _peak_power = _o->peak_power; 2044 auto _max_msg_len = _o->max_msg_len; 2045 auto _platform_id = _o->platform_id; 2046 auto _chre_platform_version = _o->chre_platform_version; 2047 return chre::fbs::CreateHubInfoResponse( 2048 _fbb, 2049 _name, 2050 _vendor, 2051 _toolchain, 2052 _platform_version, 2053 _toolchain_version, 2054 _peak_mips, 2055 _stopped_power, 2056 _sleep_power, 2057 _peak_power, 2058 _max_msg_len, 2059 _platform_id, 2060 _chre_platform_version); 2061 } 2062 2063 inline NanoappListRequestT *NanoappListRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2064 auto _o = new NanoappListRequestT(); 2065 UnPackTo(_o, _resolver); 2066 return _o; 2067 } 2068 2069 inline void NanoappListRequest::UnPackTo(NanoappListRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2070 (void)_o; 2071 (void)_resolver; 2072 } 2073 2074 inline flatbuffers::Offset<NanoappListRequest> NanoappListRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2075 return CreateNanoappListRequest(_fbb, _o, _rehasher); 2076 } 2077 2078 inline flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2079 (void)_rehasher; 2080 (void)_o; 2081 return chre::fbs::CreateNanoappListRequest( 2082 _fbb); 2083 } 2084 2085 inline NanoappListEntryT *NanoappListEntry::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2086 auto _o = new NanoappListEntryT(); 2087 UnPackTo(_o, _resolver); 2088 return _o; 2089 } 2090 2091 inline void NanoappListEntry::UnPackTo(NanoappListEntryT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2092 (void)_o; 2093 (void)_resolver; 2094 { auto _e = app_id(); _o->app_id = _e; }; 2095 { auto _e = version(); _o->version = _e; }; 2096 { auto _e = enabled(); _o->enabled = _e; }; 2097 { auto _e = is_system(); _o->is_system = _e; }; 2098 } 2099 2100 inline flatbuffers::Offset<NanoappListEntry> NanoappListEntry::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListEntryT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2101 return CreateNanoappListEntry(_fbb, _o, _rehasher); 2102 } 2103 2104 inline flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntry(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListEntryT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2105 (void)_rehasher; 2106 (void)_o; 2107 auto _app_id = _o->app_id; 2108 auto _version = _o->version; 2109 auto _enabled = _o->enabled; 2110 auto _is_system = _o->is_system; 2111 return chre::fbs::CreateNanoappListEntry( 2112 _fbb, 2113 _app_id, 2114 _version, 2115 _enabled, 2116 _is_system); 2117 } 2118 2119 inline NanoappListResponseT *NanoappListResponse::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2120 auto _o = new NanoappListResponseT(); 2121 UnPackTo(_o, _resolver); 2122 return _o; 2123 } 2124 2125 inline void NanoappListResponse::UnPackTo(NanoappListResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2126 (void)_o; 2127 (void)_resolver; 2128 { auto _e = nanoapps(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->nanoapps.push_back(std::unique_ptr<NanoappListEntryT>(_e->Get(_i)->UnPack(_resolver))); } }; 2129 } 2130 2131 inline flatbuffers::Offset<NanoappListResponse> NanoappListResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2132 return CreateNanoappListResponse(_fbb, _o, _rehasher); 2133 } 2134 2135 inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2136 (void)_rehasher; 2137 (void)_o; 2138 auto _nanoapps = _fbb.CreateVector<flatbuffers::Offset<NanoappListEntry>>(_o->nanoapps.size(), [&](size_t i) { return CreateNanoappListEntry(_fbb, _o->nanoapps[i].get(), _rehasher); }); 2139 return chre::fbs::CreateNanoappListResponse( 2140 _fbb, 2141 _nanoapps); 2142 } 2143 2144 inline LoadNanoappRequestT *LoadNanoappRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2145 auto _o = new LoadNanoappRequestT(); 2146 UnPackTo(_o, _resolver); 2147 return _o; 2148 } 2149 2150 inline void LoadNanoappRequest::UnPackTo(LoadNanoappRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2151 (void)_o; 2152 (void)_resolver; 2153 { auto _e = transaction_id(); _o->transaction_id = _e; }; 2154 { auto _e = app_id(); _o->app_id = _e; }; 2155 { auto _e = app_version(); _o->app_version = _e; }; 2156 { auto _e = target_api_version(); _o->target_api_version = _e; }; 2157 { auto _e = app_binary(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->app_binary.push_back(_e->Get(_i)); } }; 2158 { auto _e = fragment_id(); _o->fragment_id = _e; }; 2159 { auto _e = total_app_size(); _o->total_app_size = _e; }; 2160 } 2161 2162 inline flatbuffers::Offset<LoadNanoappRequest> LoadNanoappRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2163 return CreateLoadNanoappRequest(_fbb, _o, _rehasher); 2164 } 2165 2166 inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2167 (void)_rehasher; 2168 (void)_o; 2169 auto _transaction_id = _o->transaction_id; 2170 auto _app_id = _o->app_id; 2171 auto _app_version = _o->app_version; 2172 auto _target_api_version = _o->target_api_version; 2173 auto _app_binary = _fbb.CreateVector(_o->app_binary); 2174 auto _fragment_id = _o->fragment_id; 2175 auto _total_app_size = _o->total_app_size; 2176 return chre::fbs::CreateLoadNanoappRequest( 2177 _fbb, 2178 _transaction_id, 2179 _app_id, 2180 _app_version, 2181 _target_api_version, 2182 _app_binary, 2183 _fragment_id, 2184 _total_app_size); 2185 } 2186 2187 inline LoadNanoappResponseT *LoadNanoappResponse::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2188 auto _o = new LoadNanoappResponseT(); 2189 UnPackTo(_o, _resolver); 2190 return _o; 2191 } 2192 2193 inline void LoadNanoappResponse::UnPackTo(LoadNanoappResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2194 (void)_o; 2195 (void)_resolver; 2196 { auto _e = transaction_id(); _o->transaction_id = _e; }; 2197 { auto _e = success(); _o->success = _e; }; 2198 { auto _e = fragment_id(); _o->fragment_id = _e; }; 2199 } 2200 2201 inline flatbuffers::Offset<LoadNanoappResponse> LoadNanoappResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2202 return CreateLoadNanoappResponse(_fbb, _o, _rehasher); 2203 } 2204 2205 inline flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2206 (void)_rehasher; 2207 (void)_o; 2208 auto _transaction_id = _o->transaction_id; 2209 auto _success = _o->success; 2210 auto _fragment_id = _o->fragment_id; 2211 return chre::fbs::CreateLoadNanoappResponse( 2212 _fbb, 2213 _transaction_id, 2214 _success, 2215 _fragment_id); 2216 } 2217 2218 inline UnloadNanoappRequestT *UnloadNanoappRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2219 auto _o = new UnloadNanoappRequestT(); 2220 UnPackTo(_o, _resolver); 2221 return _o; 2222 } 2223 2224 inline void UnloadNanoappRequest::UnPackTo(UnloadNanoappRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2225 (void)_o; 2226 (void)_resolver; 2227 { auto _e = transaction_id(); _o->transaction_id = _e; }; 2228 { auto _e = app_id(); _o->app_id = _e; }; 2229 { auto _e = allow_system_nanoapp_unload(); _o->allow_system_nanoapp_unload = _e; }; 2230 } 2231 2232 inline flatbuffers::Offset<UnloadNanoappRequest> UnloadNanoappRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2233 return CreateUnloadNanoappRequest(_fbb, _o, _rehasher); 2234 } 2235 2236 inline flatbuffers::Offset<UnloadNanoappRequest> CreateUnloadNanoappRequest(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2237 (void)_rehasher; 2238 (void)_o; 2239 auto _transaction_id = _o->transaction_id; 2240 auto _app_id = _o->app_id; 2241 auto _allow_system_nanoapp_unload = _o->allow_system_nanoapp_unload; 2242 return chre::fbs::CreateUnloadNanoappRequest( 2243 _fbb, 2244 _transaction_id, 2245 _app_id, 2246 _allow_system_nanoapp_unload); 2247 } 2248 2249 inline UnloadNanoappResponseT *UnloadNanoappResponse::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2250 auto _o = new UnloadNanoappResponseT(); 2251 UnPackTo(_o, _resolver); 2252 return _o; 2253 } 2254 2255 inline void UnloadNanoappResponse::UnPackTo(UnloadNanoappResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2256 (void)_o; 2257 (void)_resolver; 2258 { auto _e = transaction_id(); _o->transaction_id = _e; }; 2259 { auto _e = success(); _o->success = _e; }; 2260 } 2261 2262 inline flatbuffers::Offset<UnloadNanoappResponse> UnloadNanoappResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2263 return CreateUnloadNanoappResponse(_fbb, _o, _rehasher); 2264 } 2265 2266 inline flatbuffers::Offset<UnloadNanoappResponse> CreateUnloadNanoappResponse(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2267 (void)_rehasher; 2268 (void)_o; 2269 auto _transaction_id = _o->transaction_id; 2270 auto _success = _o->success; 2271 return chre::fbs::CreateUnloadNanoappResponse( 2272 _fbb, 2273 _transaction_id, 2274 _success); 2275 } 2276 2277 inline LogMessageT *LogMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2278 auto _o = new LogMessageT(); 2279 UnPackTo(_o, _resolver); 2280 return _o; 2281 } 2282 2283 inline void LogMessage::UnPackTo(LogMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2284 (void)_o; 2285 (void)_resolver; 2286 { auto _e = buffer(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->buffer.push_back(_e->Get(_i)); } }; 2287 } 2288 2289 inline flatbuffers::Offset<LogMessage> LogMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2290 return CreateLogMessage(_fbb, _o, _rehasher); 2291 } 2292 2293 inline flatbuffers::Offset<LogMessage> CreateLogMessage(flatbuffers::FlatBufferBuilder &_fbb, const LogMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2294 (void)_rehasher; 2295 (void)_o; 2296 auto _buffer = _o->buffer.size() ? _fbb.CreateVector(_o->buffer) : 0; 2297 return chre::fbs::CreateLogMessage( 2298 _fbb, 2299 _buffer); 2300 } 2301 2302 inline TimeSyncMessageT *TimeSyncMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2303 auto _o = new TimeSyncMessageT(); 2304 UnPackTo(_o, _resolver); 2305 return _o; 2306 } 2307 2308 inline void TimeSyncMessage::UnPackTo(TimeSyncMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2309 (void)_o; 2310 (void)_resolver; 2311 { auto _e = offset(); _o->offset = _e; }; 2312 } 2313 2314 inline flatbuffers::Offset<TimeSyncMessage> TimeSyncMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TimeSyncMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2315 return CreateTimeSyncMessage(_fbb, _o, _rehasher); 2316 } 2317 2318 inline flatbuffers::Offset<TimeSyncMessage> CreateTimeSyncMessage(flatbuffers::FlatBufferBuilder &_fbb, const TimeSyncMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2319 (void)_rehasher; 2320 (void)_o; 2321 auto _offset = _o->offset; 2322 return chre::fbs::CreateTimeSyncMessage( 2323 _fbb, 2324 _offset); 2325 } 2326 2327 inline DebugDumpRequestT *DebugDumpRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2328 auto _o = new DebugDumpRequestT(); 2329 UnPackTo(_o, _resolver); 2330 return _o; 2331 } 2332 2333 inline void DebugDumpRequest::UnPackTo(DebugDumpRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2334 (void)_o; 2335 (void)_resolver; 2336 } 2337 2338 inline flatbuffers::Offset<DebugDumpRequest> DebugDumpRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2339 return CreateDebugDumpRequest(_fbb, _o, _rehasher); 2340 } 2341 2342 inline flatbuffers::Offset<DebugDumpRequest> CreateDebugDumpRequest(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2343 (void)_rehasher; 2344 (void)_o; 2345 return chre::fbs::CreateDebugDumpRequest( 2346 _fbb); 2347 } 2348 2349 inline DebugDumpDataT *DebugDumpData::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2350 auto _o = new DebugDumpDataT(); 2351 UnPackTo(_o, _resolver); 2352 return _o; 2353 } 2354 2355 inline void DebugDumpData::UnPackTo(DebugDumpDataT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2356 (void)_o; 2357 (void)_resolver; 2358 { auto _e = debug_str(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->debug_str.push_back(_e->Get(_i)); } }; 2359 } 2360 2361 inline flatbuffers::Offset<DebugDumpData> DebugDumpData::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpDataT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2362 return CreateDebugDumpData(_fbb, _o, _rehasher); 2363 } 2364 2365 inline flatbuffers::Offset<DebugDumpData> CreateDebugDumpData(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpDataT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2366 (void)_rehasher; 2367 (void)_o; 2368 auto _debug_str = _o->debug_str.size() ? _fbb.CreateVector(_o->debug_str) : 0; 2369 return chre::fbs::CreateDebugDumpData( 2370 _fbb, 2371 _debug_str); 2372 } 2373 2374 inline DebugDumpResponseT *DebugDumpResponse::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2375 auto _o = new DebugDumpResponseT(); 2376 UnPackTo(_o, _resolver); 2377 return _o; 2378 } 2379 2380 inline void DebugDumpResponse::UnPackTo(DebugDumpResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2381 (void)_o; 2382 (void)_resolver; 2383 { auto _e = success(); _o->success = _e; }; 2384 { auto _e = data_count(); _o->data_count = _e; }; 2385 } 2386 2387 inline flatbuffers::Offset<DebugDumpResponse> DebugDumpResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2388 return CreateDebugDumpResponse(_fbb, _o, _rehasher); 2389 } 2390 2391 inline flatbuffers::Offset<DebugDumpResponse> CreateDebugDumpResponse(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2392 (void)_rehasher; 2393 (void)_o; 2394 auto _success = _o->success; 2395 auto _data_count = _o->data_count; 2396 return chre::fbs::CreateDebugDumpResponse( 2397 _fbb, 2398 _success, 2399 _data_count); 2400 } 2401 2402 inline TimeSyncRequestT *TimeSyncRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2403 auto _o = new TimeSyncRequestT(); 2404 UnPackTo(_o, _resolver); 2405 return _o; 2406 } 2407 2408 inline void TimeSyncRequest::UnPackTo(TimeSyncRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2409 (void)_o; 2410 (void)_resolver; 2411 } 2412 2413 inline flatbuffers::Offset<TimeSyncRequest> TimeSyncRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TimeSyncRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2414 return CreateTimeSyncRequest(_fbb, _o, _rehasher); 2415 } 2416 2417 inline flatbuffers::Offset<TimeSyncRequest> CreateTimeSyncRequest(flatbuffers::FlatBufferBuilder &_fbb, const TimeSyncRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2418 (void)_rehasher; 2419 (void)_o; 2420 return chre::fbs::CreateTimeSyncRequest( 2421 _fbb); 2422 } 2423 2424 inline LowPowerMicAccessRequestT *LowPowerMicAccessRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2425 auto _o = new LowPowerMicAccessRequestT(); 2426 UnPackTo(_o, _resolver); 2427 return _o; 2428 } 2429 2430 inline void LowPowerMicAccessRequest::UnPackTo(LowPowerMicAccessRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2431 (void)_o; 2432 (void)_resolver; 2433 } 2434 2435 inline flatbuffers::Offset<LowPowerMicAccessRequest> LowPowerMicAccessRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LowPowerMicAccessRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2436 return CreateLowPowerMicAccessRequest(_fbb, _o, _rehasher); 2437 } 2438 2439 inline flatbuffers::Offset<LowPowerMicAccessRequest> CreateLowPowerMicAccessRequest(flatbuffers::FlatBufferBuilder &_fbb, const LowPowerMicAccessRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2440 (void)_rehasher; 2441 (void)_o; 2442 return chre::fbs::CreateLowPowerMicAccessRequest( 2443 _fbb); 2444 } 2445 2446 inline LowPowerMicAccessReleaseT *LowPowerMicAccessRelease::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2447 auto _o = new LowPowerMicAccessReleaseT(); 2448 UnPackTo(_o, _resolver); 2449 return _o; 2450 } 2451 2452 inline void LowPowerMicAccessRelease::UnPackTo(LowPowerMicAccessReleaseT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2453 (void)_o; 2454 (void)_resolver; 2455 } 2456 2457 inline flatbuffers::Offset<LowPowerMicAccessRelease> LowPowerMicAccessRelease::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LowPowerMicAccessReleaseT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2458 return CreateLowPowerMicAccessRelease(_fbb, _o, _rehasher); 2459 } 2460 2461 inline flatbuffers::Offset<LowPowerMicAccessRelease> CreateLowPowerMicAccessRelease(flatbuffers::FlatBufferBuilder &_fbb, const LowPowerMicAccessReleaseT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2462 (void)_rehasher; 2463 (void)_o; 2464 return chre::fbs::CreateLowPowerMicAccessRelease( 2465 _fbb); 2466 } 2467 2468 inline MessageContainerT *MessageContainer::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 2469 auto _o = new MessageContainerT(); 2470 UnPackTo(_o, _resolver); 2471 return _o; 2472 } 2473 2474 inline void MessageContainer::UnPackTo(MessageContainerT *_o, const flatbuffers::resolver_function_t *_resolver) const { 2475 (void)_o; 2476 (void)_resolver; 2477 { auto _e = message_type(); _o->message.type = _e; }; 2478 { auto _e = message(); if (_e) _o->message.table = ChreMessageUnion::UnPack(_e, message_type(),_resolver); }; 2479 { auto _e = host_addr(); if (_e) _o->host_addr = std::unique_ptr<HostAddress>(new HostAddress(*_e)); }; 2480 } 2481 2482 inline flatbuffers::Offset<MessageContainer> MessageContainer::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 2483 return CreateMessageContainer(_fbb, _o, _rehasher); 2484 } 2485 2486 inline flatbuffers::Offset<MessageContainer> CreateMessageContainer(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 2487 (void)_rehasher; 2488 (void)_o; 2489 auto _message_type = _o->message.type; 2490 auto _message = _o->message.Pack(_fbb); 2491 auto _host_addr = _o->host_addr ? _o->host_addr.get() : 0; 2492 return chre::fbs::CreateMessageContainer( 2493 _fbb, 2494 _message_type, 2495 _message, 2496 _host_addr); 2497 } 2498 2499 inline bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type) { 2500 switch (type) { 2501 case ChreMessage::NONE: { 2502 return true; 2503 } 2504 case ChreMessage::NanoappMessage: { 2505 auto ptr = reinterpret_cast<const NanoappMessage *>(obj); 2506 return verifier.VerifyTable(ptr); 2507 } 2508 case ChreMessage::HubInfoRequest: { 2509 auto ptr = reinterpret_cast<const HubInfoRequest *>(obj); 2510 return verifier.VerifyTable(ptr); 2511 } 2512 case ChreMessage::HubInfoResponse: { 2513 auto ptr = reinterpret_cast<const HubInfoResponse *>(obj); 2514 return verifier.VerifyTable(ptr); 2515 } 2516 case ChreMessage::NanoappListRequest: { 2517 auto ptr = reinterpret_cast<const NanoappListRequest *>(obj); 2518 return verifier.VerifyTable(ptr); 2519 } 2520 case ChreMessage::NanoappListResponse: { 2521 auto ptr = reinterpret_cast<const NanoappListResponse *>(obj); 2522 return verifier.VerifyTable(ptr); 2523 } 2524 case ChreMessage::LoadNanoappRequest: { 2525 auto ptr = reinterpret_cast<const LoadNanoappRequest *>(obj); 2526 return verifier.VerifyTable(ptr); 2527 } 2528 case ChreMessage::LoadNanoappResponse: { 2529 auto ptr = reinterpret_cast<const LoadNanoappResponse *>(obj); 2530 return verifier.VerifyTable(ptr); 2531 } 2532 case ChreMessage::UnloadNanoappRequest: { 2533 auto ptr = reinterpret_cast<const UnloadNanoappRequest *>(obj); 2534 return verifier.VerifyTable(ptr); 2535 } 2536 case ChreMessage::UnloadNanoappResponse: { 2537 auto ptr = reinterpret_cast<const UnloadNanoappResponse *>(obj); 2538 return verifier.VerifyTable(ptr); 2539 } 2540 case ChreMessage::LogMessage: { 2541 auto ptr = reinterpret_cast<const LogMessage *>(obj); 2542 return verifier.VerifyTable(ptr); 2543 } 2544 case ChreMessage::TimeSyncMessage: { 2545 auto ptr = reinterpret_cast<const TimeSyncMessage *>(obj); 2546 return verifier.VerifyTable(ptr); 2547 } 2548 case ChreMessage::DebugDumpRequest: { 2549 auto ptr = reinterpret_cast<const DebugDumpRequest *>(obj); 2550 return verifier.VerifyTable(ptr); 2551 } 2552 case ChreMessage::DebugDumpData: { 2553 auto ptr = reinterpret_cast<const DebugDumpData *>(obj); 2554 return verifier.VerifyTable(ptr); 2555 } 2556 case ChreMessage::DebugDumpResponse: { 2557 auto ptr = reinterpret_cast<const DebugDumpResponse *>(obj); 2558 return verifier.VerifyTable(ptr); 2559 } 2560 case ChreMessage::TimeSyncRequest: { 2561 auto ptr = reinterpret_cast<const TimeSyncRequest *>(obj); 2562 return verifier.VerifyTable(ptr); 2563 } 2564 case ChreMessage::LowPowerMicAccessRequest: { 2565 auto ptr = reinterpret_cast<const LowPowerMicAccessRequest *>(obj); 2566 return verifier.VerifyTable(ptr); 2567 } 2568 case ChreMessage::LowPowerMicAccessRelease: { 2569 auto ptr = reinterpret_cast<const LowPowerMicAccessRelease *>(obj); 2570 return verifier.VerifyTable(ptr); 2571 } 2572 default: return false; 2573 } 2574 } 2575 2576 inline bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) { 2577 if (values->size() != types->size()) return false; 2578 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { 2579 if (!VerifyChreMessage( 2580 verifier, values->Get(i), types->GetEnum<ChreMessage>(i))) { 2581 return false; 2582 } 2583 } 2584 return true; 2585 } 2586 2587 inline flatbuffers::NativeTable *ChreMessageUnion::UnPack(const void *obj, ChreMessage type, const flatbuffers::resolver_function_t *resolver) { 2588 switch (type) { 2589 case ChreMessage::NanoappMessage: { 2590 auto ptr = reinterpret_cast<const NanoappMessage *>(obj); 2591 return ptr->UnPack(resolver); 2592 } 2593 case ChreMessage::HubInfoRequest: { 2594 auto ptr = reinterpret_cast<const HubInfoRequest *>(obj); 2595 return ptr->UnPack(resolver); 2596 } 2597 case ChreMessage::HubInfoResponse: { 2598 auto ptr = reinterpret_cast<const HubInfoResponse *>(obj); 2599 return ptr->UnPack(resolver); 2600 } 2601 case ChreMessage::NanoappListRequest: { 2602 auto ptr = reinterpret_cast<const NanoappListRequest *>(obj); 2603 return ptr->UnPack(resolver); 2604 } 2605 case ChreMessage::NanoappListResponse: { 2606 auto ptr = reinterpret_cast<const NanoappListResponse *>(obj); 2607 return ptr->UnPack(resolver); 2608 } 2609 case ChreMessage::LoadNanoappRequest: { 2610 auto ptr = reinterpret_cast<const LoadNanoappRequest *>(obj); 2611 return ptr->UnPack(resolver); 2612 } 2613 case ChreMessage::LoadNanoappResponse: { 2614 auto ptr = reinterpret_cast<const LoadNanoappResponse *>(obj); 2615 return ptr->UnPack(resolver); 2616 } 2617 case ChreMessage::UnloadNanoappRequest: { 2618 auto ptr = reinterpret_cast<const UnloadNanoappRequest *>(obj); 2619 return ptr->UnPack(resolver); 2620 } 2621 case ChreMessage::UnloadNanoappResponse: { 2622 auto ptr = reinterpret_cast<const UnloadNanoappResponse *>(obj); 2623 return ptr->UnPack(resolver); 2624 } 2625 case ChreMessage::LogMessage: { 2626 auto ptr = reinterpret_cast<const LogMessage *>(obj); 2627 return ptr->UnPack(resolver); 2628 } 2629 case ChreMessage::TimeSyncMessage: { 2630 auto ptr = reinterpret_cast<const TimeSyncMessage *>(obj); 2631 return ptr->UnPack(resolver); 2632 } 2633 case ChreMessage::DebugDumpRequest: { 2634 auto ptr = reinterpret_cast<const DebugDumpRequest *>(obj); 2635 return ptr->UnPack(resolver); 2636 } 2637 case ChreMessage::DebugDumpData: { 2638 auto ptr = reinterpret_cast<const DebugDumpData *>(obj); 2639 return ptr->UnPack(resolver); 2640 } 2641 case ChreMessage::DebugDumpResponse: { 2642 auto ptr = reinterpret_cast<const DebugDumpResponse *>(obj); 2643 return ptr->UnPack(resolver); 2644 } 2645 case ChreMessage::TimeSyncRequest: { 2646 auto ptr = reinterpret_cast<const TimeSyncRequest *>(obj); 2647 return ptr->UnPack(resolver); 2648 } 2649 case ChreMessage::LowPowerMicAccessRequest: { 2650 auto ptr = reinterpret_cast<const LowPowerMicAccessRequest *>(obj); 2651 return ptr->UnPack(resolver); 2652 } 2653 case ChreMessage::LowPowerMicAccessRelease: { 2654 auto ptr = reinterpret_cast<const LowPowerMicAccessRelease *>(obj); 2655 return ptr->UnPack(resolver); 2656 } 2657 default: return nullptr; 2658 } 2659 } 2660 2661 inline flatbuffers::Offset<void> ChreMessageUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { 2662 switch (type) { 2663 case ChreMessage::NanoappMessage: { 2664 auto ptr = reinterpret_cast<const NanoappMessageT *>(table); 2665 return CreateNanoappMessage(_fbb, ptr, _rehasher).Union(); 2666 } 2667 case ChreMessage::HubInfoRequest: { 2668 auto ptr = reinterpret_cast<const HubInfoRequestT *>(table); 2669 return CreateHubInfoRequest(_fbb, ptr, _rehasher).Union(); 2670 } 2671 case ChreMessage::HubInfoResponse: { 2672 auto ptr = reinterpret_cast<const HubInfoResponseT *>(table); 2673 return CreateHubInfoResponse(_fbb, ptr, _rehasher).Union(); 2674 } 2675 case ChreMessage::NanoappListRequest: { 2676 auto ptr = reinterpret_cast<const NanoappListRequestT *>(table); 2677 return CreateNanoappListRequest(_fbb, ptr, _rehasher).Union(); 2678 } 2679 case ChreMessage::NanoappListResponse: { 2680 auto ptr = reinterpret_cast<const NanoappListResponseT *>(table); 2681 return CreateNanoappListResponse(_fbb, ptr, _rehasher).Union(); 2682 } 2683 case ChreMessage::LoadNanoappRequest: { 2684 auto ptr = reinterpret_cast<const LoadNanoappRequestT *>(table); 2685 return CreateLoadNanoappRequest(_fbb, ptr, _rehasher).Union(); 2686 } 2687 case ChreMessage::LoadNanoappResponse: { 2688 auto ptr = reinterpret_cast<const LoadNanoappResponseT *>(table); 2689 return CreateLoadNanoappResponse(_fbb, ptr, _rehasher).Union(); 2690 } 2691 case ChreMessage::UnloadNanoappRequest: { 2692 auto ptr = reinterpret_cast<const UnloadNanoappRequestT *>(table); 2693 return CreateUnloadNanoappRequest(_fbb, ptr, _rehasher).Union(); 2694 } 2695 case ChreMessage::UnloadNanoappResponse: { 2696 auto ptr = reinterpret_cast<const UnloadNanoappResponseT *>(table); 2697 return CreateUnloadNanoappResponse(_fbb, ptr, _rehasher).Union(); 2698 } 2699 case ChreMessage::LogMessage: { 2700 auto ptr = reinterpret_cast<const LogMessageT *>(table); 2701 return CreateLogMessage(_fbb, ptr, _rehasher).Union(); 2702 } 2703 case ChreMessage::TimeSyncMessage: { 2704 auto ptr = reinterpret_cast<const TimeSyncMessageT *>(table); 2705 return CreateTimeSyncMessage(_fbb, ptr, _rehasher).Union(); 2706 } 2707 case ChreMessage::DebugDumpRequest: { 2708 auto ptr = reinterpret_cast<const DebugDumpRequestT *>(table); 2709 return CreateDebugDumpRequest(_fbb, ptr, _rehasher).Union(); 2710 } 2711 case ChreMessage::DebugDumpData: { 2712 auto ptr = reinterpret_cast<const DebugDumpDataT *>(table); 2713 return CreateDebugDumpData(_fbb, ptr, _rehasher).Union(); 2714 } 2715 case ChreMessage::DebugDumpResponse: { 2716 auto ptr = reinterpret_cast<const DebugDumpResponseT *>(table); 2717 return CreateDebugDumpResponse(_fbb, ptr, _rehasher).Union(); 2718 } 2719 case ChreMessage::TimeSyncRequest: { 2720 auto ptr = reinterpret_cast<const TimeSyncRequestT *>(table); 2721 return CreateTimeSyncRequest(_fbb, ptr, _rehasher).Union(); 2722 } 2723 case ChreMessage::LowPowerMicAccessRequest: { 2724 auto ptr = reinterpret_cast<const LowPowerMicAccessRequestT *>(table); 2725 return CreateLowPowerMicAccessRequest(_fbb, ptr, _rehasher).Union(); 2726 } 2727 case ChreMessage::LowPowerMicAccessRelease: { 2728 auto ptr = reinterpret_cast<const LowPowerMicAccessReleaseT *>(table); 2729 return CreateLowPowerMicAccessRelease(_fbb, ptr, _rehasher).Union(); 2730 } 2731 default: return 0; 2732 } 2733 } 2734 2735 inline void ChreMessageUnion::Reset() { 2736 switch (type) { 2737 case ChreMessage::NanoappMessage: { 2738 auto ptr = reinterpret_cast<NanoappMessageT *>(table); 2739 delete ptr; 2740 break; 2741 } 2742 case ChreMessage::HubInfoRequest: { 2743 auto ptr = reinterpret_cast<HubInfoRequestT *>(table); 2744 delete ptr; 2745 break; 2746 } 2747 case ChreMessage::HubInfoResponse: { 2748 auto ptr = reinterpret_cast<HubInfoResponseT *>(table); 2749 delete ptr; 2750 break; 2751 } 2752 case ChreMessage::NanoappListRequest: { 2753 auto ptr = reinterpret_cast<NanoappListRequestT *>(table); 2754 delete ptr; 2755 break; 2756 } 2757 case ChreMessage::NanoappListResponse: { 2758 auto ptr = reinterpret_cast<NanoappListResponseT *>(table); 2759 delete ptr; 2760 break; 2761 } 2762 case ChreMessage::LoadNanoappRequest: { 2763 auto ptr = reinterpret_cast<LoadNanoappRequestT *>(table); 2764 delete ptr; 2765 break; 2766 } 2767 case ChreMessage::LoadNanoappResponse: { 2768 auto ptr = reinterpret_cast<LoadNanoappResponseT *>(table); 2769 delete ptr; 2770 break; 2771 } 2772 case ChreMessage::UnloadNanoappRequest: { 2773 auto ptr = reinterpret_cast<UnloadNanoappRequestT *>(table); 2774 delete ptr; 2775 break; 2776 } 2777 case ChreMessage::UnloadNanoappResponse: { 2778 auto ptr = reinterpret_cast<UnloadNanoappResponseT *>(table); 2779 delete ptr; 2780 break; 2781 } 2782 case ChreMessage::LogMessage: { 2783 auto ptr = reinterpret_cast<LogMessageT *>(table); 2784 delete ptr; 2785 break; 2786 } 2787 case ChreMessage::TimeSyncMessage: { 2788 auto ptr = reinterpret_cast<TimeSyncMessageT *>(table); 2789 delete ptr; 2790 break; 2791 } 2792 case ChreMessage::DebugDumpRequest: { 2793 auto ptr = reinterpret_cast<DebugDumpRequestT *>(table); 2794 delete ptr; 2795 break; 2796 } 2797 case ChreMessage::DebugDumpData: { 2798 auto ptr = reinterpret_cast<DebugDumpDataT *>(table); 2799 delete ptr; 2800 break; 2801 } 2802 case ChreMessage::DebugDumpResponse: { 2803 auto ptr = reinterpret_cast<DebugDumpResponseT *>(table); 2804 delete ptr; 2805 break; 2806 } 2807 case ChreMessage::TimeSyncRequest: { 2808 auto ptr = reinterpret_cast<TimeSyncRequestT *>(table); 2809 delete ptr; 2810 break; 2811 } 2812 case ChreMessage::LowPowerMicAccessRequest: { 2813 auto ptr = reinterpret_cast<LowPowerMicAccessRequestT *>(table); 2814 delete ptr; 2815 break; 2816 } 2817 case ChreMessage::LowPowerMicAccessRelease: { 2818 auto ptr = reinterpret_cast<LowPowerMicAccessReleaseT *>(table); 2819 delete ptr; 2820 break; 2821 } 2822 default: break; 2823 } 2824 table = nullptr; 2825 type = ChreMessage::NONE; 2826 } 2827 2828 inline const chre::fbs::MessageContainer *GetMessageContainer(const void *buf) { 2829 return flatbuffers::GetRoot<chre::fbs::MessageContainer>(buf); 2830 } 2831 2832 inline MessageContainer *GetMutableMessageContainer(void *buf) { 2833 return flatbuffers::GetMutableRoot<MessageContainer>(buf); 2834 } 2835 2836 inline bool VerifyMessageContainerBuffer( 2837 flatbuffers::Verifier &verifier) { 2838 return verifier.VerifyBuffer<chre::fbs::MessageContainer>(nullptr); 2839 } 2840 2841 inline void FinishMessageContainerBuffer( 2842 flatbuffers::FlatBufferBuilder &fbb, 2843 flatbuffers::Offset<chre::fbs::MessageContainer> root) { 2844 fbb.Finish(root); 2845 } 2846 2847 inline std::unique_ptr<MessageContainerT> UnPackMessageContainer( 2848 const void *buf, 2849 const flatbuffers::resolver_function_t *res = nullptr) { 2850 return std::unique_ptr<MessageContainerT>(GetMessageContainer(buf)->UnPack(res)); 2851 } 2852 2853 } // namespace fbs 2854 } // namespace chre 2855 2856 #endif // FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_ 2857