From 021fe80f6f1028336ff95cb085613e1a83080a19 Mon Sep 17 00:00:00 2001 From: Anay Wadhera Date: Sun, 13 Aug 2023 10:04:02 -0400 Subject: [PATCH] Update compiled_proto --- .../proto/offline_wire_formats.pb.cc | 1014 +++++++++++++++- .../proto/offline_wire_formats.pb.h | 1036 +++++++++++++++- compiled_proto/proto/connections_enums.pb.cc | 1078 +++++++++++++++++ compiled_proto/proto/connections_enums.pb.h | 284 +++++ compiled_proto/proto/mediums/ble_frames.pb.cc | 64 +- compiled_proto/proto/mediums/ble_frames.pb.h | 95 +- compiled_proto/proto/sharing_enums.pb.cc | 955 +++++++++++++-- compiled_proto/proto/sharing_enums.pb.h | 250 +++- 8 files changed, 4550 insertions(+), 226 deletions(-) diff --git a/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.cc b/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.cc index 33628b31..7e041c19 100644 --- a/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.cc +++ b/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.cc @@ -41,6 +41,8 @@ constexpr V1Frame::V1Frame( , paired_key_encryption_(nullptr) , authentication_message_(nullptr) , authentication_result_(nullptr) + , auto_resume_(nullptr) + , auto_reconnect_(nullptr) , type_(0) {} struct V1FrameDefaultTypeInternal { @@ -83,7 +85,8 @@ constexpr ConnectionResponseFrame::ConnectionResponseFrame( , response_(0) , multiplex_socket_bitmask_(0) - , nearby_connections_version_(0){} + , nearby_connections_version_(0) + , safe_to_disconnect_version_(0){} struct ConnectionResponseFrameDefaultTypeInternal { constexpr ConnectionResponseFrameDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -115,7 +118,8 @@ constexpr PayloadTransferFrame_PayloadChunk::PayloadTransferFrame_PayloadChunk( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : body_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , offset_(int64_t{0}) - , flags_(0){} + , flags_(0) + , index_(0){} struct PayloadTransferFrame_PayloadChunkDefaultTypeInternal { constexpr PayloadTransferFrame_PayloadChunkDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -304,7 +308,8 @@ struct BandwidthUpgradeNegotiationFrameDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BandwidthUpgradeNegotiationFrameDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_default_instance_; constexpr KeepAliveFrame::KeepAliveFrame( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : ack_(false){} + : ack_(false) + , seq_num_(0u){} struct KeepAliveFrameDefaultTypeInternal { constexpr KeepAliveFrameDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -363,6 +368,35 @@ struct AuthenticationResultFrameDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AuthenticationResultFrameDefaultTypeInternal _AuthenticationResultFrame_default_instance_; +constexpr AutoResumeFrame::AutoResumeFrame( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : pending_payload_id_(int64_t{0}) + , event_type_(0) + + , next_payload_chunk_index_(0){} +struct AutoResumeFrameDefaultTypeInternal { + constexpr AutoResumeFrameDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~AutoResumeFrameDefaultTypeInternal() {} + union { + AutoResumeFrame _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AutoResumeFrameDefaultTypeInternal _AutoResumeFrame_default_instance_; +constexpr AutoReconnectFrame::AutoReconnectFrame( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : endpoint_id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , event_type_(0) +{} +struct AutoReconnectFrameDefaultTypeInternal { + constexpr AutoReconnectFrameDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~AutoReconnectFrameDefaultTypeInternal() {} + union { + AutoReconnectFrame _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AutoReconnectFrameDefaultTypeInternal _AutoReconnectFrame_default_instance_; constexpr MediumMetadata::MediumMetadata( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : bssid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) @@ -606,17 +640,21 @@ bool V1Frame_FrameType_IsValid(int value) { case 7: case 8: case 9: + case 10: + case 11: return true; default: return false; } } -static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed V1Frame_FrameType_strings[10] = {}; +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed V1Frame_FrameType_strings[12] = {}; static const char V1Frame_FrameType_names[] = "AUTHENTICATION_MESSAGE" "AUTHENTICATION_RESULT" + "AUTO_RECONNECT" + "AUTO_RESUME" "BANDWIDTH_UPGRADE_NEGOTIATION" "CONNECTION_REQUEST" "CONNECTION_RESPONSE" @@ -629,27 +667,31 @@ static const char V1Frame_FrameType_names[] = static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry V1Frame_FrameType_entries[] = { { {V1Frame_FrameType_names + 0, 22}, 8 }, { {V1Frame_FrameType_names + 22, 21}, 9 }, - { {V1Frame_FrameType_names + 43, 29}, 4 }, - { {V1Frame_FrameType_names + 72, 18}, 1 }, - { {V1Frame_FrameType_names + 90, 19}, 2 }, - { {V1Frame_FrameType_names + 109, 13}, 6 }, - { {V1Frame_FrameType_names + 122, 10}, 5 }, - { {V1Frame_FrameType_names + 132, 21}, 7 }, - { {V1Frame_FrameType_names + 153, 16}, 3 }, - { {V1Frame_FrameType_names + 169, 18}, 0 }, + { {V1Frame_FrameType_names + 43, 14}, 11 }, + { {V1Frame_FrameType_names + 57, 11}, 10 }, + { {V1Frame_FrameType_names + 68, 29}, 4 }, + { {V1Frame_FrameType_names + 97, 18}, 1 }, + { {V1Frame_FrameType_names + 115, 19}, 2 }, + { {V1Frame_FrameType_names + 134, 13}, 6 }, + { {V1Frame_FrameType_names + 147, 10}, 5 }, + { {V1Frame_FrameType_names + 157, 21}, 7 }, + { {V1Frame_FrameType_names + 178, 16}, 3 }, + { {V1Frame_FrameType_names + 194, 18}, 0 }, }; static const int V1Frame_FrameType_entries_by_number[] = { - 9, // 0 -> UNKNOWN_FRAME_TYPE - 3, // 1 -> CONNECTION_REQUEST - 4, // 2 -> CONNECTION_RESPONSE - 8, // 3 -> PAYLOAD_TRANSFER - 2, // 4 -> BANDWIDTH_UPGRADE_NEGOTIATION - 6, // 5 -> KEEP_ALIVE - 5, // 6 -> DISCONNECTION - 7, // 7 -> PAIRED_KEY_ENCRYPTION + 11, // 0 -> UNKNOWN_FRAME_TYPE + 5, // 1 -> CONNECTION_REQUEST + 6, // 2 -> CONNECTION_RESPONSE + 10, // 3 -> PAYLOAD_TRANSFER + 4, // 4 -> BANDWIDTH_UPGRADE_NEGOTIATION + 8, // 5 -> KEEP_ALIVE + 7, // 6 -> DISCONNECTION + 9, // 7 -> PAIRED_KEY_ENCRYPTION 0, // 8 -> AUTHENTICATION_MESSAGE 1, // 9 -> AUTHENTICATION_RESULT + 3, // 10 -> AUTO_RESUME + 2, // 11 -> AUTO_RECONNECT }; const std::string& V1Frame_FrameType_Name( @@ -658,12 +700,12 @@ const std::string& V1Frame_FrameType_Name( ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( V1Frame_FrameType_entries, V1Frame_FrameType_entries_by_number, - 10, V1Frame_FrameType_strings); + 12, V1Frame_FrameType_strings); (void) dummy; int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( V1Frame_FrameType_entries, V1Frame_FrameType_entries_by_number, - 10, value); + 12, value); return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : V1Frame_FrameType_strings[idx].get(); } @@ -671,7 +713,7 @@ bool V1Frame_FrameType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V1Frame_FrameType* value) { int int_value; bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( - V1Frame_FrameType_entries, 10, name, &int_value); + V1Frame_FrameType_entries, 12, name, &int_value); if (success) { *value = static_cast(int_value); } @@ -688,6 +730,8 @@ constexpr V1Frame_FrameType V1Frame::DISCONNECTION; constexpr V1Frame_FrameType V1Frame::PAIRED_KEY_ENCRYPTION; constexpr V1Frame_FrameType V1Frame::AUTHENTICATION_MESSAGE; constexpr V1Frame_FrameType V1Frame::AUTHENTICATION_RESULT; +constexpr V1Frame_FrameType V1Frame::AUTO_RESUME; +constexpr V1Frame_FrameType V1Frame::AUTO_RECONNECT; constexpr V1Frame_FrameType V1Frame::FrameType_MIN; constexpr V1Frame_FrameType V1Frame::FrameType_MAX; constexpr int V1Frame::FrameType_ARRAYSIZE; @@ -1301,6 +1345,132 @@ constexpr BandwidthUpgradeNegotiationFrame_EventType BandwidthUpgradeNegotiation constexpr BandwidthUpgradeNegotiationFrame_EventType BandwidthUpgradeNegotiationFrame::EventType_MAX; constexpr int BandwidthUpgradeNegotiationFrame::EventType_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +bool AutoResumeFrame_EventType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed AutoResumeFrame_EventType_strings[3] = {}; + +static const char AutoResumeFrame_EventType_names[] = + "PAYLOAD_RESUME_TRANSFER_ACK" + "PAYLOAD_RESUME_TRANSFER_START" + "UNKNOWN_AUTO_RESUME_EVENT_TYPE"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AutoResumeFrame_EventType_entries[] = { + { {AutoResumeFrame_EventType_names + 0, 27}, 2 }, + { {AutoResumeFrame_EventType_names + 27, 29}, 1 }, + { {AutoResumeFrame_EventType_names + 56, 30}, 0 }, +}; + +static const int AutoResumeFrame_EventType_entries_by_number[] = { + 2, // 0 -> UNKNOWN_AUTO_RESUME_EVENT_TYPE + 1, // 1 -> PAYLOAD_RESUME_TRANSFER_START + 0, // 2 -> PAYLOAD_RESUME_TRANSFER_ACK +}; + +const std::string& AutoResumeFrame_EventType_Name( + AutoResumeFrame_EventType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + AutoResumeFrame_EventType_entries, + AutoResumeFrame_EventType_entries_by_number, + 3, AutoResumeFrame_EventType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + AutoResumeFrame_EventType_entries, + AutoResumeFrame_EventType_entries_by_number, + 3, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + AutoResumeFrame_EventType_strings[idx].get(); +} +bool AutoResumeFrame_EventType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AutoResumeFrame_EventType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + AutoResumeFrame_EventType_entries, 3, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr AutoResumeFrame_EventType AutoResumeFrame::UNKNOWN_AUTO_RESUME_EVENT_TYPE; +constexpr AutoResumeFrame_EventType AutoResumeFrame::PAYLOAD_RESUME_TRANSFER_START; +constexpr AutoResumeFrame_EventType AutoResumeFrame::PAYLOAD_RESUME_TRANSFER_ACK; +constexpr AutoResumeFrame_EventType AutoResumeFrame::EventType_MIN; +constexpr AutoResumeFrame_EventType AutoResumeFrame::EventType_MAX; +constexpr int AutoResumeFrame::EventType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +bool AutoReconnectFrame_EventType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed AutoReconnectFrame_EventType_strings[3] = {}; + +static const char AutoReconnectFrame_EventType_names[] = + "CLIENT_INTRODUCTION" + "CLIENT_INTRODUCTION_ACK" + "UNKNOWN_EVENT_TYPE"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AutoReconnectFrame_EventType_entries[] = { + { {AutoReconnectFrame_EventType_names + 0, 19}, 1 }, + { {AutoReconnectFrame_EventType_names + 19, 23}, 2 }, + { {AutoReconnectFrame_EventType_names + 42, 18}, 0 }, +}; + +static const int AutoReconnectFrame_EventType_entries_by_number[] = { + 2, // 0 -> UNKNOWN_EVENT_TYPE + 0, // 1 -> CLIENT_INTRODUCTION + 1, // 2 -> CLIENT_INTRODUCTION_ACK +}; + +const std::string& AutoReconnectFrame_EventType_Name( + AutoReconnectFrame_EventType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + AutoReconnectFrame_EventType_entries, + AutoReconnectFrame_EventType_entries_by_number, + 3, AutoReconnectFrame_EventType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + AutoReconnectFrame_EventType_entries, + AutoReconnectFrame_EventType_entries_by_number, + 3, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + AutoReconnectFrame_EventType_strings[idx].get(); +} +bool AutoReconnectFrame_EventType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AutoReconnectFrame_EventType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + AutoReconnectFrame_EventType_entries, 3, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr AutoReconnectFrame_EventType AutoReconnectFrame::UNKNOWN_EVENT_TYPE; +constexpr AutoReconnectFrame_EventType AutoReconnectFrame::CLIENT_INTRODUCTION; +constexpr AutoReconnectFrame_EventType AutoReconnectFrame::CLIENT_INTRODUCTION_ACK; +constexpr AutoReconnectFrame_EventType AutoReconnectFrame::EventType_MIN; +constexpr AutoReconnectFrame_EventType AutoReconnectFrame::EventType_MAX; +constexpr int AutoReconnectFrame::EventType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) bool LocationStandard_Format_IsValid(int value) { switch (value) { case 0: @@ -1839,7 +2009,7 @@ class V1Frame::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_type(HasBits* has_bits) { - (*has_bits)[0] |= 512u; + (*has_bits)[0] |= 2048u; } static const ::location::nearby::connections::ConnectionRequestFrame& connection_request(const V1Frame* msg); static void set_has_connection_request(HasBits* has_bits) { @@ -1877,6 +2047,14 @@ class V1Frame::_Internal { static void set_has_authentication_result(HasBits* has_bits) { (*has_bits)[0] |= 256u; } + static const ::location::nearby::connections::AutoResumeFrame& auto_resume(const V1Frame* msg); + static void set_has_auto_resume(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static const ::location::nearby::connections::AutoReconnectFrame& auto_reconnect(const V1Frame* msg); + static void set_has_auto_reconnect(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } }; const ::location::nearby::connections::ConnectionRequestFrame& @@ -1915,6 +2093,14 @@ const ::location::nearby::connections::AuthenticationResultFrame& V1Frame::_Internal::authentication_result(const V1Frame* msg) { return *msg->authentication_result_; } +const ::location::nearby::connections::AutoResumeFrame& +V1Frame::_Internal::auto_resume(const V1Frame* msg) { + return *msg->auto_resume_; +} +const ::location::nearby::connections::AutoReconnectFrame& +V1Frame::_Internal::auto_reconnect(const V1Frame* msg) { + return *msg->auto_reconnect_; +} V1Frame::V1Frame(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { @@ -1973,6 +2159,16 @@ V1Frame::V1Frame(const V1Frame& from) } else { authentication_result_ = nullptr; } + if (from._internal_has_auto_resume()) { + auto_resume_ = new ::location::nearby::connections::AutoResumeFrame(*from.auto_resume_); + } else { + auto_resume_ = nullptr; + } + if (from._internal_has_auto_reconnect()) { + auto_reconnect_ = new ::location::nearby::connections::AutoReconnectFrame(*from.auto_reconnect_); + } else { + auto_reconnect_ = nullptr; + } type_ = from.type_; // @@protoc_insertion_point(copy_constructor:location.nearby.connections.V1Frame) } @@ -2002,6 +2198,8 @@ inline void V1Frame::SharedDtor() { if (this != internal_default_instance()) delete paired_key_encryption_; if (this != internal_default_instance()) delete authentication_message_; if (this != internal_default_instance()) delete authentication_result_; + if (this != internal_default_instance()) delete auto_resume_; + if (this != internal_default_instance()) delete auto_reconnect_; } void V1Frame::ArenaDtor(void* object) { @@ -2055,9 +2253,19 @@ void V1Frame::Clear() { authentication_message_->Clear(); } } - if (cached_has_bits & 0x00000100u) { - GOOGLE_DCHECK(authentication_result_ != nullptr); - authentication_result_->Clear(); + if (cached_has_bits & 0x00000700u) { + if (cached_has_bits & 0x00000100u) { + GOOGLE_DCHECK(authentication_result_ != nullptr); + authentication_result_->Clear(); + } + if (cached_has_bits & 0x00000200u) { + GOOGLE_DCHECK(auto_resume_ != nullptr); + auto_resume_->Clear(); + } + if (cached_has_bits & 0x00000400u) { + GOOGLE_DCHECK(auto_reconnect_ != nullptr); + auto_reconnect_->Clear(); + } } type_ = 0; _has_bits_.Clear(); @@ -2156,6 +2364,22 @@ const char* V1Frame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in } else goto handle_unusual; continue; + // optional .location.nearby.connections.AutoResumeFrame auto_resume = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + ptr = ctx->ParseMessage(_internal_mutable_auto_resume(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.AutoReconnectFrame auto_reconnect = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { + ptr = ctx->ParseMessage(_internal_mutable_auto_reconnect(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -2188,7 +2412,7 @@ uint8_t* V1Frame::_InternalSerialize( cached_has_bits = _has_bits_[0]; // optional .location.nearby.connections.V1Frame.FrameType type = 1; - if (cached_has_bits & 0x00000200u) { + if (cached_has_bits & 0x00000800u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1, this->_internal_type(), target); @@ -2266,6 +2490,22 @@ uint8_t* V1Frame::_InternalSerialize( 10, _Internal::authentication_result(this), target, stream); } + // optional .location.nearby.connections.AutoResumeFrame auto_resume = 11; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 11, _Internal::auto_resume(this), target, stream); + } + + // optional .location.nearby.connections.AutoReconnectFrame auto_reconnect = 12; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 12, _Internal::auto_reconnect(this), target, stream); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); @@ -2341,7 +2581,7 @@ size_t V1Frame::ByteSizeLong() const { } } - if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x00000f00u) { // optional .location.nearby.connections.AuthenticationResultFrame authentication_result = 10; if (cached_has_bits & 0x00000100u) { total_size += 1 + @@ -2349,8 +2589,22 @@ size_t V1Frame::ByteSizeLong() const { *authentication_result_); } - // optional .location.nearby.connections.V1Frame.FrameType type = 1; + // optional .location.nearby.connections.AutoResumeFrame auto_resume = 11; if (cached_has_bits & 0x00000200u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *auto_resume_); + } + + // optional .location.nearby.connections.AutoReconnectFrame auto_reconnect = 12; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *auto_reconnect_); + } + + // optional .location.nearby.connections.V1Frame.FrameType type = 1; + if (cached_has_bits & 0x00000800u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); } @@ -2403,11 +2657,17 @@ void V1Frame::MergeFrom(const V1Frame& from) { _internal_mutable_authentication_message()->::location::nearby::connections::AuthenticationMessageFrame::MergeFrom(from._internal_authentication_message()); } } - if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x00000f00u) { if (cached_has_bits & 0x00000100u) { _internal_mutable_authentication_result()->::location::nearby::connections::AuthenticationResultFrame::MergeFrom(from._internal_authentication_result()); } if (cached_has_bits & 0x00000200u) { + _internal_mutable_auto_resume()->::location::nearby::connections::AutoResumeFrame::MergeFrom(from._internal_auto_resume()); + } + if (cached_has_bits & 0x00000400u) { + _internal_mutable_auto_reconnect()->::location::nearby::connections::AutoReconnectFrame::MergeFrom(from._internal_auto_reconnect()); + } + if (cached_has_bits & 0x00000800u) { type_ = from.type_; } _has_bits_[0] |= cached_has_bits; @@ -3248,6 +3508,9 @@ class ConnectionResponseFrame::_Internal { static void set_has_nearby_connections_version(HasBits* has_bits) { (*has_bits)[0] |= 32u; } + static void set_has_safe_to_disconnect_version(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } }; const ::location::nearby::connections::OsInfo& @@ -3281,8 +3544,8 @@ ConnectionResponseFrame::ConnectionResponseFrame(const ConnectionResponseFrame& os_info_ = nullptr; } ::memcpy(&status_, &from.status_, - static_cast(reinterpret_cast(&nearby_connections_version_) - - reinterpret_cast(&status_)) + sizeof(nearby_connections_version_)); + static_cast(reinterpret_cast(&safe_to_disconnect_version_) - + reinterpret_cast(&status_)) + sizeof(safe_to_disconnect_version_)); // @@protoc_insertion_point(copy_constructor:location.nearby.connections.ConnectionResponseFrame) } @@ -3293,8 +3556,8 @@ handshake_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStr #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&os_info_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nearby_connections_version_) - - reinterpret_cast(&os_info_)) + sizeof(nearby_connections_version_)); + 0, static_cast(reinterpret_cast(&safe_to_disconnect_version_) - + reinterpret_cast(&os_info_)) + sizeof(safe_to_disconnect_version_)); } ConnectionResponseFrame::~ConnectionResponseFrame() { @@ -3336,10 +3599,10 @@ void ConnectionResponseFrame::Clear() { os_info_->Clear(); } } - if (cached_has_bits & 0x0000003cu) { + if (cached_has_bits & 0x0000007cu) { ::memset(&status_, 0, static_cast( - reinterpret_cast(&nearby_connections_version_) - - reinterpret_cast(&status_)) + sizeof(nearby_connections_version_)); + reinterpret_cast(&safe_to_disconnect_version_) - + reinterpret_cast(&status_)) + sizeof(safe_to_disconnect_version_)); } _has_bits_.Clear(); _internal_metadata_.Clear(); @@ -3400,7 +3663,7 @@ const char* ConnectionResponseFrame::_InternalParse(const char* ptr, ::PROTOBUF_ } else goto handle_unusual; continue; - // optional int32 nearby_connections_version = 6; + // optional int32 nearby_connections_version = 6 [deprecated = true]; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { _Internal::set_has_nearby_connections_version(&has_bits); @@ -3409,6 +3672,15 @@ const char* ConnectionResponseFrame::_InternalParse(const char* ptr, ::PROTOBUF_ } else goto handle_unusual; continue; + // optional int32 safe_to_disconnect_version = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_safe_to_disconnect_version(&has_bits); + safe_to_disconnect_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -3473,12 +3745,18 @@ uint8_t* ConnectionResponseFrame::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_multiplex_socket_bitmask(), target); } - // optional int32 nearby_connections_version = 6; + // optional int32 nearby_connections_version = 6 [deprecated = true]; if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(6, this->_internal_nearby_connections_version(), target); } + // optional int32 safe_to_disconnect_version = 7; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(7, this->_internal_safe_to_disconnect_version(), target); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); @@ -3496,7 +3774,7 @@ size_t ConnectionResponseFrame::ByteSizeLong() const { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x0000007fu) { // optional bytes handshake_data = 2; if (cached_has_bits & 0x00000001u) { total_size += 1 + @@ -3527,11 +3805,16 @@ size_t ConnectionResponseFrame::ByteSizeLong() const { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_multiplex_socket_bitmask()); } - // optional int32 nearby_connections_version = 6; + // optional int32 nearby_connections_version = 6 [deprecated = true]; if (cached_has_bits & 0x00000020u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_nearby_connections_version()); } + // optional int32 safe_to_disconnect_version = 7; + if (cached_has_bits & 0x00000040u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_safe_to_disconnect_version()); + } + } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); @@ -3554,7 +3837,7 @@ void ConnectionResponseFrame::MergeFrom(const ConnectionResponseFrame& from) { (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; - if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x0000007fu) { if (cached_has_bits & 0x00000001u) { _internal_set_handshake_data(from._internal_handshake_data()); } @@ -3573,6 +3856,9 @@ void ConnectionResponseFrame::MergeFrom(const ConnectionResponseFrame& from) { if (cached_has_bits & 0x00000020u) { nearby_connections_version_ = from.nearby_connections_version_; } + if (cached_has_bits & 0x00000040u) { + safe_to_disconnect_version_ = from.safe_to_disconnect_version_; + } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom(from._internal_metadata_); @@ -3601,8 +3887,8 @@ void ConnectionResponseFrame::InternalSwap(ConnectionResponseFrame* other) { &other->handshake_data_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ConnectionResponseFrame, nearby_connections_version_) - + sizeof(ConnectionResponseFrame::nearby_connections_version_) + PROTOBUF_FIELD_OFFSET(ConnectionResponseFrame, safe_to_disconnect_version_) + + sizeof(ConnectionResponseFrame::safe_to_disconnect_version_) - PROTOBUF_FIELD_OFFSET(ConnectionResponseFrame, os_info_)>( reinterpret_cast(&os_info_), reinterpret_cast(&other->os_info_)); @@ -4021,6 +4307,9 @@ class PayloadTransferFrame_PayloadChunk::_Internal { static void set_has_body(HasBits* has_bits) { (*has_bits)[0] |= 1u; } + static void set_has_index(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } }; PayloadTransferFrame_PayloadChunk::PayloadTransferFrame_PayloadChunk(::PROTOBUF_NAMESPACE_ID::Arena* arena, @@ -4045,8 +4334,8 @@ PayloadTransferFrame_PayloadChunk::PayloadTransferFrame_PayloadChunk(const Paylo GetArenaForAllocation()); } ::memcpy(&offset_, &from.offset_, - static_cast(reinterpret_cast(&flags_) - - reinterpret_cast(&offset_)) + sizeof(flags_)); + static_cast(reinterpret_cast(&index_) - + reinterpret_cast(&offset_)) + sizeof(index_)); // @@protoc_insertion_point(copy_constructor:location.nearby.connections.PayloadTransferFrame.PayloadChunk) } @@ -4057,8 +4346,8 @@ body_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlready #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&offset_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&flags_) - - reinterpret_cast(&offset_)) + sizeof(flags_)); + 0, static_cast(reinterpret_cast(&index_) - + reinterpret_cast(&offset_)) + sizeof(index_)); } PayloadTransferFrame_PayloadChunk::~PayloadTransferFrame_PayloadChunk() { @@ -4093,10 +4382,10 @@ void PayloadTransferFrame_PayloadChunk::Clear() { if (cached_has_bits & 0x00000001u) { body_.ClearNonDefaultToEmpty(); } - if (cached_has_bits & 0x00000006u) { + if (cached_has_bits & 0x0000000eu) { ::memset(&offset_, 0, static_cast( - reinterpret_cast(&flags_) - - reinterpret_cast(&offset_)) + sizeof(flags_)); + reinterpret_cast(&index_) - + reinterpret_cast(&offset_)) + sizeof(index_)); } _has_bits_.Clear(); _internal_metadata_.Clear(); @@ -4136,6 +4425,15 @@ const char* PayloadTransferFrame_PayloadChunk::_InternalParse(const char* ptr, : } else goto handle_unusual; continue; + // optional int32 index = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_index(&has_bits); + index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -4185,6 +4483,12 @@ uint8_t* PayloadTransferFrame_PayloadChunk::_InternalSerialize( 3, this->_internal_body(), target); } + // optional int32 index = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_index(), target); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); @@ -4202,7 +4506,7 @@ size_t PayloadTransferFrame_PayloadChunk::ByteSizeLong() const { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x0000000fu) { // optional bytes body = 3; if (cached_has_bits & 0x00000001u) { total_size += 1 + @@ -4220,6 +4524,11 @@ size_t PayloadTransferFrame_PayloadChunk::ByteSizeLong() const { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_flags()); } + // optional int32 index = 4; + if (cached_has_bits & 0x00000008u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_index()); + } + } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); @@ -4242,7 +4551,7 @@ void PayloadTransferFrame_PayloadChunk::MergeFrom(const PayloadTransferFrame_Pay (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x0000000fu) { if (cached_has_bits & 0x00000001u) { _internal_set_body(from._internal_body()); } @@ -4252,6 +4561,9 @@ void PayloadTransferFrame_PayloadChunk::MergeFrom(const PayloadTransferFrame_Pay if (cached_has_bits & 0x00000004u) { flags_ = from.flags_; } + if (cached_has_bits & 0x00000008u) { + index_ = from.index_; + } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom(from._internal_metadata_); @@ -4280,8 +4592,8 @@ void PayloadTransferFrame_PayloadChunk::InternalSwap(PayloadTransferFrame_Payloa &other->body_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(PayloadTransferFrame_PayloadChunk, flags_) - + sizeof(PayloadTransferFrame_PayloadChunk::flags_) + PROTOBUF_FIELD_OFFSET(PayloadTransferFrame_PayloadChunk, index_) + + sizeof(PayloadTransferFrame_PayloadChunk::index_) - PROTOBUF_FIELD_OFFSET(PayloadTransferFrame_PayloadChunk, offset_)>( reinterpret_cast(&offset_), reinterpret_cast(&other->offset_)); @@ -8034,6 +8346,9 @@ class KeepAliveFrame::_Internal { static void set_has_ack(HasBits* has_bits) { (*has_bits)[0] |= 1u; } + static void set_has_seq_num(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } }; KeepAliveFrame::KeepAliveFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, @@ -8049,12 +8364,17 @@ KeepAliveFrame::KeepAliveFrame(const KeepAliveFrame& from) : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom(from._internal_metadata_); - ack_ = from.ack_; + ::memcpy(&ack_, &from.ack_, + static_cast(reinterpret_cast(&seq_num_) - + reinterpret_cast(&ack_)) + sizeof(seq_num_)); // @@protoc_insertion_point(copy_constructor:location.nearby.connections.KeepAliveFrame) } inline void KeepAliveFrame::SharedCtor() { -ack_ = false; +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&ack_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&seq_num_) - + reinterpret_cast(&ack_)) + sizeof(seq_num_)); } KeepAliveFrame::~KeepAliveFrame() { @@ -8084,7 +8404,12 @@ void KeepAliveFrame::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - ack_ = false; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&ack_, 0, static_cast( + reinterpret_cast(&seq_num_) - + reinterpret_cast(&ack_)) + sizeof(seq_num_)); + } _has_bits_.Clear(); _internal_metadata_.Clear(); } @@ -8105,6 +8430,15 @@ const char* KeepAliveFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE } else goto handle_unusual; continue; + // optional uint32 seq_num = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_seq_num(&has_bits); + seq_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -8142,6 +8476,12 @@ uint8_t* KeepAliveFrame::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_ack(), target); } + // optional uint32 seq_num = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_seq_num(), target); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); @@ -8158,12 +8498,19 @@ size_t KeepAliveFrame::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // optional bool ack = 1; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + 1; - } + if (cached_has_bits & 0x00000003u) { + // optional bool ack = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 1; + } + // optional uint32 seq_num = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_seq_num()); + } + + } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); } @@ -8184,8 +8531,15 @@ void KeepAliveFrame::MergeFrom(const KeepAliveFrame& from) { uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from._internal_has_ack()) { - _internal_set_ack(from._internal_ack()); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + ack_ = from.ack_; + } + if (cached_has_bits & 0x00000002u) { + seq_num_ = from.seq_num_; + } + _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom(from._internal_metadata_); } @@ -8205,7 +8559,12 @@ void KeepAliveFrame::InternalSwap(KeepAliveFrame* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); - swap(ack_, other->ack_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(KeepAliveFrame, seq_num_) + + sizeof(KeepAliveFrame::seq_num_) + - PROTOBUF_FIELD_OFFSET(KeepAliveFrame, ack_)>( + reinterpret_cast(&ack_), + reinterpret_cast(&other->ack_)); } std::string KeepAliveFrame::GetTypeName() const { @@ -9049,6 +9408,523 @@ std::string AuthenticationResultFrame::GetTypeName() const { } +// =================================================================== + +class AutoResumeFrame::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_event_type(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_pending_payload_id(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_next_payload_chunk_index(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +AutoResumeFrame::AutoResumeFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.AutoResumeFrame) +} +AutoResumeFrame::AutoResumeFrame(const AutoResumeFrame& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::memcpy(&pending_payload_id_, &from.pending_payload_id_, + static_cast(reinterpret_cast(&next_payload_chunk_index_) - + reinterpret_cast(&pending_payload_id_)) + sizeof(next_payload_chunk_index_)); + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.AutoResumeFrame) +} + +inline void AutoResumeFrame::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&pending_payload_id_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&next_payload_chunk_index_) - + reinterpret_cast(&pending_payload_id_)) + sizeof(next_payload_chunk_index_)); +} + +AutoResumeFrame::~AutoResumeFrame() { + // @@protoc_insertion_point(destructor:location.nearby.connections.AutoResumeFrame) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void AutoResumeFrame::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void AutoResumeFrame::ArenaDtor(void* object) { + AutoResumeFrame* _this = reinterpret_cast< AutoResumeFrame* >(object); + (void)_this; +} +void AutoResumeFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void AutoResumeFrame::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void AutoResumeFrame::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.AutoResumeFrame) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + ::memset(&pending_payload_id_, 0, static_cast( + reinterpret_cast(&next_payload_chunk_index_) - + reinterpret_cast(&pending_payload_id_)) + sizeof(next_payload_chunk_index_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* AutoResumeFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .location.nearby.connections.AutoResumeFrame.EventType event_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::connections::AutoResumeFrame_EventType_IsValid(val))) { + _internal_set_event_type(static_cast<::location::nearby::connections::AutoResumeFrame_EventType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional int64 pending_payload_id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_pending_payload_id(&has_bits); + pending_payload_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 next_payload_chunk_index = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_next_payload_chunk_index(&has_bits); + next_payload_chunk_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* AutoResumeFrame::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.AutoResumeFrame) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .location.nearby.connections.AutoResumeFrame.EventType event_type = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_event_type(), target); + } + + // optional int64 pending_payload_id = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_pending_payload_id(), target); + } + + // optional int32 next_payload_chunk_index = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_next_payload_chunk_index(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.AutoResumeFrame) + return target; +} + +size_t AutoResumeFrame::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.AutoResumeFrame) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional int64 pending_payload_id = 2; + if (cached_has_bits & 0x00000001u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_pending_payload_id()); + } + + // optional .location.nearby.connections.AutoResumeFrame.EventType event_type = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_event_type()); + } + + // optional int32 next_payload_chunk_index = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_next_payload_chunk_index()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void AutoResumeFrame::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void AutoResumeFrame::MergeFrom(const AutoResumeFrame& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.AutoResumeFrame) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + pending_payload_id_ = from.pending_payload_id_; + } + if (cached_has_bits & 0x00000002u) { + event_type_ = from.event_type_; + } + if (cached_has_bits & 0x00000004u) { + next_payload_chunk_index_ = from.next_payload_chunk_index_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void AutoResumeFrame::CopyFrom(const AutoResumeFrame& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.AutoResumeFrame) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AutoResumeFrame::IsInitialized() const { + return true; +} + +void AutoResumeFrame::InternalSwap(AutoResumeFrame* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(AutoResumeFrame, next_payload_chunk_index_) + + sizeof(AutoResumeFrame::next_payload_chunk_index_) + - PROTOBUF_FIELD_OFFSET(AutoResumeFrame, pending_payload_id_)>( + reinterpret_cast(&pending_payload_id_), + reinterpret_cast(&other->pending_payload_id_)); +} + +std::string AutoResumeFrame::GetTypeName() const { + return "location.nearby.connections.AutoResumeFrame"; +} + + +// =================================================================== + +class AutoReconnectFrame::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_endpoint_id(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_event_type(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +AutoReconnectFrame::AutoReconnectFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.AutoReconnectFrame) +} +AutoReconnectFrame::AutoReconnectFrame(const AutoReconnectFrame& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + endpoint_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + endpoint_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_endpoint_id()) { + endpoint_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_endpoint_id(), + GetArenaForAllocation()); + } + event_type_ = from.event_type_; + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.AutoReconnectFrame) +} + +inline void AutoReconnectFrame::SharedCtor() { +endpoint_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + endpoint_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +event_type_ = 0; +} + +AutoReconnectFrame::~AutoReconnectFrame() { + // @@protoc_insertion_point(destructor:location.nearby.connections.AutoReconnectFrame) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void AutoReconnectFrame::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + endpoint_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void AutoReconnectFrame::ArenaDtor(void* object) { + AutoReconnectFrame* _this = reinterpret_cast< AutoReconnectFrame* >(object); + (void)_this; +} +void AutoReconnectFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void AutoReconnectFrame::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void AutoReconnectFrame::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.AutoReconnectFrame) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + endpoint_id_.ClearNonDefaultToEmpty(); + } + event_type_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* AutoReconnectFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string endpoint_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_endpoint_id(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.AutoReconnectFrame.EventType event_type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::connections::AutoReconnectFrame_EventType_IsValid(val))) { + _internal_set_event_type(static_cast<::location::nearby::connections::AutoReconnectFrame_EventType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* AutoReconnectFrame::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.AutoReconnectFrame) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string endpoint_id = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased( + 1, this->_internal_endpoint_id(), target); + } + + // optional .location.nearby.connections.AutoReconnectFrame.EventType event_type = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_event_type(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.AutoReconnectFrame) + return target; +} + +size_t AutoReconnectFrame::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.AutoReconnectFrame) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string endpoint_id = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_endpoint_id()); + } + + // optional .location.nearby.connections.AutoReconnectFrame.EventType event_type = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_event_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void AutoReconnectFrame::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void AutoReconnectFrame::MergeFrom(const AutoReconnectFrame& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.AutoReconnectFrame) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_endpoint_id(from._internal_endpoint_id()); + } + if (cached_has_bits & 0x00000002u) { + event_type_ = from.event_type_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void AutoReconnectFrame::CopyFrom(const AutoReconnectFrame& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.AutoReconnectFrame) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AutoReconnectFrame::IsInitialized() const { + return true; +} + +void AutoReconnectFrame::InternalSwap(AutoReconnectFrame* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &endpoint_id_, lhs_arena, + &other->endpoint_id_, rhs_arena + ); + swap(event_type_, other->event_type_); +} + +std::string AutoReconnectFrame::GetTypeName() const { + return "location.nearby.connections.AutoReconnectFrame"; +} + + // =================================================================== class MediumMetadata::_Internal { @@ -12222,6 +13098,12 @@ template<> PROTOBUF_NOINLINE ::location::nearby::connections::AuthenticationMess template<> PROTOBUF_NOINLINE ::location::nearby::connections::AuthenticationResultFrame* Arena::CreateMaybeMessage< ::location::nearby::connections::AuthenticationResultFrame >(Arena* arena) { return Arena::CreateMessageInternal< ::location::nearby::connections::AuthenticationResultFrame >(arena); } +template<> PROTOBUF_NOINLINE ::location::nearby::connections::AutoResumeFrame* Arena::CreateMaybeMessage< ::location::nearby::connections::AutoResumeFrame >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::AutoResumeFrame >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::AutoReconnectFrame* Arena::CreateMaybeMessage< ::location::nearby::connections::AutoReconnectFrame >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::AutoReconnectFrame >(arena); +} template<> PROTOBUF_NOINLINE ::location::nearby::connections::MediumMetadata* Arena::CreateMaybeMessage< ::location::nearby::connections::MediumMetadata >(Arena* arena) { return Arena::CreateMessageInternal< ::location::nearby::connections::MediumMetadata >(arena); } diff --git a/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.h b/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.h index c75669f6..22ca5e23 100644 --- a/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.h +++ b/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.h @@ -45,7 +45,7 @@ struct TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fforma PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[34] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[36] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -60,6 +60,12 @@ extern AuthenticationMessageFrameDefaultTypeInternal _AuthenticationMessageFrame class AuthenticationResultFrame; struct AuthenticationResultFrameDefaultTypeInternal; extern AuthenticationResultFrameDefaultTypeInternal _AuthenticationResultFrame_default_instance_; +class AutoReconnectFrame; +struct AutoReconnectFrameDefaultTypeInternal; +extern AutoReconnectFrameDefaultTypeInternal _AutoReconnectFrame_default_instance_; +class AutoResumeFrame; +struct AutoResumeFrameDefaultTypeInternal; +extern AutoResumeFrameDefaultTypeInternal _AutoResumeFrame_default_instance_; class AvailableChannels; struct AvailableChannelsDefaultTypeInternal; extern AvailableChannelsDefaultTypeInternal _AvailableChannels_default_instance_; @@ -162,6 +168,8 @@ extern WifiLanUsableChannelsDefaultTypeInternal _WifiLanUsableChannels_default_i PROTOBUF_NAMESPACE_OPEN template<> ::location::nearby::connections::AuthenticationMessageFrame* Arena::CreateMaybeMessage<::location::nearby::connections::AuthenticationMessageFrame>(Arena*); template<> ::location::nearby::connections::AuthenticationResultFrame* Arena::CreateMaybeMessage<::location::nearby::connections::AuthenticationResultFrame>(Arena*); +template<> ::location::nearby::connections::AutoReconnectFrame* Arena::CreateMaybeMessage<::location::nearby::connections::AutoReconnectFrame>(Arena*); +template<> ::location::nearby::connections::AutoResumeFrame* Arena::CreateMaybeMessage<::location::nearby::connections::AutoResumeFrame>(Arena*); template<> ::location::nearby::connections::AvailableChannels* Arena::CreateMaybeMessage<::location::nearby::connections::AvailableChannels>(Arena*); template<> ::location::nearby::connections::BandwidthUpgradeNegotiationFrame* Arena::CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame>(Arena*); template<> ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction* Arena::CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction>(Arena*); @@ -228,11 +236,13 @@ enum V1Frame_FrameType : int { V1Frame_FrameType_DISCONNECTION = 6, V1Frame_FrameType_PAIRED_KEY_ENCRYPTION = 7, V1Frame_FrameType_AUTHENTICATION_MESSAGE = 8, - V1Frame_FrameType_AUTHENTICATION_RESULT = 9 + V1Frame_FrameType_AUTHENTICATION_RESULT = 9, + V1Frame_FrameType_AUTO_RESUME = 10, + V1Frame_FrameType_AUTO_RECONNECT = 11 }; bool V1Frame_FrameType_IsValid(int value); constexpr V1Frame_FrameType V1Frame_FrameType_FrameType_MIN = V1Frame_FrameType_UNKNOWN_FRAME_TYPE; -constexpr V1Frame_FrameType V1Frame_FrameType_FrameType_MAX = V1Frame_FrameType_AUTHENTICATION_RESULT; +constexpr V1Frame_FrameType V1Frame_FrameType_FrameType_MAX = V1Frame_FrameType_AUTO_RECONNECT; constexpr int V1Frame_FrameType_FrameType_ARRAYSIZE = V1Frame_FrameType_FrameType_MAX + 1; const std::string& V1Frame_FrameType_Name(V1Frame_FrameType value); @@ -426,6 +436,46 @@ inline const std::string& BandwidthUpgradeNegotiationFrame_EventType_Name(T enum } bool BandwidthUpgradeNegotiationFrame_EventType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BandwidthUpgradeNegotiationFrame_EventType* value); +enum AutoResumeFrame_EventType : int { + AutoResumeFrame_EventType_UNKNOWN_AUTO_RESUME_EVENT_TYPE = 0, + AutoResumeFrame_EventType_PAYLOAD_RESUME_TRANSFER_START = 1, + AutoResumeFrame_EventType_PAYLOAD_RESUME_TRANSFER_ACK = 2 +}; +bool AutoResumeFrame_EventType_IsValid(int value); +constexpr AutoResumeFrame_EventType AutoResumeFrame_EventType_EventType_MIN = AutoResumeFrame_EventType_UNKNOWN_AUTO_RESUME_EVENT_TYPE; +constexpr AutoResumeFrame_EventType AutoResumeFrame_EventType_EventType_MAX = AutoResumeFrame_EventType_PAYLOAD_RESUME_TRANSFER_ACK; +constexpr int AutoResumeFrame_EventType_EventType_ARRAYSIZE = AutoResumeFrame_EventType_EventType_MAX + 1; + +const std::string& AutoResumeFrame_EventType_Name(AutoResumeFrame_EventType value); +template +inline const std::string& AutoResumeFrame_EventType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function AutoResumeFrame_EventType_Name."); + return AutoResumeFrame_EventType_Name(static_cast(enum_t_value)); +} +bool AutoResumeFrame_EventType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AutoResumeFrame_EventType* value); +enum AutoReconnectFrame_EventType : int { + AutoReconnectFrame_EventType_UNKNOWN_EVENT_TYPE = 0, + AutoReconnectFrame_EventType_CLIENT_INTRODUCTION = 1, + AutoReconnectFrame_EventType_CLIENT_INTRODUCTION_ACK = 2 +}; +bool AutoReconnectFrame_EventType_IsValid(int value); +constexpr AutoReconnectFrame_EventType AutoReconnectFrame_EventType_EventType_MIN = AutoReconnectFrame_EventType_UNKNOWN_EVENT_TYPE; +constexpr AutoReconnectFrame_EventType AutoReconnectFrame_EventType_EventType_MAX = AutoReconnectFrame_EventType_CLIENT_INTRODUCTION_ACK; +constexpr int AutoReconnectFrame_EventType_EventType_ARRAYSIZE = AutoReconnectFrame_EventType_EventType_MAX + 1; + +const std::string& AutoReconnectFrame_EventType_Name(AutoReconnectFrame_EventType value); +template +inline const std::string& AutoReconnectFrame_EventType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function AutoReconnectFrame_EventType_Name."); + return AutoReconnectFrame_EventType_Name(static_cast(enum_t_value)); +} +bool AutoReconnectFrame_EventType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AutoReconnectFrame_EventType* value); enum LocationStandard_Format : int { LocationStandard_Format_UNKNOWN = 0, LocationStandard_Format_E164_CALLING = 1, @@ -834,6 +884,10 @@ class V1Frame final : V1Frame_FrameType_AUTHENTICATION_MESSAGE; static constexpr FrameType AUTHENTICATION_RESULT = V1Frame_FrameType_AUTHENTICATION_RESULT; + static constexpr FrameType AUTO_RESUME = + V1Frame_FrameType_AUTO_RESUME; + static constexpr FrameType AUTO_RECONNECT = + V1Frame_FrameType_AUTO_RECONNECT; static inline bool FrameType_IsValid(int value) { return V1Frame_FrameType_IsValid(value); } @@ -867,6 +921,8 @@ class V1Frame final : kPairedKeyEncryptionFieldNumber = 8, kAuthenticationMessageFieldNumber = 9, kAuthenticationResultFieldNumber = 10, + kAutoResumeFieldNumber = 11, + kAutoReconnectFieldNumber = 12, kTypeFieldNumber = 1, }; // optional .location.nearby.connections.ConnectionRequestFrame connection_request = 2; @@ -1031,6 +1087,42 @@ class V1Frame final : ::location::nearby::connections::AuthenticationResultFrame* authentication_result); ::location::nearby::connections::AuthenticationResultFrame* unsafe_arena_release_authentication_result(); + // optional .location.nearby.connections.AutoResumeFrame auto_resume = 11; + bool has_auto_resume() const; + private: + bool _internal_has_auto_resume() const; + public: + void clear_auto_resume(); + const ::location::nearby::connections::AutoResumeFrame& auto_resume() const; + PROTOBUF_NODISCARD ::location::nearby::connections::AutoResumeFrame* release_auto_resume(); + ::location::nearby::connections::AutoResumeFrame* mutable_auto_resume(); + void set_allocated_auto_resume(::location::nearby::connections::AutoResumeFrame* auto_resume); + private: + const ::location::nearby::connections::AutoResumeFrame& _internal_auto_resume() const; + ::location::nearby::connections::AutoResumeFrame* _internal_mutable_auto_resume(); + public: + void unsafe_arena_set_allocated_auto_resume( + ::location::nearby::connections::AutoResumeFrame* auto_resume); + ::location::nearby::connections::AutoResumeFrame* unsafe_arena_release_auto_resume(); + + // optional .location.nearby.connections.AutoReconnectFrame auto_reconnect = 12; + bool has_auto_reconnect() const; + private: + bool _internal_has_auto_reconnect() const; + public: + void clear_auto_reconnect(); + const ::location::nearby::connections::AutoReconnectFrame& auto_reconnect() const; + PROTOBUF_NODISCARD ::location::nearby::connections::AutoReconnectFrame* release_auto_reconnect(); + ::location::nearby::connections::AutoReconnectFrame* mutable_auto_reconnect(); + void set_allocated_auto_reconnect(::location::nearby::connections::AutoReconnectFrame* auto_reconnect); + private: + const ::location::nearby::connections::AutoReconnectFrame& _internal_auto_reconnect() const; + ::location::nearby::connections::AutoReconnectFrame* _internal_mutable_auto_reconnect(); + public: + void unsafe_arena_set_allocated_auto_reconnect( + ::location::nearby::connections::AutoReconnectFrame* auto_reconnect); + ::location::nearby::connections::AutoReconnectFrame* unsafe_arena_release_auto_reconnect(); + // optional .location.nearby.connections.V1Frame.FrameType type = 1; bool has_type() const; private: @@ -1062,6 +1154,8 @@ class V1Frame final : ::location::nearby::connections::PairedKeyEncryptionFrame* paired_key_encryption_; ::location::nearby::connections::AuthenticationMessageFrame* authentication_message_; ::location::nearby::connections::AuthenticationResultFrame* authentication_result_; + ::location::nearby::connections::AutoResumeFrame* auto_resume_; + ::location::nearby::connections::AutoReconnectFrame* auto_reconnect_; int type_; friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; }; @@ -1645,6 +1739,7 @@ class ConnectionResponseFrame final : kResponseFieldNumber = 3, kMultiplexSocketBitmaskFieldNumber = 5, kNearbyConnectionsVersionFieldNumber = 6, + kSafeToDisconnectVersionFieldNumber = 7, }; // optional bytes handshake_data = 2; bool has_handshake_data() const; @@ -1721,19 +1816,32 @@ class ConnectionResponseFrame final : void _internal_set_multiplex_socket_bitmask(int32_t value); public: - // optional int32 nearby_connections_version = 6; - bool has_nearby_connections_version() const; + // optional int32 nearby_connections_version = 6 [deprecated = true]; + PROTOBUF_DEPRECATED bool has_nearby_connections_version() const; private: bool _internal_has_nearby_connections_version() const; public: - void clear_nearby_connections_version(); - int32_t nearby_connections_version() const; - void set_nearby_connections_version(int32_t value); + PROTOBUF_DEPRECATED void clear_nearby_connections_version(); + PROTOBUF_DEPRECATED int32_t nearby_connections_version() const; + PROTOBUF_DEPRECATED void set_nearby_connections_version(int32_t value); private: int32_t _internal_nearby_connections_version() const; void _internal_set_nearby_connections_version(int32_t value); public: + // optional int32 safe_to_disconnect_version = 7; + bool has_safe_to_disconnect_version() const; + private: + bool _internal_has_safe_to_disconnect_version() const; + public: + void clear_safe_to_disconnect_version(); + int32_t safe_to_disconnect_version() const; + void set_safe_to_disconnect_version(int32_t value); + private: + int32_t _internal_safe_to_disconnect_version() const; + void _internal_set_safe_to_disconnect_version(int32_t value); + public: + // @@protoc_insertion_point(class_scope:location.nearby.connections.ConnectionResponseFrame) private: class _Internal; @@ -1749,6 +1857,7 @@ class ConnectionResponseFrame final : int response_; int32_t multiplex_socket_bitmask_; int32_t nearby_connections_version_; + int32_t safe_to_disconnect_version_; friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; }; // ------------------------------------------------------------------- @@ -2150,6 +2259,7 @@ class PayloadTransferFrame_PayloadChunk final : kBodyFieldNumber = 3, kOffsetFieldNumber = 2, kFlagsFieldNumber = 1, + kIndexFieldNumber = 4, }; // optional bytes body = 3; bool has_body() const; @@ -2195,6 +2305,19 @@ class PayloadTransferFrame_PayloadChunk final : void _internal_set_flags(int32_t value); public: + // optional int32 index = 4; + bool has_index() const; + private: + bool _internal_has_index() const; + public: + void clear_index(); + int32_t index() const; + void set_index(int32_t value); + private: + int32_t _internal_index() const; + void _internal_set_index(int32_t value); + public: + // @@protoc_insertion_point(class_scope:location.nearby.connections.PayloadTransferFrame.PayloadChunk) private: class _Internal; @@ -2207,6 +2330,7 @@ class PayloadTransferFrame_PayloadChunk final : ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_; int64_t offset_; int32_t flags_; + int32_t index_; friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; }; // ------------------------------------------------------------------- @@ -4756,6 +4880,7 @@ class KeepAliveFrame final : enum : int { kAckFieldNumber = 1, + kSeqNumFieldNumber = 2, }; // optional bool ack = 1; bool has_ack() const; @@ -4770,6 +4895,19 @@ class KeepAliveFrame final : void _internal_set_ack(bool value); public: + // optional uint32 seq_num = 2; + bool has_seq_num() const; + private: + bool _internal_has_seq_num() const; + public: + void clear_seq_num(); + uint32_t seq_num() const; + void set_seq_num(uint32_t value); + private: + uint32_t _internal_seq_num() const; + void _internal_set_seq_num(uint32_t value); + public: + // @@protoc_insertion_point(class_scope:location.nearby.connections.KeepAliveFrame) private: class _Internal; @@ -4780,6 +4918,7 @@ class KeepAliveFrame final : ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; bool ack_; + uint32_t seq_num_; friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; }; // ------------------------------------------------------------------- @@ -5377,6 +5516,396 @@ class AuthenticationResultFrame final : }; // ------------------------------------------------------------------- +class AutoResumeFrame final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.AutoResumeFrame) */ { + public: + inline AutoResumeFrame() : AutoResumeFrame(nullptr) {} + ~AutoResumeFrame() override; + explicit constexpr AutoResumeFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + AutoResumeFrame(const AutoResumeFrame& from); + AutoResumeFrame(AutoResumeFrame&& from) noexcept + : AutoResumeFrame() { + *this = ::std::move(from); + } + + inline AutoResumeFrame& operator=(const AutoResumeFrame& from) { + CopyFrom(from); + return *this; + } + inline AutoResumeFrame& operator=(AutoResumeFrame&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const AutoResumeFrame& default_instance() { + return *internal_default_instance(); + } + static inline const AutoResumeFrame* internal_default_instance() { + return reinterpret_cast( + &_AutoResumeFrame_default_instance_); + } + static constexpr int kIndexInFileMessages = + 23; + + friend void swap(AutoResumeFrame& a, AutoResumeFrame& b) { + a.Swap(&b); + } + inline void Swap(AutoResumeFrame* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(AutoResumeFrame* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + AutoResumeFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const AutoResumeFrame& from); + void MergeFrom(const AutoResumeFrame& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(AutoResumeFrame* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.AutoResumeFrame"; + } + protected: + explicit AutoResumeFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef AutoResumeFrame_EventType EventType; + static constexpr EventType UNKNOWN_AUTO_RESUME_EVENT_TYPE = + AutoResumeFrame_EventType_UNKNOWN_AUTO_RESUME_EVENT_TYPE; + static constexpr EventType PAYLOAD_RESUME_TRANSFER_START = + AutoResumeFrame_EventType_PAYLOAD_RESUME_TRANSFER_START; + static constexpr EventType PAYLOAD_RESUME_TRANSFER_ACK = + AutoResumeFrame_EventType_PAYLOAD_RESUME_TRANSFER_ACK; + static inline bool EventType_IsValid(int value) { + return AutoResumeFrame_EventType_IsValid(value); + } + static constexpr EventType EventType_MIN = + AutoResumeFrame_EventType_EventType_MIN; + static constexpr EventType EventType_MAX = + AutoResumeFrame_EventType_EventType_MAX; + static constexpr int EventType_ARRAYSIZE = + AutoResumeFrame_EventType_EventType_ARRAYSIZE; + template + static inline const std::string& EventType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function EventType_Name."); + return AutoResumeFrame_EventType_Name(enum_t_value); + } + static inline bool EventType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + EventType* value) { + return AutoResumeFrame_EventType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kPendingPayloadIdFieldNumber = 2, + kEventTypeFieldNumber = 1, + kNextPayloadChunkIndexFieldNumber = 3, + }; + // optional int64 pending_payload_id = 2; + bool has_pending_payload_id() const; + private: + bool _internal_has_pending_payload_id() const; + public: + void clear_pending_payload_id(); + int64_t pending_payload_id() const; + void set_pending_payload_id(int64_t value); + private: + int64_t _internal_pending_payload_id() const; + void _internal_set_pending_payload_id(int64_t value); + public: + + // optional .location.nearby.connections.AutoResumeFrame.EventType event_type = 1; + bool has_event_type() const; + private: + bool _internal_has_event_type() const; + public: + void clear_event_type(); + ::location::nearby::connections::AutoResumeFrame_EventType event_type() const; + void set_event_type(::location::nearby::connections::AutoResumeFrame_EventType value); + private: + ::location::nearby::connections::AutoResumeFrame_EventType _internal_event_type() const; + void _internal_set_event_type(::location::nearby::connections::AutoResumeFrame_EventType value); + public: + + // optional int32 next_payload_chunk_index = 3; + bool has_next_payload_chunk_index() const; + private: + bool _internal_has_next_payload_chunk_index() const; + public: + void clear_next_payload_chunk_index(); + int32_t next_payload_chunk_index() const; + void set_next_payload_chunk_index(int32_t value); + private: + int32_t _internal_next_payload_chunk_index() const; + void _internal_set_next_payload_chunk_index(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.AutoResumeFrame) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int64_t pending_payload_id_; + int event_type_; + int32_t next_payload_chunk_index_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class AutoReconnectFrame final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.AutoReconnectFrame) */ { + public: + inline AutoReconnectFrame() : AutoReconnectFrame(nullptr) {} + ~AutoReconnectFrame() override; + explicit constexpr AutoReconnectFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + AutoReconnectFrame(const AutoReconnectFrame& from); + AutoReconnectFrame(AutoReconnectFrame&& from) noexcept + : AutoReconnectFrame() { + *this = ::std::move(from); + } + + inline AutoReconnectFrame& operator=(const AutoReconnectFrame& from) { + CopyFrom(from); + return *this; + } + inline AutoReconnectFrame& operator=(AutoReconnectFrame&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const AutoReconnectFrame& default_instance() { + return *internal_default_instance(); + } + static inline const AutoReconnectFrame* internal_default_instance() { + return reinterpret_cast( + &_AutoReconnectFrame_default_instance_); + } + static constexpr int kIndexInFileMessages = + 24; + + friend void swap(AutoReconnectFrame& a, AutoReconnectFrame& b) { + a.Swap(&b); + } + inline void Swap(AutoReconnectFrame* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(AutoReconnectFrame* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + AutoReconnectFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const AutoReconnectFrame& from); + void MergeFrom(const AutoReconnectFrame& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(AutoReconnectFrame* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.AutoReconnectFrame"; + } + protected: + explicit AutoReconnectFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef AutoReconnectFrame_EventType EventType; + static constexpr EventType UNKNOWN_EVENT_TYPE = + AutoReconnectFrame_EventType_UNKNOWN_EVENT_TYPE; + static constexpr EventType CLIENT_INTRODUCTION = + AutoReconnectFrame_EventType_CLIENT_INTRODUCTION; + static constexpr EventType CLIENT_INTRODUCTION_ACK = + AutoReconnectFrame_EventType_CLIENT_INTRODUCTION_ACK; + static inline bool EventType_IsValid(int value) { + return AutoReconnectFrame_EventType_IsValid(value); + } + static constexpr EventType EventType_MIN = + AutoReconnectFrame_EventType_EventType_MIN; + static constexpr EventType EventType_MAX = + AutoReconnectFrame_EventType_EventType_MAX; + static constexpr int EventType_ARRAYSIZE = + AutoReconnectFrame_EventType_EventType_ARRAYSIZE; + template + static inline const std::string& EventType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function EventType_Name."); + return AutoReconnectFrame_EventType_Name(enum_t_value); + } + static inline bool EventType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + EventType* value) { + return AutoReconnectFrame_EventType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kEndpointIdFieldNumber = 1, + kEventTypeFieldNumber = 2, + }; + // optional string endpoint_id = 1; + bool has_endpoint_id() const; + private: + bool _internal_has_endpoint_id() const; + public: + void clear_endpoint_id(); + const std::string& endpoint_id() const; + template + void set_endpoint_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_endpoint_id(); + PROTOBUF_NODISCARD std::string* release_endpoint_id(); + void set_allocated_endpoint_id(std::string* endpoint_id); + private: + const std::string& _internal_endpoint_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_endpoint_id(const std::string& value); + std::string* _internal_mutable_endpoint_id(); + public: + + // optional .location.nearby.connections.AutoReconnectFrame.EventType event_type = 2; + bool has_event_type() const; + private: + bool _internal_has_event_type() const; + public: + void clear_event_type(); + ::location::nearby::connections::AutoReconnectFrame_EventType event_type() const; + void set_event_type(::location::nearby::connections::AutoReconnectFrame_EventType value); + private: + ::location::nearby::connections::AutoReconnectFrame_EventType _internal_event_type() const; + void _internal_set_event_type(::location::nearby::connections::AutoReconnectFrame_EventType value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.AutoReconnectFrame) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr endpoint_id_; + int event_type_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + class MediumMetadata final : public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.MediumMetadata) */ { public: @@ -5423,7 +5952,7 @@ class MediumMetadata final : &_MediumMetadata_default_instance_); } static constexpr int kIndexInFileMessages = - 23; + 25; friend void swap(MediumMetadata& a, MediumMetadata& b) { a.Swap(&b); @@ -5750,7 +6279,7 @@ class AvailableChannels final : &_AvailableChannels_default_instance_); } static constexpr int kIndexInFileMessages = - 24; + 26; friend void swap(AvailableChannels& a, AvailableChannels& b) { a.Swap(&b); @@ -5901,7 +6430,7 @@ class WifiDirectCliUsableChannels final : &_WifiDirectCliUsableChannels_default_instance_); } static constexpr int kIndexInFileMessages = - 25; + 27; friend void swap(WifiDirectCliUsableChannels& a, WifiDirectCliUsableChannels& b) { a.Swap(&b); @@ -6052,7 +6581,7 @@ class WifiLanUsableChannels final : &_WifiLanUsableChannels_default_instance_); } static constexpr int kIndexInFileMessages = - 26; + 28; friend void swap(WifiLanUsableChannels& a, WifiLanUsableChannels& b) { a.Swap(&b); @@ -6203,7 +6732,7 @@ class WifiAwareUsableChannels final : &_WifiAwareUsableChannels_default_instance_); } static constexpr int kIndexInFileMessages = - 27; + 29; friend void swap(WifiAwareUsableChannels& a, WifiAwareUsableChannels& b) { a.Swap(&b); @@ -6354,7 +6883,7 @@ class WifiHotspotStaUsableChannels final : &_WifiHotspotStaUsableChannels_default_instance_); } static constexpr int kIndexInFileMessages = - 28; + 30; friend void swap(WifiHotspotStaUsableChannels& a, WifiHotspotStaUsableChannels& b) { a.Swap(&b); @@ -6505,7 +7034,7 @@ class LocationHint final : &_LocationHint_default_instance_); } static constexpr int kIndexInFileMessages = - 29; + 31; friend void swap(LocationHint& a, LocationHint& b) { a.Swap(&b); @@ -6667,7 +7196,7 @@ class LocationStandard final : &_LocationStandard_default_instance_); } static constexpr int kIndexInFileMessages = - 30; + 32; friend void swap(LocationStandard& a, LocationStandard& b) { a.Swap(&b); @@ -6819,7 +7348,7 @@ class OsInfo final : &_OsInfo_default_instance_); } static constexpr int kIndexInFileMessages = - 31; + 33; friend void swap(OsInfo& a, OsInfo& b) { a.Swap(&b); @@ -6995,7 +7524,7 @@ class ConnectionsDevice final : &_ConnectionsDevice_default_instance_); } static constexpr int kIndexInFileMessages = - 32; + 34; friend void swap(ConnectionsDevice& a, ConnectionsDevice& b) { a.Swap(&b); @@ -7197,7 +7726,7 @@ class PresenceDevice final : &_PresenceDevice_default_instance_); } static constexpr int kIndexInFileMessages = - 33; + 35; friend void swap(PresenceDevice& a, PresenceDevice& b) { a.Swap(&b); @@ -7643,7 +8172,7 @@ inline void OfflineFrame::set_allocated_v1(::location::nearby::connections::V1Fr // optional .location.nearby.connections.V1Frame.FrameType type = 1; inline bool V1Frame::_internal_has_type() const { - bool value = (_has_bits_[0] & 0x00000200u) != 0; + bool value = (_has_bits_[0] & 0x00000800u) != 0; return value; } inline bool V1Frame::has_type() const { @@ -7651,7 +8180,7 @@ inline bool V1Frame::has_type() const { } inline void V1Frame::clear_type() { type_ = 0; - _has_bits_[0] &= ~0x00000200u; + _has_bits_[0] &= ~0x00000800u; } inline ::location::nearby::connections::V1Frame_FrameType V1Frame::_internal_type() const { return static_cast< ::location::nearby::connections::V1Frame_FrameType >(type_); @@ -7662,7 +8191,7 @@ inline ::location::nearby::connections::V1Frame_FrameType V1Frame::type() const } inline void V1Frame::_internal_set_type(::location::nearby::connections::V1Frame_FrameType value) { assert(::location::nearby::connections::V1Frame_FrameType_IsValid(value)); - _has_bits_[0] |= 0x00000200u; + _has_bits_[0] |= 0x00000800u; type_ = value; } inline void V1Frame::set_type(::location::nearby::connections::V1Frame_FrameType value) { @@ -8480,6 +9009,186 @@ inline void V1Frame::set_allocated_authentication_result(::location::nearby::con // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.V1Frame.authentication_result) } +// optional .location.nearby.connections.AutoResumeFrame auto_resume = 11; +inline bool V1Frame::_internal_has_auto_resume() const { + bool value = (_has_bits_[0] & 0x00000200u) != 0; + PROTOBUF_ASSUME(!value || auto_resume_ != nullptr); + return value; +} +inline bool V1Frame::has_auto_resume() const { + return _internal_has_auto_resume(); +} +inline void V1Frame::clear_auto_resume() { + if (auto_resume_ != nullptr) auto_resume_->Clear(); + _has_bits_[0] &= ~0x00000200u; +} +inline const ::location::nearby::connections::AutoResumeFrame& V1Frame::_internal_auto_resume() const { + const ::location::nearby::connections::AutoResumeFrame* p = auto_resume_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_AutoResumeFrame_default_instance_); +} +inline const ::location::nearby::connections::AutoResumeFrame& V1Frame::auto_resume() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.V1Frame.auto_resume) + return _internal_auto_resume(); +} +inline void V1Frame::unsafe_arena_set_allocated_auto_resume( + ::location::nearby::connections::AutoResumeFrame* auto_resume) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(auto_resume_); + } + auto_resume_ = auto_resume; + if (auto_resume) { + _has_bits_[0] |= 0x00000200u; + } else { + _has_bits_[0] &= ~0x00000200u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.V1Frame.auto_resume) +} +inline ::location::nearby::connections::AutoResumeFrame* V1Frame::release_auto_resume() { + _has_bits_[0] &= ~0x00000200u; + ::location::nearby::connections::AutoResumeFrame* temp = auto_resume_; + auto_resume_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::location::nearby::connections::AutoResumeFrame* V1Frame::unsafe_arena_release_auto_resume() { + // @@protoc_insertion_point(field_release:location.nearby.connections.V1Frame.auto_resume) + _has_bits_[0] &= ~0x00000200u; + ::location::nearby::connections::AutoResumeFrame* temp = auto_resume_; + auto_resume_ = nullptr; + return temp; +} +inline ::location::nearby::connections::AutoResumeFrame* V1Frame::_internal_mutable_auto_resume() { + _has_bits_[0] |= 0x00000200u; + if (auto_resume_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::AutoResumeFrame>(GetArenaForAllocation()); + auto_resume_ = p; + } + return auto_resume_; +} +inline ::location::nearby::connections::AutoResumeFrame* V1Frame::mutable_auto_resume() { + ::location::nearby::connections::AutoResumeFrame* _msg = _internal_mutable_auto_resume(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.V1Frame.auto_resume) + return _msg; +} +inline void V1Frame::set_allocated_auto_resume(::location::nearby::connections::AutoResumeFrame* auto_resume) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete auto_resume_; + } + if (auto_resume) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::AutoResumeFrame>::GetOwningArena(auto_resume); + if (message_arena != submessage_arena) { + auto_resume = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, auto_resume, submessage_arena); + } + _has_bits_[0] |= 0x00000200u; + } else { + _has_bits_[0] &= ~0x00000200u; + } + auto_resume_ = auto_resume; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.V1Frame.auto_resume) +} + +// optional .location.nearby.connections.AutoReconnectFrame auto_reconnect = 12; +inline bool V1Frame::_internal_has_auto_reconnect() const { + bool value = (_has_bits_[0] & 0x00000400u) != 0; + PROTOBUF_ASSUME(!value || auto_reconnect_ != nullptr); + return value; +} +inline bool V1Frame::has_auto_reconnect() const { + return _internal_has_auto_reconnect(); +} +inline void V1Frame::clear_auto_reconnect() { + if (auto_reconnect_ != nullptr) auto_reconnect_->Clear(); + _has_bits_[0] &= ~0x00000400u; +} +inline const ::location::nearby::connections::AutoReconnectFrame& V1Frame::_internal_auto_reconnect() const { + const ::location::nearby::connections::AutoReconnectFrame* p = auto_reconnect_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_AutoReconnectFrame_default_instance_); +} +inline const ::location::nearby::connections::AutoReconnectFrame& V1Frame::auto_reconnect() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.V1Frame.auto_reconnect) + return _internal_auto_reconnect(); +} +inline void V1Frame::unsafe_arena_set_allocated_auto_reconnect( + ::location::nearby::connections::AutoReconnectFrame* auto_reconnect) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(auto_reconnect_); + } + auto_reconnect_ = auto_reconnect; + if (auto_reconnect) { + _has_bits_[0] |= 0x00000400u; + } else { + _has_bits_[0] &= ~0x00000400u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.V1Frame.auto_reconnect) +} +inline ::location::nearby::connections::AutoReconnectFrame* V1Frame::release_auto_reconnect() { + _has_bits_[0] &= ~0x00000400u; + ::location::nearby::connections::AutoReconnectFrame* temp = auto_reconnect_; + auto_reconnect_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::location::nearby::connections::AutoReconnectFrame* V1Frame::unsafe_arena_release_auto_reconnect() { + // @@protoc_insertion_point(field_release:location.nearby.connections.V1Frame.auto_reconnect) + _has_bits_[0] &= ~0x00000400u; + ::location::nearby::connections::AutoReconnectFrame* temp = auto_reconnect_; + auto_reconnect_ = nullptr; + return temp; +} +inline ::location::nearby::connections::AutoReconnectFrame* V1Frame::_internal_mutable_auto_reconnect() { + _has_bits_[0] |= 0x00000400u; + if (auto_reconnect_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::AutoReconnectFrame>(GetArenaForAllocation()); + auto_reconnect_ = p; + } + return auto_reconnect_; +} +inline ::location::nearby::connections::AutoReconnectFrame* V1Frame::mutable_auto_reconnect() { + ::location::nearby::connections::AutoReconnectFrame* _msg = _internal_mutable_auto_reconnect(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.V1Frame.auto_reconnect) + return _msg; +} +inline void V1Frame::set_allocated_auto_reconnect(::location::nearby::connections::AutoReconnectFrame* auto_reconnect) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete auto_reconnect_; + } + if (auto_reconnect) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::AutoReconnectFrame>::GetOwningArena(auto_reconnect); + if (message_arena != submessage_arena) { + auto_reconnect = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, auto_reconnect, submessage_arena); + } + _has_bits_[0] |= 0x00000400u; + } else { + _has_bits_[0] &= ~0x00000400u; + } + auto_reconnect_ = auto_reconnect; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.V1Frame.auto_reconnect) +} + // ------------------------------------------------------------------- // ConnectionRequestFrame @@ -9481,7 +10190,7 @@ inline void ConnectionResponseFrame::set_multiplex_socket_bitmask(int32_t value) // @@protoc_insertion_point(field_set:location.nearby.connections.ConnectionResponseFrame.multiplex_socket_bitmask) } -// optional int32 nearby_connections_version = 6; +// optional int32 nearby_connections_version = 6 [deprecated = true]; inline bool ConnectionResponseFrame::_internal_has_nearby_connections_version() const { bool value = (_has_bits_[0] & 0x00000020u) != 0; return value; @@ -9509,6 +10218,34 @@ inline void ConnectionResponseFrame::set_nearby_connections_version(int32_t valu // @@protoc_insertion_point(field_set:location.nearby.connections.ConnectionResponseFrame.nearby_connections_version) } +// optional int32 safe_to_disconnect_version = 7; +inline bool ConnectionResponseFrame::_internal_has_safe_to_disconnect_version() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool ConnectionResponseFrame::has_safe_to_disconnect_version() const { + return _internal_has_safe_to_disconnect_version(); +} +inline void ConnectionResponseFrame::clear_safe_to_disconnect_version() { + safe_to_disconnect_version_ = 0; + _has_bits_[0] &= ~0x00000040u; +} +inline int32_t ConnectionResponseFrame::_internal_safe_to_disconnect_version() const { + return safe_to_disconnect_version_; +} +inline int32_t ConnectionResponseFrame::safe_to_disconnect_version() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.ConnectionResponseFrame.safe_to_disconnect_version) + return _internal_safe_to_disconnect_version(); +} +inline void ConnectionResponseFrame::_internal_set_safe_to_disconnect_version(int32_t value) { + _has_bits_[0] |= 0x00000040u; + safe_to_disconnect_version_ = value; +} +inline void ConnectionResponseFrame::set_safe_to_disconnect_version(int32_t value) { + _internal_set_safe_to_disconnect_version(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.ConnectionResponseFrame.safe_to_disconnect_version) +} + // ------------------------------------------------------------------- // PayloadTransferFrame_PayloadHeader @@ -9893,6 +10630,34 @@ inline void PayloadTransferFrame_PayloadChunk::set_allocated_body(std::string* b // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.PayloadTransferFrame.PayloadChunk.body) } +// optional int32 index = 4; +inline bool PayloadTransferFrame_PayloadChunk::_internal_has_index() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool PayloadTransferFrame_PayloadChunk::has_index() const { + return _internal_has_index(); +} +inline void PayloadTransferFrame_PayloadChunk::clear_index() { + index_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline int32_t PayloadTransferFrame_PayloadChunk::_internal_index() const { + return index_; +} +inline int32_t PayloadTransferFrame_PayloadChunk::index() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.PayloadTransferFrame.PayloadChunk.index) + return _internal_index(); +} +inline void PayloadTransferFrame_PayloadChunk::_internal_set_index(int32_t value) { + _has_bits_[0] |= 0x00000008u; + index_ = value; +} +inline void PayloadTransferFrame_PayloadChunk::set_index(int32_t value) { + _internal_set_index(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.PayloadTransferFrame.PayloadChunk.index) +} + // ------------------------------------------------------------------- // PayloadTransferFrame_ControlMessage @@ -12528,6 +13293,34 @@ inline void KeepAliveFrame::set_ack(bool value) { // @@protoc_insertion_point(field_set:location.nearby.connections.KeepAliveFrame.ack) } +// optional uint32 seq_num = 2; +inline bool KeepAliveFrame::_internal_has_seq_num() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool KeepAliveFrame::has_seq_num() const { + return _internal_has_seq_num(); +} +inline void KeepAliveFrame::clear_seq_num() { + seq_num_ = 0u; + _has_bits_[0] &= ~0x00000002u; +} +inline uint32_t KeepAliveFrame::_internal_seq_num() const { + return seq_num_; +} +inline uint32_t KeepAliveFrame::seq_num() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.KeepAliveFrame.seq_num) + return _internal_seq_num(); +} +inline void KeepAliveFrame::_internal_set_seq_num(uint32_t value) { + _has_bits_[0] |= 0x00000002u; + seq_num_ = value; +} +inline void KeepAliveFrame::set_seq_num(uint32_t value) { + _internal_set_seq_num(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.KeepAliveFrame.seq_num) +} + // ------------------------------------------------------------------- // DisconnectionFrame @@ -12768,6 +13561,197 @@ inline void AuthenticationResultFrame::set_result(int32_t value) { // ------------------------------------------------------------------- +// AutoResumeFrame + +// optional .location.nearby.connections.AutoResumeFrame.EventType event_type = 1; +inline bool AutoResumeFrame::_internal_has_event_type() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool AutoResumeFrame::has_event_type() const { + return _internal_has_event_type(); +} +inline void AutoResumeFrame::clear_event_type() { + event_type_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline ::location::nearby::connections::AutoResumeFrame_EventType AutoResumeFrame::_internal_event_type() const { + return static_cast< ::location::nearby::connections::AutoResumeFrame_EventType >(event_type_); +} +inline ::location::nearby::connections::AutoResumeFrame_EventType AutoResumeFrame::event_type() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.AutoResumeFrame.event_type) + return _internal_event_type(); +} +inline void AutoResumeFrame::_internal_set_event_type(::location::nearby::connections::AutoResumeFrame_EventType value) { + assert(::location::nearby::connections::AutoResumeFrame_EventType_IsValid(value)); + _has_bits_[0] |= 0x00000002u; + event_type_ = value; +} +inline void AutoResumeFrame::set_event_type(::location::nearby::connections::AutoResumeFrame_EventType value) { + _internal_set_event_type(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.AutoResumeFrame.event_type) +} + +// optional int64 pending_payload_id = 2; +inline bool AutoResumeFrame::_internal_has_pending_payload_id() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool AutoResumeFrame::has_pending_payload_id() const { + return _internal_has_pending_payload_id(); +} +inline void AutoResumeFrame::clear_pending_payload_id() { + pending_payload_id_ = int64_t{0}; + _has_bits_[0] &= ~0x00000001u; +} +inline int64_t AutoResumeFrame::_internal_pending_payload_id() const { + return pending_payload_id_; +} +inline int64_t AutoResumeFrame::pending_payload_id() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.AutoResumeFrame.pending_payload_id) + return _internal_pending_payload_id(); +} +inline void AutoResumeFrame::_internal_set_pending_payload_id(int64_t value) { + _has_bits_[0] |= 0x00000001u; + pending_payload_id_ = value; +} +inline void AutoResumeFrame::set_pending_payload_id(int64_t value) { + _internal_set_pending_payload_id(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.AutoResumeFrame.pending_payload_id) +} + +// optional int32 next_payload_chunk_index = 3; +inline bool AutoResumeFrame::_internal_has_next_payload_chunk_index() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool AutoResumeFrame::has_next_payload_chunk_index() const { + return _internal_has_next_payload_chunk_index(); +} +inline void AutoResumeFrame::clear_next_payload_chunk_index() { + next_payload_chunk_index_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline int32_t AutoResumeFrame::_internal_next_payload_chunk_index() const { + return next_payload_chunk_index_; +} +inline int32_t AutoResumeFrame::next_payload_chunk_index() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.AutoResumeFrame.next_payload_chunk_index) + return _internal_next_payload_chunk_index(); +} +inline void AutoResumeFrame::_internal_set_next_payload_chunk_index(int32_t value) { + _has_bits_[0] |= 0x00000004u; + next_payload_chunk_index_ = value; +} +inline void AutoResumeFrame::set_next_payload_chunk_index(int32_t value) { + _internal_set_next_payload_chunk_index(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.AutoResumeFrame.next_payload_chunk_index) +} + +// ------------------------------------------------------------------- + +// AutoReconnectFrame + +// optional string endpoint_id = 1; +inline bool AutoReconnectFrame::_internal_has_endpoint_id() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool AutoReconnectFrame::has_endpoint_id() const { + return _internal_has_endpoint_id(); +} +inline void AutoReconnectFrame::clear_endpoint_id() { + endpoint_id_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& AutoReconnectFrame::endpoint_id() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.AutoReconnectFrame.endpoint_id) + return _internal_endpoint_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void AutoReconnectFrame::set_endpoint_id(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + endpoint_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.AutoReconnectFrame.endpoint_id) +} +inline std::string* AutoReconnectFrame::mutable_endpoint_id() { + std::string* _s = _internal_mutable_endpoint_id(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.AutoReconnectFrame.endpoint_id) + return _s; +} +inline const std::string& AutoReconnectFrame::_internal_endpoint_id() const { + return endpoint_id_.Get(); +} +inline void AutoReconnectFrame::_internal_set_endpoint_id(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + endpoint_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* AutoReconnectFrame::_internal_mutable_endpoint_id() { + _has_bits_[0] |= 0x00000001u; + return endpoint_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* AutoReconnectFrame::release_endpoint_id() { + // @@protoc_insertion_point(field_release:location.nearby.connections.AutoReconnectFrame.endpoint_id) + if (!_internal_has_endpoint_id()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = endpoint_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (endpoint_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + endpoint_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void AutoReconnectFrame::set_allocated_endpoint_id(std::string* endpoint_id) { + if (endpoint_id != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + endpoint_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), endpoint_id, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (endpoint_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + endpoint_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.AutoReconnectFrame.endpoint_id) +} + +// optional .location.nearby.connections.AutoReconnectFrame.EventType event_type = 2; +inline bool AutoReconnectFrame::_internal_has_event_type() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool AutoReconnectFrame::has_event_type() const { + return _internal_has_event_type(); +} +inline void AutoReconnectFrame::clear_event_type() { + event_type_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline ::location::nearby::connections::AutoReconnectFrame_EventType AutoReconnectFrame::_internal_event_type() const { + return static_cast< ::location::nearby::connections::AutoReconnectFrame_EventType >(event_type_); +} +inline ::location::nearby::connections::AutoReconnectFrame_EventType AutoReconnectFrame::event_type() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.AutoReconnectFrame.event_type) + return _internal_event_type(); +} +inline void AutoReconnectFrame::_internal_set_event_type(::location::nearby::connections::AutoReconnectFrame_EventType value) { + assert(::location::nearby::connections::AutoReconnectFrame_EventType_IsValid(value)); + _has_bits_[0] |= 0x00000002u; + event_type_ = value; +} +inline void AutoReconnectFrame::set_event_type(::location::nearby::connections::AutoReconnectFrame_EventType value) { + _internal_set_event_type(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.AutoReconnectFrame.event_type) +} + +// ------------------------------------------------------------------- + // MediumMetadata // optional bool supports_5_ghz = 1; @@ -14678,6 +15662,10 @@ PresenceDevice::mutable_identity_type() { // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) @@ -14697,6 +15685,8 @@ template <> struct is_proto_enum< ::location::nearby::connections::PayloadTransf template <> struct is_proto_enum< ::location::nearby::connections::PayloadTransferFrame_PacketType> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_EventType> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::connections::AutoResumeFrame_EventType> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::connections::AutoReconnectFrame_EventType> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::connections::LocationStandard_Format> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::connections::OsInfo_OsType> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::connections::PresenceDevice_DeviceType> : ::std::true_type {}; diff --git a/compiled_proto/proto/connections_enums.pb.cc b/compiled_proto/proto/connections_enums.pb.cc index e5fac4cc..20cd2d6f 100644 --- a/compiled_proto/proto/connections_enums.pb.cc +++ b/compiled_proto/proto/connections_enums.pb.cc @@ -1414,6 +1414,1084 @@ bool PowerLevel_Parse( } return success; } +bool OperationResultCategory_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed OperationResultCategory_strings[10] = {}; + +static const char OperationResultCategory_names[] = + "CATEGORY_CLIENT_CANCELLATION" + "CATEGORY_CLIENT_ERROR" + "CATEGORY_CONNECTIVITY_ERROR" + "CATEGORY_DEVICE_STATE_ERROR" + "CATEGORY_IO_ERROR" + "CATEGORY_MEDIUM_UNAVAILABLE" + "CATEGORY_MISCELLANEOUS" + "CATEGORY_NEARBY_ERROR" + "CATEGORY_SUCCESS" + "CATEGORY_UNKNOWN"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry OperationResultCategory_entries[] = { + { {OperationResultCategory_names + 0, 28}, 2 }, + { {OperationResultCategory_names + 28, 21}, 5 }, + { {OperationResultCategory_names + 49, 27}, 7 }, + { {OperationResultCategory_names + 76, 27}, 4 }, + { {OperationResultCategory_names + 103, 17}, 9 }, + { {OperationResultCategory_names + 120, 27}, 3 }, + { {OperationResultCategory_names + 147, 22}, 8 }, + { {OperationResultCategory_names + 169, 21}, 6 }, + { {OperationResultCategory_names + 190, 16}, 1 }, + { {OperationResultCategory_names + 206, 16}, 0 }, +}; + +static const int OperationResultCategory_entries_by_number[] = { + 9, // 0 -> CATEGORY_UNKNOWN + 8, // 1 -> CATEGORY_SUCCESS + 0, // 2 -> CATEGORY_CLIENT_CANCELLATION + 5, // 3 -> CATEGORY_MEDIUM_UNAVAILABLE + 3, // 4 -> CATEGORY_DEVICE_STATE_ERROR + 1, // 5 -> CATEGORY_CLIENT_ERROR + 7, // 6 -> CATEGORY_NEARBY_ERROR + 2, // 7 -> CATEGORY_CONNECTIVITY_ERROR + 6, // 8 -> CATEGORY_MISCELLANEOUS + 4, // 9 -> CATEGORY_IO_ERROR +}; + +const std::string& OperationResultCategory_Name( + OperationResultCategory value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + OperationResultCategory_entries, + OperationResultCategory_entries_by_number, + 10, OperationResultCategory_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + OperationResultCategory_entries, + OperationResultCategory_entries_by_number, + 10, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + OperationResultCategory_strings[idx].get(); +} +bool OperationResultCategory_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OperationResultCategory* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + OperationResultCategory_entries, 10, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +bool OperationResultDetail_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 500: + case 501: + case 502: + case 503: + case 504: + case 505: + case 506: + case 507: + case 508: + case 509: + case 510: + case 511: + case 512: + case 513: + case 514: + case 515: + case 516: + case 517: + case 518: + case 519: + case 520: + case 521: + case 522: + case 523: + case 1000: + case 1001: + case 1002: + case 1003: + case 1004: + case 1500: + case 1501: + case 1502: + case 1503: + case 1504: + case 1505: + case 1506: + case 1507: + case 1508: + case 1509: + case 1510: + case 1511: + case 1512: + case 1513: + case 1514: + case 1515: + case 1516: + case 1517: + case 1518: + case 1519: + case 1520: + case 1521: + case 1522: + case 1523: + case 1524: + case 1525: + case 1526: + case 1527: + case 1528: + case 1529: + case 1530: + case 1531: + case 1532: + case 1533: + case 1534: + case 1535: + case 1536: + case 1537: + case 1538: + case 2000: + case 2001: + case 2002: + case 2003: + case 2004: + case 2005: + case 2006: + case 2007: + case 2008: + case 2009: + case 2010: + case 2011: + case 2012: + case 2013: + case 2014: + case 2015: + case 2016: + case 2500: + case 2501: + case 2502: + case 2503: + case 2504: + case 2505: + case 2506: + case 2507: + case 2508: + case 2509: + case 2510: + case 2511: + case 2512: + case 3000: + case 3001: + case 3002: + case 3003: + case 3004: + case 3005: + case 3006: + case 3007: + case 3008: + case 3009: + case 3010: + case 3011: + case 3012: + case 3013: + case 3014: + case 3500: + case 3501: + case 3502: + case 3503: + case 3504: + case 3505: + case 3506: + case 3507: + case 3508: + case 3509: + case 3510: + case 3511: + case 3512: + case 3513: + case 3514: + case 3515: + case 3516: + case 3517: + case 3518: + case 3519: + case 3520: + case 3521: + case 3522: + case 3523: + case 3524: + case 3525: + case 3526: + case 3527: + case 3528: + case 3529: + case 3530: + case 3531: + case 3532: + case 3533: + case 3534: + case 3535: + case 3536: + case 3537: + case 3538: + case 3539: + case 3540: + case 3541: + case 3542: + case 3543: + case 3544: + case 3545: + case 3546: + case 3547: + case 3548: + case 3549: + case 3550: + case 3551: + case 3552: + case 3553: + case 3554: + case 3555: + case 4500: + case 4501: + case 4502: + case 4503: + case 4504: + case 4505: + case 4506: + case 4507: + case 4508: + case 4509: + case 4510: + case 4511: + case 4512: + case 4513: + case 4514: + case 4515: + case 4516: + case 4517: + case 4518: + case 4519: + case 4520: + case 4521: + case 4522: + case 4523: + case 4524: + case 4525: + case 4526: + case 4527: + case 4528: + case 4529: + case 4530: + case 4531: + case 4532: + case 4533: + case 4534: + case 4535: + case 4536: + case 4537: + case 4538: + case 4539: + case 4540: + case 4541: + case 4542: + case 4543: + case 4544: + case 4545: + case 4546: + case 4547: + case 4548: + case 4549: + case 4550: + case 4551: + case 4552: + case 4553: + case 4554: + case 4555: + case 4556: + case 4557: + case 4558: + case 4559: + case 4560: + case 4561: + case 4562: + case 4563: + case 4564: + case 4565: + case 4566: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed OperationResultDetail_strings[238] = {}; + +static const char OperationResultDetail_names[] = + "CLIENT_CANCELLATION_BT_SERVER_SOCKET_CREATION" + "CLIENT_CANCELLATION_CANCEL_BLE_OUTGOING_CONNECTION" + "CLIENT_CANCELLATION_CANCEL_BT_OUTGOING_CONNECTION" + "CLIENT_CANCELLATION_CANCEL_INCOMING_CONNECTION" + "CLIENT_CANCELLATION_CANCEL_L2CAP_OUTGOING_CONNECTION" + "CLIENT_CANCELLATION_CANCEL_LAN_OUTGOING_CONNECTION" + "CLIENT_CANCELLATION_CANCEL_NFC_OUTGOING_CONNECTION" + "CLIENT_CANCELLATION_CANCEL_OUTGOING_CONNECTION" + "CLIENT_CANCELLATION_CANCEL_USB_OUTGOING_CONNECTION" + "CLIENT_CANCELLATION_CANCEL_WEB_RTC_OUTGOING_CONNECTION" + "CLIENT_CANCELLATION_CANCEL_WIFI_AWARE_OUTGOING_CONNECTION" + "CLIENT_CANCELLATION_CANCEL_WIFI_DIRECT_OUTGOING_CONNECTION" + "CLIENT_CANCELLATION_CANCEL_WIFI_HOTSPOT_OUTGOING_CONNECTION" + "CLIENT_CANCELLATION_LOCAL_CANCEL_PAYLOAD" + "CLIENT_CANCELLATION_LOCAL_DISCONNECT" + "CLIENT_CANCELLATION_REMOTE_CANCEL_PAYLOAD" + "CLIENT_CANCELLATION_REMOTE_DISCONNECT" + "CLIENT_CANCELLATION_REMOTE_IN_CANCELED_STATE" + "CLIENT_CANCELLATION_UPGRADE_CANCELED_BY_REMOTE" + "CLIENT_CANCELLATION_WEB_RTC_SERVER_SOCKET_CREATION" + "CLIENT_CANCELLATION_WIFI_AWARE_SERVER_SOCKET_CREATION" + "CLIENT_CANCELLATION_WIFI_DIRECT_SERVER_SOCKET_CREATION" + "CLIENT_CANCELLATION_WIFI_HOTSPOT_SERVER_SOCKET_CREATION" + "CLIENT_CANCELLATION_WIFI_LAN_SERVER_SOCKET_CREATION" + "CLIENT_DUPLICATE_ACCEPTING_BLE_CONNECTION_REQUEST" + "CLIENT_DUPLICATE_ACCEPTING_BT_CONNECTION_REQUEST" + "CLIENT_DUPLICATE_ACCEPTING_L2CAP_CONNECTION_REQUEST" + "CLIENT_DUPLICATE_ACCEPTING_LAN_CONNECTION_REQUEST" + "CLIENT_DUPLICATE_ACCEPTING_NFC_CONNECTION_REQUEST" + "CLIENT_DUPLICATE_ACCEPTING_USB_CONNECTION_REQUEST" + "CLIENT_DUPLICATE_ACCEPTING_WEB_RTC_CONNECTION_REQUEST" + "CLIENT_DUPLICATE_ACCEPTING_WIFI_AWARE_CONNECTION_REQUEST" + "CLIENT_DUPLICATE_ACCEPTING_WIFI_DIRECT_CONNECTION_REQUEST" + "CLIENT_DUPLICATE_ACCEPTING_WIFI_HOTSPOT_CONNECTION_REQUEST" + "CLIENT_DUPLICATE_WIFI_AWARE_CONNECTION_REQUEST" + "CLIENT_DUPLICATE_WIFI_AWARE_SUBSCRIBING_REQUEST" + "CLIENT_DUPLICATE_WIFI_DIRECT_CONNECTION_REQUEST" + "CLIENT_DUPLICATE_WIFI_HOTSPOT_CONNECTION_REQUEST" + "CLIENT_UNSUPPORTED_USB_TO_BE_UPGRADE_MEDIUM" + "CLIENT_WIFI_DIRECT_ALREADY_HOSTING_DIRECT_GROUP_FOR_THIS_CLIENT" + "CLIENT_WIFI_HOTSPOT_ALREADY_HOSTING_HOTSPOT_FOR_THIS_CLIENT" + "CONNECTIVITY_BLE_CLIENT_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_BLE_CREATE_GATT_CONNECTION_FAILURE" + "CONNECTIVITY_BLE_SERVER_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_BLUETOOTH_DEVICE_OBTAIN_FAILURE" + "CONNECTIVITY_BLUETOOTH_INVALID_CREDENTIAL" + "CONNECTIVITY_BT_CLIENT_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_BT_SERVER_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_BT_SERVER_SOCKET_CREATION_SECURITY_EXCEPTION_FAILURE" + "CONNECTIVITY_GATT_SERVER_OPEN_FAILURE" + "CONNECTIVITY_GENERIC_PAYLOAD_SENT_ERROR" + "CONNECTIVITY_GENERIC_WRITE_CLIENT_INTRODUCTION_ACK_IO_ERROR" + "CONNECTIVITY_GENERIC_WRITING_CHANNEL_IO_ERROR" + "CONNECTIVITY_L2CAP_CLIENT_OBTAIN_FAIURE" + "CONNECTIVITY_L2CAP_CLIENT_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_L2CAP_DATA_CONNECTION_FAILURE" + "CONNECTIVITY_L2CAP_SERVER_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_L2CAP_SERVER_SOCKET_CREATION_SECURITY_EXCEPTION_FAILURE" + "CONNECTIVITY_LAN_CLIENT_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_LAN_GET_NETWORK_INTERFACES_FAILURE" + "CONNECTIVITY_LAN_SERVER_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_LAN_UNREACHABLE" + "CONNECTIVITY_NFC_CLIENT_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_NFC_SERVER_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_USB_CLIENT_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_WEB_RTC_CLIENT_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_WEB_RTC_CONNECT_TO_TACHYON_FAILURE" + "CONNECTIVITY_WEB_RTC_INVALID_CREDENTIAL" + "CONNECTIVITY_WEB_RTC_SERVER_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_WIFI_AWARE_ATTACH_FAILURE" + "CONNECTIVITY_WIFI_AWARE_CLIENT_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_WIFI_AWARE_DISCOVERED_PEER_NULL" + "CONNECTIVITY_WIFI_AWARE_GET_REMOTE_IP_ADDRESS_FAILURE" + "CONNECTIVITY_WIFI_AWARE_GET_REMOTE_IP_FRAME_FAILURE" + "CONNECTIVITY_WIFI_AWARE_INVALID_CREDENTIAL" + "CONNECTIVITY_WIFI_AWARE_L2MESSAGE_NETWORK_AVAILABLE_FRAME_NULL" + "CONNECTIVITY_WIFI_AWARE_L2MESSAGE_SEND_HOST_NETWORK_FRAME_FAILURE" + "CONNECTIVITY_WIFI_AWARE_SERVER_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_WIFI_AWARE_UPDATE_PUBLISH_FAILURE" + "CONNECTIVITY_WIFI_DIRECT_CLIENT_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_WIFI_DIRECT_GET_NETWORK_INTERFACES_FAILURE" + "CONNECTIVITY_WIFI_DIRECT_INCONSISTENT_HOSTED_WIFI_BAND" + "CONNECTIVITY_WIFI_DIRECT_INVALID_CREDENTIAL" + "CONNECTIVITY_WIFI_DIRECT_P2P_CHANNEL_INITIALIZE_FAILURE" + "CONNECTIVITY_WIFI_DIRECT_P2P_GROUP_CREATION_FAILURE" + "CONNECTIVITY_WIFI_DIRECT_SERVER_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_WIFI_HOTSPOT_CLIENT_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_WIFI_HOTSPOT_GET_NETWORK_INTERFACES_FAILURE" + "CONNECTIVITY_WIFI_HOTSPOT_INCONSISTENT_HOSTED_WIFI_BAND" + "CONNECTIVITY_WIFI_HOTSPOT_INVALID_CREDENTIAL" + "CONNECTIVITY_WIFI_HOTSPOT_LOHS_CREATION_FAILURE" + "CONNECTIVITY_WIFI_HOTSPOT_P2P_CHANNEL_INITIALIZE_FAILURE" + "CONNECTIVITY_WIFI_HOTSPOT_P2P_GROUP_CREATION_FAILURE" + "CONNECTIVITY_WIFI_HOTSPOT_SERVER_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_WIFI_HOTSPOT_SOFT_AP_CREATION_FAILURE" + "CONNECTIVITY_WIFI_LAN_INVALID_CREDENTIAL" + "CONNECTIVITY_WIFI_LAN_IP_ADDRESS_ERROR" + "DETAIL_SUCCESS" + "DETAIL_UNKNOWN" + "DEVICE_STATE_ERROR_UNFINISHED_UPGRADE_ATTEMPTS" + "DEVICE_STATE_ERROR_USER_HOTSPOT_ENABLED" + "DEVICE_STATE_LOCATION_DISABLED" + "DEVICE_STATE_RADIO_DISABLING_FAILURE" + "DEVICE_STATE_RADIO_ENABLING_FAILURE" + "IO_ENDPOINT_IO_ERROR_ON_BLE" + "IO_ENDPOINT_IO_ERROR_ON_BT" + "IO_ENDPOINT_IO_ERROR_ON_L2CAP" + "IO_ENDPOINT_IO_ERROR_ON_LAN" + "IO_ENDPOINT_IO_ERROR_ON_NFC" + "IO_ENDPOINT_IO_ERROR_ON_USB" + "IO_ENDPOINT_IO_ERROR_ON_WEB_RTC" + "IO_ENDPOINT_IO_ERROR_ON_WIFI_AWARE" + "IO_ENDPOINT_IO_ERROR_ON_WIFI_DIRECT" + "IO_ENDPOINT_IO_ERROR_ON_WIFI_HOTSPOT" + "IO_FILE_OPENING_ERROR" + "IO_FILE_READING_ERROR" + "IO_FILE_WRITING_ERROR" + "IO_FOLDER_CREATION_ERROR" + "IO_STREAM_CREATE_PIPE_FAILURE" + "MEDIUM_UNAVAILABLE_ALREADY_HAVE_A_WIFI_DIRECT_GROUP" + "MEDIUM_UNAVAILABLE_ALREADY_HOSTING_HOTSPOT_FOR_OTHER_CLIENTS" + "MEDIUM_UNAVAILABLE_BLE_NC_LOGICAL_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_BLE_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_BLUETOOTH_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_BT_NC_LOGICAL_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_DIRECT_HOTSPOT_NOT_SUPPORT" + "MEDIUM_UNAVAILABLE_L2CAP_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_LAN_NC_LOGICAL_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_LAN_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_LOCAL_ONLY_HOTSPOT_DISRUPTIVE_FALSE" + "MEDIUM_UNAVAILABLE_LOCAL_ONLY_HOTSPOT_NOT_SUPPORT" + "MEDIUM_UNAVAILABLE_LOCAL_ONLY_HOTSPOT_NOT_SUPPORT_5G" + "MEDIUM_UNAVAILABLE_NFC_NC_LOGICAL_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_NFC_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_REJECT_L2CAP_ON_GATT_MULTIPLEX_CONNECTION" + "MEDIUM_UNAVAILABLE_SOFT_AP_DISRUPTIVE_FALSE" + "MEDIUM_UNAVAILABLE_SOFT_AP_NOT_SUPPORT" + "MEDIUM_UNAVAILABLE_UPGRADE_ON_SAME_MEDIUM" + "MEDIUM_UNAVAILABLE_UPGRADE_SKIP_BLE_LOW_QUALITY_MEDIUMS" + "MEDIUM_UNAVAILABLE_UPGRADE_SKIP_BT_LOW_QUALITY_MEDIUMS" + "MEDIUM_UNAVAILABLE_UPGRADE_SKIP_L2CAP_LOW_QUALITY_MEDIUMS" + "MEDIUM_UNAVAILABLE_UPGRADE_SKIP_LAN_LOW_QUALITY_MEDIUMS" + "MEDIUM_UNAVAILABLE_UPGRADE_SKIP_USB_LOW_QUALITY_MEDIUMS" + "MEDIUM_UNAVAILABLE_UPGRADE_SKIP_WEB_RTC_LOW_QUALITY_MEDIUMS" + "MEDIUM_UNAVAILABLE_USB_NC_LOGICAL_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_USB_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_WEB_RTC_NC_LOGICAL_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_WEB_RTC_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_WEB_RTC_NO_INTERNET" + "MEDIUM_UNAVAILABLE_WIFI_AWARE_NC_LOGICAL_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_WIFI_AWARE_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_WIFI_AWARE_RESOURCE_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_WIFI_DIRECT_NC_LOGICAL_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_WIFI_DIRECT_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_WIFI_DIRECT_P2P_RESOURCE_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_WIFI_HOTSPOT_NC_LOGICAL_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_WIFI_HOTSPOT_NOT_AVAILABLE" + "MEDIUM_UNAVAILABLE_WIFI_HOTSPOT_P2P_RESOURCE_NOT_AVAILABLE" + "MISCELLEANEOUS_BLE_SYSTEM_SERVICE_NULL" + "MISCELLEANEOUS_BLUETOOTH_MAC_ADDRESS_NULL" + "MISCELLEANEOUS_BT_NOT_ACCEPTING_CONNECTION_FOR_WORK_PROFILE" + "MISCELLEANEOUS_BT_SYSTEM_SERVICE_NULL" + "MISCELLEANEOUS_L2CAP_SYSTEM_SERVICE_NULL" + "MISCELLEANEOUS_MOVE_TO_NEW_MEDIUM" + "MISCELLEANEOUS_WEB_RTC_GET_DROIDGUARD_RESULT_FAILURE" + "MISCELLEANEOUS_WEB_RTC_TACHYON_SIGNALING_MESSENGER_NULL" + "MISCELLEANEOUS_WIFI_AWARE_SYSTEM_SERVICE_NULL" + "MISCELLEANEOUS_WIFI_DIRECT_SYSTEM_SERVICE_NULL" + "MISCELLEANEOUS_WIFI_HOTSPOT_SOFT_AP_BLOCKED_BY_PROVISION" + "MISCELLEANEOUS_WIFI_HOTSPOT_SYSTEM_SERVICE_NULL" + "MISCELLEANEOUS_WIFI_LAN_SYSTEM_SERVICE_NULL" + "NEARBY_BLE_ADVERTISEMENT_MAPPING_TO_MAC_ERROR" + "NEARBY_BLE_ENDPOINT_CHANNEL_CREATION_FAILURE" + "NEARBY_BLE_GATT_ADVERTISEMENT_NULL_FOR_CONNECTION" + "NEARBY_BLE_GATT_NULL_CALLBACK" + "NEARBY_BLE_OPERATION_REGISTERED_FAILED" + "NEARBY_BLUETOOTH_MAC_ADDRESS_INVALID_FOR_CONNECT" + "NEARBY_BT_ENDPOINT_CHANNEL_CREATION_FAILURE" + "NEARBY_BT_MULTIPLEX_SOCKET_DISABLED" + "NEARBY_BT_NULL_CALLBACK" + "NEARBY_BT_OPERATION_REGISTERED_FAILED" + "NEARBY_BT_VIRTUAL_SOCKET_CREATION_FAILURE" + "NEARBY_GENERIC_CONNECTION_CLOSED" + "NEARBY_GENERIC_ENDPOINT_UNENCRYPTED" + "NEARBY_GENERIC_INCOMING_PAYLOAD_NOT_DATA_TYPE" + "NEARBY_GENERIC_NEW_ENDPOINT_CHANNEL_NULL" + "NEARBY_GENERIC_OLD_ENDPOINT_CHANNEL_NULL" + "NEARBY_GENERIC_OUTGOING_PAYLOAD_CREATION_FAILURE" + "NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_EVENT_TYPE_ERROR" + "NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_FORMAT_ERROR" + "NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_FRAME_TYPE_ERROR" + "NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_EVENT_TYPE_ERROR" + "NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_FORMAT_ERROR" + "NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_FRAME_TYPE_ERROR" + "NEARBY_GENERIC_REMOTE_ENDPOINT_STATUS_ERROR" + "NEARBY_GENERIC_REMOTE_REPORT_PAYLOADS_ERROR" + "NEARBY_GENERIC_REMOTE_UPGRADE_FAILURE" + "NEARBY_GENERIC_SEND_PAYLOAD_EXECUTOR_NULL" + "NEARBY_L2CAP_ENDPOINT_CHANNEL_CREATION_FAILURE" + "NEARBY_L2CAP_NULL_CALLBACK" + "NEARBY_L2CAP_OPERATION_REGISTERED_FAILED" + "NEARBY_L2CAP_PSM_NOT_POSITIVE" + "NEARBY_LAN_ENDPOINT_CHANNEL_CREATION_FAILURE" + "NEARBY_LAN_MULTIPLEX_SOCKET_DISABLED" + "NEARBY_LAN_NULL_CALLBACK" + "NEARBY_LAN_OPERATION_REGISTERED_FAILED" + "NEARBY_LAN_VIRTUAL_SOCKET_CREATION_FAILURE" + "NEARBY_NFC_ENDPOINT_CHANNEL_CREATION_FAILURE" + "NEARBY_NFC_NULL_CALLBACK" + "NEARBY_USB_ENDPOINT_CHANNEL_CREATION_FAILURE" + "NEARBY_USB_NULL_CALLBACK" + "NEARBY_WEB_RTC_CONNECTION_FLOW_NULL" + "NEARBY_WEB_RTC_ENDPOINT_CHANNEL_CREATION_FAILURE" + "NEARBY_WEB_RTC_NULL_CALLBACK" + "NEARBY_WEB_RTC_OPERATION_REGISTERED_FAILED" + "NEARBY_WIFI_AWARE_ENDPOINT_CHANNEL_CREATION_FAILURE" + "NEARBY_WIFI_AWARE_NULL_CALLBACK" + "NEARBY_WIFI_AWARE_OPERATION_REGISTERED_FAILED" + "NEARBY_WIFI_DIRECT_ENDPOINT_CHANNEL_CREATION_FAILURE" + "NEARBY_WIFI_DIRECT_HOST_ON_SRD_CHANNELS" + "NEARBY_WIFI_DIRECT_NO_GROUP_FOR_LISTENING" + "NEARBY_WIFI_DIRECT_NULL_CALLBACK" + "NEARBY_WIFI_DIRECT_NULL_PASSWORD" + "NEARBY_WIFI_DIRECT_NULL_SSID" + "NEARBY_WIFI_DIRECT_OPERATION_REGISTERED_FAILED" + "NEARBY_WIFI_DIRECT_P2P_NON_DBS_WANT_2G_BUT_AP_5G" + "NEARBY_WIFI_DIRECT_P2P_NON_DBS_WANT_5G_BUT_AP_2G" + "NEARBY_WIFI_HOTSPOT_CLIENT_OPERATION_REGISTERED_FAILED" + "NEARBY_WIFI_HOTSPOT_DIRECT_OPERATION_REGISTERED_FAILED" + "NEARBY_WIFI_HOTSPOT_ENDPOINT_CHANNEL_CREATION_FAILURE" + "NEARBY_WIFI_HOTSPOT_HOST_ON_SRD_CHANNELS" + "NEARBY_WIFI_HOTSPOT_LOHS_OPERATION_REGISTERED_FAILED" + "NEARBY_WIFI_HOTSPOT_NO_HOTSPOT_FOR_LISTENING" + "NEARBY_WIFI_HOTSPOT_NULL_CALLBACK" + "NEARBY_WIFI_HOTSPOT_P2P_NON_DBS_WANT_2G_BUT_AP_5G" + "NEARBY_WIFI_HOTSPOT_P2P_NON_DBS_WANT_5G_BUT_AP_2G" + "NEARBY_WIFI_HOTSPOT_SOFT_AP_OPERATION_REGISTERED_FAILED" + "NEARBY_WIFI_LAN_IP_ADDRESS_ERROR"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry OperationResultDetail_entries[] = { + { {OperationResultDetail_names + 0, 45}, 519 }, + { {OperationResultDetail_names + 45, 50}, 504 }, + { {OperationResultDetail_names + 95, 49}, 505 }, + { {OperationResultDetail_names + 144, 46}, 515 }, + { {OperationResultDetail_names + 190, 52}, 506 }, + { {OperationResultDetail_names + 242, 50}, 507 }, + { {OperationResultDetail_names + 292, 50}, 508 }, + { {OperationResultDetail_names + 342, 46}, 514 }, + { {OperationResultDetail_names + 388, 50}, 509 }, + { {OperationResultDetail_names + 438, 54}, 513 }, + { {OperationResultDetail_names + 492, 57}, 510 }, + { {OperationResultDetail_names + 549, 58}, 511 }, + { {OperationResultDetail_names + 607, 59}, 512 }, + { {OperationResultDetail_names + 666, 40}, 501 }, + { {OperationResultDetail_names + 706, 36}, 522 }, + { {OperationResultDetail_names + 742, 41}, 502 }, + { {OperationResultDetail_names + 783, 37}, 523 }, + { {OperationResultDetail_names + 820, 44}, 500 }, + { {OperationResultDetail_names + 864, 46}, 503 }, + { {OperationResultDetail_names + 910, 50}, 520 }, + { {OperationResultDetail_names + 960, 53}, 516 }, + { {OperationResultDetail_names + 1013, 54}, 517 }, + { {OperationResultDetail_names + 1067, 55}, 518 }, + { {OperationResultDetail_names + 1122, 51}, 521 }, + { {OperationResultDetail_names + 1173, 49}, 2002 }, + { {OperationResultDetail_names + 1222, 48}, 2004 }, + { {OperationResultDetail_names + 1270, 51}, 2003 }, + { {OperationResultDetail_names + 1321, 49}, 2005 }, + { {OperationResultDetail_names + 1370, 49}, 2006 }, + { {OperationResultDetail_names + 1419, 49}, 2011 }, + { {OperationResultDetail_names + 1468, 53}, 2007 }, + { {OperationResultDetail_names + 1521, 56}, 2008 }, + { {OperationResultDetail_names + 1577, 57}, 2010 }, + { {OperationResultDetail_names + 1634, 58}, 2009 }, + { {OperationResultDetail_names + 1692, 46}, 2012 }, + { {OperationResultDetail_names + 1738, 47}, 2015 }, + { {OperationResultDetail_names + 1785, 47}, 2013 }, + { {OperationResultDetail_names + 1832, 48}, 2014 }, + { {OperationResultDetail_names + 1880, 43}, 2016 }, + { {OperationResultDetail_names + 1923, 63}, 2000 }, + { {OperationResultDetail_names + 1986, 59}, 2001 }, + { {OperationResultDetail_names + 2045, 47}, 3502 }, + { {OperationResultDetail_names + 2092, 47}, 3513 }, + { {OperationResultDetail_names + 2139, 47}, 3539 }, + { {OperationResultDetail_names + 2186, 44}, 3501 }, + { {OperationResultDetail_names + 2230, 41}, 3518 }, + { {OperationResultDetail_names + 2271, 46}, 3504 }, + { {OperationResultDetail_names + 2317, 46}, 3541 }, + { {OperationResultDetail_names + 2363, 65}, 3555 }, + { {OperationResultDetail_names + 2428, 37}, 3538 }, + { {OperationResultDetail_names + 2465, 39}, 3553 }, + { {OperationResultDetail_names + 2504, 59}, 3551 }, + { {OperationResultDetail_names + 2563, 45}, 3550 }, + { {OperationResultDetail_names + 2608, 39}, 3525 }, + { {OperationResultDetail_names + 2647, 49}, 3503 }, + { {OperationResultDetail_names + 2696, 42}, 3526 }, + { {OperationResultDetail_names + 2738, 49}, 3540 }, + { {OperationResultDetail_names + 2787, 68}, 3554 }, + { {OperationResultDetail_names + 2855, 47}, 3505 }, + { {OperationResultDetail_names + 2902, 47}, 3531 }, + { {OperationResultDetail_names + 2949, 47}, 3542 }, + { {OperationResultDetail_names + 2996, 28}, 3529 }, + { {OperationResultDetail_names + 3024, 47}, 3506 }, + { {OperationResultDetail_names + 3071, 47}, 3547 }, + { {OperationResultDetail_names + 3118, 47}, 3511 }, + { {OperationResultDetail_names + 3165, 51}, 3507 }, + { {OperationResultDetail_names + 3216, 47}, 3512 }, + { {OperationResultDetail_names + 3263, 39}, 3523 }, + { {OperationResultDetail_names + 3302, 51}, 3543 }, + { {OperationResultDetail_names + 3353, 38}, 3500 }, + { {OperationResultDetail_names + 3391, 54}, 3508 }, + { {OperationResultDetail_names + 3445, 44}, 3552 }, + { {OperationResultDetail_names + 3489, 53}, 3515 }, + { {OperationResultDetail_names + 3542, 51}, 3514 }, + { {OperationResultDetail_names + 3593, 42}, 3522 }, + { {OperationResultDetail_names + 3635, 62}, 3527 }, + { {OperationResultDetail_names + 3697, 65}, 3528 }, + { {OperationResultDetail_names + 3762, 54}, 3544 }, + { {OperationResultDetail_names + 3816, 46}, 3549 }, + { {OperationResultDetail_names + 3862, 55}, 3510 }, + { {OperationResultDetail_names + 3917, 55}, 3532 }, + { {OperationResultDetail_names + 3972, 54}, 3516 }, + { {OperationResultDetail_names + 4026, 43}, 3520 }, + { {OperationResultDetail_names + 4069, 55}, 3535 }, + { {OperationResultDetail_names + 4124, 51}, 3537 }, + { {OperationResultDetail_names + 4175, 55}, 3546 }, + { {OperationResultDetail_names + 4230, 56}, 3509 }, + { {OperationResultDetail_names + 4286, 56}, 3533 }, + { {OperationResultDetail_names + 4342, 55}, 3517 }, + { {OperationResultDetail_names + 4397, 44}, 3521 }, + { {OperationResultDetail_names + 4441, 47}, 3530 }, + { {OperationResultDetail_names + 4488, 56}, 3534 }, + { {OperationResultDetail_names + 4544, 52}, 3536 }, + { {OperationResultDetail_names + 4596, 56}, 3545 }, + { {OperationResultDetail_names + 4652, 50}, 3548 }, + { {OperationResultDetail_names + 4702, 40}, 3519 }, + { {OperationResultDetail_names + 4742, 38}, 3524 }, + { {OperationResultDetail_names + 4780, 14}, 1 }, + { {OperationResultDetail_names + 4794, 14}, 0 }, + { {OperationResultDetail_names + 4808, 46}, 1000 }, + { {OperationResultDetail_names + 4854, 39}, 1001 }, + { {OperationResultDetail_names + 4893, 30}, 1002 }, + { {OperationResultDetail_names + 4923, 36}, 1003 }, + { {OperationResultDetail_names + 4959, 35}, 1004 }, + { {OperationResultDetail_names + 4994, 27}, 3005 }, + { {OperationResultDetail_names + 5021, 26}, 3007 }, + { {OperationResultDetail_names + 5047, 29}, 3006 }, + { {OperationResultDetail_names + 5076, 27}, 3009 }, + { {OperationResultDetail_names + 5103, 27}, 3013 }, + { {OperationResultDetail_names + 5130, 27}, 3014 }, + { {OperationResultDetail_names + 5157, 31}, 3008 }, + { {OperationResultDetail_names + 5188, 34}, 3012 }, + { {OperationResultDetail_names + 5222, 35}, 3010 }, + { {OperationResultDetail_names + 5257, 36}, 3011 }, + { {OperationResultDetail_names + 5293, 21}, 3000 }, + { {OperationResultDetail_names + 5314, 21}, 3001 }, + { {OperationResultDetail_names + 5335, 21}, 3002 }, + { {OperationResultDetail_names + 5356, 24}, 3003 }, + { {OperationResultDetail_names + 5380, 29}, 3004 }, + { {OperationResultDetail_names + 5409, 51}, 1534 }, + { {OperationResultDetail_names + 5460, 60}, 1535 }, + { {OperationResultDetail_names + 5520, 47}, 1515 }, + { {OperationResultDetail_names + 5567, 36}, 1505 }, + { {OperationResultDetail_names + 5603, 42}, 1507 }, + { {OperationResultDetail_names + 5645, 46}, 1516 }, + { {OperationResultDetail_names + 5691, 45}, 1501 }, + { {OperationResultDetail_names + 5736, 38}, 1506 }, + { {OperationResultDetail_names + 5774, 47}, 1517 }, + { {OperationResultDetail_names + 5821, 36}, 1513 }, + { {OperationResultDetail_names + 5857, 54}, 1532 }, + { {OperationResultDetail_names + 5911, 49}, 1503 }, + { {OperationResultDetail_names + 5960, 52}, 1504 }, + { {OperationResultDetail_names + 6012, 47}, 1518 }, + { {OperationResultDetail_names + 6059, 36}, 1512 }, + { {OperationResultDetail_names + 6095, 60}, 1536 }, + { {OperationResultDetail_names + 6155, 43}, 1533 }, + { {OperationResultDetail_names + 6198, 38}, 1502 }, + { {OperationResultDetail_names + 6236, 41}, 1537 }, + { {OperationResultDetail_names + 6277, 55}, 1526 }, + { {OperationResultDetail_names + 6332, 54}, 1530 }, + { {OperationResultDetail_names + 6386, 57}, 1527 }, + { {OperationResultDetail_names + 6443, 55}, 1529 }, + { {OperationResultDetail_names + 6498, 55}, 1531 }, + { {OperationResultDetail_names + 6553, 59}, 1528 }, + { {OperationResultDetail_names + 6612, 47}, 1519 }, + { {OperationResultDetail_names + 6659, 36}, 1514 }, + { {OperationResultDetail_names + 6695, 51}, 1520 }, + { {OperationResultDetail_names + 6746, 40}, 1508 }, + { {OperationResultDetail_names + 6786, 38}, 1538 }, + { {OperationResultDetail_names + 6824, 54}, 1521 }, + { {OperationResultDetail_names + 6878, 43}, 1509 }, + { {OperationResultDetail_names + 6921, 52}, 1500 }, + { {OperationResultDetail_names + 6973, 55}, 1523 }, + { {OperationResultDetail_names + 7028, 44}, 1511 }, + { {OperationResultDetail_names + 7072, 57}, 1525 }, + { {OperationResultDetail_names + 7129, 56}, 1522 }, + { {OperationResultDetail_names + 7185, 45}, 1510 }, + { {OperationResultDetail_names + 7230, 58}, 1524 }, + { {OperationResultDetail_names + 7288, 38}, 2503 }, + { {OperationResultDetail_names + 7326, 41}, 2500 }, + { {OperationResultDetail_names + 7367, 59}, 2510 }, + { {OperationResultDetail_names + 7426, 37}, 2505 }, + { {OperationResultDetail_names + 7463, 40}, 2504 }, + { {OperationResultDetail_names + 7503, 33}, 2501 }, + { {OperationResultDetail_names + 7536, 52}, 2511 }, + { {OperationResultDetail_names + 7588, 55}, 2512 }, + { {OperationResultDetail_names + 7643, 45}, 2506 }, + { {OperationResultDetail_names + 7688, 46}, 2507 }, + { {OperationResultDetail_names + 7734, 56}, 2502 }, + { {OperationResultDetail_names + 7790, 47}, 2509 }, + { {OperationResultDetail_names + 7837, 43}, 2508 }, + { {OperationResultDetail_names + 7880, 45}, 4500 }, + { {OperationResultDetail_names + 7925, 44}, 4504 }, + { {OperationResultDetail_names + 7969, 49}, 4515 }, + { {OperationResultDetail_names + 8018, 29}, 4518 }, + { {OperationResultDetail_names + 8047, 38}, 4536 }, + { {OperationResultDetail_names + 8085, 48}, 4501 }, + { {OperationResultDetail_names + 8133, 43}, 4506 }, + { {OperationResultDetail_names + 8176, 35}, 4530 }, + { {OperationResultDetail_names + 8211, 23}, 4520 }, + { {OperationResultDetail_names + 8234, 37}, 4538 }, + { {OperationResultDetail_names + 8271, 41}, 4563 }, + { {OperationResultDetail_names + 8312, 32}, 4503 }, + { {OperationResultDetail_names + 8344, 35}, 4514 }, + { {OperationResultDetail_names + 8379, 45}, 4552 }, + { {OperationResultDetail_names + 8424, 40}, 4532 }, + { {OperationResultDetail_names + 8464, 40}, 4535 }, + { {OperationResultDetail_names + 8504, 48}, 4547 }, + { {OperationResultDetail_names + 8552, 60}, 4556 }, + { {OperationResultDetail_names + 8612, 56}, 4558 }, + { {OperationResultDetail_names + 8668, 60}, 4557 }, + { {OperationResultDetail_names + 8728, 56}, 4553 }, + { {OperationResultDetail_names + 8784, 52}, 4555 }, + { {OperationResultDetail_names + 8836, 56}, 4554 }, + { {OperationResultDetail_names + 8892, 43}, 4559 }, + { {OperationResultDetail_names + 8935, 43}, 4560 }, + { {OperationResultDetail_names + 8978, 37}, 4561 }, + { {OperationResultDetail_names + 9015, 41}, 4562 }, + { {OperationResultDetail_names + 9056, 46}, 4505 }, + { {OperationResultDetail_names + 9102, 26}, 4519 }, + { {OperationResultDetail_names + 9128, 40}, 4537 }, + { {OperationResultDetail_names + 9168, 29}, 4566 }, + { {OperationResultDetail_names + 9197, 44}, 4507 }, + { {OperationResultDetail_names + 9241, 36}, 4531 }, + { {OperationResultDetail_names + 9277, 24}, 4525 }, + { {OperationResultDetail_names + 9301, 38}, 4539 }, + { {OperationResultDetail_names + 9339, 42}, 4564 }, + { {OperationResultDetail_names + 9381, 44}, 4508 }, + { {OperationResultDetail_names + 9425, 24}, 4522 }, + { {OperationResultDetail_names + 9449, 44}, 4513 }, + { {OperationResultDetail_names + 9493, 24}, 4521 }, + { {OperationResultDetail_names + 9517, 35}, 4502 }, + { {OperationResultDetail_names + 9552, 48}, 4512 }, + { {OperationResultDetail_names + 9600, 28}, 4524 }, + { {OperationResultDetail_names + 9628, 42}, 4540 }, + { {OperationResultDetail_names + 9670, 51}, 4509 }, + { {OperationResultDetail_names + 9721, 31}, 4523 }, + { {OperationResultDetail_names + 9752, 45}, 4541 }, + { {OperationResultDetail_names + 9797, 52}, 4511 }, + { {OperationResultDetail_names + 9849, 39}, 4516 }, + { {OperationResultDetail_names + 9888, 41}, 4533 }, + { {OperationResultDetail_names + 9929, 32}, 4527 }, + { {OperationResultDetail_names + 9961, 32}, 4529 }, + { {OperationResultDetail_names + 9993, 28}, 4528 }, + { {OperationResultDetail_names + 10021, 46}, 4546 }, + { {OperationResultDetail_names + 10067, 48}, 4549 }, + { {OperationResultDetail_names + 10115, 48}, 4551 }, + { {OperationResultDetail_names + 10163, 54}, 4545 }, + { {OperationResultDetail_names + 10217, 54}, 4542 }, + { {OperationResultDetail_names + 10271, 53}, 4510 }, + { {OperationResultDetail_names + 10324, 40}, 4517 }, + { {OperationResultDetail_names + 10364, 52}, 4544 }, + { {OperationResultDetail_names + 10416, 44}, 4534 }, + { {OperationResultDetail_names + 10460, 33}, 4526 }, + { {OperationResultDetail_names + 10493, 49}, 4548 }, + { {OperationResultDetail_names + 10542, 49}, 4550 }, + { {OperationResultDetail_names + 10591, 55}, 4543 }, + { {OperationResultDetail_names + 10646, 32}, 4565 }, +}; + +static const int OperationResultDetail_entries_by_number[] = { + 98, // 0 -> DETAIL_UNKNOWN + 97, // 1 -> DETAIL_SUCCESS + 17, // 500 -> CLIENT_CANCELLATION_REMOTE_IN_CANCELED_STATE + 13, // 501 -> CLIENT_CANCELLATION_LOCAL_CANCEL_PAYLOAD + 15, // 502 -> CLIENT_CANCELLATION_REMOTE_CANCEL_PAYLOAD + 18, // 503 -> CLIENT_CANCELLATION_UPGRADE_CANCELED_BY_REMOTE + 1, // 504 -> CLIENT_CANCELLATION_CANCEL_BLE_OUTGOING_CONNECTION + 2, // 505 -> CLIENT_CANCELLATION_CANCEL_BT_OUTGOING_CONNECTION + 4, // 506 -> CLIENT_CANCELLATION_CANCEL_L2CAP_OUTGOING_CONNECTION + 5, // 507 -> CLIENT_CANCELLATION_CANCEL_LAN_OUTGOING_CONNECTION + 6, // 508 -> CLIENT_CANCELLATION_CANCEL_NFC_OUTGOING_CONNECTION + 8, // 509 -> CLIENT_CANCELLATION_CANCEL_USB_OUTGOING_CONNECTION + 10, // 510 -> CLIENT_CANCELLATION_CANCEL_WIFI_AWARE_OUTGOING_CONNECTION + 11, // 511 -> CLIENT_CANCELLATION_CANCEL_WIFI_DIRECT_OUTGOING_CONNECTION + 12, // 512 -> CLIENT_CANCELLATION_CANCEL_WIFI_HOTSPOT_OUTGOING_CONNECTION + 9, // 513 -> CLIENT_CANCELLATION_CANCEL_WEB_RTC_OUTGOING_CONNECTION + 7, // 514 -> CLIENT_CANCELLATION_CANCEL_OUTGOING_CONNECTION + 3, // 515 -> CLIENT_CANCELLATION_CANCEL_INCOMING_CONNECTION + 20, // 516 -> CLIENT_CANCELLATION_WIFI_AWARE_SERVER_SOCKET_CREATION + 21, // 517 -> CLIENT_CANCELLATION_WIFI_DIRECT_SERVER_SOCKET_CREATION + 22, // 518 -> CLIENT_CANCELLATION_WIFI_HOTSPOT_SERVER_SOCKET_CREATION + 0, // 519 -> CLIENT_CANCELLATION_BT_SERVER_SOCKET_CREATION + 19, // 520 -> CLIENT_CANCELLATION_WEB_RTC_SERVER_SOCKET_CREATION + 23, // 521 -> CLIENT_CANCELLATION_WIFI_LAN_SERVER_SOCKET_CREATION + 14, // 522 -> CLIENT_CANCELLATION_LOCAL_DISCONNECT + 16, // 523 -> CLIENT_CANCELLATION_REMOTE_DISCONNECT + 99, // 1000 -> DEVICE_STATE_ERROR_UNFINISHED_UPGRADE_ATTEMPTS + 100, // 1001 -> DEVICE_STATE_ERROR_USER_HOTSPOT_ENABLED + 101, // 1002 -> DEVICE_STATE_LOCATION_DISABLED + 102, // 1003 -> DEVICE_STATE_RADIO_DISABLING_FAILURE + 103, // 1004 -> DEVICE_STATE_RADIO_ENABLING_FAILURE + 151, // 1500 -> MEDIUM_UNAVAILABLE_WIFI_AWARE_RESOURCE_NOT_AVAILABLE + 125, // 1501 -> MEDIUM_UNAVAILABLE_DIRECT_HOTSPOT_NOT_SUPPORT + 136, // 1502 -> MEDIUM_UNAVAILABLE_SOFT_AP_NOT_SUPPORT + 130, // 1503 -> MEDIUM_UNAVAILABLE_LOCAL_ONLY_HOTSPOT_NOT_SUPPORT + 131, // 1504 -> MEDIUM_UNAVAILABLE_LOCAL_ONLY_HOTSPOT_NOT_SUPPORT_5G + 122, // 1505 -> MEDIUM_UNAVAILABLE_BLE_NOT_AVAILABLE + 126, // 1506 -> MEDIUM_UNAVAILABLE_L2CAP_NOT_AVAILABLE + 123, // 1507 -> MEDIUM_UNAVAILABLE_BLUETOOTH_NOT_AVAILABLE + 147, // 1508 -> MEDIUM_UNAVAILABLE_WEB_RTC_NOT_AVAILABLE + 150, // 1509 -> MEDIUM_UNAVAILABLE_WIFI_AWARE_NOT_AVAILABLE + 156, // 1510 -> MEDIUM_UNAVAILABLE_WIFI_HOTSPOT_NOT_AVAILABLE + 153, // 1511 -> MEDIUM_UNAVAILABLE_WIFI_DIRECT_NOT_AVAILABLE + 133, // 1512 -> MEDIUM_UNAVAILABLE_NFC_NOT_AVAILABLE + 128, // 1513 -> MEDIUM_UNAVAILABLE_LAN_NOT_AVAILABLE + 145, // 1514 -> MEDIUM_UNAVAILABLE_USB_NOT_AVAILABLE + 121, // 1515 -> MEDIUM_UNAVAILABLE_BLE_NC_LOGICAL_NOT_AVAILABLE + 124, // 1516 -> MEDIUM_UNAVAILABLE_BT_NC_LOGICAL_NOT_AVAILABLE + 127, // 1517 -> MEDIUM_UNAVAILABLE_LAN_NC_LOGICAL_NOT_AVAILABLE + 132, // 1518 -> MEDIUM_UNAVAILABLE_NFC_NC_LOGICAL_NOT_AVAILABLE + 144, // 1519 -> MEDIUM_UNAVAILABLE_USB_NC_LOGICAL_NOT_AVAILABLE + 146, // 1520 -> MEDIUM_UNAVAILABLE_WEB_RTC_NC_LOGICAL_NOT_AVAILABLE + 149, // 1521 -> MEDIUM_UNAVAILABLE_WIFI_AWARE_NC_LOGICAL_NOT_AVAILABLE + 155, // 1522 -> MEDIUM_UNAVAILABLE_WIFI_HOTSPOT_NC_LOGICAL_NOT_AVAILABLE + 152, // 1523 -> MEDIUM_UNAVAILABLE_WIFI_DIRECT_NC_LOGICAL_NOT_AVAILABLE + 157, // 1524 -> MEDIUM_UNAVAILABLE_WIFI_HOTSPOT_P2P_RESOURCE_NOT_AVAILABLE + 154, // 1525 -> MEDIUM_UNAVAILABLE_WIFI_DIRECT_P2P_RESOURCE_NOT_AVAILABLE + 138, // 1526 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_BLE_LOW_QUALITY_MEDIUMS + 140, // 1527 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_L2CAP_LOW_QUALITY_MEDIUMS + 143, // 1528 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_WEB_RTC_LOW_QUALITY_MEDIUMS + 141, // 1529 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_LAN_LOW_QUALITY_MEDIUMS + 139, // 1530 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_BT_LOW_QUALITY_MEDIUMS + 142, // 1531 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_USB_LOW_QUALITY_MEDIUMS + 129, // 1532 -> MEDIUM_UNAVAILABLE_LOCAL_ONLY_HOTSPOT_DISRUPTIVE_FALSE + 135, // 1533 -> MEDIUM_UNAVAILABLE_SOFT_AP_DISRUPTIVE_FALSE + 119, // 1534 -> MEDIUM_UNAVAILABLE_ALREADY_HAVE_A_WIFI_DIRECT_GROUP + 120, // 1535 -> MEDIUM_UNAVAILABLE_ALREADY_HOSTING_HOTSPOT_FOR_OTHER_CLIENTS + 134, // 1536 -> MEDIUM_UNAVAILABLE_REJECT_L2CAP_ON_GATT_MULTIPLEX_CONNECTION + 137, // 1537 -> MEDIUM_UNAVAILABLE_UPGRADE_ON_SAME_MEDIUM + 148, // 1538 -> MEDIUM_UNAVAILABLE_WEB_RTC_NO_INTERNET + 39, // 2000 -> CLIENT_WIFI_DIRECT_ALREADY_HOSTING_DIRECT_GROUP_FOR_THIS_CLIENT + 40, // 2001 -> CLIENT_WIFI_HOTSPOT_ALREADY_HOSTING_HOTSPOT_FOR_THIS_CLIENT + 24, // 2002 -> CLIENT_DUPLICATE_ACCEPTING_BLE_CONNECTION_REQUEST + 26, // 2003 -> CLIENT_DUPLICATE_ACCEPTING_L2CAP_CONNECTION_REQUEST + 25, // 2004 -> CLIENT_DUPLICATE_ACCEPTING_BT_CONNECTION_REQUEST + 27, // 2005 -> CLIENT_DUPLICATE_ACCEPTING_LAN_CONNECTION_REQUEST + 28, // 2006 -> CLIENT_DUPLICATE_ACCEPTING_NFC_CONNECTION_REQUEST + 30, // 2007 -> CLIENT_DUPLICATE_ACCEPTING_WEB_RTC_CONNECTION_REQUEST + 31, // 2008 -> CLIENT_DUPLICATE_ACCEPTING_WIFI_AWARE_CONNECTION_REQUEST + 33, // 2009 -> CLIENT_DUPLICATE_ACCEPTING_WIFI_HOTSPOT_CONNECTION_REQUEST + 32, // 2010 -> CLIENT_DUPLICATE_ACCEPTING_WIFI_DIRECT_CONNECTION_REQUEST + 29, // 2011 -> CLIENT_DUPLICATE_ACCEPTING_USB_CONNECTION_REQUEST + 34, // 2012 -> CLIENT_DUPLICATE_WIFI_AWARE_CONNECTION_REQUEST + 36, // 2013 -> CLIENT_DUPLICATE_WIFI_DIRECT_CONNECTION_REQUEST + 37, // 2014 -> CLIENT_DUPLICATE_WIFI_HOTSPOT_CONNECTION_REQUEST + 35, // 2015 -> CLIENT_DUPLICATE_WIFI_AWARE_SUBSCRIBING_REQUEST + 38, // 2016 -> CLIENT_UNSUPPORTED_USB_TO_BE_UPGRADE_MEDIUM + 159, // 2500 -> MISCELLEANEOUS_BLUETOOTH_MAC_ADDRESS_NULL + 163, // 2501 -> MISCELLEANEOUS_MOVE_TO_NEW_MEDIUM + 168, // 2502 -> MISCELLEANEOUS_WIFI_HOTSPOT_SOFT_AP_BLOCKED_BY_PROVISION + 158, // 2503 -> MISCELLEANEOUS_BLE_SYSTEM_SERVICE_NULL + 162, // 2504 -> MISCELLEANEOUS_L2CAP_SYSTEM_SERVICE_NULL + 161, // 2505 -> MISCELLEANEOUS_BT_SYSTEM_SERVICE_NULL + 166, // 2506 -> MISCELLEANEOUS_WIFI_AWARE_SYSTEM_SERVICE_NULL + 167, // 2507 -> MISCELLEANEOUS_WIFI_DIRECT_SYSTEM_SERVICE_NULL + 170, // 2508 -> MISCELLEANEOUS_WIFI_LAN_SYSTEM_SERVICE_NULL + 169, // 2509 -> MISCELLEANEOUS_WIFI_HOTSPOT_SYSTEM_SERVICE_NULL + 160, // 2510 -> MISCELLEANEOUS_BT_NOT_ACCEPTING_CONNECTION_FOR_WORK_PROFILE + 164, // 2511 -> MISCELLEANEOUS_WEB_RTC_GET_DROIDGUARD_RESULT_FAILURE + 165, // 2512 -> MISCELLEANEOUS_WEB_RTC_TACHYON_SIGNALING_MESSENGER_NULL + 114, // 3000 -> IO_FILE_OPENING_ERROR + 115, // 3001 -> IO_FILE_READING_ERROR + 116, // 3002 -> IO_FILE_WRITING_ERROR + 117, // 3003 -> IO_FOLDER_CREATION_ERROR + 118, // 3004 -> IO_STREAM_CREATE_PIPE_FAILURE + 104, // 3005 -> IO_ENDPOINT_IO_ERROR_ON_BLE + 106, // 3006 -> IO_ENDPOINT_IO_ERROR_ON_L2CAP + 105, // 3007 -> IO_ENDPOINT_IO_ERROR_ON_BT + 110, // 3008 -> IO_ENDPOINT_IO_ERROR_ON_WEB_RTC + 107, // 3009 -> IO_ENDPOINT_IO_ERROR_ON_LAN + 112, // 3010 -> IO_ENDPOINT_IO_ERROR_ON_WIFI_DIRECT + 113, // 3011 -> IO_ENDPOINT_IO_ERROR_ON_WIFI_HOTSPOT + 111, // 3012 -> IO_ENDPOINT_IO_ERROR_ON_WIFI_AWARE + 108, // 3013 -> IO_ENDPOINT_IO_ERROR_ON_NFC + 109, // 3014 -> IO_ENDPOINT_IO_ERROR_ON_USB + 69, // 3500 -> CONNECTIVITY_WIFI_AWARE_ATTACH_FAILURE + 44, // 3501 -> CONNECTIVITY_BLUETOOTH_DEVICE_OBTAIN_FAILURE + 41, // 3502 -> CONNECTIVITY_BLE_CLIENT_SOCKET_CREATION_FAILURE + 54, // 3503 -> CONNECTIVITY_L2CAP_CLIENT_SOCKET_CREATION_FAILURE + 46, // 3504 -> CONNECTIVITY_BT_CLIENT_SOCKET_CREATION_FAILURE + 58, // 3505 -> CONNECTIVITY_LAN_CLIENT_SOCKET_CREATION_FAILURE + 62, // 3506 -> CONNECTIVITY_NFC_CLIENT_SOCKET_CREATION_FAILURE + 65, // 3507 -> CONNECTIVITY_WEB_RTC_CLIENT_SOCKET_CREATION_FAILURE + 70, // 3508 -> CONNECTIVITY_WIFI_AWARE_CLIENT_SOCKET_CREATION_FAILURE + 86, // 3509 -> CONNECTIVITY_WIFI_HOTSPOT_CLIENT_SOCKET_CREATION_FAILURE + 79, // 3510 -> CONNECTIVITY_WIFI_DIRECT_CLIENT_SOCKET_CREATION_FAILURE + 64, // 3511 -> CONNECTIVITY_USB_CLIENT_SOCKET_CREATION_FAILURE + 66, // 3512 -> CONNECTIVITY_WEB_RTC_CONNECT_TO_TACHYON_FAILURE + 42, // 3513 -> CONNECTIVITY_BLE_CREATE_GATT_CONNECTION_FAILURE + 73, // 3514 -> CONNECTIVITY_WIFI_AWARE_GET_REMOTE_IP_FRAME_FAILURE + 72, // 3515 -> CONNECTIVITY_WIFI_AWARE_GET_REMOTE_IP_ADDRESS_FAILURE + 81, // 3516 -> CONNECTIVITY_WIFI_DIRECT_INCONSISTENT_HOSTED_WIFI_BAND + 88, // 3517 -> CONNECTIVITY_WIFI_HOTSPOT_INCONSISTENT_HOSTED_WIFI_BAND + 45, // 3518 -> CONNECTIVITY_BLUETOOTH_INVALID_CREDENTIAL + 95, // 3519 -> CONNECTIVITY_WIFI_LAN_INVALID_CREDENTIAL + 82, // 3520 -> CONNECTIVITY_WIFI_DIRECT_INVALID_CREDENTIAL + 89, // 3521 -> CONNECTIVITY_WIFI_HOTSPOT_INVALID_CREDENTIAL + 74, // 3522 -> CONNECTIVITY_WIFI_AWARE_INVALID_CREDENTIAL + 67, // 3523 -> CONNECTIVITY_WEB_RTC_INVALID_CREDENTIAL + 96, // 3524 -> CONNECTIVITY_WIFI_LAN_IP_ADDRESS_ERROR + 53, // 3525 -> CONNECTIVITY_L2CAP_CLIENT_OBTAIN_FAIURE + 55, // 3526 -> CONNECTIVITY_L2CAP_DATA_CONNECTION_FAILURE + 75, // 3527 -> CONNECTIVITY_WIFI_AWARE_L2MESSAGE_NETWORK_AVAILABLE_FRAME_NULL + 76, // 3528 -> CONNECTIVITY_WIFI_AWARE_L2MESSAGE_SEND_HOST_NETWORK_FRAME_FAILURE + 61, // 3529 -> CONNECTIVITY_LAN_UNREACHABLE + 90, // 3530 -> CONNECTIVITY_WIFI_HOTSPOT_LOHS_CREATION_FAILURE + 59, // 3531 -> CONNECTIVITY_LAN_GET_NETWORK_INTERFACES_FAILURE + 80, // 3532 -> CONNECTIVITY_WIFI_DIRECT_GET_NETWORK_INTERFACES_FAILURE + 87, // 3533 -> CONNECTIVITY_WIFI_HOTSPOT_GET_NETWORK_INTERFACES_FAILURE + 91, // 3534 -> CONNECTIVITY_WIFI_HOTSPOT_P2P_CHANNEL_INITIALIZE_FAILURE + 83, // 3535 -> CONNECTIVITY_WIFI_DIRECT_P2P_CHANNEL_INITIALIZE_FAILURE + 92, // 3536 -> CONNECTIVITY_WIFI_HOTSPOT_P2P_GROUP_CREATION_FAILURE + 84, // 3537 -> CONNECTIVITY_WIFI_DIRECT_P2P_GROUP_CREATION_FAILURE + 49, // 3538 -> CONNECTIVITY_GATT_SERVER_OPEN_FAILURE + 43, // 3539 -> CONNECTIVITY_BLE_SERVER_SOCKET_CREATION_FAILURE + 56, // 3540 -> CONNECTIVITY_L2CAP_SERVER_SOCKET_CREATION_FAILURE + 47, // 3541 -> CONNECTIVITY_BT_SERVER_SOCKET_CREATION_FAILURE + 60, // 3542 -> CONNECTIVITY_LAN_SERVER_SOCKET_CREATION_FAILURE + 68, // 3543 -> CONNECTIVITY_WEB_RTC_SERVER_SOCKET_CREATION_FAILURE + 77, // 3544 -> CONNECTIVITY_WIFI_AWARE_SERVER_SOCKET_CREATION_FAILURE + 93, // 3545 -> CONNECTIVITY_WIFI_HOTSPOT_SERVER_SOCKET_CREATION_FAILURE + 85, // 3546 -> CONNECTIVITY_WIFI_DIRECT_SERVER_SOCKET_CREATION_FAILURE + 63, // 3547 -> CONNECTIVITY_NFC_SERVER_SOCKET_CREATION_FAILURE + 94, // 3548 -> CONNECTIVITY_WIFI_HOTSPOT_SOFT_AP_CREATION_FAILURE + 78, // 3549 -> CONNECTIVITY_WIFI_AWARE_UPDATE_PUBLISH_FAILURE + 52, // 3550 -> CONNECTIVITY_GENERIC_WRITING_CHANNEL_IO_ERROR + 51, // 3551 -> CONNECTIVITY_GENERIC_WRITE_CLIENT_INTRODUCTION_ACK_IO_ERROR + 71, // 3552 -> CONNECTIVITY_WIFI_AWARE_DISCOVERED_PEER_NULL + 50, // 3553 -> CONNECTIVITY_GENERIC_PAYLOAD_SENT_ERROR + 57, // 3554 -> CONNECTIVITY_L2CAP_SERVER_SOCKET_CREATION_SECURITY_EXCEPTION_FAILURE + 48, // 3555 -> CONNECTIVITY_BT_SERVER_SOCKET_CREATION_SECURITY_EXCEPTION_FAILURE + 171, // 4500 -> NEARBY_BLE_ADVERTISEMENT_MAPPING_TO_MAC_ERROR + 176, // 4501 -> NEARBY_BLUETOOTH_MAC_ADDRESS_INVALID_FOR_CONNECT + 211, // 4502 -> NEARBY_WEB_RTC_CONNECTION_FLOW_NULL + 182, // 4503 -> NEARBY_GENERIC_CONNECTION_CLOSED + 172, // 4504 -> NEARBY_BLE_ENDPOINT_CHANNEL_CREATION_FAILURE + 198, // 4505 -> NEARBY_L2CAP_ENDPOINT_CHANNEL_CREATION_FAILURE + 177, // 4506 -> NEARBY_BT_ENDPOINT_CHANNEL_CREATION_FAILURE + 202, // 4507 -> NEARBY_LAN_ENDPOINT_CHANNEL_CREATION_FAILURE + 207, // 4508 -> NEARBY_NFC_ENDPOINT_CHANNEL_CREATION_FAILURE + 215, // 4509 -> NEARBY_WIFI_AWARE_ENDPOINT_CHANNEL_CREATION_FAILURE + 229, // 4510 -> NEARBY_WIFI_HOTSPOT_ENDPOINT_CHANNEL_CREATION_FAILURE + 218, // 4511 -> NEARBY_WIFI_DIRECT_ENDPOINT_CHANNEL_CREATION_FAILURE + 212, // 4512 -> NEARBY_WEB_RTC_ENDPOINT_CHANNEL_CREATION_FAILURE + 209, // 4513 -> NEARBY_USB_ENDPOINT_CHANNEL_CREATION_FAILURE + 183, // 4514 -> NEARBY_GENERIC_ENDPOINT_UNENCRYPTED + 173, // 4515 -> NEARBY_BLE_GATT_ADVERTISEMENT_NULL_FOR_CONNECTION + 219, // 4516 -> NEARBY_WIFI_DIRECT_HOST_ON_SRD_CHANNELS + 230, // 4517 -> NEARBY_WIFI_HOTSPOT_HOST_ON_SRD_CHANNELS + 174, // 4518 -> NEARBY_BLE_GATT_NULL_CALLBACK + 199, // 4519 -> NEARBY_L2CAP_NULL_CALLBACK + 179, // 4520 -> NEARBY_BT_NULL_CALLBACK + 210, // 4521 -> NEARBY_USB_NULL_CALLBACK + 208, // 4522 -> NEARBY_NFC_NULL_CALLBACK + 216, // 4523 -> NEARBY_WIFI_AWARE_NULL_CALLBACK + 213, // 4524 -> NEARBY_WEB_RTC_NULL_CALLBACK + 204, // 4525 -> NEARBY_LAN_NULL_CALLBACK + 233, // 4526 -> NEARBY_WIFI_HOTSPOT_NULL_CALLBACK + 221, // 4527 -> NEARBY_WIFI_DIRECT_NULL_CALLBACK + 223, // 4528 -> NEARBY_WIFI_DIRECT_NULL_SSID + 222, // 4529 -> NEARBY_WIFI_DIRECT_NULL_PASSWORD + 178, // 4530 -> NEARBY_BT_MULTIPLEX_SOCKET_DISABLED + 203, // 4531 -> NEARBY_LAN_MULTIPLEX_SOCKET_DISABLED + 185, // 4532 -> NEARBY_GENERIC_NEW_ENDPOINT_CHANNEL_NULL + 220, // 4533 -> NEARBY_WIFI_DIRECT_NO_GROUP_FOR_LISTENING + 232, // 4534 -> NEARBY_WIFI_HOTSPOT_NO_HOTSPOT_FOR_LISTENING + 186, // 4535 -> NEARBY_GENERIC_OLD_ENDPOINT_CHANNEL_NULL + 175, // 4536 -> NEARBY_BLE_OPERATION_REGISTERED_FAILED + 200, // 4537 -> NEARBY_L2CAP_OPERATION_REGISTERED_FAILED + 180, // 4538 -> NEARBY_BT_OPERATION_REGISTERED_FAILED + 205, // 4539 -> NEARBY_LAN_OPERATION_REGISTERED_FAILED + 214, // 4540 -> NEARBY_WEB_RTC_OPERATION_REGISTERED_FAILED + 217, // 4541 -> NEARBY_WIFI_AWARE_OPERATION_REGISTERED_FAILED + 228, // 4542 -> NEARBY_WIFI_HOTSPOT_DIRECT_OPERATION_REGISTERED_FAILED + 236, // 4543 -> NEARBY_WIFI_HOTSPOT_SOFT_AP_OPERATION_REGISTERED_FAILED + 231, // 4544 -> NEARBY_WIFI_HOTSPOT_LOHS_OPERATION_REGISTERED_FAILED + 227, // 4545 -> NEARBY_WIFI_HOTSPOT_CLIENT_OPERATION_REGISTERED_FAILED + 224, // 4546 -> NEARBY_WIFI_DIRECT_OPERATION_REGISTERED_FAILED + 187, // 4547 -> NEARBY_GENERIC_OUTGOING_PAYLOAD_CREATION_FAILURE + 234, // 4548 -> NEARBY_WIFI_HOTSPOT_P2P_NON_DBS_WANT_2G_BUT_AP_5G + 225, // 4549 -> NEARBY_WIFI_DIRECT_P2P_NON_DBS_WANT_2G_BUT_AP_5G + 235, // 4550 -> NEARBY_WIFI_HOTSPOT_P2P_NON_DBS_WANT_5G_BUT_AP_2G + 226, // 4551 -> NEARBY_WIFI_DIRECT_P2P_NON_DBS_WANT_5G_BUT_AP_2G + 184, // 4552 -> NEARBY_GENERIC_INCOMING_PAYLOAD_NOT_DATA_TYPE + 191, // 4553 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_EVENT_TYPE_ERROR + 193, // 4554 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_FRAME_TYPE_ERROR + 192, // 4555 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_FORMAT_ERROR + 188, // 4556 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_EVENT_TYPE_ERROR + 190, // 4557 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_FRAME_TYPE_ERROR + 189, // 4558 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_FORMAT_ERROR + 194, // 4559 -> NEARBY_GENERIC_REMOTE_ENDPOINT_STATUS_ERROR + 195, // 4560 -> NEARBY_GENERIC_REMOTE_REPORT_PAYLOADS_ERROR + 196, // 4561 -> NEARBY_GENERIC_REMOTE_UPGRADE_FAILURE + 197, // 4562 -> NEARBY_GENERIC_SEND_PAYLOAD_EXECUTOR_NULL + 181, // 4563 -> NEARBY_BT_VIRTUAL_SOCKET_CREATION_FAILURE + 206, // 4564 -> NEARBY_LAN_VIRTUAL_SOCKET_CREATION_FAILURE + 237, // 4565 -> NEARBY_WIFI_LAN_IP_ADDRESS_ERROR + 201, // 4566 -> NEARBY_L2CAP_PSM_NOT_POSITIVE +}; + +const std::string& OperationResultDetail_Name( + OperationResultDetail value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + OperationResultDetail_entries, + OperationResultDetail_entries_by_number, + 238, OperationResultDetail_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + OperationResultDetail_entries, + OperationResultDetail_entries_by_number, + 238, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + OperationResultDetail_strings[idx].get(); +} +bool OperationResultDetail_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OperationResultDetail* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + OperationResultDetail_entries, 238, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} // @@protoc_insertion_point(namespace_scope) } // namespace connections diff --git a/compiled_proto/proto/connections_enums.pb.h b/compiled_proto/proto/connections_enums.pb.h index 079b18b6..5f00902d 100644 --- a/compiled_proto/proto/connections_enums.pb.h +++ b/compiled_proto/proto/connections_enums.pb.h @@ -517,6 +517,288 @@ inline const std::string& PowerLevel_Name(T enum_t_value) { } bool PowerLevel_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PowerLevel* value); +enum OperationResultCategory : int { + CATEGORY_UNKNOWN = 0, + CATEGORY_SUCCESS = 1, + CATEGORY_CLIENT_CANCELLATION = 2, + CATEGORY_MEDIUM_UNAVAILABLE = 3, + CATEGORY_DEVICE_STATE_ERROR = 4, + CATEGORY_CLIENT_ERROR = 5, + CATEGORY_NEARBY_ERROR = 6, + CATEGORY_CONNECTIVITY_ERROR = 7, + CATEGORY_MISCELLANEOUS = 8, + CATEGORY_IO_ERROR = 9 +}; +bool OperationResultCategory_IsValid(int value); +constexpr OperationResultCategory OperationResultCategory_MIN = CATEGORY_UNKNOWN; +constexpr OperationResultCategory OperationResultCategory_MAX = CATEGORY_IO_ERROR; +constexpr int OperationResultCategory_ARRAYSIZE = OperationResultCategory_MAX + 1; + +const std::string& OperationResultCategory_Name(OperationResultCategory value); +template +inline const std::string& OperationResultCategory_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function OperationResultCategory_Name."); + return OperationResultCategory_Name(static_cast(enum_t_value)); +} +bool OperationResultCategory_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OperationResultCategory* value); +enum OperationResultDetail : int { + DETAIL_UNKNOWN = 0, + DETAIL_SUCCESS = 1, + CLIENT_CANCELLATION_REMOTE_IN_CANCELED_STATE = 500, + CLIENT_CANCELLATION_LOCAL_CANCEL_PAYLOAD = 501, + CLIENT_CANCELLATION_REMOTE_CANCEL_PAYLOAD = 502, + CLIENT_CANCELLATION_UPGRADE_CANCELED_BY_REMOTE = 503, + CLIENT_CANCELLATION_CANCEL_BLE_OUTGOING_CONNECTION = 504, + CLIENT_CANCELLATION_CANCEL_BT_OUTGOING_CONNECTION = 505, + CLIENT_CANCELLATION_CANCEL_L2CAP_OUTGOING_CONNECTION = 506, + CLIENT_CANCELLATION_CANCEL_LAN_OUTGOING_CONNECTION = 507, + CLIENT_CANCELLATION_CANCEL_NFC_OUTGOING_CONNECTION = 508, + CLIENT_CANCELLATION_CANCEL_USB_OUTGOING_CONNECTION = 509, + CLIENT_CANCELLATION_CANCEL_WIFI_AWARE_OUTGOING_CONNECTION = 510, + CLIENT_CANCELLATION_CANCEL_WIFI_DIRECT_OUTGOING_CONNECTION = 511, + CLIENT_CANCELLATION_CANCEL_WIFI_HOTSPOT_OUTGOING_CONNECTION = 512, + CLIENT_CANCELLATION_CANCEL_WEB_RTC_OUTGOING_CONNECTION = 513, + CLIENT_CANCELLATION_CANCEL_OUTGOING_CONNECTION = 514, + CLIENT_CANCELLATION_CANCEL_INCOMING_CONNECTION = 515, + CLIENT_CANCELLATION_WIFI_AWARE_SERVER_SOCKET_CREATION = 516, + CLIENT_CANCELLATION_WIFI_DIRECT_SERVER_SOCKET_CREATION = 517, + CLIENT_CANCELLATION_WIFI_HOTSPOT_SERVER_SOCKET_CREATION = 518, + CLIENT_CANCELLATION_BT_SERVER_SOCKET_CREATION = 519, + CLIENT_CANCELLATION_WEB_RTC_SERVER_SOCKET_CREATION = 520, + CLIENT_CANCELLATION_WIFI_LAN_SERVER_SOCKET_CREATION = 521, + CLIENT_CANCELLATION_LOCAL_DISCONNECT = 522, + CLIENT_CANCELLATION_REMOTE_DISCONNECT = 523, + DEVICE_STATE_ERROR_UNFINISHED_UPGRADE_ATTEMPTS = 1000, + DEVICE_STATE_ERROR_USER_HOTSPOT_ENABLED = 1001, + DEVICE_STATE_LOCATION_DISABLED = 1002, + DEVICE_STATE_RADIO_DISABLING_FAILURE = 1003, + DEVICE_STATE_RADIO_ENABLING_FAILURE = 1004, + MEDIUM_UNAVAILABLE_WIFI_AWARE_RESOURCE_NOT_AVAILABLE = 1500, + MEDIUM_UNAVAILABLE_DIRECT_HOTSPOT_NOT_SUPPORT = 1501, + MEDIUM_UNAVAILABLE_SOFT_AP_NOT_SUPPORT = 1502, + MEDIUM_UNAVAILABLE_LOCAL_ONLY_HOTSPOT_NOT_SUPPORT = 1503, + MEDIUM_UNAVAILABLE_LOCAL_ONLY_HOTSPOT_NOT_SUPPORT_5G = 1504, + MEDIUM_UNAVAILABLE_BLE_NOT_AVAILABLE = 1505, + MEDIUM_UNAVAILABLE_L2CAP_NOT_AVAILABLE = 1506, + MEDIUM_UNAVAILABLE_BLUETOOTH_NOT_AVAILABLE = 1507, + MEDIUM_UNAVAILABLE_WEB_RTC_NOT_AVAILABLE = 1508, + MEDIUM_UNAVAILABLE_WIFI_AWARE_NOT_AVAILABLE = 1509, + MEDIUM_UNAVAILABLE_WIFI_HOTSPOT_NOT_AVAILABLE = 1510, + MEDIUM_UNAVAILABLE_WIFI_DIRECT_NOT_AVAILABLE = 1511, + MEDIUM_UNAVAILABLE_NFC_NOT_AVAILABLE = 1512, + MEDIUM_UNAVAILABLE_LAN_NOT_AVAILABLE = 1513, + MEDIUM_UNAVAILABLE_USB_NOT_AVAILABLE = 1514, + MEDIUM_UNAVAILABLE_BLE_NC_LOGICAL_NOT_AVAILABLE = 1515, + MEDIUM_UNAVAILABLE_BT_NC_LOGICAL_NOT_AVAILABLE = 1516, + MEDIUM_UNAVAILABLE_LAN_NC_LOGICAL_NOT_AVAILABLE = 1517, + MEDIUM_UNAVAILABLE_NFC_NC_LOGICAL_NOT_AVAILABLE = 1518, + MEDIUM_UNAVAILABLE_USB_NC_LOGICAL_NOT_AVAILABLE = 1519, + MEDIUM_UNAVAILABLE_WEB_RTC_NC_LOGICAL_NOT_AVAILABLE = 1520, + MEDIUM_UNAVAILABLE_WIFI_AWARE_NC_LOGICAL_NOT_AVAILABLE = 1521, + MEDIUM_UNAVAILABLE_WIFI_HOTSPOT_NC_LOGICAL_NOT_AVAILABLE = 1522, + MEDIUM_UNAVAILABLE_WIFI_DIRECT_NC_LOGICAL_NOT_AVAILABLE = 1523, + MEDIUM_UNAVAILABLE_WIFI_HOTSPOT_P2P_RESOURCE_NOT_AVAILABLE = 1524, + MEDIUM_UNAVAILABLE_WIFI_DIRECT_P2P_RESOURCE_NOT_AVAILABLE = 1525, + MEDIUM_UNAVAILABLE_UPGRADE_SKIP_BLE_LOW_QUALITY_MEDIUMS = 1526, + MEDIUM_UNAVAILABLE_UPGRADE_SKIP_L2CAP_LOW_QUALITY_MEDIUMS = 1527, + MEDIUM_UNAVAILABLE_UPGRADE_SKIP_WEB_RTC_LOW_QUALITY_MEDIUMS = 1528, + MEDIUM_UNAVAILABLE_UPGRADE_SKIP_LAN_LOW_QUALITY_MEDIUMS = 1529, + MEDIUM_UNAVAILABLE_UPGRADE_SKIP_BT_LOW_QUALITY_MEDIUMS = 1530, + MEDIUM_UNAVAILABLE_UPGRADE_SKIP_USB_LOW_QUALITY_MEDIUMS = 1531, + MEDIUM_UNAVAILABLE_LOCAL_ONLY_HOTSPOT_DISRUPTIVE_FALSE = 1532, + MEDIUM_UNAVAILABLE_SOFT_AP_DISRUPTIVE_FALSE = 1533, + MEDIUM_UNAVAILABLE_ALREADY_HAVE_A_WIFI_DIRECT_GROUP = 1534, + MEDIUM_UNAVAILABLE_ALREADY_HOSTING_HOTSPOT_FOR_OTHER_CLIENTS = 1535, + MEDIUM_UNAVAILABLE_REJECT_L2CAP_ON_GATT_MULTIPLEX_CONNECTION = 1536, + MEDIUM_UNAVAILABLE_UPGRADE_ON_SAME_MEDIUM = 1537, + MEDIUM_UNAVAILABLE_WEB_RTC_NO_INTERNET = 1538, + CLIENT_WIFI_DIRECT_ALREADY_HOSTING_DIRECT_GROUP_FOR_THIS_CLIENT = 2000, + CLIENT_WIFI_HOTSPOT_ALREADY_HOSTING_HOTSPOT_FOR_THIS_CLIENT = 2001, + CLIENT_DUPLICATE_ACCEPTING_BLE_CONNECTION_REQUEST = 2002, + CLIENT_DUPLICATE_ACCEPTING_L2CAP_CONNECTION_REQUEST = 2003, + CLIENT_DUPLICATE_ACCEPTING_BT_CONNECTION_REQUEST = 2004, + CLIENT_DUPLICATE_ACCEPTING_LAN_CONNECTION_REQUEST = 2005, + CLIENT_DUPLICATE_ACCEPTING_NFC_CONNECTION_REQUEST = 2006, + CLIENT_DUPLICATE_ACCEPTING_WEB_RTC_CONNECTION_REQUEST = 2007, + CLIENT_DUPLICATE_ACCEPTING_WIFI_AWARE_CONNECTION_REQUEST = 2008, + CLIENT_DUPLICATE_ACCEPTING_WIFI_HOTSPOT_CONNECTION_REQUEST = 2009, + CLIENT_DUPLICATE_ACCEPTING_WIFI_DIRECT_CONNECTION_REQUEST = 2010, + CLIENT_DUPLICATE_ACCEPTING_USB_CONNECTION_REQUEST = 2011, + CLIENT_DUPLICATE_WIFI_AWARE_CONNECTION_REQUEST = 2012, + CLIENT_DUPLICATE_WIFI_DIRECT_CONNECTION_REQUEST = 2013, + CLIENT_DUPLICATE_WIFI_HOTSPOT_CONNECTION_REQUEST = 2014, + CLIENT_DUPLICATE_WIFI_AWARE_SUBSCRIBING_REQUEST = 2015, + CLIENT_UNSUPPORTED_USB_TO_BE_UPGRADE_MEDIUM = 2016, + MISCELLEANEOUS_BLUETOOTH_MAC_ADDRESS_NULL = 2500, + MISCELLEANEOUS_MOVE_TO_NEW_MEDIUM = 2501, + MISCELLEANEOUS_WIFI_HOTSPOT_SOFT_AP_BLOCKED_BY_PROVISION = 2502, + MISCELLEANEOUS_BLE_SYSTEM_SERVICE_NULL = 2503, + MISCELLEANEOUS_L2CAP_SYSTEM_SERVICE_NULL = 2504, + MISCELLEANEOUS_BT_SYSTEM_SERVICE_NULL = 2505, + MISCELLEANEOUS_WIFI_AWARE_SYSTEM_SERVICE_NULL = 2506, + MISCELLEANEOUS_WIFI_DIRECT_SYSTEM_SERVICE_NULL = 2507, + MISCELLEANEOUS_WIFI_LAN_SYSTEM_SERVICE_NULL = 2508, + MISCELLEANEOUS_WIFI_HOTSPOT_SYSTEM_SERVICE_NULL = 2509, + MISCELLEANEOUS_BT_NOT_ACCEPTING_CONNECTION_FOR_WORK_PROFILE = 2510, + MISCELLEANEOUS_WEB_RTC_GET_DROIDGUARD_RESULT_FAILURE = 2511, + MISCELLEANEOUS_WEB_RTC_TACHYON_SIGNALING_MESSENGER_NULL = 2512, + IO_FILE_OPENING_ERROR = 3000, + IO_FILE_READING_ERROR = 3001, + IO_FILE_WRITING_ERROR = 3002, + IO_FOLDER_CREATION_ERROR = 3003, + IO_STREAM_CREATE_PIPE_FAILURE = 3004, + IO_ENDPOINT_IO_ERROR_ON_BLE = 3005, + IO_ENDPOINT_IO_ERROR_ON_L2CAP = 3006, + IO_ENDPOINT_IO_ERROR_ON_BT = 3007, + IO_ENDPOINT_IO_ERROR_ON_WEB_RTC = 3008, + IO_ENDPOINT_IO_ERROR_ON_LAN = 3009, + IO_ENDPOINT_IO_ERROR_ON_WIFI_DIRECT = 3010, + IO_ENDPOINT_IO_ERROR_ON_WIFI_HOTSPOT = 3011, + IO_ENDPOINT_IO_ERROR_ON_WIFI_AWARE = 3012, + IO_ENDPOINT_IO_ERROR_ON_NFC = 3013, + IO_ENDPOINT_IO_ERROR_ON_USB = 3014, + CONNECTIVITY_WIFI_AWARE_ATTACH_FAILURE = 3500, + CONNECTIVITY_BLUETOOTH_DEVICE_OBTAIN_FAILURE = 3501, + CONNECTIVITY_BLE_CLIENT_SOCKET_CREATION_FAILURE = 3502, + CONNECTIVITY_L2CAP_CLIENT_SOCKET_CREATION_FAILURE = 3503, + CONNECTIVITY_BT_CLIENT_SOCKET_CREATION_FAILURE = 3504, + CONNECTIVITY_LAN_CLIENT_SOCKET_CREATION_FAILURE = 3505, + CONNECTIVITY_NFC_CLIENT_SOCKET_CREATION_FAILURE = 3506, + CONNECTIVITY_WEB_RTC_CLIENT_SOCKET_CREATION_FAILURE = 3507, + CONNECTIVITY_WIFI_AWARE_CLIENT_SOCKET_CREATION_FAILURE = 3508, + CONNECTIVITY_WIFI_HOTSPOT_CLIENT_SOCKET_CREATION_FAILURE = 3509, + CONNECTIVITY_WIFI_DIRECT_CLIENT_SOCKET_CREATION_FAILURE = 3510, + CONNECTIVITY_USB_CLIENT_SOCKET_CREATION_FAILURE = 3511, + CONNECTIVITY_WEB_RTC_CONNECT_TO_TACHYON_FAILURE = 3512, + CONNECTIVITY_BLE_CREATE_GATT_CONNECTION_FAILURE = 3513, + CONNECTIVITY_WIFI_AWARE_GET_REMOTE_IP_FRAME_FAILURE = 3514, + CONNECTIVITY_WIFI_AWARE_GET_REMOTE_IP_ADDRESS_FAILURE = 3515, + CONNECTIVITY_WIFI_DIRECT_INCONSISTENT_HOSTED_WIFI_BAND = 3516, + CONNECTIVITY_WIFI_HOTSPOT_INCONSISTENT_HOSTED_WIFI_BAND = 3517, + CONNECTIVITY_BLUETOOTH_INVALID_CREDENTIAL = 3518, + CONNECTIVITY_WIFI_LAN_INVALID_CREDENTIAL = 3519, + CONNECTIVITY_WIFI_DIRECT_INVALID_CREDENTIAL = 3520, + CONNECTIVITY_WIFI_HOTSPOT_INVALID_CREDENTIAL = 3521, + CONNECTIVITY_WIFI_AWARE_INVALID_CREDENTIAL = 3522, + CONNECTIVITY_WEB_RTC_INVALID_CREDENTIAL = 3523, + CONNECTIVITY_WIFI_LAN_IP_ADDRESS_ERROR = 3524, + CONNECTIVITY_L2CAP_CLIENT_OBTAIN_FAIURE = 3525, + CONNECTIVITY_L2CAP_DATA_CONNECTION_FAILURE = 3526, + CONNECTIVITY_WIFI_AWARE_L2MESSAGE_NETWORK_AVAILABLE_FRAME_NULL = 3527, + CONNECTIVITY_WIFI_AWARE_L2MESSAGE_SEND_HOST_NETWORK_FRAME_FAILURE = 3528, + CONNECTIVITY_LAN_UNREACHABLE = 3529, + CONNECTIVITY_WIFI_HOTSPOT_LOHS_CREATION_FAILURE = 3530, + CONNECTIVITY_LAN_GET_NETWORK_INTERFACES_FAILURE = 3531, + CONNECTIVITY_WIFI_DIRECT_GET_NETWORK_INTERFACES_FAILURE = 3532, + CONNECTIVITY_WIFI_HOTSPOT_GET_NETWORK_INTERFACES_FAILURE = 3533, + CONNECTIVITY_WIFI_HOTSPOT_P2P_CHANNEL_INITIALIZE_FAILURE = 3534, + CONNECTIVITY_WIFI_DIRECT_P2P_CHANNEL_INITIALIZE_FAILURE = 3535, + CONNECTIVITY_WIFI_HOTSPOT_P2P_GROUP_CREATION_FAILURE = 3536, + CONNECTIVITY_WIFI_DIRECT_P2P_GROUP_CREATION_FAILURE = 3537, + CONNECTIVITY_GATT_SERVER_OPEN_FAILURE = 3538, + CONNECTIVITY_BLE_SERVER_SOCKET_CREATION_FAILURE = 3539, + CONNECTIVITY_L2CAP_SERVER_SOCKET_CREATION_FAILURE = 3540, + CONNECTIVITY_BT_SERVER_SOCKET_CREATION_FAILURE = 3541, + CONNECTIVITY_LAN_SERVER_SOCKET_CREATION_FAILURE = 3542, + CONNECTIVITY_WEB_RTC_SERVER_SOCKET_CREATION_FAILURE = 3543, + CONNECTIVITY_WIFI_AWARE_SERVER_SOCKET_CREATION_FAILURE = 3544, + CONNECTIVITY_WIFI_HOTSPOT_SERVER_SOCKET_CREATION_FAILURE = 3545, + CONNECTIVITY_WIFI_DIRECT_SERVER_SOCKET_CREATION_FAILURE = 3546, + CONNECTIVITY_NFC_SERVER_SOCKET_CREATION_FAILURE = 3547, + CONNECTIVITY_WIFI_HOTSPOT_SOFT_AP_CREATION_FAILURE = 3548, + CONNECTIVITY_WIFI_AWARE_UPDATE_PUBLISH_FAILURE = 3549, + CONNECTIVITY_GENERIC_WRITING_CHANNEL_IO_ERROR = 3550, + CONNECTIVITY_GENERIC_WRITE_CLIENT_INTRODUCTION_ACK_IO_ERROR = 3551, + CONNECTIVITY_WIFI_AWARE_DISCOVERED_PEER_NULL = 3552, + CONNECTIVITY_GENERIC_PAYLOAD_SENT_ERROR = 3553, + CONNECTIVITY_L2CAP_SERVER_SOCKET_CREATION_SECURITY_EXCEPTION_FAILURE = 3554, + CONNECTIVITY_BT_SERVER_SOCKET_CREATION_SECURITY_EXCEPTION_FAILURE = 3555, + NEARBY_BLE_ADVERTISEMENT_MAPPING_TO_MAC_ERROR = 4500, + NEARBY_BLUETOOTH_MAC_ADDRESS_INVALID_FOR_CONNECT = 4501, + NEARBY_WEB_RTC_CONNECTION_FLOW_NULL = 4502, + NEARBY_GENERIC_CONNECTION_CLOSED = 4503, + NEARBY_BLE_ENDPOINT_CHANNEL_CREATION_FAILURE = 4504, + NEARBY_L2CAP_ENDPOINT_CHANNEL_CREATION_FAILURE = 4505, + NEARBY_BT_ENDPOINT_CHANNEL_CREATION_FAILURE = 4506, + NEARBY_LAN_ENDPOINT_CHANNEL_CREATION_FAILURE = 4507, + NEARBY_NFC_ENDPOINT_CHANNEL_CREATION_FAILURE = 4508, + NEARBY_WIFI_AWARE_ENDPOINT_CHANNEL_CREATION_FAILURE = 4509, + NEARBY_WIFI_HOTSPOT_ENDPOINT_CHANNEL_CREATION_FAILURE = 4510, + NEARBY_WIFI_DIRECT_ENDPOINT_CHANNEL_CREATION_FAILURE = 4511, + NEARBY_WEB_RTC_ENDPOINT_CHANNEL_CREATION_FAILURE = 4512, + NEARBY_USB_ENDPOINT_CHANNEL_CREATION_FAILURE = 4513, + NEARBY_GENERIC_ENDPOINT_UNENCRYPTED = 4514, + NEARBY_BLE_GATT_ADVERTISEMENT_NULL_FOR_CONNECTION = 4515, + NEARBY_WIFI_DIRECT_HOST_ON_SRD_CHANNELS = 4516, + NEARBY_WIFI_HOTSPOT_HOST_ON_SRD_CHANNELS = 4517, + NEARBY_BLE_GATT_NULL_CALLBACK = 4518, + NEARBY_L2CAP_NULL_CALLBACK = 4519, + NEARBY_BT_NULL_CALLBACK = 4520, + NEARBY_USB_NULL_CALLBACK = 4521, + NEARBY_NFC_NULL_CALLBACK = 4522, + NEARBY_WIFI_AWARE_NULL_CALLBACK = 4523, + NEARBY_WEB_RTC_NULL_CALLBACK = 4524, + NEARBY_LAN_NULL_CALLBACK = 4525, + NEARBY_WIFI_HOTSPOT_NULL_CALLBACK = 4526, + NEARBY_WIFI_DIRECT_NULL_CALLBACK = 4527, + NEARBY_WIFI_DIRECT_NULL_SSID = 4528, + NEARBY_WIFI_DIRECT_NULL_PASSWORD = 4529, + NEARBY_BT_MULTIPLEX_SOCKET_DISABLED = 4530, + NEARBY_LAN_MULTIPLEX_SOCKET_DISABLED = 4531, + NEARBY_GENERIC_NEW_ENDPOINT_CHANNEL_NULL = 4532, + NEARBY_WIFI_DIRECT_NO_GROUP_FOR_LISTENING = 4533, + NEARBY_WIFI_HOTSPOT_NO_HOTSPOT_FOR_LISTENING = 4534, + NEARBY_GENERIC_OLD_ENDPOINT_CHANNEL_NULL = 4535, + NEARBY_BLE_OPERATION_REGISTERED_FAILED = 4536, + NEARBY_L2CAP_OPERATION_REGISTERED_FAILED = 4537, + NEARBY_BT_OPERATION_REGISTERED_FAILED = 4538, + NEARBY_LAN_OPERATION_REGISTERED_FAILED = 4539, + NEARBY_WEB_RTC_OPERATION_REGISTERED_FAILED = 4540, + NEARBY_WIFI_AWARE_OPERATION_REGISTERED_FAILED = 4541, + NEARBY_WIFI_HOTSPOT_DIRECT_OPERATION_REGISTERED_FAILED = 4542, + NEARBY_WIFI_HOTSPOT_SOFT_AP_OPERATION_REGISTERED_FAILED = 4543, + NEARBY_WIFI_HOTSPOT_LOHS_OPERATION_REGISTERED_FAILED = 4544, + NEARBY_WIFI_HOTSPOT_CLIENT_OPERATION_REGISTERED_FAILED = 4545, + NEARBY_WIFI_DIRECT_OPERATION_REGISTERED_FAILED = 4546, + NEARBY_GENERIC_OUTGOING_PAYLOAD_CREATION_FAILURE = 4547, + NEARBY_WIFI_HOTSPOT_P2P_NON_DBS_WANT_2G_BUT_AP_5G = 4548, + NEARBY_WIFI_DIRECT_P2P_NON_DBS_WANT_2G_BUT_AP_5G = 4549, + NEARBY_WIFI_HOTSPOT_P2P_NON_DBS_WANT_5G_BUT_AP_2G = 4550, + NEARBY_WIFI_DIRECT_P2P_NON_DBS_WANT_5G_BUT_AP_2G = 4551, + NEARBY_GENERIC_INCOMING_PAYLOAD_NOT_DATA_TYPE = 4552, + NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_EVENT_TYPE_ERROR = 4553, + NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_FRAME_TYPE_ERROR = 4554, + NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_FORMAT_ERROR = 4555, + NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_EVENT_TYPE_ERROR = 4556, + NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_FRAME_TYPE_ERROR = 4557, + NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_FORMAT_ERROR = 4558, + NEARBY_GENERIC_REMOTE_ENDPOINT_STATUS_ERROR = 4559, + NEARBY_GENERIC_REMOTE_REPORT_PAYLOADS_ERROR = 4560, + NEARBY_GENERIC_REMOTE_UPGRADE_FAILURE = 4561, + NEARBY_GENERIC_SEND_PAYLOAD_EXECUTOR_NULL = 4562, + NEARBY_BT_VIRTUAL_SOCKET_CREATION_FAILURE = 4563, + NEARBY_LAN_VIRTUAL_SOCKET_CREATION_FAILURE = 4564, + NEARBY_WIFI_LAN_IP_ADDRESS_ERROR = 4565, + NEARBY_L2CAP_PSM_NOT_POSITIVE = 4566 +}; +bool OperationResultDetail_IsValid(int value); +constexpr OperationResultDetail OperationResultDetail_MIN = DETAIL_UNKNOWN; +constexpr OperationResultDetail OperationResultDetail_MAX = NEARBY_L2CAP_PSM_NOT_POSITIVE; +constexpr int OperationResultDetail_ARRAYSIZE = OperationResultDetail_MAX + 1; + +const std::string& OperationResultDetail_Name(OperationResultDetail value); +template +inline const std::string& OperationResultDetail_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function OperationResultDetail_Name."); + return OperationResultDetail_Name(static_cast(enum_t_value)); +} +bool OperationResultDetail_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OperationResultDetail* value); // =================================================================== @@ -560,6 +842,8 @@ template <> struct is_proto_enum< ::location::nearby::proto::connections::Bandwi template <> struct is_proto_enum< ::location::nearby::proto::connections::BandwidthUpgradeErrorStage> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::connections::LogSource> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::connections::PowerLevel> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::proto::connections::OperationResultCategory> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::proto::connections::OperationResultDetail> : ::std::true_type {}; PROTOBUF_NAMESPACE_CLOSE diff --git a/compiled_proto/proto/mediums/ble_frames.pb.cc b/compiled_proto/proto/mediums/ble_frames.pb.cc index 42f55f75..e52eb70c 100644 --- a/compiled_proto/proto/mediums/ble_frames.pb.cc +++ b/compiled_proto/proto/mediums/ble_frames.pb.cc @@ -35,6 +35,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SocketControlFrameDefaultTypeIn constexpr IntroductionFrame::IntroductionFrame( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : service_id_hash_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , service_id_hash_salt_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , socket_version_(0) {} struct IntroductionFrameDefaultTypeInternal { @@ -552,6 +553,9 @@ class IntroductionFrame::_Internal { (*has_bits)[0] |= 1u; } static void set_has_socket_version(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_service_id_hash_salt(HasBits* has_bits) { (*has_bits)[0] |= 2u; } }; @@ -577,6 +581,14 @@ IntroductionFrame::IntroductionFrame(const IntroductionFrame& from) service_id_hash_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_service_id_hash(), GetArenaForAllocation()); } + service_id_hash_salt_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + service_id_hash_salt_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_service_id_hash_salt()) { + service_id_hash_salt_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_service_id_hash_salt(), + GetArenaForAllocation()); + } socket_version_ = from.socket_version_; // @@protoc_insertion_point(copy_constructor:location.nearby.mediums.IntroductionFrame) } @@ -586,6 +598,10 @@ service_id_hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptySt #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING service_id_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +service_id_hash_salt_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + service_id_hash_salt_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING socket_version_ = 0; } @@ -599,6 +615,7 @@ IntroductionFrame::~IntroductionFrame() { inline void IntroductionFrame::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); service_id_hash_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + service_id_hash_salt_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void IntroductionFrame::ArenaDtor(void* object) { @@ -618,8 +635,13 @@ void IntroductionFrame::Clear() { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - service_id_hash_.ClearNonDefaultToEmpty(); + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + service_id_hash_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + service_id_hash_salt_.ClearNonDefaultToEmpty(); + } } socket_version_ = 0; _has_bits_.Clear(); @@ -655,6 +677,15 @@ const char* IntroductionFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP } else goto handle_unusual; continue; + // optional string service_id_hash_salt = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_service_id_hash_salt(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -693,12 +724,18 @@ uint8_t* IntroductionFrame::_InternalSerialize( } // optional .location.nearby.mediums.SocketVersion socket_version = 2; - if (cached_has_bits & 0x00000002u) { + if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 2, this->_internal_socket_version(), target); } + // optional string service_id_hash_salt = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteStringMaybeAliased( + 3, this->_internal_service_id_hash_salt(), target); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); @@ -716,7 +753,7 @@ size_t IntroductionFrame::ByteSizeLong() const { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000007u) { // optional bytes service_id_hash = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + @@ -724,8 +761,15 @@ size_t IntroductionFrame::ByteSizeLong() const { this->_internal_service_id_hash()); } - // optional .location.nearby.mediums.SocketVersion socket_version = 2; + // optional string service_id_hash_salt = 3; if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_service_id_hash_salt()); + } + + // optional .location.nearby.mediums.SocketVersion socket_version = 2; + if (cached_has_bits & 0x00000004u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_socket_version()); } @@ -752,11 +796,14 @@ void IntroductionFrame::MergeFrom(const IntroductionFrame& from) { (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; - if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { _internal_set_service_id_hash(from._internal_service_id_hash()); } if (cached_has_bits & 0x00000002u) { + _internal_set_service_id_hash_salt(from._internal_service_id_hash_salt()); + } + if (cached_has_bits & 0x00000004u) { socket_version_ = from.socket_version_; } _has_bits_[0] |= cached_has_bits; @@ -786,6 +833,11 @@ void IntroductionFrame::InternalSwap(IntroductionFrame* other) { &service_id_hash_, lhs_arena, &other->service_id_hash_, rhs_arena ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &service_id_hash_salt_, lhs_arena, + &other->service_id_hash_salt_, rhs_arena + ); swap(socket_version_, other->socket_version_); } diff --git a/compiled_proto/proto/mediums/ble_frames.pb.h b/compiled_proto/proto/mediums/ble_frames.pb.h index fec28893..a57a4e39 100644 --- a/compiled_proto/proto/mediums/ble_frames.pb.h +++ b/compiled_proto/proto/mediums/ble_frames.pb.h @@ -468,6 +468,7 @@ class IntroductionFrame final : enum : int { kServiceIdHashFieldNumber = 1, + kServiceIdHashSaltFieldNumber = 3, kSocketVersionFieldNumber = 2, }; // optional bytes service_id_hash = 1; @@ -488,6 +489,24 @@ class IntroductionFrame final : std::string* _internal_mutable_service_id_hash(); public: + // optional string service_id_hash_salt = 3; + bool has_service_id_hash_salt() const; + private: + bool _internal_has_service_id_hash_salt() const; + public: + void clear_service_id_hash_salt(); + const std::string& service_id_hash_salt() const; + template + void set_service_id_hash_salt(ArgT0&& arg0, ArgT... args); + std::string* mutable_service_id_hash_salt(); + PROTOBUF_NODISCARD std::string* release_service_id_hash_salt(); + void set_allocated_service_id_hash_salt(std::string* service_id_hash_salt); + private: + const std::string& _internal_service_id_hash_salt() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_id_hash_salt(const std::string& value); + std::string* _internal_mutable_service_id_hash_salt(); + public: + // optional .location.nearby.mediums.SocketVersion socket_version = 2; bool has_socket_version() const; private: @@ -511,6 +530,7 @@ class IntroductionFrame final : ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_id_hash_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_id_hash_salt_; int socket_version_; friend struct ::TableStruct_proto_2fmediums_2fble_5fframes_2eproto; }; @@ -1208,7 +1228,7 @@ inline void IntroductionFrame::set_allocated_service_id_hash(std::string* servic // optional .location.nearby.mediums.SocketVersion socket_version = 2; inline bool IntroductionFrame::_internal_has_socket_version() const { - bool value = (_has_bits_[0] & 0x00000002u) != 0; + bool value = (_has_bits_[0] & 0x00000004u) != 0; return value; } inline bool IntroductionFrame::has_socket_version() const { @@ -1216,7 +1236,7 @@ inline bool IntroductionFrame::has_socket_version() const { } inline void IntroductionFrame::clear_socket_version() { socket_version_ = 0; - _has_bits_[0] &= ~0x00000002u; + _has_bits_[0] &= ~0x00000004u; } inline ::location::nearby::mediums::SocketVersion IntroductionFrame::_internal_socket_version() const { return static_cast< ::location::nearby::mediums::SocketVersion >(socket_version_); @@ -1227,7 +1247,7 @@ inline ::location::nearby::mediums::SocketVersion IntroductionFrame::socket_vers } inline void IntroductionFrame::_internal_set_socket_version(::location::nearby::mediums::SocketVersion value) { assert(::location::nearby::mediums::SocketVersion_IsValid(value)); - _has_bits_[0] |= 0x00000002u; + _has_bits_[0] |= 0x00000004u; socket_version_ = value; } inline void IntroductionFrame::set_socket_version(::location::nearby::mediums::SocketVersion value) { @@ -1235,6 +1255,75 @@ inline void IntroductionFrame::set_socket_version(::location::nearby::mediums::S // @@protoc_insertion_point(field_set:location.nearby.mediums.IntroductionFrame.socket_version) } +// optional string service_id_hash_salt = 3; +inline bool IntroductionFrame::_internal_has_service_id_hash_salt() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool IntroductionFrame::has_service_id_hash_salt() const { + return _internal_has_service_id_hash_salt(); +} +inline void IntroductionFrame::clear_service_id_hash_salt() { + service_id_hash_salt_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& IntroductionFrame::service_id_hash_salt() const { + // @@protoc_insertion_point(field_get:location.nearby.mediums.IntroductionFrame.service_id_hash_salt) + return _internal_service_id_hash_salt(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void IntroductionFrame::set_service_id_hash_salt(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + service_id_hash_salt_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.mediums.IntroductionFrame.service_id_hash_salt) +} +inline std::string* IntroductionFrame::mutable_service_id_hash_salt() { + std::string* _s = _internal_mutable_service_id_hash_salt(); + // @@protoc_insertion_point(field_mutable:location.nearby.mediums.IntroductionFrame.service_id_hash_salt) + return _s; +} +inline const std::string& IntroductionFrame::_internal_service_id_hash_salt() const { + return service_id_hash_salt_.Get(); +} +inline void IntroductionFrame::_internal_set_service_id_hash_salt(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + service_id_hash_salt_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* IntroductionFrame::_internal_mutable_service_id_hash_salt() { + _has_bits_[0] |= 0x00000002u; + return service_id_hash_salt_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* IntroductionFrame::release_service_id_hash_salt() { + // @@protoc_insertion_point(field_release:location.nearby.mediums.IntroductionFrame.service_id_hash_salt) + if (!_internal_has_service_id_hash_salt()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto* p = service_id_hash_salt_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (service_id_hash_salt_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + service_id_hash_salt_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void IntroductionFrame::set_allocated_service_id_hash_salt(std::string* service_id_hash_salt) { + if (service_id_hash_salt != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + service_id_hash_salt_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_id_hash_salt, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (service_id_hash_salt_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + service_id_hash_salt_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.IntroductionFrame.service_id_hash_salt) +} + // ------------------------------------------------------------------- // DisconnectionFrame diff --git a/compiled_proto/proto/sharing_enums.pb.cc b/compiled_proto/proto/sharing_enums.pb.cc index 0c7a9b0b..9b200e94 100644 --- a/compiled_proto/proto/sharing_enums.pb.cc +++ b/compiled_proto/proto/sharing_enums.pb.cc @@ -86,13 +86,18 @@ bool EventType_IsValid(int value) { case 57: case 58: case 59: + case 60: + case 61: + case 62: + case 63: + case 64: return true; default: return false; } } -static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed EventType_strings[60] = {}; +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed EventType_strings[65] = {}; static const char EventType_names[] = "ACCEPT_AGREEMENTS" @@ -107,6 +112,7 @@ static const char EventType_names[] = "CANCEL_RECEIVING_ATTACHMENTS" "CANCEL_SENDING_ATTACHMENTS" "DECLINE_AGREEMENTS" + "DECRYPT_CERTIFICATE_FAILURE" "DEFAULT_OPT_IN" "DESCRIBE_ATTACHMENTS" "DEVICE_SETTINGS" @@ -117,6 +123,7 @@ static const char EventType_names[] = "DISPLAY_PRIVACY_NOTIFICATION" "ENABLE_NEARBY_SHARING" "ESTABLISH_CONNECTION" + "FAST_INIT_DISCOVER_DEVICE" "FAST_SHARE_SERVER_RESPONSE" "INSTALL_APK" "LAUNCH_ACTIVITY" @@ -124,6 +131,7 @@ static const char EventType_names[] = "LAUNCH_PHONE_CONSENT" "LAUNCH_SETUP_ACTIVITY" "OPEN_RECEIVED_ATTACHMENTS" + "PARSING_FAILED_ENDPOINT_ID" "PREFERENCES_USAGE" "PROCESS_RECEIVED_ATTACHMENTS_END" "QR_CODE_LINK_SHOWN" @@ -139,10 +147,12 @@ static const char EventType_names[] = "SCAN_FOR_SHARE_TARGETS_START" "SEND_ATTACHMENTS_END" "SEND_ATTACHMENTS_START" + "SEND_DESKTOP_NOTIFICATION" "SEND_FAST_INITIALIZATION" "SEND_INTRODUCTION" "SEND_START" "SETUP_WIZARD" + "SET_ACCOUNT" "SET_DATA_USAGE" "SET_DEVICE_NAME" "SET_VISIBILITY" @@ -169,117 +179,127 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry EventType_entries[] = { {EventType_names + 195, 28}, 20 }, { {EventType_names + 223, 26}, 19 }, { {EventType_names + 249, 18}, 46 }, - { {EventType_names + 267, 14}, 56 }, - { {EventType_names + 281, 20}, 4 }, - { {EventType_names + 301, 15}, 49 }, - { {EventType_names + 316, 21}, 11 }, - { {EventType_names + 337, 27}, 29 }, - { {EventType_names + 364, 28}, 32 }, - { {EventType_names + 392, 21}, 54 }, - { {EventType_names + 413, 28}, 53 }, - { {EventType_names + 441, 21}, 2 }, - { {EventType_names + 462, 20}, 48 }, - { {EventType_names + 482, 26}, 25 }, - { {EventType_names + 508, 11}, 40 }, - { {EventType_names + 519, 15}, 31 }, - { {EventType_names + 534, 14}, 42 }, - { {EventType_names + 548, 20}, 38 }, - { {EventType_names + 568, 21}, 22 }, - { {EventType_names + 589, 25}, 21 }, - { {EventType_names + 614, 17}, 55 }, - { {EventType_names + 631, 32}, 43 }, - { {EventType_names + 663, 18}, 59 }, - { {EventType_names + 681, 23}, 18 }, - { {EventType_names + 704, 25}, 17 }, - { {EventType_names + 729, 27}, 10 }, - { {EventType_names + 756, 20}, 13 }, - { {EventType_names + 776, 14}, 24 }, - { {EventType_names + 790, 26}, 37 }, - { {EventType_names + 816, 27}, 47 }, - { {EventType_names + 843, 23}, 14 }, - { {EventType_names + 866, 26}, 6 }, - { {EventType_names + 892, 28}, 5 }, - { {EventType_names + 920, 20}, 16 }, - { {EventType_names + 940, 22}, 15 }, - { {EventType_names + 962, 24}, 9 }, - { {EventType_names + 986, 17}, 12 }, - { {EventType_names + 1003, 10}, 26 }, - { {EventType_names + 1013, 12}, 57 }, - { {EventType_names + 1025, 14}, 28 }, - { {EventType_names + 1039, 15}, 45 }, - { {EventType_names + 1054, 14}, 3 }, - { {EventType_names + 1068, 12}, 35 }, - { {EventType_names + 1080, 8}, 34 }, - { {EventType_names + 1088, 24}, 33 }, - { {EventType_names + 1112, 11}, 58 }, - { {EventType_names + 1123, 29}, 52 }, - { {EventType_names + 1152, 23}, 39 }, - { {EventType_names + 1175, 24}, 44 }, - { {EventType_names + 1199, 18}, 0 }, - { {EventType_names + 1217, 10}, 41 }, + { {EventType_names + 267, 27}, 64 }, + { {EventType_names + 294, 14}, 56 }, + { {EventType_names + 308, 20}, 4 }, + { {EventType_names + 328, 15}, 49 }, + { {EventType_names + 343, 21}, 11 }, + { {EventType_names + 364, 27}, 29 }, + { {EventType_names + 391, 28}, 32 }, + { {EventType_names + 419, 21}, 54 }, + { {EventType_names + 440, 28}, 53 }, + { {EventType_names + 468, 21}, 2 }, + { {EventType_names + 489, 20}, 48 }, + { {EventType_names + 509, 25}, 61 }, + { {EventType_names + 534, 26}, 25 }, + { {EventType_names + 560, 11}, 40 }, + { {EventType_names + 571, 15}, 31 }, + { {EventType_names + 586, 14}, 42 }, + { {EventType_names + 600, 20}, 38 }, + { {EventType_names + 620, 21}, 22 }, + { {EventType_names + 641, 25}, 21 }, + { {EventType_names + 666, 26}, 60 }, + { {EventType_names + 692, 17}, 55 }, + { {EventType_names + 709, 32}, 43 }, + { {EventType_names + 741, 18}, 59 }, + { {EventType_names + 759, 23}, 18 }, + { {EventType_names + 782, 25}, 17 }, + { {EventType_names + 807, 27}, 10 }, + { {EventType_names + 834, 20}, 13 }, + { {EventType_names + 854, 14}, 24 }, + { {EventType_names + 868, 26}, 37 }, + { {EventType_names + 894, 27}, 47 }, + { {EventType_names + 921, 23}, 14 }, + { {EventType_names + 944, 26}, 6 }, + { {EventType_names + 970, 28}, 5 }, + { {EventType_names + 998, 20}, 16 }, + { {EventType_names + 1018, 22}, 15 }, + { {EventType_names + 1040, 25}, 62 }, + { {EventType_names + 1065, 24}, 9 }, + { {EventType_names + 1089, 17}, 12 }, + { {EventType_names + 1106, 10}, 26 }, + { {EventType_names + 1116, 12}, 57 }, + { {EventType_names + 1128, 11}, 63 }, + { {EventType_names + 1139, 14}, 28 }, + { {EventType_names + 1153, 15}, 45 }, + { {EventType_names + 1168, 14}, 3 }, + { {EventType_names + 1182, 12}, 35 }, + { {EventType_names + 1194, 8}, 34 }, + { {EventType_names + 1202, 24}, 33 }, + { {EventType_names + 1226, 11}, 58 }, + { {EventType_names + 1237, 29}, 52 }, + { {EventType_names + 1266, 23}, 39 }, + { {EventType_names + 1289, 24}, 44 }, + { {EventType_names + 1313, 18}, 0 }, + { {EventType_names + 1331, 10}, 41 }, }; static const int EventType_entries_by_number[] = { - 58, // 0 -> UNKNOWN_EVENT_TYPE + 63, // 0 -> UNKNOWN_EVENT_TYPE 0, // 1 -> ACCEPT_AGREEMENTS - 20, // 2 -> ENABLE_NEARBY_SHARING - 50, // 3 -> SET_VISIBILITY - 13, // 4 -> DESCRIBE_ATTACHMENTS - 41, // 5 -> SCAN_FOR_SHARE_TARGETS_START - 40, // 6 -> SCAN_FOR_SHARE_TARGETS_END + 21, // 2 -> ENABLE_NEARBY_SHARING + 55, // 3 -> SET_VISIBILITY + 14, // 4 -> DESCRIBE_ATTACHMENTS + 44, // 5 -> SCAN_FOR_SHARE_TARGETS_START + 43, // 6 -> SCAN_FOR_SHARE_TARGETS_END 5, // 7 -> ADVERTISE_DEVICE_PRESENCE_START 4, // 8 -> ADVERTISE_DEVICE_PRESENCE_END - 44, // 9 -> SEND_FAST_INITIALIZATION - 34, // 10 -> RECEIVE_FAST_INITIALIZATION - 15, // 11 -> DISCOVER_SHARE_TARGET - 45, // 12 -> SEND_INTRODUCTION - 35, // 13 -> RECEIVE_INTRODUCTION - 39, // 14 -> RESPOND_TO_INTRODUCTION - 43, // 15 -> SEND_ATTACHMENTS_START - 42, // 16 -> SEND_ATTACHMENTS_END - 33, // 17 -> RECEIVE_ATTACHMENTS_START - 32, // 18 -> RECEIVE_ATTACHMENTS_END + 48, // 9 -> SEND_FAST_INITIALIZATION + 37, // 10 -> RECEIVE_FAST_INITIALIZATION + 16, // 11 -> DISCOVER_SHARE_TARGET + 49, // 12 -> SEND_INTRODUCTION + 38, // 13 -> RECEIVE_INTRODUCTION + 42, // 14 -> RESPOND_TO_INTRODUCTION + 46, // 15 -> SEND_ATTACHMENTS_START + 45, // 16 -> SEND_ATTACHMENTS_END + 36, // 17 -> RECEIVE_ATTACHMENTS_START + 35, // 18 -> RECEIVE_ATTACHMENTS_END 10, // 19 -> CANCEL_SENDING_ATTACHMENTS 9, // 20 -> CANCEL_RECEIVING_ATTACHMENTS - 28, // 21 -> OPEN_RECEIVED_ATTACHMENTS - 27, // 22 -> LAUNCH_SETUP_ACTIVITY + 30, // 21 -> OPEN_RECEIVED_ATTACHMENTS + 29, // 22 -> LAUNCH_SETUP_ACTIVITY 2, // 23 -> ADD_CONTACT - 36, // 24 -> REMOVE_CONTACT - 22, // 25 -> FAST_SHARE_SERVER_RESPONSE - 46, // 26 -> SEND_START + 39, // 24 -> REMOVE_CONTACT + 24, // 25 -> FAST_SHARE_SERVER_RESPONSE + 50, // 26 -> SEND_START 1, // 27 -> ACCEPT_FAST_INITIALIZATION - 48, // 28 -> SET_DATA_USAGE - 16, // 29 -> DISMISS_FAST_INITIALIZATION + 53, // 28 -> SET_DATA_USAGE + 17, // 29 -> DISMISS_FAST_INITIALIZATION 8, // 30 -> CANCEL_CONNECTION - 24, // 31 -> LAUNCH_ACTIVITY - 17, // 32 -> DISMISS_PRIVACY_NOTIFICATION - 53, // 33 -> TAP_PRIVACY_NOTIFICATION - 52, // 34 -> TAP_HELP - 51, // 35 -> TAP_FEEDBACK + 26, // 31 -> LAUNCH_ACTIVITY + 18, // 32 -> DISMISS_PRIVACY_NOTIFICATION + 58, // 33 -> TAP_PRIVACY_NOTIFICATION + 57, // 34 -> TAP_HELP + 56, // 35 -> TAP_FEEDBACK 3, // 36 -> ADD_QUICK_SETTINGS_TILE - 37, // 37 -> REMOVE_QUICK_SETTINGS_TILE - 26, // 38 -> LAUNCH_PHONE_CONSENT - 56, // 39 -> TAP_QUICK_SETTINGS_TILE - 23, // 40 -> INSTALL_APK - 59, // 41 -> VERIFY_APK - 25, // 42 -> LAUNCH_CONSENT - 30, // 43 -> PROCESS_RECEIVED_ATTACHMENTS_END - 57, // 44 -> TOGGLE_SHOW_NOTIFICATION - 49, // 45 -> SET_DEVICE_NAME + 40, // 37 -> REMOVE_QUICK_SETTINGS_TILE + 28, // 38 -> LAUNCH_PHONE_CONSENT + 61, // 39 -> TAP_QUICK_SETTINGS_TILE + 25, // 40 -> INSTALL_APK + 64, // 41 -> VERIFY_APK + 27, // 42 -> LAUNCH_CONSENT + 33, // 43 -> PROCESS_RECEIVED_ATTACHMENTS_END + 62, // 44 -> TOGGLE_SHOW_NOTIFICATION + 54, // 45 -> SET_DEVICE_NAME 11, // 46 -> DECLINE_AGREEMENTS - 38, // 47 -> REQUEST_SETTING_PERMISSIONS - 21, // 48 -> ESTABLISH_CONNECTION - 14, // 49 -> DEVICE_SETTINGS + 41, // 47 -> REQUEST_SETTING_PERMISSIONS + 22, // 48 -> ESTABLISH_CONNECTION + 15, // 49 -> DEVICE_SETTINGS 7, // 50 -> AUTO_DISMISS_FAST_INITIALIZATION 6, // 51 -> APP_CRASH - 55, // 52 -> TAP_QUICK_SETTINGS_FILE_SHARE - 19, // 53 -> DISPLAY_PRIVACY_NOTIFICATION - 18, // 54 -> DISPLAY_PHONE_CONSENT - 29, // 55 -> PREFERENCES_USAGE - 12, // 56 -> DEFAULT_OPT_IN - 47, // 57 -> SETUP_WIZARD - 54, // 58 -> TAP_QR_CODE - 31, // 59 -> QR_CODE_LINK_SHOWN + 60, // 52 -> TAP_QUICK_SETTINGS_FILE_SHARE + 20, // 53 -> DISPLAY_PRIVACY_NOTIFICATION + 19, // 54 -> DISPLAY_PHONE_CONSENT + 32, // 55 -> PREFERENCES_USAGE + 13, // 56 -> DEFAULT_OPT_IN + 51, // 57 -> SETUP_WIZARD + 59, // 58 -> TAP_QR_CODE + 34, // 59 -> QR_CODE_LINK_SHOWN + 31, // 60 -> PARSING_FAILED_ENDPOINT_ID + 23, // 61 -> FAST_INIT_DISCOVER_DEVICE + 47, // 62 -> SEND_DESKTOP_NOTIFICATION + 52, // 63 -> SET_ACCOUNT + 12, // 64 -> DECRYPT_CERTIFICATE_FAILURE }; const std::string& EventType_Name( @@ -288,12 +308,12 @@ const std::string& EventType_Name( ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( EventType_entries, EventType_entries_by_number, - 60, EventType_strings); + 65, EventType_strings); (void) dummy; int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( EventType_entries, EventType_entries_by_number, - 60, value); + 65, value); return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : EventType_strings[idx].get(); } @@ -301,7 +321,7 @@ bool EventType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EventType* value) { int int_value; bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( - EventType_entries, 60, name, &int_value); + EventType_entries, 65, name, &int_value); if (success) { *value = static_cast(int_value); } @@ -626,13 +646,17 @@ bool AttachmentTransmissionStatus_IsValid(int value) { case 15: case 16: case 17: + case 18: + case 19: + case 20: + case 21: return true; default: return false; } } -static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed AttachmentTransmissionStatus_strings[18] = {}; +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed AttachmentTransmissionStatus_strings[22] = {}; static const char AttachmentTransmissionStatus_names[] = "AWAITING_REMOTE_ACCEPTANCE_FAILED_ATTACHMENT" @@ -643,6 +667,10 @@ static const char AttachmentTransmissionStatus_names[] = "FAILED_NO_SHARE_TARGET_ENDPOINT" "FAILED_NO_TRANSFER_UPDATE_CALLBACK" "FAILED_NULL_CONNECTION" + "FAILED_NULL_CONNECTION_DISCONNECTED" + "FAILED_NULL_CONNECTION_FAILURE" + "FAILED_NULL_CONNECTION_INIT_OUTGOING" + "FAILED_NULL_CONNECTION_LOST_CONNECTIVITY" "FAILED_PAIRED_KEYHANDSHAKE" "FAILED_UNKNOWN_REMOTE_RESPONSE" "FAILED_WRITE_INTRODUCTION" @@ -663,37 +691,45 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AttachmentTransmission { {AttachmentTransmissionStatus_names + 176, 31}, 12 }, { {AttachmentTransmissionStatus_names + 207, 34}, 8 }, { {AttachmentTransmissionStatus_names + 241, 22}, 14 }, - { {AttachmentTransmissionStatus_names + 263, 26}, 13 }, - { {AttachmentTransmissionStatus_names + 289, 30}, 17 }, - { {AttachmentTransmissionStatus_names + 319, 25}, 16 }, - { {AttachmentTransmissionStatus_names + 344, 28}, 9 }, - { {AttachmentTransmissionStatus_names + 372, 27}, 7 }, - { {AttachmentTransmissionStatus_names + 399, 19}, 11 }, - { {AttachmentTransmissionStatus_names + 418, 19}, 4 }, - { {AttachmentTransmissionStatus_names + 437, 20}, 5 }, - { {AttachmentTransmissionStatus_names + 457, 38}, 0 }, - { {AttachmentTransmissionStatus_names + 495, 38}, 10 }, + { {AttachmentTransmissionStatus_names + 263, 35}, 19 }, + { {AttachmentTransmissionStatus_names + 298, 30}, 21 }, + { {AttachmentTransmissionStatus_names + 328, 36}, 18 }, + { {AttachmentTransmissionStatus_names + 364, 40}, 20 }, + { {AttachmentTransmissionStatus_names + 404, 26}, 13 }, + { {AttachmentTransmissionStatus_names + 430, 30}, 17 }, + { {AttachmentTransmissionStatus_names + 460, 25}, 16 }, + { {AttachmentTransmissionStatus_names + 485, 28}, 9 }, + { {AttachmentTransmissionStatus_names + 513, 27}, 7 }, + { {AttachmentTransmissionStatus_names + 540, 19}, 11 }, + { {AttachmentTransmissionStatus_names + 559, 19}, 4 }, + { {AttachmentTransmissionStatus_names + 578, 20}, 5 }, + { {AttachmentTransmissionStatus_names + 598, 38}, 0 }, + { {AttachmentTransmissionStatus_names + 636, 38}, 10 }, }; static const int AttachmentTransmissionStatus_entries_by_number[] = { - 16, // 0 -> UNKNOWN_ATTACHMENT_TRANSMISSION_STATUS + 20, // 0 -> UNKNOWN_ATTACHMENT_TRANSMISSION_STATUS 2, // 1 -> COMPLETE_ATTACHMENT_TRANSMISSION_STATUS 1, // 2 -> CANCELED_ATTACHMENT_TRANSMISSION_STATUS 3, // 3 -> FAILED_ATTACHMENT_TRANSMISSION_STATUS - 14, // 4 -> REJECTED_ATTACHMENT - 15, // 5 -> TIMED_OUT_ATTACHMENT + 18, // 4 -> REJECTED_ATTACHMENT + 19, // 5 -> TIMED_OUT_ATTACHMENT 0, // 6 -> AWAITING_REMOTE_ACCEPTANCE_FAILED_ATTACHMENT - 12, // 7 -> NOT_ENOUGH_SPACE_ATTACHMENT + 16, // 7 -> NOT_ENOUGH_SPACE_ATTACHMENT 6, // 8 -> FAILED_NO_TRANSFER_UPDATE_CALLBACK - 11, // 9 -> MEDIA_UNAVAILABLE_ATTACHMENT - 17, // 10 -> UNSUPPORTED_ATTACHMENT_TYPE_ATTACHMENT - 13, // 11 -> NO_ATTACHMENT_FOUND + 15, // 9 -> MEDIA_UNAVAILABLE_ATTACHMENT + 21, // 10 -> UNSUPPORTED_ATTACHMENT_TYPE_ATTACHMENT + 17, // 11 -> NO_ATTACHMENT_FOUND 5, // 12 -> FAILED_NO_SHARE_TARGET_ENDPOINT - 8, // 13 -> FAILED_PAIRED_KEYHANDSHAKE + 12, // 13 -> FAILED_PAIRED_KEYHANDSHAKE 7, // 14 -> FAILED_NULL_CONNECTION 4, // 15 -> FAILED_NO_PAYLOAD - 10, // 16 -> FAILED_WRITE_INTRODUCTION - 9, // 17 -> FAILED_UNKNOWN_REMOTE_RESPONSE + 14, // 16 -> FAILED_WRITE_INTRODUCTION + 13, // 17 -> FAILED_UNKNOWN_REMOTE_RESPONSE + 10, // 18 -> FAILED_NULL_CONNECTION_INIT_OUTGOING + 8, // 19 -> FAILED_NULL_CONNECTION_DISCONNECTED + 11, // 20 -> FAILED_NULL_CONNECTION_LOST_CONNECTIVITY + 9, // 21 -> FAILED_NULL_CONNECTION_FAILURE }; const std::string& AttachmentTransmissionStatus_Name( @@ -702,12 +738,12 @@ const std::string& AttachmentTransmissionStatus_Name( ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( AttachmentTransmissionStatus_entries, AttachmentTransmissionStatus_entries_by_number, - 18, AttachmentTransmissionStatus_strings); + 22, AttachmentTransmissionStatus_strings); (void) dummy; int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( AttachmentTransmissionStatus_entries, AttachmentTransmissionStatus_entries_by_number, - 18, value); + 22, value); return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : AttachmentTransmissionStatus_strings[idx].get(); } @@ -715,12 +751,131 @@ bool AttachmentTransmissionStatus_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AttachmentTransmissionStatus* value) { int int_value; bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( - AttachmentTransmissionStatus_entries, 18, name, &int_value); + AttachmentTransmissionStatus_entries, 22, name, &int_value); if (success) { *value = static_cast(int_value); } return success; } +bool ConnectionLayerStatus_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + case 14: + case 15: + case 16: + case 17: + case 18: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed ConnectionLayerStatus_strings[19] = {}; + +static const char ConnectionLayerStatus_names[] = + "CONNECTION_LAYER_STATUS_ALREADY_ADVERTISING" + "CONNECTION_LAYER_STATUS_ALREADY_CONNECTED_TO_END_POINT" + "CONNECTION_LAYER_STATUS_ALREADY_DISCOVERING" + "CONNECTION_LAYER_STATUS_ALREADY_HAVE_ACTIVE_STRATEGY" + "CONNECTION_LAYER_STATUS_ALREADY_LISTENING" + "CONNECTION_LAYER_STATUS_BLE_ERROR" + "CONNECTION_LAYER_STATUS_BLUETOOTH_ERROR" + "CONNECTION_LAYER_STATUS_CONNECTION_REJECTED" + "CONNECTION_LAYER_STATUS_END_POINT_IO_ERROR" + "CONNECTION_LAYER_STATUS_END_POINT_UNKNOWN" + "CONNECTION_LAYER_STATUS_ERROR" + "CONNECTION_LAYER_STATUS_NOT_CONNECTED_TO_END_POINT" + "CONNECTION_LAYER_STATUS_OUT_OF_ORDER_API_CALL" + "CONNECTION_LAYER_STATUS_PAYLOAD_UNKNOWN" + "CONNECTION_LAYER_STATUS_RESET" + "CONNECTION_LAYER_STATUS_SUCCESS" + "CONNECTION_LAYER_STATUS_TIMEOUT" + "CONNECTION_LAYER_STATUS_UNKNOWN" + "CONNECTION_LAYER_STATUS_WIFI_LAN_ERROR"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ConnectionLayerStatus_entries[] = { + { {ConnectionLayerStatus_names + 0, 43}, 5 }, + { {ConnectionLayerStatus_names + 43, 54}, 11 }, + { {ConnectionLayerStatus_names + 97, 43}, 6 }, + { {ConnectionLayerStatus_names + 140, 52}, 4 }, + { {ConnectionLayerStatus_names + 192, 41}, 7 }, + { {ConnectionLayerStatus_names + 233, 33}, 14 }, + { {ConnectionLayerStatus_names + 266, 39}, 13 }, + { {ConnectionLayerStatus_names + 305, 43}, 10 }, + { {ConnectionLayerStatus_names + 348, 42}, 8 }, + { {ConnectionLayerStatus_names + 390, 41}, 9 }, + { {ConnectionLayerStatus_names + 431, 29}, 2 }, + { {ConnectionLayerStatus_names + 460, 50}, 12 }, + { {ConnectionLayerStatus_names + 510, 45}, 3 }, + { {ConnectionLayerStatus_names + 555, 39}, 16 }, + { {ConnectionLayerStatus_names + 594, 29}, 17 }, + { {ConnectionLayerStatus_names + 623, 31}, 1 }, + { {ConnectionLayerStatus_names + 654, 31}, 18 }, + { {ConnectionLayerStatus_names + 685, 31}, 0 }, + { {ConnectionLayerStatus_names + 716, 38}, 15 }, +}; + +static const int ConnectionLayerStatus_entries_by_number[] = { + 17, // 0 -> CONNECTION_LAYER_STATUS_UNKNOWN + 15, // 1 -> CONNECTION_LAYER_STATUS_SUCCESS + 10, // 2 -> CONNECTION_LAYER_STATUS_ERROR + 12, // 3 -> CONNECTION_LAYER_STATUS_OUT_OF_ORDER_API_CALL + 3, // 4 -> CONNECTION_LAYER_STATUS_ALREADY_HAVE_ACTIVE_STRATEGY + 0, // 5 -> CONNECTION_LAYER_STATUS_ALREADY_ADVERTISING + 2, // 6 -> CONNECTION_LAYER_STATUS_ALREADY_DISCOVERING + 4, // 7 -> CONNECTION_LAYER_STATUS_ALREADY_LISTENING + 8, // 8 -> CONNECTION_LAYER_STATUS_END_POINT_IO_ERROR + 9, // 9 -> CONNECTION_LAYER_STATUS_END_POINT_UNKNOWN + 7, // 10 -> CONNECTION_LAYER_STATUS_CONNECTION_REJECTED + 1, // 11 -> CONNECTION_LAYER_STATUS_ALREADY_CONNECTED_TO_END_POINT + 11, // 12 -> CONNECTION_LAYER_STATUS_NOT_CONNECTED_TO_END_POINT + 6, // 13 -> CONNECTION_LAYER_STATUS_BLUETOOTH_ERROR + 5, // 14 -> CONNECTION_LAYER_STATUS_BLE_ERROR + 18, // 15 -> CONNECTION_LAYER_STATUS_WIFI_LAN_ERROR + 13, // 16 -> CONNECTION_LAYER_STATUS_PAYLOAD_UNKNOWN + 14, // 17 -> CONNECTION_LAYER_STATUS_RESET + 16, // 18 -> CONNECTION_LAYER_STATUS_TIMEOUT +}; + +const std::string& ConnectionLayerStatus_Name( + ConnectionLayerStatus value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + ConnectionLayerStatus_entries, + ConnectionLayerStatus_entries_by_number, + 19, ConnectionLayerStatus_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + ConnectionLayerStatus_entries, + ConnectionLayerStatus_entries_by_number, + 19, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + ConnectionLayerStatus_strings[idx].get(); +} +bool ConnectionLayerStatus_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionLayerStatus* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + ConnectionLayerStatus_entries, 19, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} bool ProcessReceivedAttachmentsStatus_IsValid(int value) { switch (value) { case 0: @@ -1328,6 +1483,168 @@ bool ServerResponseState_Parse( } return success; } +bool SyncPurpose_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + case 14: + case 15: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed SyncPurpose_strings[16] = {}; + +static const char SyncPurpose_names[] = + "SYNC_PURPOSE_ACCOUNT_CHANGE" + "SYNC_PURPOSE_CHECK_DEFAULT_OPT_IN" + "SYNC_PURPOSE_CHIME_NOTIFICATION" + "SYNC_PURPOSE_CONTACT_LIST_CHANGE" + "SYNC_PURPOSE_DAILY_SYNC" + "SYNC_PURPOSE_NEARBY_SHARE_ENABLED" + "SYNC_PURPOSE_ON_DEMAND_SYNC" + "SYNC_PURPOSE_OPT_IN_FIRST_SYNC" + "SYNC_PURPOSE_REGULAR_CHECK_CONTACT_REACHABILITY" + "SYNC_PURPOSE_SHOW_C11N_VIEW" + "SYNC_PURPOSE_SYNC_AT_ADVERTISEMENT" + "SYNC_PURPOSE_SYNC_AT_DISCOVERY" + "SYNC_PURPOSE_SYNC_AT_FAST_INIT" + "SYNC_PURPOSE_SYNC_AT_LOAD_PRIVATE_CERTIFICATE" + "SYNC_PURPOSE_UNKNOWN" + "SYNC_PURPOSE_VISIBILITY_SELECTED_CONTACT_CHANGE"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry SyncPurpose_entries[] = { + { {SyncPurpose_names + 0, 27}, 15 }, + { {SyncPurpose_names + 27, 33}, 5 }, + { {SyncPurpose_names + 60, 31}, 2 }, + { {SyncPurpose_names + 91, 32}, 11 }, + { {SyncPurpose_names + 123, 23}, 3 }, + { {SyncPurpose_names + 146, 33}, 6 }, + { {SyncPurpose_names + 179, 27}, 1 }, + { {SyncPurpose_names + 206, 30}, 4 }, + { {SyncPurpose_names + 236, 47}, 13 }, + { {SyncPurpose_names + 283, 27}, 12 }, + { {SyncPurpose_names + 310, 34}, 10 }, + { {SyncPurpose_names + 344, 30}, 8 }, + { {SyncPurpose_names + 374, 30}, 7 }, + { {SyncPurpose_names + 404, 45}, 9 }, + { {SyncPurpose_names + 449, 20}, 0 }, + { {SyncPurpose_names + 469, 47}, 14 }, +}; + +static const int SyncPurpose_entries_by_number[] = { + 14, // 0 -> SYNC_PURPOSE_UNKNOWN + 6, // 1 -> SYNC_PURPOSE_ON_DEMAND_SYNC + 2, // 2 -> SYNC_PURPOSE_CHIME_NOTIFICATION + 4, // 3 -> SYNC_PURPOSE_DAILY_SYNC + 7, // 4 -> SYNC_PURPOSE_OPT_IN_FIRST_SYNC + 1, // 5 -> SYNC_PURPOSE_CHECK_DEFAULT_OPT_IN + 5, // 6 -> SYNC_PURPOSE_NEARBY_SHARE_ENABLED + 12, // 7 -> SYNC_PURPOSE_SYNC_AT_FAST_INIT + 11, // 8 -> SYNC_PURPOSE_SYNC_AT_DISCOVERY + 13, // 9 -> SYNC_PURPOSE_SYNC_AT_LOAD_PRIVATE_CERTIFICATE + 10, // 10 -> SYNC_PURPOSE_SYNC_AT_ADVERTISEMENT + 3, // 11 -> SYNC_PURPOSE_CONTACT_LIST_CHANGE + 9, // 12 -> SYNC_PURPOSE_SHOW_C11N_VIEW + 8, // 13 -> SYNC_PURPOSE_REGULAR_CHECK_CONTACT_REACHABILITY + 15, // 14 -> SYNC_PURPOSE_VISIBILITY_SELECTED_CONTACT_CHANGE + 0, // 15 -> SYNC_PURPOSE_ACCOUNT_CHANGE +}; + +const std::string& SyncPurpose_Name( + SyncPurpose value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + SyncPurpose_entries, + SyncPurpose_entries_by_number, + 16, SyncPurpose_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + SyncPurpose_entries, + SyncPurpose_entries_by_number, + 16, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + SyncPurpose_strings[idx].get(); +} +bool SyncPurpose_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SyncPurpose* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + SyncPurpose_entries, 16, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +bool ClientRole_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed ClientRole_strings[3] = {}; + +static const char ClientRole_names[] = + "CLIENT_ROLE_RECEIVER" + "CLIENT_ROLE_SENDER" + "CLIENT_ROLE_UNKNOWN"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ClientRole_entries[] = { + { {ClientRole_names + 0, 20}, 2 }, + { {ClientRole_names + 20, 18}, 1 }, + { {ClientRole_names + 38, 19}, 0 }, +}; + +static const int ClientRole_entries_by_number[] = { + 2, // 0 -> CLIENT_ROLE_UNKNOWN + 1, // 1 -> CLIENT_ROLE_SENDER + 0, // 2 -> CLIENT_ROLE_RECEIVER +}; + +const std::string& ClientRole_Name( + ClientRole value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + ClientRole_entries, + ClientRole_entries_by_number, + 3, ClientRole_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + ClientRole_entries, + ClientRole_entries_by_number, + 3, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + ClientRole_strings[idx].get(); +} +bool ClientRole_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientRole* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + ClientRole_entries, 3, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} bool ScanType_IsValid(int value) { switch (value) { case 0: @@ -1391,6 +1708,61 @@ bool ScanType_Parse( } return success; } +bool ParsingFailedType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed ParsingFailedType_strings[3] = {}; + +static const char ParsingFailedType_names[] = + "FAILED_CONVERT_SHARE_TARGET" + "FAILED_PARSE_ADVERTISEMENT" + "FAILED_UNKNOWN_TYPE"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ParsingFailedType_entries[] = { + { {ParsingFailedType_names + 0, 27}, 2 }, + { {ParsingFailedType_names + 27, 26}, 1 }, + { {ParsingFailedType_names + 53, 19}, 0 }, +}; + +static const int ParsingFailedType_entries_by_number[] = { + 2, // 0 -> FAILED_UNKNOWN_TYPE + 1, // 1 -> FAILED_PARSE_ADVERTISEMENT + 0, // 2 -> FAILED_CONVERT_SHARE_TARGET +}; + +const std::string& ParsingFailedType_Name( + ParsingFailedType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + ParsingFailedType_entries, + ParsingFailedType_entries_by_number, + 3, ParsingFailedType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + ParsingFailedType_entries, + ParsingFailedType_entries_by_number, + 3, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + ParsingFailedType_strings[idx].get(); +} +bool ParsingFailedType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ParsingFailedType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + ParsingFailedType_entries, 3, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} bool AdvertisingMode_IsValid(int value) { switch (value) { case 0: @@ -2348,6 +2720,341 @@ bool PreferencesActionStatus_Parse( } return success; } +bool FastInitState_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed FastInitState_strings[4] = {}; + +static const char FastInitState_names[] = + "FAST_INIT_CLOSE_STATE" + "FAST_INIT_FAR_STATE" + "FAST_INIT_LOST_STATE" + "FAST_INIT_UNKNOWN_STATE"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry FastInitState_entries[] = { + { {FastInitState_names + 0, 21}, 1 }, + { {FastInitState_names + 21, 19}, 2 }, + { {FastInitState_names + 40, 20}, 3 }, + { {FastInitState_names + 60, 23}, 0 }, +}; + +static const int FastInitState_entries_by_number[] = { + 3, // 0 -> FAST_INIT_UNKNOWN_STATE + 0, // 1 -> FAST_INIT_CLOSE_STATE + 1, // 2 -> FAST_INIT_FAR_STATE + 2, // 3 -> FAST_INIT_LOST_STATE +}; + +const std::string& FastInitState_Name( + FastInitState value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + FastInitState_entries, + FastInitState_entries_by_number, + 4, FastInitState_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + FastInitState_entries, + FastInitState_entries_by_number, + 4, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + FastInitState_strings[idx].get(); +} +bool FastInitState_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FastInitState* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + FastInitState_entries, 4, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +bool FastInitType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed FastInitType_strings[3] = {}; + +static const char FastInitType_names[] = + "FAST_INIT_NOTIFY_TYPE" + "FAST_INIT_SILENT_TYPE" + "FAST_INIT_UNKNOWN_TYPE"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry FastInitType_entries[] = { + { {FastInitType_names + 0, 21}, 1 }, + { {FastInitType_names + 21, 21}, 2 }, + { {FastInitType_names + 42, 22}, 0 }, +}; + +static const int FastInitType_entries_by_number[] = { + 2, // 0 -> FAST_INIT_UNKNOWN_TYPE + 0, // 1 -> FAST_INIT_NOTIFY_TYPE + 1, // 2 -> FAST_INIT_SILENT_TYPE +}; + +const std::string& FastInitType_Name( + FastInitType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + FastInitType_entries, + FastInitType_entries_by_number, + 3, FastInitType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + FastInitType_entries, + FastInitType_entries_by_number, + 3, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + FastInitType_strings[idx].get(); +} +bool FastInitType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FastInitType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + FastInitType_entries, 3, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +bool DesktopNotification_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed DesktopNotification_strings[6] = {}; + +static const char DesktopNotification_names[] = + "DESKTOP_NOTIFICATION_ACCEPT" + "DESKTOP_NOTIFICATION_CONNECTING" + "DESKTOP_NOTIFICATION_ERROR" + "DESKTOP_NOTIFICATION_PROGRESS" + "DESKTOP_NOTIFICATION_RECEIVED" + "DESKTOP_NOTIFICATION_UNKNOWN"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DesktopNotification_entries[] = { + { {DesktopNotification_names + 0, 27}, 3 }, + { {DesktopNotification_names + 27, 31}, 1 }, + { {DesktopNotification_names + 58, 26}, 5 }, + { {DesktopNotification_names + 84, 29}, 2 }, + { {DesktopNotification_names + 113, 29}, 4 }, + { {DesktopNotification_names + 142, 28}, 0 }, +}; + +static const int DesktopNotification_entries_by_number[] = { + 5, // 0 -> DESKTOP_NOTIFICATION_UNKNOWN + 1, // 1 -> DESKTOP_NOTIFICATION_CONNECTING + 3, // 2 -> DESKTOP_NOTIFICATION_PROGRESS + 0, // 3 -> DESKTOP_NOTIFICATION_ACCEPT + 4, // 4 -> DESKTOP_NOTIFICATION_RECEIVED + 2, // 5 -> DESKTOP_NOTIFICATION_ERROR +}; + +const std::string& DesktopNotification_Name( + DesktopNotification value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + DesktopNotification_entries, + DesktopNotification_entries_by_number, + 6, DesktopNotification_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + DesktopNotification_entries, + DesktopNotification_entries_by_number, + 6, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + DesktopNotification_strings[idx].get(); +} +bool DesktopNotification_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DesktopNotification* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + DesktopNotification_entries, 6, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +bool DesktopTransferEventType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed DesktopTransferEventType_strings[10] = {}; + +static const char DesktopTransferEventType_names[] = + "DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_ACCEPT" + "DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_ERROR" + "DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_PROGRESS" + "DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_RECEIVED" + "DESKTOP_TRANSFER_EVENT_SEND_TYPE_ERROR" + "DESKTOP_TRANSFER_EVENT_SEND_TYPE_PROGRESS" + "DESKTOP_TRANSFER_EVENT_SEND_TYPE_SELECT_A_DEVICE" + "DESKTOP_TRANSFER_EVENT_SEND_TYPE_SENT" + "DESKTOP_TRANSFER_EVENT_SEND_TYPE_START" + "DESKTOP_TRANSFER_EVENT_TYPE_UNKNOWN"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DesktopTransferEventType_entries[] = { + { {DesktopTransferEventType_names + 0, 42}, 1 }, + { {DesktopTransferEventType_names + 42, 41}, 4 }, + { {DesktopTransferEventType_names + 83, 44}, 2 }, + { {DesktopTransferEventType_names + 127, 44}, 3 }, + { {DesktopTransferEventType_names + 171, 38}, 9 }, + { {DesktopTransferEventType_names + 209, 41}, 7 }, + { {DesktopTransferEventType_names + 250, 48}, 6 }, + { {DesktopTransferEventType_names + 298, 37}, 8 }, + { {DesktopTransferEventType_names + 335, 38}, 5 }, + { {DesktopTransferEventType_names + 373, 35}, 0 }, +}; + +static const int DesktopTransferEventType_entries_by_number[] = { + 9, // 0 -> DESKTOP_TRANSFER_EVENT_TYPE_UNKNOWN + 0, // 1 -> DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_ACCEPT + 2, // 2 -> DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_PROGRESS + 3, // 3 -> DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_RECEIVED + 1, // 4 -> DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_ERROR + 8, // 5 -> DESKTOP_TRANSFER_EVENT_SEND_TYPE_START + 6, // 6 -> DESKTOP_TRANSFER_EVENT_SEND_TYPE_SELECT_A_DEVICE + 5, // 7 -> DESKTOP_TRANSFER_EVENT_SEND_TYPE_PROGRESS + 7, // 8 -> DESKTOP_TRANSFER_EVENT_SEND_TYPE_SENT + 4, // 9 -> DESKTOP_TRANSFER_EVENT_SEND_TYPE_ERROR +}; + +const std::string& DesktopTransferEventType_Name( + DesktopTransferEventType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + DesktopTransferEventType_entries, + DesktopTransferEventType_entries_by_number, + 10, DesktopTransferEventType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + DesktopTransferEventType_entries, + DesktopTransferEventType_entries_by_number, + 10, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + DesktopTransferEventType_strings[idx].get(); +} +bool DesktopTransferEventType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DesktopTransferEventType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + DesktopTransferEventType_entries, 10, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +bool DecryptCertificateFailureStatus_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed DecryptCertificateFailureStatus_strings[7] = {}; + +static const char DecryptCertificateFailureStatus_names[] = + "DECRYPT_CERT_BAD_PADDING_FAILURE" + "DECRYPT_CERT_ILLEGAL_BLOCK_SIZE_FAILURE" + "DECRYPT_CERT_INVALID_ALGORITHM_PARAMETER_FAILURE" + "DECRYPT_CERT_INVALID_KEY_FAILURE" + "DECRYPT_CERT_NO_SUCH_ALGORITHM_FAILURE" + "DECRYPT_CERT_NO_SUCH_PADDING_FAILURE" + "DECRYPT_CERT_UNKNOWN_FAILURE"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DecryptCertificateFailureStatus_entries[] = { + { {DecryptCertificateFailureStatus_names + 0, 32}, 6 }, + { {DecryptCertificateFailureStatus_names + 32, 39}, 5 }, + { {DecryptCertificateFailureStatus_names + 71, 48}, 4 }, + { {DecryptCertificateFailureStatus_names + 119, 32}, 3 }, + { {DecryptCertificateFailureStatus_names + 151, 38}, 1 }, + { {DecryptCertificateFailureStatus_names + 189, 36}, 2 }, + { {DecryptCertificateFailureStatus_names + 225, 28}, 0 }, +}; + +static const int DecryptCertificateFailureStatus_entries_by_number[] = { + 6, // 0 -> DECRYPT_CERT_UNKNOWN_FAILURE + 4, // 1 -> DECRYPT_CERT_NO_SUCH_ALGORITHM_FAILURE + 5, // 2 -> DECRYPT_CERT_NO_SUCH_PADDING_FAILURE + 3, // 3 -> DECRYPT_CERT_INVALID_KEY_FAILURE + 2, // 4 -> DECRYPT_CERT_INVALID_ALGORITHM_PARAMETER_FAILURE + 1, // 5 -> DECRYPT_CERT_ILLEGAL_BLOCK_SIZE_FAILURE + 0, // 6 -> DECRYPT_CERT_BAD_PADDING_FAILURE +}; + +const std::string& DecryptCertificateFailureStatus_Name( + DecryptCertificateFailureStatus value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + DecryptCertificateFailureStatus_entries, + DecryptCertificateFailureStatus_entries_by_number, + 7, DecryptCertificateFailureStatus_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + DecryptCertificateFailureStatus_entries, + DecryptCertificateFailureStatus_entries_by_number, + 7, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + DecryptCertificateFailureStatus_strings[idx].get(); +} +bool DecryptCertificateFailureStatus_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DecryptCertificateFailureStatus* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + DecryptCertificateFailureStatus_entries, 7, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} // @@protoc_insertion_point(namespace_scope) } // namespace sharing diff --git a/compiled_proto/proto/sharing_enums.pb.h b/compiled_proto/proto/sharing_enums.pb.h index 21e0a4b7..6bf8b7c6 100644 --- a/compiled_proto/proto/sharing_enums.pb.h +++ b/compiled_proto/proto/sharing_enums.pb.h @@ -117,11 +117,16 @@ enum EventType : int { DEFAULT_OPT_IN = 56, SETUP_WIZARD = 57, TAP_QR_CODE = 58, - QR_CODE_LINK_SHOWN = 59 + QR_CODE_LINK_SHOWN = 59, + PARSING_FAILED_ENDPOINT_ID = 60, + FAST_INIT_DISCOVER_DEVICE = 61, + SEND_DESKTOP_NOTIFICATION = 62, + SET_ACCOUNT = 63, + DECRYPT_CERTIFICATE_FAILURE = 64 }; bool EventType_IsValid(int value); constexpr EventType EventType_MIN = UNKNOWN_EVENT_TYPE; -constexpr EventType EventType_MAX = QR_CODE_LINK_SHOWN; +constexpr EventType EventType_MAX = DECRYPT_CERTIFICATE_FAILURE; constexpr int EventType_ARRAYSIZE = EventType_MAX + 1; const std::string& EventType_Name(EventType value); @@ -258,11 +263,15 @@ enum AttachmentTransmissionStatus : int { FAILED_NULL_CONNECTION = 14, FAILED_NO_PAYLOAD = 15, FAILED_WRITE_INTRODUCTION = 16, - FAILED_UNKNOWN_REMOTE_RESPONSE = 17 + FAILED_UNKNOWN_REMOTE_RESPONSE = 17, + FAILED_NULL_CONNECTION_INIT_OUTGOING = 18, + FAILED_NULL_CONNECTION_DISCONNECTED = 19, + FAILED_NULL_CONNECTION_LOST_CONNECTIVITY = 20, + FAILED_NULL_CONNECTION_FAILURE = 21 }; bool AttachmentTransmissionStatus_IsValid(int value); constexpr AttachmentTransmissionStatus AttachmentTransmissionStatus_MIN = UNKNOWN_ATTACHMENT_TRANSMISSION_STATUS; -constexpr AttachmentTransmissionStatus AttachmentTransmissionStatus_MAX = FAILED_UNKNOWN_REMOTE_RESPONSE; +constexpr AttachmentTransmissionStatus AttachmentTransmissionStatus_MAX = FAILED_NULL_CONNECTION_FAILURE; constexpr int AttachmentTransmissionStatus_ARRAYSIZE = AttachmentTransmissionStatus_MAX + 1; const std::string& AttachmentTransmissionStatus_Name(AttachmentTransmissionStatus value); @@ -275,6 +284,42 @@ inline const std::string& AttachmentTransmissionStatus_Name(T enum_t_value) { } bool AttachmentTransmissionStatus_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AttachmentTransmissionStatus* value); +enum ConnectionLayerStatus : int { + CONNECTION_LAYER_STATUS_UNKNOWN = 0, + CONNECTION_LAYER_STATUS_SUCCESS = 1, + CONNECTION_LAYER_STATUS_ERROR = 2, + CONNECTION_LAYER_STATUS_OUT_OF_ORDER_API_CALL = 3, + CONNECTION_LAYER_STATUS_ALREADY_HAVE_ACTIVE_STRATEGY = 4, + CONNECTION_LAYER_STATUS_ALREADY_ADVERTISING = 5, + CONNECTION_LAYER_STATUS_ALREADY_DISCOVERING = 6, + CONNECTION_LAYER_STATUS_ALREADY_LISTENING = 7, + CONNECTION_LAYER_STATUS_END_POINT_IO_ERROR = 8, + CONNECTION_LAYER_STATUS_END_POINT_UNKNOWN = 9, + CONNECTION_LAYER_STATUS_CONNECTION_REJECTED = 10, + CONNECTION_LAYER_STATUS_ALREADY_CONNECTED_TO_END_POINT = 11, + CONNECTION_LAYER_STATUS_NOT_CONNECTED_TO_END_POINT = 12, + CONNECTION_LAYER_STATUS_BLUETOOTH_ERROR = 13, + CONNECTION_LAYER_STATUS_BLE_ERROR = 14, + CONNECTION_LAYER_STATUS_WIFI_LAN_ERROR = 15, + CONNECTION_LAYER_STATUS_PAYLOAD_UNKNOWN = 16, + CONNECTION_LAYER_STATUS_RESET = 17, + CONNECTION_LAYER_STATUS_TIMEOUT = 18 +}; +bool ConnectionLayerStatus_IsValid(int value); +constexpr ConnectionLayerStatus ConnectionLayerStatus_MIN = CONNECTION_LAYER_STATUS_UNKNOWN; +constexpr ConnectionLayerStatus ConnectionLayerStatus_MAX = CONNECTION_LAYER_STATUS_TIMEOUT; +constexpr int ConnectionLayerStatus_ARRAYSIZE = ConnectionLayerStatus_MAX + 1; + +const std::string& ConnectionLayerStatus_Name(ConnectionLayerStatus value); +template +inline const std::string& ConnectionLayerStatus_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ConnectionLayerStatus_Name."); + return ConnectionLayerStatus_Name(static_cast(enum_t_value)); +} +bool ConnectionLayerStatus_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionLayerStatus* value); enum ProcessReceivedAttachmentsStatus : int { PROCESSING_STATUS_UNKNOWN = 0, PROCESSING_STATUS_COMPLETE_PROCESSING_ATTACHMENTS = 1, @@ -483,6 +528,59 @@ inline const std::string& ServerResponseState_Name(T enum_t_value) { } bool ServerResponseState_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ServerResponseState* value); +enum SyncPurpose : int { + SYNC_PURPOSE_UNKNOWN = 0, + SYNC_PURPOSE_ON_DEMAND_SYNC = 1, + SYNC_PURPOSE_CHIME_NOTIFICATION = 2, + SYNC_PURPOSE_DAILY_SYNC = 3, + SYNC_PURPOSE_OPT_IN_FIRST_SYNC = 4, + SYNC_PURPOSE_CHECK_DEFAULT_OPT_IN = 5, + SYNC_PURPOSE_NEARBY_SHARE_ENABLED = 6, + SYNC_PURPOSE_SYNC_AT_FAST_INIT = 7, + SYNC_PURPOSE_SYNC_AT_DISCOVERY = 8, + SYNC_PURPOSE_SYNC_AT_LOAD_PRIVATE_CERTIFICATE = 9, + SYNC_PURPOSE_SYNC_AT_ADVERTISEMENT = 10, + SYNC_PURPOSE_CONTACT_LIST_CHANGE = 11, + SYNC_PURPOSE_SHOW_C11N_VIEW = 12, + SYNC_PURPOSE_REGULAR_CHECK_CONTACT_REACHABILITY = 13, + SYNC_PURPOSE_VISIBILITY_SELECTED_CONTACT_CHANGE = 14, + SYNC_PURPOSE_ACCOUNT_CHANGE = 15 +}; +bool SyncPurpose_IsValid(int value); +constexpr SyncPurpose SyncPurpose_MIN = SYNC_PURPOSE_UNKNOWN; +constexpr SyncPurpose SyncPurpose_MAX = SYNC_PURPOSE_ACCOUNT_CHANGE; +constexpr int SyncPurpose_ARRAYSIZE = SyncPurpose_MAX + 1; + +const std::string& SyncPurpose_Name(SyncPurpose value); +template +inline const std::string& SyncPurpose_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SyncPurpose_Name."); + return SyncPurpose_Name(static_cast(enum_t_value)); +} +bool SyncPurpose_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SyncPurpose* value); +enum ClientRole : int { + CLIENT_ROLE_UNKNOWN = 0, + CLIENT_ROLE_SENDER = 1, + CLIENT_ROLE_RECEIVER = 2 +}; +bool ClientRole_IsValid(int value); +constexpr ClientRole ClientRole_MIN = CLIENT_ROLE_UNKNOWN; +constexpr ClientRole ClientRole_MAX = CLIENT_ROLE_RECEIVER; +constexpr int ClientRole_ARRAYSIZE = ClientRole_MAX + 1; + +const std::string& ClientRole_Name(ClientRole value); +template +inline const std::string& ClientRole_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ClientRole_Name."); + return ClientRole_Name(static_cast(enum_t_value)); +} +bool ClientRole_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientRole* value); enum ScanType : int { UNKNOWN_SCAN_TYPE = 0, FOREGROUND_SCAN = 1, @@ -505,6 +603,26 @@ inline const std::string& ScanType_Name(T enum_t_value) { } bool ScanType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ScanType* value); +enum ParsingFailedType : int { + FAILED_UNKNOWN_TYPE = 0, + FAILED_PARSE_ADVERTISEMENT = 1, + FAILED_CONVERT_SHARE_TARGET = 2 +}; +bool ParsingFailedType_IsValid(int value); +constexpr ParsingFailedType ParsingFailedType_MIN = FAILED_UNKNOWN_TYPE; +constexpr ParsingFailedType ParsingFailedType_MAX = FAILED_CONVERT_SHARE_TARGET; +constexpr int ParsingFailedType_ARRAYSIZE = ParsingFailedType_MAX + 1; + +const std::string& ParsingFailedType_Name(ParsingFailedType value); +template +inline const std::string& ParsingFailedType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ParsingFailedType_Name."); + return ParsingFailedType_Name(static_cast(enum_t_value)); +} +bool ParsingFailedType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ParsingFailedType* value); enum AdvertisingMode : int { UNKNOWN_ADVERTISING_MODE = 0, SCREEN_OFF_ADVERTISING_MODE = 1, @@ -838,6 +956,121 @@ inline const std::string& PreferencesActionStatus_Name(T enum_t_value) { } bool PreferencesActionStatus_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PreferencesActionStatus* value); +enum FastInitState : int { + FAST_INIT_UNKNOWN_STATE = 0, + FAST_INIT_CLOSE_STATE = 1, + FAST_INIT_FAR_STATE = 2, + FAST_INIT_LOST_STATE = 3 +}; +bool FastInitState_IsValid(int value); +constexpr FastInitState FastInitState_MIN = FAST_INIT_UNKNOWN_STATE; +constexpr FastInitState FastInitState_MAX = FAST_INIT_LOST_STATE; +constexpr int FastInitState_ARRAYSIZE = FastInitState_MAX + 1; + +const std::string& FastInitState_Name(FastInitState value); +template +inline const std::string& FastInitState_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function FastInitState_Name."); + return FastInitState_Name(static_cast(enum_t_value)); +} +bool FastInitState_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FastInitState* value); +enum FastInitType : int { + FAST_INIT_UNKNOWN_TYPE = 0, + FAST_INIT_NOTIFY_TYPE = 1, + FAST_INIT_SILENT_TYPE = 2 +}; +bool FastInitType_IsValid(int value); +constexpr FastInitType FastInitType_MIN = FAST_INIT_UNKNOWN_TYPE; +constexpr FastInitType FastInitType_MAX = FAST_INIT_SILENT_TYPE; +constexpr int FastInitType_ARRAYSIZE = FastInitType_MAX + 1; + +const std::string& FastInitType_Name(FastInitType value); +template +inline const std::string& FastInitType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function FastInitType_Name."); + return FastInitType_Name(static_cast(enum_t_value)); +} +bool FastInitType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FastInitType* value); +enum DesktopNotification : int { + DESKTOP_NOTIFICATION_UNKNOWN = 0, + DESKTOP_NOTIFICATION_CONNECTING = 1, + DESKTOP_NOTIFICATION_PROGRESS = 2, + DESKTOP_NOTIFICATION_ACCEPT = 3, + DESKTOP_NOTIFICATION_RECEIVED = 4, + DESKTOP_NOTIFICATION_ERROR = 5 +}; +bool DesktopNotification_IsValid(int value); +constexpr DesktopNotification DesktopNotification_MIN = DESKTOP_NOTIFICATION_UNKNOWN; +constexpr DesktopNotification DesktopNotification_MAX = DESKTOP_NOTIFICATION_ERROR; +constexpr int DesktopNotification_ARRAYSIZE = DesktopNotification_MAX + 1; + +const std::string& DesktopNotification_Name(DesktopNotification value); +template +inline const std::string& DesktopNotification_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DesktopNotification_Name."); + return DesktopNotification_Name(static_cast(enum_t_value)); +} +bool DesktopNotification_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DesktopNotification* value); +enum DesktopTransferEventType : int { + DESKTOP_TRANSFER_EVENT_TYPE_UNKNOWN = 0, + DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_ACCEPT = 1, + DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_PROGRESS = 2, + DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_RECEIVED = 3, + DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_ERROR = 4, + DESKTOP_TRANSFER_EVENT_SEND_TYPE_START = 5, + DESKTOP_TRANSFER_EVENT_SEND_TYPE_SELECT_A_DEVICE = 6, + DESKTOP_TRANSFER_EVENT_SEND_TYPE_PROGRESS = 7, + DESKTOP_TRANSFER_EVENT_SEND_TYPE_SENT = 8, + DESKTOP_TRANSFER_EVENT_SEND_TYPE_ERROR = 9 +}; +bool DesktopTransferEventType_IsValid(int value); +constexpr DesktopTransferEventType DesktopTransferEventType_MIN = DESKTOP_TRANSFER_EVENT_TYPE_UNKNOWN; +constexpr DesktopTransferEventType DesktopTransferEventType_MAX = DESKTOP_TRANSFER_EVENT_SEND_TYPE_ERROR; +constexpr int DesktopTransferEventType_ARRAYSIZE = DesktopTransferEventType_MAX + 1; + +const std::string& DesktopTransferEventType_Name(DesktopTransferEventType value); +template +inline const std::string& DesktopTransferEventType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DesktopTransferEventType_Name."); + return DesktopTransferEventType_Name(static_cast(enum_t_value)); +} +bool DesktopTransferEventType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DesktopTransferEventType* value); +enum DecryptCertificateFailureStatus : int { + DECRYPT_CERT_UNKNOWN_FAILURE = 0, + DECRYPT_CERT_NO_SUCH_ALGORITHM_FAILURE = 1, + DECRYPT_CERT_NO_SUCH_PADDING_FAILURE = 2, + DECRYPT_CERT_INVALID_KEY_FAILURE = 3, + DECRYPT_CERT_INVALID_ALGORITHM_PARAMETER_FAILURE = 4, + DECRYPT_CERT_ILLEGAL_BLOCK_SIZE_FAILURE = 5, + DECRYPT_CERT_BAD_PADDING_FAILURE = 6 +}; +bool DecryptCertificateFailureStatus_IsValid(int value); +constexpr DecryptCertificateFailureStatus DecryptCertificateFailureStatus_MIN = DECRYPT_CERT_UNKNOWN_FAILURE; +constexpr DecryptCertificateFailureStatus DecryptCertificateFailureStatus_MAX = DECRYPT_CERT_BAD_PADDING_FAILURE; +constexpr int DecryptCertificateFailureStatus_ARRAYSIZE = DecryptCertificateFailureStatus_MAX + 1; + +const std::string& DecryptCertificateFailureStatus_Name(DecryptCertificateFailureStatus value); +template +inline const std::string& DecryptCertificateFailureStatus_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DecryptCertificateFailureStatus_Name."); + return DecryptCertificateFailureStatus_Name(static_cast(enum_t_value)); +} +bool DecryptCertificateFailureStatus_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DecryptCertificateFailureStatus* value); // =================================================================== @@ -870,6 +1103,7 @@ template <> struct is_proto_enum< ::location::nearby::proto::sharing::Visibility template <> struct is_proto_enum< ::location::nearby::proto::sharing::DataUsage> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::sharing::EstablishConnectionStatus> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::sharing::AttachmentTransmissionStatus> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::proto::sharing::ConnectionLayerStatus> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::sharing::ProcessReceivedAttachmentsStatus> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::sharing::SessionStatus> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::sharing::ResponseToIntroduction> : ::std::true_type {}; @@ -879,7 +1113,10 @@ template <> struct is_proto_enum< ::location::nearby::proto::sharing::DeviceRela template <> struct is_proto_enum< ::location::nearby::proto::sharing::LogSource> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::sharing::ServerActionName> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::sharing::ServerResponseState> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::proto::sharing::SyncPurpose> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::proto::sharing::ClientRole> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::sharing::ScanType> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::proto::sharing::ParsingFailedType> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::sharing::AdvertisingMode> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::sharing::ActivityName> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::sharing::ConsentType> : ::std::true_type {}; @@ -895,6 +1132,11 @@ template <> struct is_proto_enum< ::location::nearby::proto::sharing::AppCrashRe template <> struct is_proto_enum< ::location::nearby::proto::sharing::AttachmentSourceType> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::sharing::PreferencesAction> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::sharing::PreferencesActionStatus> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::proto::sharing::FastInitState> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::proto::sharing::FastInitType> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::proto::sharing::DesktopNotification> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::proto::sharing::DesktopTransferEventType> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::proto::sharing::DecryptCertificateFailureStatus> : ::std::true_type {}; PROTOBUF_NAMESPACE_CLOSE