| // automatically generated by the FlatBuffers compiler, do not modify |
| |
| |
| #ifndef FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_ |
| #define FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_ |
| |
| #include "flatbuffers/flatbuffers.h" |
| |
| namespace chre { |
| namespace fbs { |
| |
| struct NanoappMessage; |
| struct NanoappMessageBuilder; |
| |
| struct HubInfoRequest; |
| struct HubInfoRequestBuilder; |
| |
| struct HubInfoResponse; |
| struct HubInfoResponseBuilder; |
| |
| struct NanoappListRequest; |
| struct NanoappListRequestBuilder; |
| |
| struct NanoappListEntry; |
| struct NanoappListEntryBuilder; |
| |
| struct NanoappListResponse; |
| struct NanoappListResponseBuilder; |
| |
| struct LoadNanoappRequest; |
| struct LoadNanoappRequestBuilder; |
| |
| struct LoadNanoappResponse; |
| struct LoadNanoappResponseBuilder; |
| |
| struct UnloadNanoappRequest; |
| struct UnloadNanoappRequestBuilder; |
| |
| struct UnloadNanoappResponse; |
| struct UnloadNanoappResponseBuilder; |
| |
| struct LogMessage; |
| struct LogMessageBuilder; |
| |
| struct TimeSyncMessage; |
| struct TimeSyncMessageBuilder; |
| |
| struct DebugDumpRequest; |
| struct DebugDumpRequestBuilder; |
| |
| struct DebugDumpData; |
| struct DebugDumpDataBuilder; |
| |
| struct DebugDumpResponse; |
| struct DebugDumpResponseBuilder; |
| |
| struct TimeSyncRequest; |
| struct TimeSyncRequestBuilder; |
| |
| struct LowPowerMicAccessRequest; |
| struct LowPowerMicAccessRequestBuilder; |
| |
| struct LowPowerMicAccessRelease; |
| struct LowPowerMicAccessReleaseBuilder; |
| |
| struct SettingChangeMessage; |
| struct SettingChangeMessageBuilder; |
| |
| struct HostAddress; |
| |
| struct MessageContainer; |
| struct MessageContainerBuilder; |
| |
| /// An enum describing the setting type. |
| enum class Setting : int8_t { |
| LOCATION = 0, |
| MIN = LOCATION, |
| MAX = LOCATION |
| }; |
| |
| inline const Setting (&EnumValuesSetting())[1] { |
| static const Setting values[] = { |
| Setting::LOCATION |
| }; |
| return values; |
| } |
| |
| inline const char * const *EnumNamesSetting() { |
| static const char * const names[2] = { |
| "LOCATION", |
| nullptr |
| }; |
| return names; |
| } |
| |
| inline const char *EnumNameSetting(Setting e) { |
| if (flatbuffers::IsOutRange(e, Setting::LOCATION, Setting::LOCATION)) return ""; |
| const size_t index = static_cast<size_t>(e); |
| return EnumNamesSetting()[index]; |
| } |
| |
| /// An enum describing the state of a setting. |
| enum class SettingState : int8_t { |
| DISABLED = 0, |
| ENABLED = 1, |
| MIN = DISABLED, |
| MAX = ENABLED |
| }; |
| |
| inline const SettingState (&EnumValuesSettingState())[2] { |
| static const SettingState values[] = { |
| SettingState::DISABLED, |
| SettingState::ENABLED |
| }; |
| return values; |
| } |
| |
| inline const char * const *EnumNamesSettingState() { |
| static const char * const names[3] = { |
| "DISABLED", |
| "ENABLED", |
| nullptr |
| }; |
| return names; |
| } |
| |
| inline const char *EnumNameSettingState(SettingState e) { |
| if (flatbuffers::IsOutRange(e, SettingState::DISABLED, SettingState::ENABLED)) return ""; |
| const size_t index = static_cast<size_t>(e); |
| return EnumNamesSettingState()[index]; |
| } |
| |
| /// A union that joins together all possible messages. Note that in FlatBuffers, |
| /// unions have an implicit type |
| enum class ChreMessage : uint8_t { |
| NONE = 0, |
| NanoappMessage = 1, |
| HubInfoRequest = 2, |
| HubInfoResponse = 3, |
| NanoappListRequest = 4, |
| NanoappListResponse = 5, |
| LoadNanoappRequest = 6, |
| LoadNanoappResponse = 7, |
| UnloadNanoappRequest = 8, |
| UnloadNanoappResponse = 9, |
| LogMessage = 10, |
| TimeSyncMessage = 11, |
| DebugDumpRequest = 12, |
| DebugDumpData = 13, |
| DebugDumpResponse = 14, |
| TimeSyncRequest = 15, |
| LowPowerMicAccessRequest = 16, |
| LowPowerMicAccessRelease = 17, |
| SettingChangeMessage = 18, |
| MIN = NONE, |
| MAX = SettingChangeMessage |
| }; |
| |
| inline const ChreMessage (&EnumValuesChreMessage())[19] { |
| static const ChreMessage values[] = { |
| ChreMessage::NONE, |
| ChreMessage::NanoappMessage, |
| ChreMessage::HubInfoRequest, |
| ChreMessage::HubInfoResponse, |
| ChreMessage::NanoappListRequest, |
| ChreMessage::NanoappListResponse, |
| ChreMessage::LoadNanoappRequest, |
| ChreMessage::LoadNanoappResponse, |
| ChreMessage::UnloadNanoappRequest, |
| ChreMessage::UnloadNanoappResponse, |
| ChreMessage::LogMessage, |
| ChreMessage::TimeSyncMessage, |
| ChreMessage::DebugDumpRequest, |
| ChreMessage::DebugDumpData, |
| ChreMessage::DebugDumpResponse, |
| ChreMessage::TimeSyncRequest, |
| ChreMessage::LowPowerMicAccessRequest, |
| ChreMessage::LowPowerMicAccessRelease, |
| ChreMessage::SettingChangeMessage |
| }; |
| return values; |
| } |
| |
| inline const char * const *EnumNamesChreMessage() { |
| static const char * const names[20] = { |
| "NONE", |
| "NanoappMessage", |
| "HubInfoRequest", |
| "HubInfoResponse", |
| "NanoappListRequest", |
| "NanoappListResponse", |
| "LoadNanoappRequest", |
| "LoadNanoappResponse", |
| "UnloadNanoappRequest", |
| "UnloadNanoappResponse", |
| "LogMessage", |
| "TimeSyncMessage", |
| "DebugDumpRequest", |
| "DebugDumpData", |
| "DebugDumpResponse", |
| "TimeSyncRequest", |
| "LowPowerMicAccessRequest", |
| "LowPowerMicAccessRelease", |
| "SettingChangeMessage", |
| nullptr |
| }; |
| return names; |
| } |
| |
| inline const char *EnumNameChreMessage(ChreMessage e) { |
| if (flatbuffers::IsOutRange(e, ChreMessage::NONE, ChreMessage::SettingChangeMessage)) return ""; |
| const size_t index = static_cast<size_t>(e); |
| return EnumNamesChreMessage()[index]; |
| } |
| |
| template<typename T> struct ChreMessageTraits { |
| static const ChreMessage enum_value = ChreMessage::NONE; |
| }; |
| |
| template<> struct ChreMessageTraits<chre::fbs::NanoappMessage> { |
| static const ChreMessage enum_value = ChreMessage::NanoappMessage; |
| }; |
| |
| template<> struct ChreMessageTraits<chre::fbs::HubInfoRequest> { |
| static const ChreMessage enum_value = ChreMessage::HubInfoRequest; |
| }; |
| |
| template<> struct ChreMessageTraits<chre::fbs::HubInfoResponse> { |
| static const ChreMessage enum_value = ChreMessage::HubInfoResponse; |
| }; |
| |
| template<> struct ChreMessageTraits<chre::fbs::NanoappListRequest> { |
| static const ChreMessage enum_value = ChreMessage::NanoappListRequest; |
| }; |
| |
| template<> struct ChreMessageTraits<chre::fbs::NanoappListResponse> { |
| static const ChreMessage enum_value = ChreMessage::NanoappListResponse; |
| }; |
| |
| template<> struct ChreMessageTraits<chre::fbs::LoadNanoappRequest> { |
| static const ChreMessage enum_value = ChreMessage::LoadNanoappRequest; |
| }; |
| |
| template<> struct ChreMessageTraits<chre::fbs::LoadNanoappResponse> { |
| static const ChreMessage enum_value = ChreMessage::LoadNanoappResponse; |
| }; |
| |
| template<> struct ChreMessageTraits<chre::fbs::UnloadNanoappRequest> { |
| static const ChreMessage enum_value = ChreMessage::UnloadNanoappRequest; |
| }; |
| |
| template<> struct ChreMessageTraits<chre::fbs::UnloadNanoappResponse> { |
| static const ChreMessage enum_value = ChreMessage::UnloadNanoappResponse; |
| }; |
| |
| template<> struct ChreMessageTraits<chre::fbs::LogMessage> { |
| static const ChreMessage enum_value = ChreMessage::LogMessage; |
| }; |
| |
| template<> struct ChreMessageTraits<chre::fbs::TimeSyncMessage> { |
| static const ChreMessage enum_value = ChreMessage::TimeSyncMessage; |
| }; |
| |
| template<> struct ChreMessageTraits<chre::fbs::DebugDumpRequest> { |
| static const ChreMessage enum_value = ChreMessage::DebugDumpRequest; |
| }; |
| |
| template<> struct ChreMessageTraits<chre::fbs::DebugDumpData> { |
| static const ChreMessage enum_value = ChreMessage::DebugDumpData; |
| }; |
| |
| template<> struct ChreMessageTraits<chre::fbs::DebugDumpResponse> { |
| static const ChreMessage enum_value = ChreMessage::DebugDumpResponse; |
| }; |
| |
| template<> struct ChreMessageTraits<chre::fbs::TimeSyncRequest> { |
| static const ChreMessage enum_value = ChreMessage::TimeSyncRequest; |
| }; |
| |
| template<> struct ChreMessageTraits<chre::fbs::LowPowerMicAccessRequest> { |
| static const ChreMessage enum_value = ChreMessage::LowPowerMicAccessRequest; |
| }; |
| |
| template<> struct ChreMessageTraits<chre::fbs::LowPowerMicAccessRelease> { |
| static const ChreMessage enum_value = ChreMessage::LowPowerMicAccessRelease; |
| }; |
| |
| template<> struct ChreMessageTraits<chre::fbs::SettingChangeMessage> { |
| static const ChreMessage enum_value = ChreMessage::SettingChangeMessage; |
| }; |
| |
| bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type); |
| bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types); |
| |
| FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) HostAddress FLATBUFFERS_FINAL_CLASS { |
| private: |
| uint16_t client_id_; |
| |
| public: |
| HostAddress() { |
| memset(static_cast<void *>(this), 0, sizeof(HostAddress)); |
| } |
| HostAddress(uint16_t _client_id) |
| : client_id_(flatbuffers::EndianScalar(_client_id)) { |
| } |
| uint16_t client_id() const { |
| return flatbuffers::EndianScalar(client_id_); |
| } |
| }; |
| FLATBUFFERS_STRUCT_END(HostAddress, 2); |
| |
| /// Represents a message sent to/from a nanoapp from/to a client on the host |
| struct NanoappMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef NanoappMessageBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_APP_ID = 4, |
| VT_MESSAGE_TYPE = 6, |
| VT_HOST_ENDPOINT = 8, |
| VT_MESSAGE = 10 |
| }; |
| uint64_t app_id() const { |
| return GetField<uint64_t>(VT_APP_ID, 0); |
| } |
| uint32_t message_type() const { |
| return GetField<uint32_t>(VT_MESSAGE_TYPE, 0); |
| } |
| /// Identifies the host-side endpoint on the host that sent or should receive |
| /// this message. The default value is a special value defined in the HAL and |
| /// elsewhere that indicates that the endpoint is unspecified. |
| uint16_t host_endpoint() const { |
| return GetField<uint16_t>(VT_HOST_ENDPOINT, 65534); |
| } |
| /// Vector containing arbitrary application-specific message data |
| const flatbuffers::Vector<uint8_t> *message() const { |
| return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MESSAGE); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyField<uint64_t>(verifier, VT_APP_ID) && |
| VerifyField<uint32_t>(verifier, VT_MESSAGE_TYPE) && |
| VerifyField<uint16_t>(verifier, VT_HOST_ENDPOINT) && |
| VerifyOffsetRequired(verifier, VT_MESSAGE) && |
| verifier.VerifyVector(message()) && |
| verifier.EndTable(); |
| } |
| }; |
| |
| struct NanoappMessageBuilder { |
| typedef NanoappMessage Table; |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_app_id(uint64_t app_id) { |
| fbb_.AddElement<uint64_t>(NanoappMessage::VT_APP_ID, app_id, 0); |
| } |
| void add_message_type(uint32_t message_type) { |
| fbb_.AddElement<uint32_t>(NanoappMessage::VT_MESSAGE_TYPE, message_type, 0); |
| } |
| void add_host_endpoint(uint16_t host_endpoint) { |
| fbb_.AddElement<uint16_t>(NanoappMessage::VT_HOST_ENDPOINT, host_endpoint, 65534); |
| } |
| void add_message(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message) { |
| fbb_.AddOffset(NanoappMessage::VT_MESSAGE, message); |
| } |
| explicit NanoappMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| NanoappMessageBuilder &operator=(const NanoappMessageBuilder &); |
| flatbuffers::Offset<NanoappMessage> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<NanoappMessage>(end); |
| fbb_.Required(o, NanoappMessage::VT_MESSAGE); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessage( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| uint64_t app_id = 0, |
| uint32_t message_type = 0, |
| uint16_t host_endpoint = 65534, |
| flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message = 0) { |
| NanoappMessageBuilder builder_(_fbb); |
| builder_.add_app_id(app_id); |
| builder_.add_message(message); |
| builder_.add_message_type(message_type); |
| builder_.add_host_endpoint(host_endpoint); |
| return builder_.Finish(); |
| } |
| |
| inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessageDirect( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| uint64_t app_id = 0, |
| uint32_t message_type = 0, |
| uint16_t host_endpoint = 65534, |
| const std::vector<uint8_t> *message = nullptr) { |
| auto message__ = message ? _fbb.CreateVector<uint8_t>(*message) : 0; |
| return chre::fbs::CreateNanoappMessage( |
| _fbb, |
| app_id, |
| message_type, |
| host_endpoint, |
| message__); |
| } |
| |
| struct HubInfoRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef HubInfoRequestBuilder Builder; |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| verifier.EndTable(); |
| } |
| }; |
| |
| struct HubInfoRequestBuilder { |
| typedef HubInfoRequest Table; |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| explicit HubInfoRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| HubInfoRequestBuilder &operator=(const HubInfoRequestBuilder &); |
| flatbuffers::Offset<HubInfoRequest> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<HubInfoRequest>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest( |
| flatbuffers::FlatBufferBuilder &_fbb) { |
| HubInfoRequestBuilder builder_(_fbb); |
| return builder_.Finish(); |
| } |
| |
| struct HubInfoResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef HubInfoResponseBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_NAME = 4, |
| VT_VENDOR = 6, |
| VT_TOOLCHAIN = 8, |
| VT_PLATFORM_VERSION = 10, |
| VT_TOOLCHAIN_VERSION = 12, |
| VT_PEAK_MIPS = 14, |
| VT_STOPPED_POWER = 16, |
| VT_SLEEP_POWER = 18, |
| VT_PEAK_POWER = 20, |
| VT_MAX_MSG_LEN = 22, |
| VT_PLATFORM_ID = 24, |
| VT_CHRE_PLATFORM_VERSION = 26 |
| }; |
| /// The name of the hub. Nominally a UTF-8 string, but note that we're not |
| /// using the built-in "string" data type from FlatBuffers here, because the |
| /// generated C++ uses std::string which is not well-supported in CHRE. This |
| /// applies for vendor and toolchain as well. |
| const flatbuffers::Vector<int8_t> *name() const { |
| return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_NAME); |
| } |
| const flatbuffers::Vector<int8_t> *vendor() const { |
| return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_VENDOR); |
| } |
| const flatbuffers::Vector<int8_t> *toolchain() const { |
| return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_TOOLCHAIN); |
| } |
| /// Legacy platform version reported in the HAL; semantics not strictly |
| /// defined |
| uint32_t platform_version() const { |
| return GetField<uint32_t>(VT_PLATFORM_VERSION, 0); |
| } |
| /// Toolchain version reported in the HAL; semantics not strictly defined |
| uint32_t toolchain_version() const { |
| return GetField<uint32_t>(VT_TOOLCHAIN_VERSION, 0); |
| } |
| float peak_mips() const { |
| return GetField<float>(VT_PEAK_MIPS, 0.0f); |
| } |
| float stopped_power() const { |
| return GetField<float>(VT_STOPPED_POWER, 0.0f); |
| } |
| float sleep_power() const { |
| return GetField<float>(VT_SLEEP_POWER, 0.0f); |
| } |
| float peak_power() const { |
| return GetField<float>(VT_PEAK_POWER, 0.0f); |
| } |
| /// Maximum size message that can be sent to a nanoapp |
| uint32_t max_msg_len() const { |
| return GetField<uint32_t>(VT_MAX_MSG_LEN, 0); |
| } |
| /// @see chreGetPlatformId() |
| uint64_t platform_id() const { |
| return GetField<uint64_t>(VT_PLATFORM_ID, 0); |
| } |
| /// @see chreGetVersion() |
| uint32_t chre_platform_version() const { |
| return GetField<uint32_t>(VT_CHRE_PLATFORM_VERSION, 0); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_NAME) && |
| verifier.VerifyVector(name()) && |
| VerifyOffset(verifier, VT_VENDOR) && |
| verifier.VerifyVector(vendor()) && |
| VerifyOffset(verifier, VT_TOOLCHAIN) && |
| verifier.VerifyVector(toolchain()) && |
| VerifyField<uint32_t>(verifier, VT_PLATFORM_VERSION) && |
| VerifyField<uint32_t>(verifier, VT_TOOLCHAIN_VERSION) && |
| VerifyField<float>(verifier, VT_PEAK_MIPS) && |
| VerifyField<float>(verifier, VT_STOPPED_POWER) && |
| VerifyField<float>(verifier, VT_SLEEP_POWER) && |
| VerifyField<float>(verifier, VT_PEAK_POWER) && |
| VerifyField<uint32_t>(verifier, VT_MAX_MSG_LEN) && |
| VerifyField<uint64_t>(verifier, VT_PLATFORM_ID) && |
| VerifyField<uint32_t>(verifier, VT_CHRE_PLATFORM_VERSION) && |
| verifier.EndTable(); |
| } |
| }; |
| |
| struct HubInfoResponseBuilder { |
| typedef HubInfoResponse Table; |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> name) { |
| fbb_.AddOffset(HubInfoResponse::VT_NAME, name); |
| } |
| void add_vendor(flatbuffers::Offset<flatbuffers::Vector<int8_t>> vendor) { |
| fbb_.AddOffset(HubInfoResponse::VT_VENDOR, vendor); |
| } |
| void add_toolchain(flatbuffers::Offset<flatbuffers::Vector<int8_t>> toolchain) { |
| fbb_.AddOffset(HubInfoResponse::VT_TOOLCHAIN, toolchain); |
| } |
| void add_platform_version(uint32_t platform_version) { |
| fbb_.AddElement<uint32_t>(HubInfoResponse::VT_PLATFORM_VERSION, platform_version, 0); |
| } |
| void add_toolchain_version(uint32_t toolchain_version) { |
| fbb_.AddElement<uint32_t>(HubInfoResponse::VT_TOOLCHAIN_VERSION, toolchain_version, 0); |
| } |
| void add_peak_mips(float peak_mips) { |
| fbb_.AddElement<float>(HubInfoResponse::VT_PEAK_MIPS, peak_mips, 0.0f); |
| } |
| void add_stopped_power(float stopped_power) { |
| fbb_.AddElement<float>(HubInfoResponse::VT_STOPPED_POWER, stopped_power, 0.0f); |
| } |
| void add_sleep_power(float sleep_power) { |
| fbb_.AddElement<float>(HubInfoResponse::VT_SLEEP_POWER, sleep_power, 0.0f); |
| } |
| void add_peak_power(float peak_power) { |
| fbb_.AddElement<float>(HubInfoResponse::VT_PEAK_POWER, peak_power, 0.0f); |
| } |
| void add_max_msg_len(uint32_t max_msg_len) { |
| fbb_.AddElement<uint32_t>(HubInfoResponse::VT_MAX_MSG_LEN, max_msg_len, 0); |
| } |
| void add_platform_id(uint64_t platform_id) { |
| fbb_.AddElement<uint64_t>(HubInfoResponse::VT_PLATFORM_ID, platform_id, 0); |
| } |
| void add_chre_platform_version(uint32_t chre_platform_version) { |
| fbb_.AddElement<uint32_t>(HubInfoResponse::VT_CHRE_PLATFORM_VERSION, chre_platform_version, 0); |
| } |
| explicit HubInfoResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| HubInfoResponseBuilder &operator=(const HubInfoResponseBuilder &); |
| flatbuffers::Offset<HubInfoResponse> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<HubInfoResponse>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponse( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| flatbuffers::Offset<flatbuffers::Vector<int8_t>> name = 0, |
| flatbuffers::Offset<flatbuffers::Vector<int8_t>> vendor = 0, |
| flatbuffers::Offset<flatbuffers::Vector<int8_t>> toolchain = 0, |
| uint32_t platform_version = 0, |
| uint32_t toolchain_version = 0, |
| float peak_mips = 0.0f, |
| float stopped_power = 0.0f, |
| float sleep_power = 0.0f, |
| float peak_power = 0.0f, |
| uint32_t max_msg_len = 0, |
| uint64_t platform_id = 0, |
| uint32_t chre_platform_version = 0) { |
| HubInfoResponseBuilder builder_(_fbb); |
| builder_.add_platform_id(platform_id); |
| builder_.add_chre_platform_version(chre_platform_version); |
| builder_.add_max_msg_len(max_msg_len); |
| builder_.add_peak_power(peak_power); |
| builder_.add_sleep_power(sleep_power); |
| builder_.add_stopped_power(stopped_power); |
| builder_.add_peak_mips(peak_mips); |
| builder_.add_toolchain_version(toolchain_version); |
| builder_.add_platform_version(platform_version); |
| builder_.add_toolchain(toolchain); |
| builder_.add_vendor(vendor); |
| builder_.add_name(name); |
| return builder_.Finish(); |
| } |
| |
| inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponseDirect( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| const std::vector<int8_t> *name = nullptr, |
| const std::vector<int8_t> *vendor = nullptr, |
| const std::vector<int8_t> *toolchain = nullptr, |
| uint32_t platform_version = 0, |
| uint32_t toolchain_version = 0, |
| float peak_mips = 0.0f, |
| float stopped_power = 0.0f, |
| float sleep_power = 0.0f, |
| float peak_power = 0.0f, |
| uint32_t max_msg_len = 0, |
| uint64_t platform_id = 0, |
| uint32_t chre_platform_version = 0) { |
| auto name__ = name ? _fbb.CreateVector<int8_t>(*name) : 0; |
| auto vendor__ = vendor ? _fbb.CreateVector<int8_t>(*vendor) : 0; |
| auto toolchain__ = toolchain ? _fbb.CreateVector<int8_t>(*toolchain) : 0; |
| return chre::fbs::CreateHubInfoResponse( |
| _fbb, |
| name__, |
| vendor__, |
| toolchain__, |
| platform_version, |
| toolchain_version, |
| peak_mips, |
| stopped_power, |
| sleep_power, |
| peak_power, |
| max_msg_len, |
| platform_id, |
| chre_platform_version); |
| } |
| |
| struct NanoappListRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef NanoappListRequestBuilder Builder; |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| verifier.EndTable(); |
| } |
| }; |
| |
| struct NanoappListRequestBuilder { |
| typedef NanoappListRequest Table; |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| explicit NanoappListRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| NanoappListRequestBuilder &operator=(const NanoappListRequestBuilder &); |
| flatbuffers::Offset<NanoappListRequest> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<NanoappListRequest>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest( |
| flatbuffers::FlatBufferBuilder &_fbb) { |
| NanoappListRequestBuilder builder_(_fbb); |
| return builder_.Finish(); |
| } |
| |
| struct NanoappListEntry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef NanoappListEntryBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_APP_ID = 4, |
| VT_VERSION = 6, |
| VT_ENABLED = 8, |
| VT_IS_SYSTEM = 10 |
| }; |
| uint64_t app_id() const { |
| return GetField<uint64_t>(VT_APP_ID, 0); |
| } |
| uint32_t version() const { |
| return GetField<uint32_t>(VT_VERSION, 0); |
| } |
| bool enabled() const { |
| return GetField<uint8_t>(VT_ENABLED, 1) != 0; |
| } |
| /// Whether the nanoapp is a pre-loaded "system" nanoapp, i.e. one that should |
| /// not show up in the list of nanoapps in the context hub HAL. System |
| /// nanoapps are typically used to leverage CHRE for some device functionality |
| /// and do not interact via the context hub HAL. |
| bool is_system() const { |
| return GetField<uint8_t>(VT_IS_SYSTEM, 0) != 0; |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyField<uint64_t>(verifier, VT_APP_ID) && |
| VerifyField<uint32_t>(verifier, VT_VERSION) && |
| VerifyField<uint8_t>(verifier, VT_ENABLED) && |
| VerifyField<uint8_t>(verifier, VT_IS_SYSTEM) && |
| verifier.EndTable(); |
| } |
| }; |
| |
| struct NanoappListEntryBuilder { |
| typedef NanoappListEntry Table; |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_app_id(uint64_t app_id) { |
| fbb_.AddElement<uint64_t>(NanoappListEntry::VT_APP_ID, app_id, 0); |
| } |
| void add_version(uint32_t version) { |
| fbb_.AddElement<uint32_t>(NanoappListEntry::VT_VERSION, version, 0); |
| } |
| void add_enabled(bool enabled) { |
| fbb_.AddElement<uint8_t>(NanoappListEntry::VT_ENABLED, static_cast<uint8_t>(enabled), 1); |
| } |
| void add_is_system(bool is_system) { |
| fbb_.AddElement<uint8_t>(NanoappListEntry::VT_IS_SYSTEM, static_cast<uint8_t>(is_system), 0); |
| } |
| explicit NanoappListEntryBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| NanoappListEntryBuilder &operator=(const NanoappListEntryBuilder &); |
| flatbuffers::Offset<NanoappListEntry> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<NanoappListEntry>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntry( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| uint64_t app_id = 0, |
| uint32_t version = 0, |
| bool enabled = true, |
| bool is_system = false) { |
| NanoappListEntryBuilder builder_(_fbb); |
| builder_.add_app_id(app_id); |
| builder_.add_version(version); |
| builder_.add_is_system(is_system); |
| builder_.add_enabled(enabled); |
| return builder_.Finish(); |
| } |
| |
| struct NanoappListResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef NanoappListResponseBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_NANOAPPS = 4 |
| }; |
| const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>> *nanoapps() const { |
| return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>> *>(VT_NANOAPPS); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffsetRequired(verifier, VT_NANOAPPS) && |
| verifier.VerifyVector(nanoapps()) && |
| verifier.VerifyVectorOfTables(nanoapps()) && |
| verifier.EndTable(); |
| } |
| }; |
| |
| struct NanoappListResponseBuilder { |
| typedef NanoappListResponse Table; |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_nanoapps(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>>> nanoapps) { |
| fbb_.AddOffset(NanoappListResponse::VT_NANOAPPS, nanoapps); |
| } |
| explicit NanoappListResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| NanoappListResponseBuilder &operator=(const NanoappListResponseBuilder &); |
| flatbuffers::Offset<NanoappListResponse> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<NanoappListResponse>(end); |
| fbb_.Required(o, NanoappListResponse::VT_NANOAPPS); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>>> nanoapps = 0) { |
| NanoappListResponseBuilder builder_(_fbb); |
| builder_.add_nanoapps(nanoapps); |
| return builder_.Finish(); |
| } |
| |
| inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponseDirect( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| const std::vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>> *nanoapps = nullptr) { |
| auto nanoapps__ = nanoapps ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::NanoappListEntry>>(*nanoapps) : 0; |
| return chre::fbs::CreateNanoappListResponse( |
| _fbb, |
| nanoapps__); |
| } |
| |
| /// Represents a request for loading a nanoapp. |
| /// The nanaopp can either be requested to be loaded via a file or via a buffer. |
| /// For loading via a file, the following steps will be taken: |
| /// 1. The loader sends a LoadNanoappRequest message to CHRE. app_binary must |
| /// be set for legacy purposes, but should be empty. Additionally, |
| /// fragment_id and total_app_size are unused in this request. The loading |
| /// that happens as part of this request is serialized, but asynchronous |
| /// meaning that load requests will be processed in the order they are sent |
| /// but multiple requests can be outstanding at any given time. |
| /// 2. CHRE stores the filename and waits until its event loop is able to |
| /// process the request. |
| /// 3. Once ready, the nanoapp will be loaded from the file specified in the |
| /// original request and will send a callback indicating the |
| /// completion/failure of the request. |
| /// For loading via a buffer, loading may optionally be fragmented into multiple |
| /// sequential requests, which will follow the following steps: |
| /// 1. The loader sends a LoadNanoappRequest message to CHRE. If the request |
| /// is fragmented, then the fields fragment_id and total_app_size must |
| /// be defined. Once the first fragment is sent to CHRE, all subsequent |
| /// fragments must be delivered before a new LoadNanoappRequest can be |
| /// issued. If a new request is received while a current request has |
| /// outstanding fragments, the current request will be overridden with the |
| /// new one. |
| /// 2. CHRE preallocates the required amount of memory, and loads app_binary, |
| /// appending to already loaded fragments as appropriate. |
| /// 3. If the request is fragmented, then the requestor must sequentially send |
| /// multiple LoadNanoappRequest with incremental nanoapp binary fragments. |
| /// CHRE will respond with LoadNanoappResponse for each request. For |
| /// requests starting from the second fragment, all fields except |
| /// fragment_id and app_binary should be ignored by CHRE. |
| /// |
| /// Once the LoadNanoappRepsonse for the last fragment is received |
| /// by the HAL, the HAL client will receive a callback indicating the |
| /// completion/failure of a load request. |
| /// |
| /// If any request fragment is lost, then the entire load request will be |
| /// considered to have failed. If the request times out (e.g. the requestor |
| /// process crashes), then the load request will be cancelled at CHRE and fail. |
| struct LoadNanoappRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef LoadNanoappRequestBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_TRANSACTION_ID = 4, |
| VT_APP_ID = 6, |
| VT_APP_VERSION = 8, |
| VT_TARGET_API_VERSION = 10, |
| VT_APP_BINARY = 12, |
| VT_FRAGMENT_ID = 14, |
| VT_TOTAL_APP_SIZE = 16, |
| VT_APP_BINARY_FILE_NAME = 18, |
| VT_APP_FLAGS = 20 |
| }; |
| uint32_t transaction_id() const { |
| return GetField<uint32_t>(VT_TRANSACTION_ID, 0); |
| } |
| uint64_t app_id() const { |
| return GetField<uint64_t>(VT_APP_ID, 0); |
| } |
| uint32_t app_version() const { |
| return GetField<uint32_t>(VT_APP_VERSION, 0); |
| } |
| uint32_t target_api_version() const { |
| return GetField<uint32_t>(VT_TARGET_API_VERSION, 0); |
| } |
| const flatbuffers::Vector<uint8_t> *app_binary() const { |
| return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_APP_BINARY); |
| } |
| /// Fields that are relevant for fragmented loading |
| /// The framgent count starts at 1 and should end at the total number of |
| /// fragments. For clients that do not support fragmented loading, the |
| /// default behavior should be to assume one fragment. |
| uint32_t fragment_id() const { |
| return GetField<uint32_t>(VT_FRAGMENT_ID, 0); |
| } |
| uint32_t total_app_size() const { |
| return GetField<uint32_t>(VT_TOTAL_APP_SIZE, 0); |
| } |
| /// Null-terminated ASCII string containing the file name that contains the |
| /// app binary to be loaded. |
| const flatbuffers::Vector<int8_t> *app_binary_file_name() const { |
| return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_APP_BINARY_FILE_NAME); |
| } |
| /// The nanoapp flag values from the nanoapp header defined in |
| /// build/build_template.mk. Refer to that file for more details. |
| uint32_t app_flags() const { |
| return GetField<uint32_t>(VT_APP_FLAGS, 0); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) && |
| VerifyField<uint64_t>(verifier, VT_APP_ID) && |
| VerifyField<uint32_t>(verifier, VT_APP_VERSION) && |
| VerifyField<uint32_t>(verifier, VT_TARGET_API_VERSION) && |
| VerifyOffsetRequired(verifier, VT_APP_BINARY) && |
| verifier.VerifyVector(app_binary()) && |
| VerifyField<uint32_t>(verifier, VT_FRAGMENT_ID) && |
| VerifyField<uint32_t>(verifier, VT_TOTAL_APP_SIZE) && |
| VerifyOffset(verifier, VT_APP_BINARY_FILE_NAME) && |
| verifier.VerifyVector(app_binary_file_name()) && |
| VerifyField<uint32_t>(verifier, VT_APP_FLAGS) && |
| verifier.EndTable(); |
| } |
| }; |
| |
| struct LoadNanoappRequestBuilder { |
| typedef LoadNanoappRequest Table; |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_transaction_id(uint32_t transaction_id) { |
| fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TRANSACTION_ID, transaction_id, 0); |
| } |
| void add_app_id(uint64_t app_id) { |
| fbb_.AddElement<uint64_t>(LoadNanoappRequest::VT_APP_ID, app_id, 0); |
| } |
| void add_app_version(uint32_t app_version) { |
| fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_APP_VERSION, app_version, 0); |
| } |
| void add_target_api_version(uint32_t target_api_version) { |
| fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TARGET_API_VERSION, target_api_version, 0); |
| } |
| void add_app_binary(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary) { |
| fbb_.AddOffset(LoadNanoappRequest::VT_APP_BINARY, app_binary); |
| } |
| void add_fragment_id(uint32_t fragment_id) { |
| fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_FRAGMENT_ID, fragment_id, 0); |
| } |
| void add_total_app_size(uint32_t total_app_size) { |
| fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TOTAL_APP_SIZE, total_app_size, 0); |
| } |
| void add_app_binary_file_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> app_binary_file_name) { |
| fbb_.AddOffset(LoadNanoappRequest::VT_APP_BINARY_FILE_NAME, app_binary_file_name); |
| } |
| void add_app_flags(uint32_t app_flags) { |
| fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_APP_FLAGS, app_flags, 0); |
| } |
| explicit LoadNanoappRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| LoadNanoappRequestBuilder &operator=(const LoadNanoappRequestBuilder &); |
| flatbuffers::Offset<LoadNanoappRequest> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<LoadNanoappRequest>(end); |
| fbb_.Required(o, LoadNanoappRequest::VT_APP_BINARY); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| uint32_t transaction_id = 0, |
| uint64_t app_id = 0, |
| uint32_t app_version = 0, |
| uint32_t target_api_version = 0, |
| flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary = 0, |
| uint32_t fragment_id = 0, |
| uint32_t total_app_size = 0, |
| flatbuffers::Offset<flatbuffers::Vector<int8_t>> app_binary_file_name = 0, |
| uint32_t app_flags = 0) { |
| LoadNanoappRequestBuilder builder_(_fbb); |
| builder_.add_app_id(app_id); |
| builder_.add_app_flags(app_flags); |
| builder_.add_app_binary_file_name(app_binary_file_name); |
| builder_.add_total_app_size(total_app_size); |
| builder_.add_fragment_id(fragment_id); |
| builder_.add_app_binary(app_binary); |
| builder_.add_target_api_version(target_api_version); |
| builder_.add_app_version(app_version); |
| builder_.add_transaction_id(transaction_id); |
| return builder_.Finish(); |
| } |
| |
| inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequestDirect( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| uint32_t transaction_id = 0, |
| uint64_t app_id = 0, |
| uint32_t app_version = 0, |
| uint32_t target_api_version = 0, |
| const std::vector<uint8_t> *app_binary = nullptr, |
| uint32_t fragment_id = 0, |
| uint32_t total_app_size = 0, |
| const std::vector<int8_t> *app_binary_file_name = nullptr, |
| uint32_t app_flags = 0) { |
| auto app_binary__ = app_binary ? _fbb.CreateVector<uint8_t>(*app_binary) : 0; |
| auto app_binary_file_name__ = app_binary_file_name ? _fbb.CreateVector<int8_t>(*app_binary_file_name) : 0; |
| return chre::fbs::CreateLoadNanoappRequest( |
| _fbb, |
| transaction_id, |
| app_id, |
| app_version, |
| target_api_version, |
| app_binary__, |
| fragment_id, |
| total_app_size, |
| app_binary_file_name__, |
| app_flags); |
| } |
| |
| struct LoadNanoappResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef LoadNanoappResponseBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_TRANSACTION_ID = 4, |
| VT_SUCCESS = 6, |
| VT_FRAGMENT_ID = 8 |
| }; |
| uint32_t transaction_id() const { |
| return GetField<uint32_t>(VT_TRANSACTION_ID, 0); |
| } |
| /// Denotes whether a load request succeeded or failed. |
| /// If any fragment of a load request fails, the entire load request for |
| /// the same transaction will fail. |
| bool success() const { |
| return GetField<uint8_t>(VT_SUCCESS, 0) != 0; |
| } |
| /// The fragment count of the load reponse is for. |
| uint32_t fragment_id() const { |
| return GetField<uint32_t>(VT_FRAGMENT_ID, 0); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) && |
| VerifyField<uint8_t>(verifier, VT_SUCCESS) && |
| VerifyField<uint32_t>(verifier, VT_FRAGMENT_ID) && |
| verifier.EndTable(); |
| } |
| }; |
| |
| struct LoadNanoappResponseBuilder { |
| typedef LoadNanoappResponse Table; |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_transaction_id(uint32_t transaction_id) { |
| fbb_.AddElement<uint32_t>(LoadNanoappResponse::VT_TRANSACTION_ID, transaction_id, 0); |
| } |
| void add_success(bool success) { |
| fbb_.AddElement<uint8_t>(LoadNanoappResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0); |
| } |
| void add_fragment_id(uint32_t fragment_id) { |
| fbb_.AddElement<uint32_t>(LoadNanoappResponse::VT_FRAGMENT_ID, fragment_id, 0); |
| } |
| explicit LoadNanoappResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| LoadNanoappResponseBuilder &operator=(const LoadNanoappResponseBuilder &); |
| flatbuffers::Offset<LoadNanoappResponse> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<LoadNanoappResponse>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| uint32_t transaction_id = 0, |
| bool success = false, |
| uint32_t fragment_id = 0) { |
| LoadNanoappResponseBuilder builder_(_fbb); |
| builder_.add_fragment_id(fragment_id); |
| builder_.add_transaction_id(transaction_id); |
| builder_.add_success(success); |
| return builder_.Finish(); |
| } |
| |
| struct UnloadNanoappRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef UnloadNanoappRequestBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_TRANSACTION_ID = 4, |
| VT_APP_ID = 6, |
| VT_ALLOW_SYSTEM_NANOAPP_UNLOAD = 8 |
| }; |
| uint32_t transaction_id() const { |
| return GetField<uint32_t>(VT_TRANSACTION_ID, 0); |
| } |
| uint64_t app_id() const { |
| return GetField<uint64_t>(VT_APP_ID, 0); |
| } |
| /// Set to true to allow this request to unload nanoapps identified as "system |
| /// nanoapps", i.e. ones with is_system set to true in NanoappListResponse. |
| bool allow_system_nanoapp_unload() const { |
| return GetField<uint8_t>(VT_ALLOW_SYSTEM_NANOAPP_UNLOAD, 0) != 0; |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) && |
| VerifyField<uint64_t>(verifier, VT_APP_ID) && |
| VerifyField<uint8_t>(verifier, VT_ALLOW_SYSTEM_NANOAPP_UNLOAD) && |
| verifier.EndTable(); |
| } |
| }; |
| |
| struct UnloadNanoappRequestBuilder { |
| typedef UnloadNanoappRequest Table; |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_transaction_id(uint32_t transaction_id) { |
| fbb_.AddElement<uint32_t>(UnloadNanoappRequest::VT_TRANSACTION_ID, transaction_id, 0); |
| } |
| void add_app_id(uint64_t app_id) { |
| fbb_.AddElement<uint64_t>(UnloadNanoappRequest::VT_APP_ID, app_id, 0); |
| } |
| void add_allow_system_nanoapp_unload(bool allow_system_nanoapp_unload) { |
| fbb_.AddElement<uint8_t>(UnloadNanoappRequest::VT_ALLOW_SYSTEM_NANOAPP_UNLOAD, static_cast<uint8_t>(allow_system_nanoapp_unload), 0); |
| } |
| explicit UnloadNanoappRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| UnloadNanoappRequestBuilder &operator=(const UnloadNanoappRequestBuilder &); |
| flatbuffers::Offset<UnloadNanoappRequest> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<UnloadNanoappRequest>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<UnloadNanoappRequest> CreateUnloadNanoappRequest( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| uint32_t transaction_id = 0, |
| uint64_t app_id = 0, |
| bool allow_system_nanoapp_unload = false) { |
| UnloadNanoappRequestBuilder builder_(_fbb); |
| builder_.add_app_id(app_id); |
| builder_.add_transaction_id(transaction_id); |
| builder_.add_allow_system_nanoapp_unload(allow_system_nanoapp_unload); |
| return builder_.Finish(); |
| } |
| |
| struct UnloadNanoappResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef UnloadNanoappResponseBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_TRANSACTION_ID = 4, |
| VT_SUCCESS = 6 |
| }; |
| uint32_t transaction_id() const { |
| return GetField<uint32_t>(VT_TRANSACTION_ID, 0); |
| } |
| bool success() const { |
| return GetField<uint8_t>(VT_SUCCESS, 0) != 0; |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) && |
| VerifyField<uint8_t>(verifier, VT_SUCCESS) && |
| verifier.EndTable(); |
| } |
| }; |
| |
| struct UnloadNanoappResponseBuilder { |
| typedef UnloadNanoappResponse Table; |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_transaction_id(uint32_t transaction_id) { |
| fbb_.AddElement<uint32_t>(UnloadNanoappResponse::VT_TRANSACTION_ID, transaction_id, 0); |
| } |
| void add_success(bool success) { |
| fbb_.AddElement<uint8_t>(UnloadNanoappResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0); |
| } |
| explicit UnloadNanoappResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| UnloadNanoappResponseBuilder &operator=(const UnloadNanoappResponseBuilder &); |
| flatbuffers::Offset<UnloadNanoappResponse> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<UnloadNanoappResponse>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<UnloadNanoappResponse> CreateUnloadNanoappResponse( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| uint32_t transaction_id = 0, |
| bool success = false) { |
| UnloadNanoappResponseBuilder builder_(_fbb); |
| builder_.add_transaction_id(transaction_id); |
| builder_.add_success(success); |
| return builder_.Finish(); |
| } |
| |
| /// Represents log messages from CHRE. |
| struct LogMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef LogMessageBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_BUFFER = 4 |
| }; |
| /// A buffer containing formatted log data. A flat array is used here to avoid |
| /// overhead in serializing and deserializing. The format is as follows: |
| /// |
| /// uint8_t - log level (1 = error, 2 = warning, |
| /// 3 = info, 4 = debug) |
| /// uint64_t, little-endian - timestamp in nanoseconds |
| /// char[] - message to log |
| /// char, \0 - null-terminator |
| /// |
| /// This pattern repeats until the end of the buffer for multiple log |
| /// messages. The last byte will always be a null-terminator. There are no |
| /// padding bytes between these fields. Treat this like a packed struct and be |
| /// cautious with unaligned access when reading/writing this buffer. |
| const flatbuffers::Vector<int8_t> *buffer() const { |
| return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_BUFFER); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_BUFFER) && |
| verifier.VerifyVector(buffer()) && |
| verifier.EndTable(); |
| } |
| }; |
| |
| struct LogMessageBuilder { |
| typedef LogMessage Table; |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_buffer(flatbuffers::Offset<flatbuffers::Vector<int8_t>> buffer) { |
| fbb_.AddOffset(LogMessage::VT_BUFFER, buffer); |
| } |
| explicit LogMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| LogMessageBuilder &operator=(const LogMessageBuilder &); |
| flatbuffers::Offset<LogMessage> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<LogMessage>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<LogMessage> CreateLogMessage( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| flatbuffers::Offset<flatbuffers::Vector<int8_t>> buffer = 0) { |
| LogMessageBuilder builder_(_fbb); |
| builder_.add_buffer(buffer); |
| return builder_.Finish(); |
| } |
| |
| inline flatbuffers::Offset<LogMessage> CreateLogMessageDirect( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| const std::vector<int8_t> *buffer = nullptr) { |
| auto buffer__ = buffer ? _fbb.CreateVector<int8_t>(*buffer) : 0; |
| return chre::fbs::CreateLogMessage( |
| _fbb, |
| buffer__); |
| } |
| |
| /// Represents a message sent to CHRE to indicate AP timestamp for time sync |
| struct TimeSyncMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef TimeSyncMessageBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_OFFSET = 4 |
| }; |
| /// Offset between AP and CHRE timestamp |
| int64_t offset() const { |
| return GetField<int64_t>(VT_OFFSET, 0); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyField<int64_t>(verifier, VT_OFFSET) && |
| verifier.EndTable(); |
| } |
| }; |
| |
| struct TimeSyncMessageBuilder { |
| typedef TimeSyncMessage Table; |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_offset(int64_t offset) { |
| fbb_.AddElement<int64_t>(TimeSyncMessage::VT_OFFSET, offset, 0); |
| } |
| explicit TimeSyncMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| TimeSyncMessageBuilder &operator=(const TimeSyncMessageBuilder &); |
| flatbuffers::Offset<TimeSyncMessage> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<TimeSyncMessage>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<TimeSyncMessage> CreateTimeSyncMessage( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| int64_t offset = 0) { |
| TimeSyncMessageBuilder builder_(_fbb); |
| builder_.add_offset(offset); |
| return builder_.Finish(); |
| } |
| |
| /// A request to gather and return debugging information. Only one debug dump |
| /// session can be active at a time. Upon accepting a request, zero or more |
| /// DebugDumpData messages are generated, followed by a DebugDumpResponse |
| /// indicating the completion of the operation. |
| struct DebugDumpRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef DebugDumpRequestBuilder Builder; |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| verifier.EndTable(); |
| } |
| }; |
| |
| struct DebugDumpRequestBuilder { |
| typedef DebugDumpRequest Table; |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| explicit DebugDumpRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| DebugDumpRequestBuilder &operator=(const DebugDumpRequestBuilder &); |
| flatbuffers::Offset<DebugDumpRequest> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<DebugDumpRequest>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<DebugDumpRequest> CreateDebugDumpRequest( |
| flatbuffers::FlatBufferBuilder &_fbb) { |
| DebugDumpRequestBuilder builder_(_fbb); |
| return builder_.Finish(); |
| } |
| |
| struct DebugDumpData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef DebugDumpDataBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_DEBUG_STR = 4 |
| }; |
| /// Null-terminated ASCII string containing debugging information |
| const flatbuffers::Vector<int8_t> *debug_str() const { |
| return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_DEBUG_STR); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_DEBUG_STR) && |
| verifier.VerifyVector(debug_str()) && |
| verifier.EndTable(); |
| } |
| }; |
| |
| struct DebugDumpDataBuilder { |
| typedef DebugDumpData Table; |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_debug_str(flatbuffers::Offset<flatbuffers::Vector<int8_t>> debug_str) { |
| fbb_.AddOffset(DebugDumpData::VT_DEBUG_STR, debug_str); |
| } |
| explicit DebugDumpDataBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| DebugDumpDataBuilder &operator=(const DebugDumpDataBuilder &); |
| flatbuffers::Offset<DebugDumpData> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<DebugDumpData>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<DebugDumpData> CreateDebugDumpData( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| flatbuffers::Offset<flatbuffers::Vector<int8_t>> debug_str = 0) { |
| DebugDumpDataBuilder builder_(_fbb); |
| builder_.add_debug_str(debug_str); |
| return builder_.Finish(); |
| } |
| |
| inline flatbuffers::Offset<DebugDumpData> CreateDebugDumpDataDirect( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| const std::vector<int8_t> *debug_str = nullptr) { |
| auto debug_str__ = debug_str ? _fbb.CreateVector<int8_t>(*debug_str) : 0; |
| return chre::fbs::CreateDebugDumpData( |
| _fbb, |
| debug_str__); |
| } |
| |
| struct DebugDumpResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef DebugDumpResponseBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_SUCCESS = 4, |
| VT_DATA_COUNT = 6 |
| }; |
| /// true if the request was accepted and a dump was performed, false if it was |
| /// rejected or failed to complete for some reason |
| bool success() const { |
| return GetField<uint8_t>(VT_SUCCESS, 0) != 0; |
| } |
| /// The number of DebugDumpData messages sent in this session |
| uint32_t data_count() const { |
| return GetField<uint32_t>(VT_DATA_COUNT, 0); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyField<uint8_t>(verifier, VT_SUCCESS) && |
| VerifyField<uint32_t>(verifier, VT_DATA_COUNT) && |
| verifier.EndTable(); |
| } |
| }; |
| |
| struct DebugDumpResponseBuilder { |
| typedef DebugDumpResponse Table; |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_success(bool success) { |
| fbb_.AddElement<uint8_t>(DebugDumpResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0); |
| } |
| void add_data_count(uint32_t data_count) { |
| fbb_.AddElement<uint32_t>(DebugDumpResponse::VT_DATA_COUNT, data_count, 0); |
| } |
| explicit DebugDumpResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| DebugDumpResponseBuilder &operator=(const DebugDumpResponseBuilder &); |
| flatbuffers::Offset<DebugDumpResponse> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<DebugDumpResponse>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<DebugDumpResponse> CreateDebugDumpResponse( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| bool success = false, |
| uint32_t data_count = 0) { |
| DebugDumpResponseBuilder builder_(_fbb); |
| builder_.add_data_count(data_count); |
| builder_.add_success(success); |
| return builder_.Finish(); |
| } |
| |
| /// A request from CHRE for host to initiate a time sync message |
| /// (system feature, platform-specific - not all platforms necessarily use this) |
| struct TimeSyncRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef TimeSyncRequestBuilder Builder; |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| verifier.EndTable(); |
| } |
| }; |
| |
| struct TimeSyncRequestBuilder { |
| typedef TimeSyncRequest Table; |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| explicit TimeSyncRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| TimeSyncRequestBuilder &operator=(const TimeSyncRequestBuilder &); |
| flatbuffers::Offset<TimeSyncRequest> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<TimeSyncRequest>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<TimeSyncRequest> CreateTimeSyncRequest( |
| flatbuffers::FlatBufferBuilder &_fbb) { |
| TimeSyncRequestBuilder builder_(_fbb); |
| return builder_.Finish(); |
| } |
| |
| /// Request from CHRE to enable direct access to data from the low-power |
| /// microphone. On some systems, coordination via the AP (e.g. with |
| /// SoundTrigger HAL) is needed to ensure this capability is powered up when |
| /// CHRE needs it. The host does not send a response. |
| struct LowPowerMicAccessRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef LowPowerMicAccessRequestBuilder Builder; |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| verifier.EndTable(); |
| } |
| }; |
| |
| struct LowPowerMicAccessRequestBuilder { |
| typedef LowPowerMicAccessRequest Table; |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| explicit LowPowerMicAccessRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| LowPowerMicAccessRequestBuilder &operator=(const LowPowerMicAccessRequestBuilder &); |
| flatbuffers::Offset<LowPowerMicAccessRequest> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<LowPowerMicAccessRequest>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<LowPowerMicAccessRequest> CreateLowPowerMicAccessRequest( |
| flatbuffers::FlatBufferBuilder &_fbb) { |
| LowPowerMicAccessRequestBuilder builder_(_fbb); |
| return builder_.Finish(); |
| } |
| |
| /// Notification from CHRE that it no longer needs direct access to low-power |
| /// microphone data. |
| struct LowPowerMicAccessRelease FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef LowPowerMicAccessReleaseBuilder Builder; |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| verifier.EndTable(); |
| } |
| }; |
| |
| struct LowPowerMicAccessReleaseBuilder { |
| typedef LowPowerMicAccessRelease Table; |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| explicit LowPowerMicAccessReleaseBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| LowPowerMicAccessReleaseBuilder &operator=(const LowPowerMicAccessReleaseBuilder &); |
| flatbuffers::Offset<LowPowerMicAccessRelease> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<LowPowerMicAccessRelease>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<LowPowerMicAccessRelease> CreateLowPowerMicAccessRelease( |
| flatbuffers::FlatBufferBuilder &_fbb) { |
| LowPowerMicAccessReleaseBuilder builder_(_fbb); |
| return builder_.Finish(); |
| } |
| |
| /// Notification from the host that a system setting has changed |
| struct SettingChangeMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef SettingChangeMessageBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_SETTING = 4, |
| VT_STATE = 6 |
| }; |
| /// The setting that has changed |
| chre::fbs::Setting setting() const { |
| return static_cast<chre::fbs::Setting>(GetField<int8_t>(VT_SETTING, 0)); |
| } |
| /// The new setting value |
| chre::fbs::SettingState state() const { |
| return static_cast<chre::fbs::SettingState>(GetField<int8_t>(VT_STATE, 0)); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyField<int8_t>(verifier, VT_SETTING) && |
| VerifyField<int8_t>(verifier, VT_STATE) && |
| verifier.EndTable(); |
| } |
| }; |
| |
| struct SettingChangeMessageBuilder { |
| typedef SettingChangeMessage Table; |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_setting(chre::fbs::Setting setting) { |
| fbb_.AddElement<int8_t>(SettingChangeMessage::VT_SETTING, static_cast<int8_t>(setting), 0); |
| } |
| void add_state(chre::fbs::SettingState state) { |
| fbb_.AddElement<int8_t>(SettingChangeMessage::VT_STATE, static_cast<int8_t>(state), 0); |
| } |
| explicit SettingChangeMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| SettingChangeMessageBuilder &operator=(const SettingChangeMessageBuilder &); |
| flatbuffers::Offset<SettingChangeMessage> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<SettingChangeMessage>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<SettingChangeMessage> CreateSettingChangeMessage( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| chre::fbs::Setting setting = chre::fbs::Setting::LOCATION, |
| chre::fbs::SettingState state = chre::fbs::SettingState::DISABLED) { |
| SettingChangeMessageBuilder builder_(_fbb); |
| builder_.add_state(state); |
| builder_.add_setting(setting); |
| return builder_.Finish(); |
| } |
| |
| /// The top-level container that encapsulates all possible messages. Note that |
| /// per FlatBuffers requirements, we can't use a union as the top-level |
| /// structure (root type), so we must wrap it in a table. |
| struct MessageContainer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef MessageContainerBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_MESSAGE_TYPE = 4, |
| VT_MESSAGE = 6, |
| VT_HOST_ADDR = 8 |
| }; |
| chre::fbs::ChreMessage message_type() const { |
| return static_cast<chre::fbs::ChreMessage>(GetField<uint8_t>(VT_MESSAGE_TYPE, 0)); |
| } |
| const void *message() const { |
| return GetPointer<const void *>(VT_MESSAGE); |
| } |
| template<typename T> const T *message_as() const; |
| const chre::fbs::NanoappMessage *message_as_NanoappMessage() const { |
| return message_type() == chre::fbs::ChreMessage::NanoappMessage ? static_cast<const chre::fbs::NanoappMessage *>(message()) : nullptr; |
| } |
| const chre::fbs::HubInfoRequest *message_as_HubInfoRequest() const { |
| return message_type() == chre::fbs::ChreMessage::HubInfoRequest ? static_cast<const chre::fbs::HubInfoRequest *>(message()) : nullptr; |
| } |
| const chre::fbs::HubInfoResponse *message_as_HubInfoResponse() const { |
| return message_type() == chre::fbs::ChreMessage::HubInfoResponse ? static_cast<const chre::fbs::HubInfoResponse *>(message()) : nullptr; |
| } |
| const chre::fbs::NanoappListRequest *message_as_NanoappListRequest() const { |
| return message_type() == chre::fbs::ChreMessage::NanoappListRequest ? static_cast<const chre::fbs::NanoappListRequest *>(message()) : nullptr; |
| } |
| const chre::fbs::NanoappListResponse *message_as_NanoappListResponse() const { |
| return message_type() == chre::fbs::ChreMessage::NanoappListResponse ? static_cast<const chre::fbs::NanoappListResponse *>(message()) : nullptr; |
| } |
| const chre::fbs::LoadNanoappRequest *message_as_LoadNanoappRequest() const { |
| return message_type() == chre::fbs::ChreMessage::LoadNanoappRequest ? static_cast<const chre::fbs::LoadNanoappRequest *>(message()) : nullptr; |
| } |
| const chre::fbs::LoadNanoappResponse *message_as_LoadNanoappResponse() const { |
| return message_type() == chre::fbs::ChreMessage::LoadNanoappResponse ? static_cast<const chre::fbs::LoadNanoappResponse *>(message()) : nullptr; |
| } |
| const chre::fbs::UnloadNanoappRequest *message_as_UnloadNanoappRequest() const { |
| return message_type() == chre::fbs::ChreMessage::UnloadNanoappRequest ? static_cast<const chre::fbs::UnloadNanoappRequest *>(message()) : nullptr; |
| } |
| const chre::fbs::UnloadNanoappResponse *message_as_UnloadNanoappResponse() const { |
| return message_type() == chre::fbs::ChreMessage::UnloadNanoappResponse ? static_cast<const chre::fbs::UnloadNanoappResponse *>(message()) : nullptr; |
| } |
| const chre::fbs::LogMessage *message_as_LogMessage() const { |
| return message_type() == chre::fbs::ChreMessage::LogMessage ? static_cast<const chre::fbs::LogMessage *>(message()) : nullptr; |
| } |
| const chre::fbs::TimeSyncMessage *message_as_TimeSyncMessage() const { |
| return message_type() == chre::fbs::ChreMessage::TimeSyncMessage ? static_cast<const chre::fbs::TimeSyncMessage *>(message()) : nullptr; |
| } |
| const chre::fbs::DebugDumpRequest *message_as_DebugDumpRequest() const { |
| return message_type() == chre::fbs::ChreMessage::DebugDumpRequest ? static_cast<const chre::fbs::DebugDumpRequest *>(message()) : nullptr; |
| } |
| const chre::fbs::DebugDumpData *message_as_DebugDumpData() const { |
| return message_type() == chre::fbs::ChreMessage::DebugDumpData ? static_cast<const chre::fbs::DebugDumpData *>(message()) : nullptr; |
| } |
| const chre::fbs::DebugDumpResponse *message_as_DebugDumpResponse() const { |
| return message_type() == chre::fbs::ChreMessage::DebugDumpResponse ? static_cast<const chre::fbs::DebugDumpResponse *>(message()) : nullptr; |
| } |
| const chre::fbs::TimeSyncRequest *message_as_TimeSyncRequest() const { |
| return message_type() == chre::fbs::ChreMessage::TimeSyncRequest ? static_cast<const chre::fbs::TimeSyncRequest *>(message()) : nullptr; |
| } |
| const chre::fbs::LowPowerMicAccessRequest *message_as_LowPowerMicAccessRequest() const { |
| return message_type() == chre::fbs::ChreMessage::LowPowerMicAccessRequest ? static_cast<const chre::fbs::LowPowerMicAccessRequest *>(message()) : nullptr; |
| } |
| const chre::fbs::LowPowerMicAccessRelease *message_as_LowPowerMicAccessRelease() const { |
| return message_type() == chre::fbs::ChreMessage::LowPowerMicAccessRelease ? static_cast<const chre::fbs::LowPowerMicAccessRelease *>(message()) : nullptr; |
| } |
| const chre::fbs::SettingChangeMessage *message_as_SettingChangeMessage() const { |
| return message_type() == chre::fbs::ChreMessage::SettingChangeMessage ? static_cast<const chre::fbs::SettingChangeMessage *>(message()) : nullptr; |
| } |
| /// The originating or destination client ID on the host side, used to direct |
| /// responses only to the client that sent the request. Although initially |
| /// populated by the requesting client, this is enforced to be the correct |
| /// value by the entity guarding access to CHRE. |
| /// This is wrapped in a struct to ensure that it is always included when |
| /// encoding the message, so it can be mutated by the host daemon. |
| const chre::fbs::HostAddress *host_addr() const { |
| return GetStruct<const chre::fbs::HostAddress *>(VT_HOST_ADDR); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyField<uint8_t>(verifier, VT_MESSAGE_TYPE) && |
| VerifyOffsetRequired(verifier, VT_MESSAGE) && |
| VerifyChreMessage(verifier, message(), message_type()) && |
| VerifyFieldRequired<chre::fbs::HostAddress>(verifier, VT_HOST_ADDR) && |
| verifier.EndTable(); |
| } |
| }; |
| |
| template<> inline const chre::fbs::NanoappMessage *MessageContainer::message_as<chre::fbs::NanoappMessage>() const { |
| return message_as_NanoappMessage(); |
| } |
| |
| template<> inline const chre::fbs::HubInfoRequest *MessageContainer::message_as<chre::fbs::HubInfoRequest>() const { |
| return message_as_HubInfoRequest(); |
| } |
| |
| template<> inline const chre::fbs::HubInfoResponse *MessageContainer::message_as<chre::fbs::HubInfoResponse>() const { |
| return message_as_HubInfoResponse(); |
| } |
| |
| template<> inline const chre::fbs::NanoappListRequest *MessageContainer::message_as<chre::fbs::NanoappListRequest>() const { |
| return message_as_NanoappListRequest(); |
| } |
| |
| template<> inline const chre::fbs::NanoappListResponse *MessageContainer::message_as<chre::fbs::NanoappListResponse>() const { |
| return message_as_NanoappListResponse(); |
| } |
| |
| template<> inline const chre::fbs::LoadNanoappRequest *MessageContainer::message_as<chre::fbs::LoadNanoappRequest>() const { |
| return message_as_LoadNanoappRequest(); |
| } |
| |
| template<> inline const chre::fbs::LoadNanoappResponse *MessageContainer::message_as<chre::fbs::LoadNanoappResponse>() const { |
| return message_as_LoadNanoappResponse(); |
| } |
| |
| template<> inline const chre::fbs::UnloadNanoappRequest *MessageContainer::message_as<chre::fbs::UnloadNanoappRequest>() const { |
| return message_as_UnloadNanoappRequest(); |
| } |
| |
| template<> inline const chre::fbs::UnloadNanoappResponse *MessageContainer::message_as<chre::fbs::UnloadNanoappResponse>() const { |
| return message_as_UnloadNanoappResponse(); |
| } |
| |
| template<> inline const chre::fbs::LogMessage *MessageContainer::message_as<chre::fbs::LogMessage>() const { |
| return message_as_LogMessage(); |
| } |
| |
| template<> inline const chre::fbs::TimeSyncMessage *MessageContainer::message_as<chre::fbs::TimeSyncMessage>() const { |
| return message_as_TimeSyncMessage(); |
| } |
| |
| template<> inline const chre::fbs::DebugDumpRequest *MessageContainer::message_as<chre::fbs::DebugDumpRequest>() const { |
| return message_as_DebugDumpRequest(); |
| } |
| |
| template<> inline const chre::fbs::DebugDumpData *MessageContainer::message_as<chre::fbs::DebugDumpData>() const { |
| return message_as_DebugDumpData(); |
| } |
| |
| template<> inline const chre::fbs::DebugDumpResponse *MessageContainer::message_as<chre::fbs::DebugDumpResponse>() const { |
| return message_as_DebugDumpResponse(); |
| } |
| |
| template<> inline const chre::fbs::TimeSyncRequest *MessageContainer::message_as<chre::fbs::TimeSyncRequest>() const { |
| return message_as_TimeSyncRequest(); |
| } |
| |
| template<> inline const chre::fbs::LowPowerMicAccessRequest *MessageContainer::message_as<chre::fbs::LowPowerMicAccessRequest>() const { |
| return message_as_LowPowerMicAccessRequest(); |
| } |
| |
| template<> inline const chre::fbs::LowPowerMicAccessRelease *MessageContainer::message_as<chre::fbs::LowPowerMicAccessRelease>() const { |
| return message_as_LowPowerMicAccessRelease(); |
| } |
| |
| template<> inline const chre::fbs::SettingChangeMessage *MessageContainer::message_as<chre::fbs::SettingChangeMessage>() const { |
| return message_as_SettingChangeMessage(); |
| } |
| |
| struct MessageContainerBuilder { |
| typedef MessageContainer Table; |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_message_type(chre::fbs::ChreMessage message_type) { |
| fbb_.AddElement<uint8_t>(MessageContainer::VT_MESSAGE_TYPE, static_cast<uint8_t>(message_type), 0); |
| } |
| void add_message(flatbuffers::Offset<void> message) { |
| fbb_.AddOffset(MessageContainer::VT_MESSAGE, message); |
| } |
| void add_host_addr(const chre::fbs::HostAddress *host_addr) { |
| fbb_.AddStruct(MessageContainer::VT_HOST_ADDR, host_addr); |
| } |
| explicit MessageContainerBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| MessageContainerBuilder &operator=(const MessageContainerBuilder &); |
| flatbuffers::Offset<MessageContainer> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<MessageContainer>(end); |
| fbb_.Required(o, MessageContainer::VT_MESSAGE); |
| fbb_.Required(o, MessageContainer::VT_HOST_ADDR); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<MessageContainer> CreateMessageContainer( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| chre::fbs::ChreMessage message_type = chre::fbs::ChreMessage::NONE, |
| flatbuffers::Offset<void> message = 0, |
| const chre::fbs::HostAddress *host_addr = 0) { |
| MessageContainerBuilder builder_(_fbb); |
| builder_.add_host_addr(host_addr); |
| builder_.add_message(message); |
| builder_.add_message_type(message_type); |
| return builder_.Finish(); |
| } |
| |
| inline bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type) { |
| switch (type) { |
| case ChreMessage::NONE: { |
| return true; |
| } |
| case ChreMessage::NanoappMessage: { |
| auto ptr = reinterpret_cast<const chre::fbs::NanoappMessage *>(obj); |
| return verifier.VerifyTable(ptr); |
| } |
| case ChreMessage::HubInfoRequest: { |
| auto ptr = reinterpret_cast<const chre::fbs::HubInfoRequest *>(obj); |
| return verifier.VerifyTable(ptr); |
| } |
| case ChreMessage::HubInfoResponse: { |
| auto ptr = reinterpret_cast<const chre::fbs::HubInfoResponse *>(obj); |
| return verifier.VerifyTable(ptr); |
| } |
| case ChreMessage::NanoappListRequest: { |
| auto ptr = reinterpret_cast<const chre::fbs::NanoappListRequest *>(obj); |
| return verifier.VerifyTable(ptr); |
| } |
| case ChreMessage::NanoappListResponse: { |
| auto ptr = reinterpret_cast<const chre::fbs::NanoappListResponse *>(obj); |
| return verifier.VerifyTable(ptr); |
| } |
| case ChreMessage::LoadNanoappRequest: { |
| auto ptr = reinterpret_cast<const chre::fbs::LoadNanoappRequest *>(obj); |
| return verifier.VerifyTable(ptr); |
| } |
| case ChreMessage::LoadNanoappResponse: { |
| auto ptr = reinterpret_cast<const chre::fbs::LoadNanoappResponse *>(obj); |
| return verifier.VerifyTable(ptr); |
| } |
| case ChreMessage::UnloadNanoappRequest: { |
| auto ptr = reinterpret_cast<const chre::fbs::UnloadNanoappRequest *>(obj); |
| return verifier.VerifyTable(ptr); |
| } |
| case ChreMessage::UnloadNanoappResponse: { |
| auto ptr = reinterpret_cast<const chre::fbs::UnloadNanoappResponse *>(obj); |
| return verifier.VerifyTable(ptr); |
| } |
| case ChreMessage::LogMessage: { |
| auto ptr = reinterpret_cast<const chre::fbs::LogMessage *>(obj); |
| return verifier.VerifyTable(ptr); |
| } |
| case ChreMessage::TimeSyncMessage: { |
| auto ptr = reinterpret_cast<const chre::fbs::TimeSyncMessage *>(obj); |
| return verifier.VerifyTable(ptr); |
| } |
| case ChreMessage::DebugDumpRequest: { |
| auto ptr = reinterpret_cast<const chre::fbs::DebugDumpRequest *>(obj); |
| return verifier.VerifyTable(ptr); |
| } |
| case ChreMessage::DebugDumpData: { |
| auto ptr = reinterpret_cast<const chre::fbs::DebugDumpData *>(obj); |
| return verifier.VerifyTable(ptr); |
| } |
| case ChreMessage::DebugDumpResponse: { |
| auto ptr = reinterpret_cast<const chre::fbs::DebugDumpResponse *>(obj); |
| return verifier.VerifyTable(ptr); |
| } |
| case ChreMessage::TimeSyncRequest: { |
| auto ptr = reinterpret_cast<const chre::fbs::TimeSyncRequest *>(obj); |
| return verifier.VerifyTable(ptr); |
| } |
| case ChreMessage::LowPowerMicAccessRequest: { |
| auto ptr = reinterpret_cast<const chre::fbs::LowPowerMicAccessRequest *>(obj); |
| return verifier.VerifyTable(ptr); |
| } |
| case ChreMessage::LowPowerMicAccessRelease: { |
| auto ptr = reinterpret_cast<const chre::fbs::LowPowerMicAccessRelease *>(obj); |
| return verifier.VerifyTable(ptr); |
| } |
| case ChreMessage::SettingChangeMessage: { |
| auto ptr = reinterpret_cast<const chre::fbs::SettingChangeMessage *>(obj); |
| return verifier.VerifyTable(ptr); |
| } |
| default: return true; |
| } |
| } |
| |
| inline bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) { |
| if (!values || !types) return !values && !types; |
| if (values->size() != types->size()) return false; |
| for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { |
| if (!VerifyChreMessage( |
| verifier, values->Get(i), types->GetEnum<ChreMessage>(i))) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| inline const chre::fbs::MessageContainer *GetMessageContainer(const void *buf) { |
| return flatbuffers::GetRoot<chre::fbs::MessageContainer>(buf); |
| } |
| |
| inline const chre::fbs::MessageContainer *GetSizePrefixedMessageContainer(const void *buf) { |
| return flatbuffers::GetSizePrefixedRoot<chre::fbs::MessageContainer>(buf); |
| } |
| |
| inline bool VerifyMessageContainerBuffer( |
| flatbuffers::Verifier &verifier) { |
| return verifier.VerifyBuffer<chre::fbs::MessageContainer>(nullptr); |
| } |
| |
| inline bool VerifySizePrefixedMessageContainerBuffer( |
| flatbuffers::Verifier &verifier) { |
| return verifier.VerifySizePrefixedBuffer<chre::fbs::MessageContainer>(nullptr); |
| } |
| |
| inline void FinishMessageContainerBuffer( |
| flatbuffers::FlatBufferBuilder &fbb, |
| flatbuffers::Offset<chre::fbs::MessageContainer> root) { |
| fbb.Finish(root); |
| } |
| |
| inline void FinishSizePrefixedMessageContainerBuffer( |
| flatbuffers::FlatBufferBuilder &fbb, |
| flatbuffers::Offset<chre::fbs::MessageContainer> root) { |
| fbb.FinishSizePrefixed(root); |
| } |
| |
| } // namespace fbs |
| } // namespace chre |
| |
| #endif // FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_ |