From 733a483ee232716bd27c726d972b77f074d019dc Mon Sep 17 00:00:00 2001 From: Anay Wadhera Date: Thu, 4 Jan 2024 22:35:59 -0800 Subject: [PATCH] Update compiled_proto --- .../proto/offline_wire_formats.pb.cc | 464 ++++++++- .../proto/offline_wire_formats.pb.h | 489 ++++++++- .../proto/analytics/connections_log.pb.cc | 224 ++++- .../proto/analytics/connections_log.pb.h | 230 ++++- compiled_proto/proto/connections_enums.pb.cc | 932 +++++++++--------- compiled_proto/proto/connections_enums.pb.h | 35 +- 6 files changed, 1799 insertions(+), 575 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 7e041c19..fc18ba66 100644 --- a/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.cc +++ b/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.cc @@ -43,6 +43,7 @@ constexpr V1Frame::V1Frame( , authentication_result_(nullptr) , auto_resume_(nullptr) , auto_reconnect_(nullptr) + , bandwidth_upgrade_retry_(nullptr) , type_(0) {} struct V1FrameDefaultTypeInternal { @@ -306,6 +307,19 @@ struct BandwidthUpgradeNegotiationFrameDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BandwidthUpgradeNegotiationFrameDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_default_instance_; +constexpr BandwidthUpgradeRetryFrame::BandwidthUpgradeRetryFrame( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : supported_medium_() + , is_request_(false){} +struct BandwidthUpgradeRetryFrameDefaultTypeInternal { + constexpr BandwidthUpgradeRetryFrameDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~BandwidthUpgradeRetryFrameDefaultTypeInternal() {} + union { + BandwidthUpgradeRetryFrame _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BandwidthUpgradeRetryFrameDefaultTypeInternal _BandwidthUpgradeRetryFrame_default_instance_; constexpr KeepAliveFrame::KeepAliveFrame( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : ack_(false) @@ -642,13 +656,14 @@ bool V1Frame_FrameType_IsValid(int value) { case 9: case 10: case 11: + case 12: return true; default: return false; } } -static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed V1Frame_FrameType_strings[12] = {}; +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed V1Frame_FrameType_strings[13] = {}; static const char V1Frame_FrameType_names[] = "AUTHENTICATION_MESSAGE" @@ -656,6 +671,7 @@ static const char V1Frame_FrameType_names[] = "AUTO_RECONNECT" "AUTO_RESUME" "BANDWIDTH_UPGRADE_NEGOTIATION" + "BANDWIDTH_UPGRADE_RETRY" "CONNECTION_REQUEST" "CONNECTION_RESPONSE" "DISCONNECTION" @@ -670,28 +686,30 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry V1Frame_FrameType_entr { {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 }, + { {V1Frame_FrameType_names + 97, 23}, 12 }, + { {V1Frame_FrameType_names + 120, 18}, 1 }, + { {V1Frame_FrameType_names + 138, 19}, 2 }, + { {V1Frame_FrameType_names + 157, 13}, 6 }, + { {V1Frame_FrameType_names + 170, 10}, 5 }, + { {V1Frame_FrameType_names + 180, 21}, 7 }, + { {V1Frame_FrameType_names + 201, 16}, 3 }, + { {V1Frame_FrameType_names + 217, 18}, 0 }, }; static const int V1Frame_FrameType_entries_by_number[] = { - 11, // 0 -> UNKNOWN_FRAME_TYPE - 5, // 1 -> CONNECTION_REQUEST - 6, // 2 -> CONNECTION_RESPONSE - 10, // 3 -> PAYLOAD_TRANSFER + 12, // 0 -> UNKNOWN_FRAME_TYPE + 6, // 1 -> CONNECTION_REQUEST + 7, // 2 -> CONNECTION_RESPONSE + 11, // 3 -> PAYLOAD_TRANSFER 4, // 4 -> BANDWIDTH_UPGRADE_NEGOTIATION - 8, // 5 -> KEEP_ALIVE - 7, // 6 -> DISCONNECTION - 9, // 7 -> PAIRED_KEY_ENCRYPTION + 9, // 5 -> KEEP_ALIVE + 8, // 6 -> DISCONNECTION + 10, // 7 -> PAIRED_KEY_ENCRYPTION 0, // 8 -> AUTHENTICATION_MESSAGE 1, // 9 -> AUTHENTICATION_RESULT 3, // 10 -> AUTO_RESUME 2, // 11 -> AUTO_RECONNECT + 5, // 12 -> BANDWIDTH_UPGRADE_RETRY }; const std::string& V1Frame_FrameType_Name( @@ -700,12 +718,12 @@ const std::string& V1Frame_FrameType_Name( ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( V1Frame_FrameType_entries, V1Frame_FrameType_entries_by_number, - 12, V1Frame_FrameType_strings); + 13, V1Frame_FrameType_strings); (void) dummy; int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( V1Frame_FrameType_entries, V1Frame_FrameType_entries_by_number, - 12, value); + 13, value); return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : V1Frame_FrameType_strings[idx].get(); } @@ -713,7 +731,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, 12, name, &int_value); + V1Frame_FrameType_entries, 13, name, &int_value); if (success) { *value = static_cast(int_value); } @@ -732,6 +750,7 @@ 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::BANDWIDTH_UPGRADE_RETRY; constexpr V1Frame_FrameType V1Frame::FrameType_MIN; constexpr V1Frame_FrameType V1Frame::FrameType_MAX; constexpr int V1Frame::FrameType_ARRAYSIZE; @@ -1101,29 +1120,33 @@ bool PayloadTransferFrame_PacketType_IsValid(int value) { case 0: case 1: case 2: + case 3: return true; default: return false; } } -static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed PayloadTransferFrame_PacketType_strings[3] = {}; +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed PayloadTransferFrame_PacketType_strings[4] = {}; static const char PayloadTransferFrame_PacketType_names[] = "CONTROL" "DATA" + "PAYLOAD_ACK" "UNKNOWN_PACKET_TYPE"; static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry PayloadTransferFrame_PacketType_entries[] = { { {PayloadTransferFrame_PacketType_names + 0, 7}, 2 }, { {PayloadTransferFrame_PacketType_names + 7, 4}, 1 }, - { {PayloadTransferFrame_PacketType_names + 11, 19}, 0 }, + { {PayloadTransferFrame_PacketType_names + 11, 11}, 3 }, + { {PayloadTransferFrame_PacketType_names + 22, 19}, 0 }, }; static const int PayloadTransferFrame_PacketType_entries_by_number[] = { - 2, // 0 -> UNKNOWN_PACKET_TYPE + 3, // 0 -> UNKNOWN_PACKET_TYPE 1, // 1 -> DATA 0, // 2 -> CONTROL + 2, // 3 -> PAYLOAD_ACK }; const std::string& PayloadTransferFrame_PacketType_Name( @@ -1132,12 +1155,12 @@ const std::string& PayloadTransferFrame_PacketType_Name( ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( PayloadTransferFrame_PacketType_entries, PayloadTransferFrame_PacketType_entries_by_number, - 3, PayloadTransferFrame_PacketType_strings); + 4, PayloadTransferFrame_PacketType_strings); (void) dummy; int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( PayloadTransferFrame_PacketType_entries, PayloadTransferFrame_PacketType_entries_by_number, - 3, value); + 4, value); return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : PayloadTransferFrame_PacketType_strings[idx].get(); } @@ -1145,7 +1168,7 @@ bool PayloadTransferFrame_PacketType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PayloadTransferFrame_PacketType* value) { int int_value; bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( - PayloadTransferFrame_PacketType_entries, 3, name, &int_value); + PayloadTransferFrame_PacketType_entries, 4, name, &int_value); if (success) { *value = static_cast(int_value); } @@ -1155,6 +1178,7 @@ bool PayloadTransferFrame_PacketType_Parse( constexpr PayloadTransferFrame_PacketType PayloadTransferFrame::UNKNOWN_PACKET_TYPE; constexpr PayloadTransferFrame_PacketType PayloadTransferFrame::DATA; constexpr PayloadTransferFrame_PacketType PayloadTransferFrame::CONTROL; +constexpr PayloadTransferFrame_PacketType PayloadTransferFrame::PAYLOAD_ACK; constexpr PayloadTransferFrame_PacketType PayloadTransferFrame::PacketType_MIN; constexpr PayloadTransferFrame_PacketType PayloadTransferFrame::PacketType_MAX; constexpr int PayloadTransferFrame::PacketType_ARRAYSIZE; @@ -1345,6 +1369,109 @@ 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 BandwidthUpgradeRetryFrame_Medium_IsValid(int value) { + switch (value) { + case 0: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed BandwidthUpgradeRetryFrame_Medium_strings[11] = {}; + +static const char BandwidthUpgradeRetryFrame_Medium_names[] = + "BLE" + "BLE_L2CAP" + "BLUETOOTH" + "NFC" + "UNKNOWN_MEDIUM" + "USB" + "WEB_RTC" + "WIFI_AWARE" + "WIFI_DIRECT" + "WIFI_HOTSPOT" + "WIFI_LAN"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry BandwidthUpgradeRetryFrame_Medium_entries[] = { + { {BandwidthUpgradeRetryFrame_Medium_names + 0, 3}, 4 }, + { {BandwidthUpgradeRetryFrame_Medium_names + 3, 9}, 10 }, + { {BandwidthUpgradeRetryFrame_Medium_names + 12, 9}, 2 }, + { {BandwidthUpgradeRetryFrame_Medium_names + 21, 3}, 7 }, + { {BandwidthUpgradeRetryFrame_Medium_names + 24, 14}, 0 }, + { {BandwidthUpgradeRetryFrame_Medium_names + 38, 3}, 11 }, + { {BandwidthUpgradeRetryFrame_Medium_names + 41, 7}, 9 }, + { {BandwidthUpgradeRetryFrame_Medium_names + 48, 10}, 6 }, + { {BandwidthUpgradeRetryFrame_Medium_names + 58, 11}, 8 }, + { {BandwidthUpgradeRetryFrame_Medium_names + 69, 12}, 3 }, + { {BandwidthUpgradeRetryFrame_Medium_names + 81, 8}, 5 }, +}; + +static const int BandwidthUpgradeRetryFrame_Medium_entries_by_number[] = { + 4, // 0 -> UNKNOWN_MEDIUM + 2, // 2 -> BLUETOOTH + 9, // 3 -> WIFI_HOTSPOT + 0, // 4 -> BLE + 10, // 5 -> WIFI_LAN + 7, // 6 -> WIFI_AWARE + 3, // 7 -> NFC + 8, // 8 -> WIFI_DIRECT + 6, // 9 -> WEB_RTC + 1, // 10 -> BLE_L2CAP + 5, // 11 -> USB +}; + +const std::string& BandwidthUpgradeRetryFrame_Medium_Name( + BandwidthUpgradeRetryFrame_Medium value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + BandwidthUpgradeRetryFrame_Medium_entries, + BandwidthUpgradeRetryFrame_Medium_entries_by_number, + 11, BandwidthUpgradeRetryFrame_Medium_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + BandwidthUpgradeRetryFrame_Medium_entries, + BandwidthUpgradeRetryFrame_Medium_entries_by_number, + 11, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + BandwidthUpgradeRetryFrame_Medium_strings[idx].get(); +} +bool BandwidthUpgradeRetryFrame_Medium_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BandwidthUpgradeRetryFrame_Medium* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + BandwidthUpgradeRetryFrame_Medium_entries, 11, 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 BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::UNKNOWN_MEDIUM; +constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::BLUETOOTH; +constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::WIFI_HOTSPOT; +constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::BLE; +constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::WIFI_LAN; +constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::WIFI_AWARE; +constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::NFC; +constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::WIFI_DIRECT; +constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::WEB_RTC; +constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::BLE_L2CAP; +constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::USB; +constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::Medium_MIN; +constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::Medium_MAX; +constexpr int BandwidthUpgradeRetryFrame::Medium_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) bool AutoResumeFrame_EventType_IsValid(int value) { switch (value) { case 0: @@ -2009,7 +2136,7 @@ class V1Frame::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_type(HasBits* has_bits) { - (*has_bits)[0] |= 2048u; + (*has_bits)[0] |= 4096u; } static const ::location::nearby::connections::ConnectionRequestFrame& connection_request(const V1Frame* msg); static void set_has_connection_request(HasBits* has_bits) { @@ -2055,6 +2182,10 @@ class V1Frame::_Internal { static void set_has_auto_reconnect(HasBits* has_bits) { (*has_bits)[0] |= 1024u; } + static const ::location::nearby::connections::BandwidthUpgradeRetryFrame& bandwidth_upgrade_retry(const V1Frame* msg); + static void set_has_bandwidth_upgrade_retry(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } }; const ::location::nearby::connections::ConnectionRequestFrame& @@ -2101,6 +2232,10 @@ const ::location::nearby::connections::AutoReconnectFrame& V1Frame::_Internal::auto_reconnect(const V1Frame* msg) { return *msg->auto_reconnect_; } +const ::location::nearby::connections::BandwidthUpgradeRetryFrame& +V1Frame::_Internal::bandwidth_upgrade_retry(const V1Frame* msg) { + return *msg->bandwidth_upgrade_retry_; +} V1Frame::V1Frame(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { @@ -2169,6 +2304,11 @@ V1Frame::V1Frame(const V1Frame& from) } else { auto_reconnect_ = nullptr; } + if (from._internal_has_bandwidth_upgrade_retry()) { + bandwidth_upgrade_retry_ = new ::location::nearby::connections::BandwidthUpgradeRetryFrame(*from.bandwidth_upgrade_retry_); + } else { + bandwidth_upgrade_retry_ = nullptr; + } type_ = from.type_; // @@protoc_insertion_point(copy_constructor:location.nearby.connections.V1Frame) } @@ -2200,6 +2340,7 @@ inline void V1Frame::SharedDtor() { if (this != internal_default_instance()) delete authentication_result_; if (this != internal_default_instance()) delete auto_resume_; if (this != internal_default_instance()) delete auto_reconnect_; + if (this != internal_default_instance()) delete bandwidth_upgrade_retry_; } void V1Frame::ArenaDtor(void* object) { @@ -2253,7 +2394,7 @@ void V1Frame::Clear() { authentication_message_->Clear(); } } - if (cached_has_bits & 0x00000700u) { + if (cached_has_bits & 0x00000f00u) { if (cached_has_bits & 0x00000100u) { GOOGLE_DCHECK(authentication_result_ != nullptr); authentication_result_->Clear(); @@ -2266,6 +2407,10 @@ void V1Frame::Clear() { GOOGLE_DCHECK(auto_reconnect_ != nullptr); auto_reconnect_->Clear(); } + if (cached_has_bits & 0x00000800u) { + GOOGLE_DCHECK(bandwidth_upgrade_retry_ != nullptr); + bandwidth_upgrade_retry_->Clear(); + } } type_ = 0; _has_bits_.Clear(); @@ -2380,6 +2525,14 @@ const char* V1Frame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in } else goto handle_unusual; continue; + // optional .location.nearby.connections.BandwidthUpgradeRetryFrame bandwidth_upgrade_retry = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + ptr = ctx->ParseMessage(_internal_mutable_bandwidth_upgrade_retry(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -2412,7 +2565,7 @@ uint8_t* V1Frame::_InternalSerialize( cached_has_bits = _has_bits_[0]; // optional .location.nearby.connections.V1Frame.FrameType type = 1; - if (cached_has_bits & 0x00000800u) { + if (cached_has_bits & 0x00001000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1, this->_internal_type(), target); @@ -2506,6 +2659,14 @@ uint8_t* V1Frame::_InternalSerialize( 12, _Internal::auto_reconnect(this), target, stream); } + // optional .location.nearby.connections.BandwidthUpgradeRetryFrame bandwidth_upgrade_retry = 13; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 13, _Internal::bandwidth_upgrade_retry(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); @@ -2581,7 +2742,7 @@ size_t V1Frame::ByteSizeLong() const { } } - if (cached_has_bits & 0x00000f00u) { + if (cached_has_bits & 0x00001f00u) { // optional .location.nearby.connections.AuthenticationResultFrame authentication_result = 10; if (cached_has_bits & 0x00000100u) { total_size += 1 + @@ -2603,8 +2764,15 @@ size_t V1Frame::ByteSizeLong() const { *auto_reconnect_); } - // optional .location.nearby.connections.V1Frame.FrameType type = 1; + // optional .location.nearby.connections.BandwidthUpgradeRetryFrame bandwidth_upgrade_retry = 13; if (cached_has_bits & 0x00000800u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *bandwidth_upgrade_retry_); + } + + // optional .location.nearby.connections.V1Frame.FrameType type = 1; + if (cached_has_bits & 0x00001000u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); } @@ -2657,7 +2825,7 @@ void V1Frame::MergeFrom(const V1Frame& from) { _internal_mutable_authentication_message()->::location::nearby::connections::AuthenticationMessageFrame::MergeFrom(from._internal_authentication_message()); } } - if (cached_has_bits & 0x00000f00u) { + if (cached_has_bits & 0x00001f00u) { if (cached_has_bits & 0x00000100u) { _internal_mutable_authentication_result()->::location::nearby::connections::AuthenticationResultFrame::MergeFrom(from._internal_authentication_result()); } @@ -2668,6 +2836,9 @@ void V1Frame::MergeFrom(const V1Frame& from) { _internal_mutable_auto_reconnect()->::location::nearby::connections::AutoReconnectFrame::MergeFrom(from._internal_auto_reconnect()); } if (cached_has_bits & 0x00000800u) { + _internal_mutable_bandwidth_upgrade_retry()->::location::nearby::connections::BandwidthUpgradeRetryFrame::MergeFrom(from._internal_bandwidth_upgrade_retry()); + } + if (cached_has_bits & 0x00001000u) { type_ = from.type_; } _has_bits_[0] |= cached_has_bits; @@ -8338,6 +8509,236 @@ std::string BandwidthUpgradeNegotiationFrame::GetTypeName() const { } +// =================================================================== + +class BandwidthUpgradeRetryFrame::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_is_request(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +BandwidthUpgradeRetryFrame::BandwidthUpgradeRetryFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), + supported_medium_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.BandwidthUpgradeRetryFrame) +} +BandwidthUpgradeRetryFrame::BandwidthUpgradeRetryFrame(const BandwidthUpgradeRetryFrame& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_), + supported_medium_(from.supported_medium_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + is_request_ = from.is_request_; + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.BandwidthUpgradeRetryFrame) +} + +inline void BandwidthUpgradeRetryFrame::SharedCtor() { +is_request_ = false; +} + +BandwidthUpgradeRetryFrame::~BandwidthUpgradeRetryFrame() { + // @@protoc_insertion_point(destructor:location.nearby.connections.BandwidthUpgradeRetryFrame) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void BandwidthUpgradeRetryFrame::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void BandwidthUpgradeRetryFrame::ArenaDtor(void* object) { + BandwidthUpgradeRetryFrame* _this = reinterpret_cast< BandwidthUpgradeRetryFrame* >(object); + (void)_this; +} +void BandwidthUpgradeRetryFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void BandwidthUpgradeRetryFrame::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void BandwidthUpgradeRetryFrame::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.BandwidthUpgradeRetryFrame) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + supported_medium_.Clear(); + is_request_ = false; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* BandwidthUpgradeRetryFrame::_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) { + // repeated .location.nearby.connections.BandwidthUpgradeRetryFrame.Medium supported_medium = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + ptr -= 1; + do { + ptr += 1; + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium_IsValid(val))) { + _internal_add_supported_medium(static_cast<::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8>(ptr)); + } else if (static_cast(tag) == 10) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_supported_medium(), ptr, ctx, ::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium_IsValid, &_internal_metadata_, 1); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool is_request = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_is_request(&has_bits); + is_request_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&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* BandwidthUpgradeRetryFrame::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.BandwidthUpgradeRetryFrame) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .location.nearby.connections.BandwidthUpgradeRetryFrame.Medium supported_medium = 1; + for (int i = 0, n = this->_internal_supported_medium_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_supported_medium(i), target); + } + + cached_has_bits = _has_bits_[0]; + // optional bool is_request = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_is_request(), 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.BandwidthUpgradeRetryFrame) + return target; +} + +size_t BandwidthUpgradeRetryFrame::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.BandwidthUpgradeRetryFrame) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .location.nearby.connections.BandwidthUpgradeRetryFrame.Medium supported_medium = 1; + { + size_t data_size = 0; + unsigned int count = static_cast(this->_internal_supported_medium_size());for (unsigned int i = 0; i < count; i++) { + data_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize( + this->_internal_supported_medium(static_cast(i))); + } + total_size += (1UL * count) + data_size; + } + + // optional bool is_request = 2; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 1; + } + + 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 BandwidthUpgradeRetryFrame::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void BandwidthUpgradeRetryFrame::MergeFrom(const BandwidthUpgradeRetryFrame& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.BandwidthUpgradeRetryFrame) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + supported_medium_.MergeFrom(from.supported_medium_); + if (from._internal_has_is_request()) { + _internal_set_is_request(from._internal_is_request()); + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void BandwidthUpgradeRetryFrame::CopyFrom(const BandwidthUpgradeRetryFrame& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.BandwidthUpgradeRetryFrame) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BandwidthUpgradeRetryFrame::IsInitialized() const { + return true; +} + +void BandwidthUpgradeRetryFrame::InternalSwap(BandwidthUpgradeRetryFrame* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + supported_medium_.InternalSwap(&other->supported_medium_); + swap(is_request_, other->is_request_); +} + +std::string BandwidthUpgradeRetryFrame::GetTypeName() const { + return "location.nearby.connections.BandwidthUpgradeRetryFrame"; +} + + // =================================================================== class KeepAliveFrame::_Internal { @@ -13083,6 +13484,9 @@ template<> PROTOBUF_NOINLINE ::location::nearby::connections::BandwidthUpgradeNe template<> PROTOBUF_NOINLINE ::location::nearby::connections::BandwidthUpgradeNegotiationFrame* Arena::CreateMaybeMessage< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame >(Arena* arena) { return Arena::CreateMessageInternal< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame >(arena); } +template<> PROTOBUF_NOINLINE ::location::nearby::connections::BandwidthUpgradeRetryFrame* Arena::CreateMaybeMessage< ::location::nearby::connections::BandwidthUpgradeRetryFrame >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::BandwidthUpgradeRetryFrame >(arena); +} template<> PROTOBUF_NOINLINE ::location::nearby::connections::KeepAliveFrame* Arena::CreateMaybeMessage< ::location::nearby::connections::KeepAliveFrame >(Arena* arena) { return Arena::CreateMessageInternal< ::location::nearby::connections::KeepAliveFrame >(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 22ca5e23..ca2d04a6 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[36] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[37] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -99,6 +99,9 @@ extern BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentialsDe class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket; struct BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocketDefaultTypeInternal; extern BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocketDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket_default_instance_; +class BandwidthUpgradeRetryFrame; +struct BandwidthUpgradeRetryFrameDefaultTypeInternal; +extern BandwidthUpgradeRetryFrameDefaultTypeInternal _BandwidthUpgradeRetryFrame_default_instance_; class ConnectionRequestFrame; struct ConnectionRequestFrameDefaultTypeInternal; extern ConnectionRequestFrameDefaultTypeInternal _ConnectionRequestFrame_default_instance_; @@ -181,6 +184,7 @@ template<> ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_Upg template<> ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* Arena::CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials>(Arena*); template<> ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* Arena::CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials>(Arena*); template<> ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* Arena::CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket>(Arena*); +template<> ::location::nearby::connections::BandwidthUpgradeRetryFrame* Arena::CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeRetryFrame>(Arena*); template<> ::location::nearby::connections::ConnectionRequestFrame* Arena::CreateMaybeMessage<::location::nearby::connections::ConnectionRequestFrame>(Arena*); template<> ::location::nearby::connections::ConnectionResponseFrame* Arena::CreateMaybeMessage<::location::nearby::connections::ConnectionResponseFrame>(Arena*); template<> ::location::nearby::connections::ConnectionsDevice* Arena::CreateMaybeMessage<::location::nearby::connections::ConnectionsDevice>(Arena*); @@ -238,11 +242,12 @@ enum V1Frame_FrameType : int { V1Frame_FrameType_AUTHENTICATION_MESSAGE = 8, V1Frame_FrameType_AUTHENTICATION_RESULT = 9, V1Frame_FrameType_AUTO_RESUME = 10, - V1Frame_FrameType_AUTO_RECONNECT = 11 + V1Frame_FrameType_AUTO_RECONNECT = 11, + V1Frame_FrameType_BANDWIDTH_UPGRADE_RETRY = 12 }; 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_AUTO_RECONNECT; +constexpr V1Frame_FrameType V1Frame_FrameType_FrameType_MAX = V1Frame_FrameType_BANDWIDTH_UPGRADE_RETRY; constexpr int V1Frame_FrameType_FrameType_ARRAYSIZE = V1Frame_FrameType_FrameType_MAX + 1; const std::string& V1Frame_FrameType_Name(V1Frame_FrameType value); @@ -347,7 +352,7 @@ enum PayloadTransferFrame_ControlMessage_EventType : int { PayloadTransferFrame_ControlMessage_EventType_UNKNOWN_EVENT_TYPE = 0, PayloadTransferFrame_ControlMessage_EventType_PAYLOAD_ERROR = 1, PayloadTransferFrame_ControlMessage_EventType_PAYLOAD_CANCELED = 2, - PayloadTransferFrame_ControlMessage_EventType_PAYLOAD_RECEIVED_ACK = 3 + PayloadTransferFrame_ControlMessage_EventType_PAYLOAD_RECEIVED_ACK PROTOBUF_DEPRECATED_ENUM = 3 }; bool PayloadTransferFrame_ControlMessage_EventType_IsValid(int value); constexpr PayloadTransferFrame_ControlMessage_EventType PayloadTransferFrame_ControlMessage_EventType_EventType_MIN = PayloadTransferFrame_ControlMessage_EventType_UNKNOWN_EVENT_TYPE; @@ -367,11 +372,12 @@ bool PayloadTransferFrame_ControlMessage_EventType_Parse( enum PayloadTransferFrame_PacketType : int { PayloadTransferFrame_PacketType_UNKNOWN_PACKET_TYPE = 0, PayloadTransferFrame_PacketType_DATA = 1, - PayloadTransferFrame_PacketType_CONTROL = 2 + PayloadTransferFrame_PacketType_CONTROL = 2, + PayloadTransferFrame_PacketType_PAYLOAD_ACK = 3 }; bool PayloadTransferFrame_PacketType_IsValid(int value); constexpr PayloadTransferFrame_PacketType PayloadTransferFrame_PacketType_PacketType_MIN = PayloadTransferFrame_PacketType_UNKNOWN_PACKET_TYPE; -constexpr PayloadTransferFrame_PacketType PayloadTransferFrame_PacketType_PacketType_MAX = PayloadTransferFrame_PacketType_CONTROL; +constexpr PayloadTransferFrame_PacketType PayloadTransferFrame_PacketType_PacketType_MAX = PayloadTransferFrame_PacketType_PAYLOAD_ACK; constexpr int PayloadTransferFrame_PacketType_PacketType_ARRAYSIZE = PayloadTransferFrame_PacketType_PacketType_MAX + 1; const std::string& PayloadTransferFrame_PacketType_Name(PayloadTransferFrame_PacketType value); @@ -436,6 +442,34 @@ inline const std::string& BandwidthUpgradeNegotiationFrame_EventType_Name(T enum } bool BandwidthUpgradeNegotiationFrame_EventType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BandwidthUpgradeNegotiationFrame_EventType* value); +enum BandwidthUpgradeRetryFrame_Medium : int { + BandwidthUpgradeRetryFrame_Medium_UNKNOWN_MEDIUM = 0, + BandwidthUpgradeRetryFrame_Medium_BLUETOOTH = 2, + BandwidthUpgradeRetryFrame_Medium_WIFI_HOTSPOT = 3, + BandwidthUpgradeRetryFrame_Medium_BLE = 4, + BandwidthUpgradeRetryFrame_Medium_WIFI_LAN = 5, + BandwidthUpgradeRetryFrame_Medium_WIFI_AWARE = 6, + BandwidthUpgradeRetryFrame_Medium_NFC = 7, + BandwidthUpgradeRetryFrame_Medium_WIFI_DIRECT = 8, + BandwidthUpgradeRetryFrame_Medium_WEB_RTC = 9, + BandwidthUpgradeRetryFrame_Medium_BLE_L2CAP = 10, + BandwidthUpgradeRetryFrame_Medium_USB = 11 +}; +bool BandwidthUpgradeRetryFrame_Medium_IsValid(int value); +constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame_Medium_Medium_MIN = BandwidthUpgradeRetryFrame_Medium_UNKNOWN_MEDIUM; +constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame_Medium_Medium_MAX = BandwidthUpgradeRetryFrame_Medium_USB; +constexpr int BandwidthUpgradeRetryFrame_Medium_Medium_ARRAYSIZE = BandwidthUpgradeRetryFrame_Medium_Medium_MAX + 1; + +const std::string& BandwidthUpgradeRetryFrame_Medium_Name(BandwidthUpgradeRetryFrame_Medium value); +template +inline const std::string& BandwidthUpgradeRetryFrame_Medium_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function BandwidthUpgradeRetryFrame_Medium_Name."); + return BandwidthUpgradeRetryFrame_Medium_Name(static_cast(enum_t_value)); +} +bool BandwidthUpgradeRetryFrame_Medium_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BandwidthUpgradeRetryFrame_Medium* value); enum AutoResumeFrame_EventType : int { AutoResumeFrame_EventType_UNKNOWN_AUTO_RESUME_EVENT_TYPE = 0, AutoResumeFrame_EventType_PAYLOAD_RESUME_TRANSFER_START = 1, @@ -888,6 +922,8 @@ class V1Frame final : V1Frame_FrameType_AUTO_RESUME; static constexpr FrameType AUTO_RECONNECT = V1Frame_FrameType_AUTO_RECONNECT; + static constexpr FrameType BANDWIDTH_UPGRADE_RETRY = + V1Frame_FrameType_BANDWIDTH_UPGRADE_RETRY; static inline bool FrameType_IsValid(int value) { return V1Frame_FrameType_IsValid(value); } @@ -923,6 +959,7 @@ class V1Frame final : kAuthenticationResultFieldNumber = 10, kAutoResumeFieldNumber = 11, kAutoReconnectFieldNumber = 12, + kBandwidthUpgradeRetryFieldNumber = 13, kTypeFieldNumber = 1, }; // optional .location.nearby.connections.ConnectionRequestFrame connection_request = 2; @@ -1123,6 +1160,24 @@ class V1Frame final : ::location::nearby::connections::AutoReconnectFrame* auto_reconnect); ::location::nearby::connections::AutoReconnectFrame* unsafe_arena_release_auto_reconnect(); + // optional .location.nearby.connections.BandwidthUpgradeRetryFrame bandwidth_upgrade_retry = 13; + bool has_bandwidth_upgrade_retry() const; + private: + bool _internal_has_bandwidth_upgrade_retry() const; + public: + void clear_bandwidth_upgrade_retry(); + const ::location::nearby::connections::BandwidthUpgradeRetryFrame& bandwidth_upgrade_retry() const; + PROTOBUF_NODISCARD ::location::nearby::connections::BandwidthUpgradeRetryFrame* release_bandwidth_upgrade_retry(); + ::location::nearby::connections::BandwidthUpgradeRetryFrame* mutable_bandwidth_upgrade_retry(); + void set_allocated_bandwidth_upgrade_retry(::location::nearby::connections::BandwidthUpgradeRetryFrame* bandwidth_upgrade_retry); + private: + const ::location::nearby::connections::BandwidthUpgradeRetryFrame& _internal_bandwidth_upgrade_retry() const; + ::location::nearby::connections::BandwidthUpgradeRetryFrame* _internal_mutable_bandwidth_upgrade_retry(); + public: + void unsafe_arena_set_allocated_bandwidth_upgrade_retry( + ::location::nearby::connections::BandwidthUpgradeRetryFrame* bandwidth_upgrade_retry); + ::location::nearby::connections::BandwidthUpgradeRetryFrame* unsafe_arena_release_bandwidth_upgrade_retry(); + // optional .location.nearby.connections.V1Frame.FrameType type = 1; bool has_type() const; private: @@ -1156,6 +1211,7 @@ class V1Frame final : ::location::nearby::connections::AuthenticationResultFrame* authentication_result_; ::location::nearby::connections::AutoResumeFrame* auto_resume_; ::location::nearby::connections::AutoReconnectFrame* auto_reconnect_; + ::location::nearby::connections::BandwidthUpgradeRetryFrame* bandwidth_upgrade_retry_; int type_; friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; }; @@ -2452,7 +2508,7 @@ class PayloadTransferFrame_ControlMessage final : PayloadTransferFrame_ControlMessage_EventType_PAYLOAD_ERROR; static constexpr EventType PAYLOAD_CANCELED = PayloadTransferFrame_ControlMessage_EventType_PAYLOAD_CANCELED; - static constexpr EventType PAYLOAD_RECEIVED_ACK = + PROTOBUF_DEPRECATED_ENUM static constexpr EventType PAYLOAD_RECEIVED_ACK = PayloadTransferFrame_ControlMessage_EventType_PAYLOAD_RECEIVED_ACK; static inline bool EventType_IsValid(int value) { return PayloadTransferFrame_ControlMessage_EventType_IsValid(value); @@ -2643,6 +2699,8 @@ class PayloadTransferFrame final : PayloadTransferFrame_PacketType_DATA; static constexpr PacketType CONTROL = PayloadTransferFrame_PacketType_CONTROL; + static constexpr PacketType PAYLOAD_ACK = + PayloadTransferFrame_PacketType_PAYLOAD_ACK; static inline bool PacketType_IsValid(int value) { return PayloadTransferFrame_PacketType_IsValid(value); } @@ -4766,6 +4824,211 @@ class BandwidthUpgradeNegotiationFrame final : }; // ------------------------------------------------------------------- +class BandwidthUpgradeRetryFrame final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.BandwidthUpgradeRetryFrame) */ { + public: + inline BandwidthUpgradeRetryFrame() : BandwidthUpgradeRetryFrame(nullptr) {} + ~BandwidthUpgradeRetryFrame() override; + explicit constexpr BandwidthUpgradeRetryFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + BandwidthUpgradeRetryFrame(const BandwidthUpgradeRetryFrame& from); + BandwidthUpgradeRetryFrame(BandwidthUpgradeRetryFrame&& from) noexcept + : BandwidthUpgradeRetryFrame() { + *this = ::std::move(from); + } + + inline BandwidthUpgradeRetryFrame& operator=(const BandwidthUpgradeRetryFrame& from) { + CopyFrom(from); + return *this; + } + inline BandwidthUpgradeRetryFrame& operator=(BandwidthUpgradeRetryFrame&& 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 BandwidthUpgradeRetryFrame& default_instance() { + return *internal_default_instance(); + } + static inline const BandwidthUpgradeRetryFrame* internal_default_instance() { + return reinterpret_cast( + &_BandwidthUpgradeRetryFrame_default_instance_); + } + static constexpr int kIndexInFileMessages = + 18; + + friend void swap(BandwidthUpgradeRetryFrame& a, BandwidthUpgradeRetryFrame& b) { + a.Swap(&b); + } + inline void Swap(BandwidthUpgradeRetryFrame* 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(BandwidthUpgradeRetryFrame* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BandwidthUpgradeRetryFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const BandwidthUpgradeRetryFrame& from); + void MergeFrom(const BandwidthUpgradeRetryFrame& 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(BandwidthUpgradeRetryFrame* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.BandwidthUpgradeRetryFrame"; + } + protected: + explicit BandwidthUpgradeRetryFrame(::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 BandwidthUpgradeRetryFrame_Medium Medium; + static constexpr Medium UNKNOWN_MEDIUM = + BandwidthUpgradeRetryFrame_Medium_UNKNOWN_MEDIUM; + static constexpr Medium BLUETOOTH = + BandwidthUpgradeRetryFrame_Medium_BLUETOOTH; + static constexpr Medium WIFI_HOTSPOT = + BandwidthUpgradeRetryFrame_Medium_WIFI_HOTSPOT; + static constexpr Medium BLE = + BandwidthUpgradeRetryFrame_Medium_BLE; + static constexpr Medium WIFI_LAN = + BandwidthUpgradeRetryFrame_Medium_WIFI_LAN; + static constexpr Medium WIFI_AWARE = + BandwidthUpgradeRetryFrame_Medium_WIFI_AWARE; + static constexpr Medium NFC = + BandwidthUpgradeRetryFrame_Medium_NFC; + static constexpr Medium WIFI_DIRECT = + BandwidthUpgradeRetryFrame_Medium_WIFI_DIRECT; + static constexpr Medium WEB_RTC = + BandwidthUpgradeRetryFrame_Medium_WEB_RTC; + static constexpr Medium BLE_L2CAP = + BandwidthUpgradeRetryFrame_Medium_BLE_L2CAP; + static constexpr Medium USB = + BandwidthUpgradeRetryFrame_Medium_USB; + static inline bool Medium_IsValid(int value) { + return BandwidthUpgradeRetryFrame_Medium_IsValid(value); + } + static constexpr Medium Medium_MIN = + BandwidthUpgradeRetryFrame_Medium_Medium_MIN; + static constexpr Medium Medium_MAX = + BandwidthUpgradeRetryFrame_Medium_Medium_MAX; + static constexpr int Medium_ARRAYSIZE = + BandwidthUpgradeRetryFrame_Medium_Medium_ARRAYSIZE; + template + static inline const std::string& Medium_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Medium_Name."); + return BandwidthUpgradeRetryFrame_Medium_Name(enum_t_value); + } + static inline bool Medium_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Medium* value) { + return BandwidthUpgradeRetryFrame_Medium_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kSupportedMediumFieldNumber = 1, + kIsRequestFieldNumber = 2, + }; + // repeated .location.nearby.connections.BandwidthUpgradeRetryFrame.Medium supported_medium = 1; + int supported_medium_size() const; + private: + int _internal_supported_medium_size() const; + public: + void clear_supported_medium(); + private: + ::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium _internal_supported_medium(int index) const; + void _internal_add_supported_medium(::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField* _internal_mutable_supported_medium(); + public: + ::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium supported_medium(int index) const; + void set_supported_medium(int index, ::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium value); + void add_supported_medium(::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField& supported_medium() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField* mutable_supported_medium(); + + // optional bool is_request = 2; + bool has_is_request() const; + private: + bool _internal_has_is_request() const; + public: + void clear_is_request(); + bool is_request() const; + void set_is_request(bool value); + private: + bool _internal_is_request() const; + void _internal_set_is_request(bool value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.BandwidthUpgradeRetryFrame) + 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::RepeatedField supported_medium_; + bool is_request_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + class KeepAliveFrame final : public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.KeepAliveFrame) */ { public: @@ -4812,7 +5075,7 @@ class KeepAliveFrame final : &_KeepAliveFrame_default_instance_); } static constexpr int kIndexInFileMessages = - 18; + 19; friend void swap(KeepAliveFrame& a, KeepAliveFrame& b) { a.Swap(&b); @@ -4969,7 +5232,7 @@ class DisconnectionFrame final : &_DisconnectionFrame_default_instance_); } static constexpr int kIndexInFileMessages = - 19; + 20; friend void swap(DisconnectionFrame& a, DisconnectionFrame& b) { a.Swap(&b); @@ -5126,7 +5389,7 @@ class PairedKeyEncryptionFrame final : &_PairedKeyEncryptionFrame_default_instance_); } static constexpr int kIndexInFileMessages = - 20; + 21; friend void swap(PairedKeyEncryptionFrame& a, PairedKeyEncryptionFrame& b) { a.Swap(&b); @@ -5273,7 +5536,7 @@ class AuthenticationMessageFrame final : &_AuthenticationMessageFrame_default_instance_); } static constexpr int kIndexInFileMessages = - 21; + 22; friend void swap(AuthenticationMessageFrame& a, AuthenticationMessageFrame& b) { a.Swap(&b); @@ -5420,7 +5683,7 @@ class AuthenticationResultFrame final : &_AuthenticationResultFrame_default_instance_); } static constexpr int kIndexInFileMessages = - 22; + 23; friend void swap(AuthenticationResultFrame& a, AuthenticationResultFrame& b) { a.Swap(&b); @@ -5562,7 +5825,7 @@ class AutoResumeFrame final : &_AutoResumeFrame_default_instance_); } static constexpr int kIndexInFileMessages = - 23; + 24; friend void swap(AutoResumeFrame& a, AutoResumeFrame& b) { a.Swap(&b); @@ -5762,7 +6025,7 @@ class AutoReconnectFrame final : &_AutoReconnectFrame_default_instance_); } static constexpr int kIndexInFileMessages = - 24; + 25; friend void swap(AutoReconnectFrame& a, AutoReconnectFrame& b) { a.Swap(&b); @@ -5952,7 +6215,7 @@ class MediumMetadata final : &_MediumMetadata_default_instance_); } static constexpr int kIndexInFileMessages = - 25; + 26; friend void swap(MediumMetadata& a, MediumMetadata& b) { a.Swap(&b); @@ -6279,7 +6542,7 @@ class AvailableChannels final : &_AvailableChannels_default_instance_); } static constexpr int kIndexInFileMessages = - 26; + 27; friend void swap(AvailableChannels& a, AvailableChannels& b) { a.Swap(&b); @@ -6430,7 +6693,7 @@ class WifiDirectCliUsableChannels final : &_WifiDirectCliUsableChannels_default_instance_); } static constexpr int kIndexInFileMessages = - 27; + 28; friend void swap(WifiDirectCliUsableChannels& a, WifiDirectCliUsableChannels& b) { a.Swap(&b); @@ -6581,7 +6844,7 @@ class WifiLanUsableChannels final : &_WifiLanUsableChannels_default_instance_); } static constexpr int kIndexInFileMessages = - 28; + 29; friend void swap(WifiLanUsableChannels& a, WifiLanUsableChannels& b) { a.Swap(&b); @@ -6732,7 +6995,7 @@ class WifiAwareUsableChannels final : &_WifiAwareUsableChannels_default_instance_); } static constexpr int kIndexInFileMessages = - 29; + 30; friend void swap(WifiAwareUsableChannels& a, WifiAwareUsableChannels& b) { a.Swap(&b); @@ -6883,7 +7146,7 @@ class WifiHotspotStaUsableChannels final : &_WifiHotspotStaUsableChannels_default_instance_); } static constexpr int kIndexInFileMessages = - 30; + 31; friend void swap(WifiHotspotStaUsableChannels& a, WifiHotspotStaUsableChannels& b) { a.Swap(&b); @@ -7034,7 +7297,7 @@ class LocationHint final : &_LocationHint_default_instance_); } static constexpr int kIndexInFileMessages = - 31; + 32; friend void swap(LocationHint& a, LocationHint& b) { a.Swap(&b); @@ -7196,7 +7459,7 @@ class LocationStandard final : &_LocationStandard_default_instance_); } static constexpr int kIndexInFileMessages = - 32; + 33; friend void swap(LocationStandard& a, LocationStandard& b) { a.Swap(&b); @@ -7348,7 +7611,7 @@ class OsInfo final : &_OsInfo_default_instance_); } static constexpr int kIndexInFileMessages = - 33; + 34; friend void swap(OsInfo& a, OsInfo& b) { a.Swap(&b); @@ -7524,7 +7787,7 @@ class ConnectionsDevice final : &_ConnectionsDevice_default_instance_); } static constexpr int kIndexInFileMessages = - 34; + 35; friend void swap(ConnectionsDevice& a, ConnectionsDevice& b) { a.Swap(&b); @@ -7726,7 +7989,7 @@ class PresenceDevice final : &_PresenceDevice_default_instance_); } static constexpr int kIndexInFileMessages = - 35; + 36; friend void swap(PresenceDevice& a, PresenceDevice& b) { a.Swap(&b); @@ -8172,7 +8435,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] & 0x00000800u) != 0; + bool value = (_has_bits_[0] & 0x00001000u) != 0; return value; } inline bool V1Frame::has_type() const { @@ -8180,7 +8443,7 @@ inline bool V1Frame::has_type() const { } inline void V1Frame::clear_type() { type_ = 0; - _has_bits_[0] &= ~0x00000800u; + _has_bits_[0] &= ~0x00001000u; } inline ::location::nearby::connections::V1Frame_FrameType V1Frame::_internal_type() const { return static_cast< ::location::nearby::connections::V1Frame_FrameType >(type_); @@ -8191,7 +8454,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] |= 0x00000800u; + _has_bits_[0] |= 0x00001000u; type_ = value; } inline void V1Frame::set_type(::location::nearby::connections::V1Frame_FrameType value) { @@ -9189,6 +9452,96 @@ inline void V1Frame::set_allocated_auto_reconnect(::location::nearby::connection // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.V1Frame.auto_reconnect) } +// optional .location.nearby.connections.BandwidthUpgradeRetryFrame bandwidth_upgrade_retry = 13; +inline bool V1Frame::_internal_has_bandwidth_upgrade_retry() const { + bool value = (_has_bits_[0] & 0x00000800u) != 0; + PROTOBUF_ASSUME(!value || bandwidth_upgrade_retry_ != nullptr); + return value; +} +inline bool V1Frame::has_bandwidth_upgrade_retry() const { + return _internal_has_bandwidth_upgrade_retry(); +} +inline void V1Frame::clear_bandwidth_upgrade_retry() { + if (bandwidth_upgrade_retry_ != nullptr) bandwidth_upgrade_retry_->Clear(); + _has_bits_[0] &= ~0x00000800u; +} +inline const ::location::nearby::connections::BandwidthUpgradeRetryFrame& V1Frame::_internal_bandwidth_upgrade_retry() const { + const ::location::nearby::connections::BandwidthUpgradeRetryFrame* p = bandwidth_upgrade_retry_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_BandwidthUpgradeRetryFrame_default_instance_); +} +inline const ::location::nearby::connections::BandwidthUpgradeRetryFrame& V1Frame::bandwidth_upgrade_retry() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.V1Frame.bandwidth_upgrade_retry) + return _internal_bandwidth_upgrade_retry(); +} +inline void V1Frame::unsafe_arena_set_allocated_bandwidth_upgrade_retry( + ::location::nearby::connections::BandwidthUpgradeRetryFrame* bandwidth_upgrade_retry) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bandwidth_upgrade_retry_); + } + bandwidth_upgrade_retry_ = bandwidth_upgrade_retry; + if (bandwidth_upgrade_retry) { + _has_bits_[0] |= 0x00000800u; + } else { + _has_bits_[0] &= ~0x00000800u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.V1Frame.bandwidth_upgrade_retry) +} +inline ::location::nearby::connections::BandwidthUpgradeRetryFrame* V1Frame::release_bandwidth_upgrade_retry() { + _has_bits_[0] &= ~0x00000800u; + ::location::nearby::connections::BandwidthUpgradeRetryFrame* temp = bandwidth_upgrade_retry_; + bandwidth_upgrade_retry_ = 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::BandwidthUpgradeRetryFrame* V1Frame::unsafe_arena_release_bandwidth_upgrade_retry() { + // @@protoc_insertion_point(field_release:location.nearby.connections.V1Frame.bandwidth_upgrade_retry) + _has_bits_[0] &= ~0x00000800u; + ::location::nearby::connections::BandwidthUpgradeRetryFrame* temp = bandwidth_upgrade_retry_; + bandwidth_upgrade_retry_ = nullptr; + return temp; +} +inline ::location::nearby::connections::BandwidthUpgradeRetryFrame* V1Frame::_internal_mutable_bandwidth_upgrade_retry() { + _has_bits_[0] |= 0x00000800u; + if (bandwidth_upgrade_retry_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeRetryFrame>(GetArenaForAllocation()); + bandwidth_upgrade_retry_ = p; + } + return bandwidth_upgrade_retry_; +} +inline ::location::nearby::connections::BandwidthUpgradeRetryFrame* V1Frame::mutable_bandwidth_upgrade_retry() { + ::location::nearby::connections::BandwidthUpgradeRetryFrame* _msg = _internal_mutable_bandwidth_upgrade_retry(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.V1Frame.bandwidth_upgrade_retry) + return _msg; +} +inline void V1Frame::set_allocated_bandwidth_upgrade_retry(::location::nearby::connections::BandwidthUpgradeRetryFrame* bandwidth_upgrade_retry) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete bandwidth_upgrade_retry_; + } + if (bandwidth_upgrade_retry) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::BandwidthUpgradeRetryFrame>::GetOwningArena(bandwidth_upgrade_retry); + if (message_arena != submessage_arena) { + bandwidth_upgrade_retry = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, bandwidth_upgrade_retry, submessage_arena); + } + _has_bits_[0] |= 0x00000800u; + } else { + _has_bits_[0] &= ~0x00000800u; + } + bandwidth_upgrade_retry_ = bandwidth_upgrade_retry; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.V1Frame.bandwidth_upgrade_retry) +} + // ------------------------------------------------------------------- // ConnectionRequestFrame @@ -13263,6 +13616,83 @@ inline void BandwidthUpgradeNegotiationFrame::set_allocated_client_introduction_ // ------------------------------------------------------------------- +// BandwidthUpgradeRetryFrame + +// repeated .location.nearby.connections.BandwidthUpgradeRetryFrame.Medium supported_medium = 1; +inline int BandwidthUpgradeRetryFrame::_internal_supported_medium_size() const { + return supported_medium_.size(); +} +inline int BandwidthUpgradeRetryFrame::supported_medium_size() const { + return _internal_supported_medium_size(); +} +inline void BandwidthUpgradeRetryFrame::clear_supported_medium() { + supported_medium_.Clear(); +} +inline ::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::_internal_supported_medium(int index) const { + return static_cast< ::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium >(supported_medium_.Get(index)); +} +inline ::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::supported_medium(int index) const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeRetryFrame.supported_medium) + return _internal_supported_medium(index); +} +inline void BandwidthUpgradeRetryFrame::set_supported_medium(int index, ::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium value) { + assert(::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium_IsValid(value)); + supported_medium_.Set(index, value); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeRetryFrame.supported_medium) +} +inline void BandwidthUpgradeRetryFrame::_internal_add_supported_medium(::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium value) { + assert(::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium_IsValid(value)); + supported_medium_.Add(value); +} +inline void BandwidthUpgradeRetryFrame::add_supported_medium(::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium value) { + _internal_add_supported_medium(value); + // @@protoc_insertion_point(field_add:location.nearby.connections.BandwidthUpgradeRetryFrame.supported_medium) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField& +BandwidthUpgradeRetryFrame::supported_medium() const { + // @@protoc_insertion_point(field_list:location.nearby.connections.BandwidthUpgradeRetryFrame.supported_medium) + return supported_medium_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* +BandwidthUpgradeRetryFrame::_internal_mutable_supported_medium() { + return &supported_medium_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* +BandwidthUpgradeRetryFrame::mutable_supported_medium() { + // @@protoc_insertion_point(field_mutable_list:location.nearby.connections.BandwidthUpgradeRetryFrame.supported_medium) + return _internal_mutable_supported_medium(); +} + +// optional bool is_request = 2; +inline bool BandwidthUpgradeRetryFrame::_internal_has_is_request() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool BandwidthUpgradeRetryFrame::has_is_request() const { + return _internal_has_is_request(); +} +inline void BandwidthUpgradeRetryFrame::clear_is_request() { + is_request_ = false; + _has_bits_[0] &= ~0x00000001u; +} +inline bool BandwidthUpgradeRetryFrame::_internal_is_request() const { + return is_request_; +} +inline bool BandwidthUpgradeRetryFrame::is_request() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeRetryFrame.is_request) + return _internal_is_request(); +} +inline void BandwidthUpgradeRetryFrame::_internal_set_is_request(bool value) { + _has_bits_[0] |= 0x00000001u; + is_request_ = value; +} +inline void BandwidthUpgradeRetryFrame::set_is_request(bool value) { + _internal_set_is_request(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeRetryFrame.is_request) +} + +// ------------------------------------------------------------------- + // KeepAliveFrame // optional bool ack = 1; @@ -15666,6 +16096,8 @@ PresenceDevice::mutable_identity_type() { // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) @@ -15685,6 +16117,7 @@ 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::BandwidthUpgradeRetryFrame_Medium> : ::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 {}; diff --git a/compiled_proto/internal/proto/analytics/connections_log.pb.cc b/compiled_proto/internal/proto/analytics/connections_log.pb.cc index 82410f52..2167e5a6 100644 --- a/compiled_proto/internal/proto/analytics/connections_log.pb.cc +++ b/compiled_proto/internal/proto/analytics/connections_log.pb.cc @@ -20,7 +20,9 @@ namespace proto { constexpr ConnectionsLog_ClientSession::ConnectionsLog_ClientSession( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : strategy_session_() - , duration_millis_(int64_t{0}){} + , connection_token_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , duration_millis_(int64_t{0}) + , client_flow_id_(int64_t{0}){} struct ConnectionsLog_ClientSessionDefaultTypeInternal { constexpr ConnectionsLog_ClientSessionDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -209,7 +211,8 @@ constexpr ConnectionsLog_Payload::ConnectionsLog_Payload( , num_chunks_(0) , num_bytes_transferred_(int64_t{0}) , status_(0) -{} + + , num_successful_auto_resume_(0){} struct ConnectionsLog_PayloadDefaultTypeInternal { constexpr ConnectionsLog_PayloadDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -272,6 +275,7 @@ constexpr ConnectionsLog_AdvertisingMetadata::ConnectionsLog_AdvertisingMetadata , supports_extended_ble_advertisements_(false) , supports_nfc_technology_(false) , multiple_advertisement_supported_(false) + , supports_dual_band_(false) , power_level_(-1) {} struct ConnectionsLog_AdvertisingMetadataDefaultTypeInternal { @@ -424,6 +428,12 @@ class ConnectionsLog_ClientSession::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_duration_millis(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_client_flow_id(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_connection_token(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; @@ -443,12 +453,29 @@ ConnectionsLog_ClientSession::ConnectionsLog_ClientSession(const ConnectionsLog_ _has_bits_(from._has_bits_), strategy_session_(from.strategy_session_) { _internal_metadata_.MergeFrom(from._internal_metadata_); - duration_millis_ = from.duration_millis_; + connection_token_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + connection_token_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_connection_token()) { + connection_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_connection_token(), + GetArenaForAllocation()); + } + ::memcpy(&duration_millis_, &from.duration_millis_, + static_cast(reinterpret_cast(&client_flow_id_) - + reinterpret_cast(&duration_millis_)) + sizeof(client_flow_id_)); // @@protoc_insertion_point(copy_constructor:location.nearby.analytics.proto.ConnectionsLog.ClientSession) } inline void ConnectionsLog_ClientSession::SharedCtor() { -duration_millis_ = int64_t{0}; +connection_token_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + connection_token_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&duration_millis_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&client_flow_id_) - + reinterpret_cast(&duration_millis_)) + sizeof(client_flow_id_)); } ConnectionsLog_ClientSession::~ConnectionsLog_ClientSession() { @@ -460,6 +487,7 @@ ConnectionsLog_ClientSession::~ConnectionsLog_ClientSession() { inline void ConnectionsLog_ClientSession::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + connection_token_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void ConnectionsLog_ClientSession::ArenaDtor(void* object) { @@ -479,7 +507,15 @@ void ConnectionsLog_ClientSession::Clear() { (void) cached_has_bits; strategy_session_.Clear(); - duration_millis_ = int64_t{0}; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + connection_token_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000006u) { + ::memset(&duration_millis_, 0, static_cast( + reinterpret_cast(&client_flow_id_) - + reinterpret_cast(&duration_millis_)) + sizeof(client_flow_id_)); + } _has_bits_.Clear(); _internal_metadata_.Clear(); } @@ -513,6 +549,24 @@ const char* ConnectionsLog_ClientSession::_InternalParse(const char* ptr, ::PROT } else goto handle_unusual; continue; + // optional int64 client_flow_id = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_client_flow_id(&has_bits); + client_flow_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string connection_token = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_connection_token(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -545,7 +599,7 @@ uint8_t* ConnectionsLog_ClientSession::_InternalSerialize( cached_has_bits = _has_bits_[0]; // optional int64 duration_millis = 1; - if (cached_has_bits & 0x00000001u) { + if (cached_has_bits & 0x00000002u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_duration_millis(), target); } @@ -558,6 +612,18 @@ uint8_t* ConnectionsLog_ClientSession::_InternalSerialize( InternalWriteMessage(2, this->_internal_strategy_session(i), target, stream); } + // optional int64 client_flow_id = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_client_flow_id(), target); + } + + // optional string connection_token = 4; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased( + 4, this->_internal_connection_token(), 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); @@ -581,12 +647,26 @@ size_t ConnectionsLog_ClientSession::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // optional int64 duration_millis = 1; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_duration_millis()); - } + if (cached_has_bits & 0x00000007u) { + // optional string connection_token = 4; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_connection_token()); + } + // optional int64 duration_millis = 1; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_duration_millis()); + } + + // optional int64 client_flow_id = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_client_flow_id()); + } + + } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); } @@ -608,8 +688,18 @@ void ConnectionsLog_ClientSession::MergeFrom(const ConnectionsLog_ClientSession& (void) cached_has_bits; strategy_session_.MergeFrom(from.strategy_session_); - if (from._internal_has_duration_millis()) { - _internal_set_duration_millis(from._internal_duration_millis()); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_connection_token(from._internal_connection_token()); + } + if (cached_has_bits & 0x00000002u) { + duration_millis_ = from.duration_millis_; + } + if (cached_has_bits & 0x00000004u) { + client_flow_id_ = from.client_flow_id_; + } + _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom(from._internal_metadata_); } @@ -627,10 +717,22 @@ bool ConnectionsLog_ClientSession::IsInitialized() const { void ConnectionsLog_ClientSession::InternalSwap(ConnectionsLog_ClientSession* 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]); strategy_session_.InternalSwap(&other->strategy_session_); - swap(duration_millis_, other->duration_millis_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &connection_token_, lhs_arena, + &other->connection_token_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ConnectionsLog_ClientSession, client_flow_id_) + + sizeof(ConnectionsLog_ClientSession::client_flow_id_) + - PROTOBUF_FIELD_OFFSET(ConnectionsLog_ClientSession, duration_millis_)>( + reinterpret_cast(&duration_millis_), + reinterpret_cast(&other->duration_millis_)); } std::string ConnectionsLog_ClientSession::GetTypeName() const { @@ -4181,6 +4283,9 @@ class ConnectionsLog_Payload::_Internal { static void set_has_status(HasBits* has_bits) { (*has_bits)[0] |= 32u; } + static void set_has_num_successful_auto_resume(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } }; ConnectionsLog_Payload::ConnectionsLog_Payload(::PROTOBUF_NAMESPACE_ID::Arena* arena, @@ -4197,16 +4302,16 @@ ConnectionsLog_Payload::ConnectionsLog_Payload(const ConnectionsLog_Payload& fro _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom(from._internal_metadata_); ::memcpy(&duration_millis_, &from.duration_millis_, - static_cast(reinterpret_cast(&status_) - - reinterpret_cast(&duration_millis_)) + sizeof(status_)); + static_cast(reinterpret_cast(&num_successful_auto_resume_) - + reinterpret_cast(&duration_millis_)) + sizeof(num_successful_auto_resume_)); // @@protoc_insertion_point(copy_constructor:location.nearby.analytics.proto.ConnectionsLog.Payload) } inline void ConnectionsLog_Payload::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&duration_millis_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&status_) - - reinterpret_cast(&duration_millis_)) + sizeof(status_)); + 0, static_cast(reinterpret_cast(&num_successful_auto_resume_) - + reinterpret_cast(&duration_millis_)) + sizeof(num_successful_auto_resume_)); } ConnectionsLog_Payload::~ConnectionsLog_Payload() { @@ -4237,10 +4342,10 @@ void ConnectionsLog_Payload::Clear() { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x0000007fu) { ::memset(&duration_millis_, 0, static_cast( - reinterpret_cast(&status_) - - reinterpret_cast(&duration_millis_)) + sizeof(status_)); + reinterpret_cast(&num_successful_auto_resume_) - + reinterpret_cast(&duration_millis_)) + sizeof(num_successful_auto_resume_)); } _has_bits_.Clear(); _internal_metadata_.Clear(); @@ -4315,6 +4420,15 @@ const char* ConnectionsLog_Payload::_InternalParse(const char* ptr, ::PROTOBUF_N } else goto handle_unusual; continue; + // optional int32 num_successful_auto_resume = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_num_successful_auto_resume(&has_bits); + num_successful_auto_resume_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -4384,6 +4498,12 @@ uint8_t* ConnectionsLog_Payload::_InternalSerialize( 6, this->_internal_status(), target); } + // optional int32 num_successful_auto_resume = 7; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(7, this->_internal_num_successful_auto_resume(), 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); @@ -4401,7 +4521,7 @@ size_t ConnectionsLog_Payload::ByteSizeLong() const { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x0000007fu) { // optional int64 duration_millis = 1; if (cached_has_bits & 0x00000001u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_duration_millis()); @@ -4434,6 +4554,11 @@ size_t ConnectionsLog_Payload::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_status()); } + // optional int32 num_successful_auto_resume = 7; + if (cached_has_bits & 0x00000040u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_num_successful_auto_resume()); + } + } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); @@ -4456,7 +4581,7 @@ void ConnectionsLog_Payload::MergeFrom(const ConnectionsLog_Payload& 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) { duration_millis_ = from.duration_millis_; } @@ -4475,6 +4600,9 @@ void ConnectionsLog_Payload::MergeFrom(const ConnectionsLog_Payload& from) { if (cached_has_bits & 0x00000020u) { status_ = from.status_; } + if (cached_has_bits & 0x00000040u) { + num_successful_auto_resume_ = from.num_successful_auto_resume_; + } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom(from._internal_metadata_); @@ -4496,8 +4624,8 @@ void ConnectionsLog_Payload::InternalSwap(ConnectionsLog_Payload* other) { _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ConnectionsLog_Payload, status_) - + sizeof(ConnectionsLog_Payload::status_) + PROTOBUF_FIELD_OFFSET(ConnectionsLog_Payload, num_successful_auto_resume_) + + sizeof(ConnectionsLog_Payload::num_successful_auto_resume_) - PROTOBUF_FIELD_OFFSET(ConnectionsLog_Payload, duration_millis_)>( reinterpret_cast(&duration_millis_), reinterpret_cast(&other->duration_millis_)); @@ -5967,6 +6095,9 @@ class ConnectionsLog_AdvertisingMetadata::_Internal { (*has_bits)[0] |= 8u; } static void set_has_power_level(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_supports_dual_band(HasBits* has_bits) { (*has_bits)[0] |= 16u; } }; @@ -5993,8 +6124,8 @@ ConnectionsLog_AdvertisingMetadata::ConnectionsLog_AdvertisingMetadata(const Con inline void ConnectionsLog_AdvertisingMetadata::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&connected_ap_frequency_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&multiple_advertisement_supported_) - - reinterpret_cast(&connected_ap_frequency_)) + sizeof(multiple_advertisement_supported_)); + 0, static_cast(reinterpret_cast(&supports_dual_band_) - + reinterpret_cast(&connected_ap_frequency_)) + sizeof(supports_dual_band_)); power_level_ = -1; } @@ -6026,10 +6157,10 @@ void ConnectionsLog_AdvertisingMetadata::Clear() { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x0000003fu) { ::memset(&connected_ap_frequency_, 0, static_cast( - reinterpret_cast(&multiple_advertisement_supported_) - - reinterpret_cast(&connected_ap_frequency_)) + sizeof(multiple_advertisement_supported_)); + reinterpret_cast(&supports_dual_band_) - + reinterpret_cast(&connected_ap_frequency_)) + sizeof(supports_dual_band_)); power_level_ = -1; } _has_bits_.Clear(); @@ -6092,6 +6223,15 @@ const char* ConnectionsLog_AdvertisingMetadata::_InternalParse(const char* ptr, } else goto handle_unusual; continue; + // optional bool supports_dual_band = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_supports_dual_band(&has_bits); + supports_dual_band_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -6148,12 +6288,18 @@ uint8_t* ConnectionsLog_AdvertisingMetadata::_InternalSerialize( } // optional .location.nearby.proto.connections.PowerLevel power_level = 5; - if (cached_has_bits & 0x00000010u) { + if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 5, this->_internal_power_level(), target); } + // optional bool supports_dual_band = 6; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_supports_dual_band(), 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); @@ -6171,7 +6317,7 @@ size_t ConnectionsLog_AdvertisingMetadata::ByteSizeLong() const { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x0000003fu) { // optional int32 connected_ap_frequency = 2; if (cached_has_bits & 0x00000001u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_connected_ap_frequency()); @@ -6192,8 +6338,13 @@ size_t ConnectionsLog_AdvertisingMetadata::ByteSizeLong() const { total_size += 1 + 1; } - // optional .location.nearby.proto.connections.PowerLevel power_level = 5; + // optional bool supports_dual_band = 6; if (cached_has_bits & 0x00000010u) { + total_size += 1 + 1; + } + + // optional .location.nearby.proto.connections.PowerLevel power_level = 5; + if (cached_has_bits & 0x00000020u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_power_level()); } @@ -6220,7 +6371,7 @@ void ConnectionsLog_AdvertisingMetadata::MergeFrom(const ConnectionsLog_Advertis (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x0000003fu) { if (cached_has_bits & 0x00000001u) { connected_ap_frequency_ = from.connected_ap_frequency_; } @@ -6234,6 +6385,9 @@ void ConnectionsLog_AdvertisingMetadata::MergeFrom(const ConnectionsLog_Advertis multiple_advertisement_supported_ = from.multiple_advertisement_supported_; } if (cached_has_bits & 0x00000010u) { + supports_dual_band_ = from.supports_dual_band_; + } + if (cached_has_bits & 0x00000020u) { power_level_ = from.power_level_; } _has_bits_[0] |= cached_has_bits; @@ -6257,8 +6411,8 @@ void ConnectionsLog_AdvertisingMetadata::InternalSwap(ConnectionsLog_Advertising _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ConnectionsLog_AdvertisingMetadata, multiple_advertisement_supported_) - + sizeof(ConnectionsLog_AdvertisingMetadata::multiple_advertisement_supported_) + PROTOBUF_FIELD_OFFSET(ConnectionsLog_AdvertisingMetadata, supports_dual_band_) + + sizeof(ConnectionsLog_AdvertisingMetadata::supports_dual_band_) - PROTOBUF_FIELD_OFFSET(ConnectionsLog_AdvertisingMetadata, connected_ap_frequency_)>( reinterpret_cast(&connected_ap_frequency_), reinterpret_cast(&other->connected_ap_frequency_)); diff --git a/compiled_proto/internal/proto/analytics/connections_log.pb.h b/compiled_proto/internal/proto/analytics/connections_log.pb.h index c90e49b3..071f3dc3 100644 --- a/compiled_proto/internal/proto/analytics/connections_log.pb.h +++ b/compiled_proto/internal/proto/analytics/connections_log.pb.h @@ -272,7 +272,9 @@ class ConnectionsLog_ClientSession final : enum : int { kStrategySessionFieldNumber = 2, + kConnectionTokenFieldNumber = 4, kDurationMillisFieldNumber = 1, + kClientFlowIdFieldNumber = 3, }; // repeated .location.nearby.analytics.proto.ConnectionsLog.StrategySession strategy_session = 2; int strategy_session_size() const; @@ -292,6 +294,24 @@ class ConnectionsLog_ClientSession final : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::location::nearby::analytics::proto::ConnectionsLog_StrategySession >& strategy_session() const; + // optional string connection_token = 4; + bool has_connection_token() const; + private: + bool _internal_has_connection_token() const; + public: + void clear_connection_token(); + const std::string& connection_token() const; + template + void set_connection_token(ArgT0&& arg0, ArgT... args); + std::string* mutable_connection_token(); + PROTOBUF_NODISCARD std::string* release_connection_token(); + void set_allocated_connection_token(std::string* connection_token); + private: + const std::string& _internal_connection_token() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_connection_token(const std::string& value); + std::string* _internal_mutable_connection_token(); + public: + // optional int64 duration_millis = 1; bool has_duration_millis() const; private: @@ -305,6 +325,19 @@ class ConnectionsLog_ClientSession final : void _internal_set_duration_millis(int64_t value); public: + // optional int64 client_flow_id = 3; + bool has_client_flow_id() const; + private: + bool _internal_has_client_flow_id() const; + public: + void clear_client_flow_id(); + int64_t client_flow_id() const; + void set_client_flow_id(int64_t value); + private: + int64_t _internal_client_flow_id() const; + void _internal_set_client_flow_id(int64_t value); + public: + // @@protoc_insertion_point(class_scope:location.nearby.analytics.proto.ConnectionsLog.ClientSession) private: class _Internal; @@ -315,7 +348,9 @@ class ConnectionsLog_ClientSession final : ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::location::nearby::analytics::proto::ConnectionsLog_StrategySession > strategy_session_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr connection_token_; int64_t duration_millis_; + int64_t client_flow_id_; friend struct ::TableStruct_internal_2fproto_2fanalytics_2fconnections_5flog_2eproto; }; // ------------------------------------------------------------------- @@ -2597,6 +2632,7 @@ class ConnectionsLog_Payload final : kNumChunksFieldNumber = 5, kNumBytesTransferredFieldNumber = 4, kStatusFieldNumber = 6, + kNumSuccessfulAutoResumeFieldNumber = 7, }; // optional int64 duration_millis = 1; bool has_duration_millis() const; @@ -2676,6 +2712,19 @@ class ConnectionsLog_Payload final : void _internal_set_status(::location::nearby::proto::connections::PayloadStatus value); public: + // optional int32 num_successful_auto_resume = 7; + bool has_num_successful_auto_resume() const; + private: + bool _internal_has_num_successful_auto_resume() const; + public: + void clear_num_successful_auto_resume(); + int32_t num_successful_auto_resume() const; + void set_num_successful_auto_resume(int32_t value); + private: + int32_t _internal_num_successful_auto_resume() const; + void _internal_set_num_successful_auto_resume(int32_t value); + public: + // @@protoc_insertion_point(class_scope:location.nearby.analytics.proto.ConnectionsLog.Payload) private: class _Internal; @@ -2691,6 +2740,7 @@ class ConnectionsLog_Payload final : int32_t num_chunks_; int64_t num_bytes_transferred_; int status_; + int32_t num_successful_auto_resume_; friend struct ::TableStruct_internal_2fproto_2fanalytics_2fconnections_5flog_2eproto; }; // ------------------------------------------------------------------- @@ -3559,6 +3609,7 @@ class ConnectionsLog_AdvertisingMetadata final : kSupportsExtendedBleAdvertisementsFieldNumber = 1, kSupportsNfcTechnologyFieldNumber = 3, kMultipleAdvertisementSupportedFieldNumber = 4, + kSupportsDualBandFieldNumber = 6, kPowerLevelFieldNumber = 5, }; // optional int32 connected_ap_frequency = 2; @@ -3613,6 +3664,19 @@ class ConnectionsLog_AdvertisingMetadata final : void _internal_set_multiple_advertisement_supported(bool value); public: + // optional bool supports_dual_band = 6; + bool has_supports_dual_band() const; + private: + bool _internal_has_supports_dual_band() const; + public: + void clear_supports_dual_band(); + bool supports_dual_band() const; + void set_supports_dual_band(bool value); + private: + bool _internal_supports_dual_band() const; + void _internal_set_supports_dual_band(bool value); + public: + // optional .location.nearby.proto.connections.PowerLevel power_level = 5; bool has_power_level() const; private: @@ -3639,6 +3703,7 @@ class ConnectionsLog_AdvertisingMetadata final : bool supports_extended_ble_advertisements_; bool supports_nfc_technology_; bool multiple_advertisement_supported_; + bool supports_dual_band_; int power_level_; friend struct ::TableStruct_internal_2fproto_2fanalytics_2fconnections_5flog_2eproto; }; @@ -4458,7 +4523,7 @@ class ConnectionsLog final : // optional int64 duration_millis = 1; inline bool ConnectionsLog_ClientSession::_internal_has_duration_millis() const { - bool value = (_has_bits_[0] & 0x00000001u) != 0; + bool value = (_has_bits_[0] & 0x00000002u) != 0; return value; } inline bool ConnectionsLog_ClientSession::has_duration_millis() const { @@ -4466,7 +4531,7 @@ inline bool ConnectionsLog_ClientSession::has_duration_millis() const { } inline void ConnectionsLog_ClientSession::clear_duration_millis() { duration_millis_ = int64_t{0}; - _has_bits_[0] &= ~0x00000001u; + _has_bits_[0] &= ~0x00000002u; } inline int64_t ConnectionsLog_ClientSession::_internal_duration_millis() const { return duration_millis_; @@ -4476,7 +4541,7 @@ inline int64_t ConnectionsLog_ClientSession::duration_millis() const { return _internal_duration_millis(); } inline void ConnectionsLog_ClientSession::_internal_set_duration_millis(int64_t value) { - _has_bits_[0] |= 0x00000001u; + _has_bits_[0] |= 0x00000002u; duration_millis_ = value; } inline void ConnectionsLog_ClientSession::set_duration_millis(int64_t value) { @@ -4524,6 +4589,103 @@ ConnectionsLog_ClientSession::strategy_session() const { return strategy_session_; } +// optional int64 client_flow_id = 3; +inline bool ConnectionsLog_ClientSession::_internal_has_client_flow_id() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ConnectionsLog_ClientSession::has_client_flow_id() const { + return _internal_has_client_flow_id(); +} +inline void ConnectionsLog_ClientSession::clear_client_flow_id() { + client_flow_id_ = int64_t{0}; + _has_bits_[0] &= ~0x00000004u; +} +inline int64_t ConnectionsLog_ClientSession::_internal_client_flow_id() const { + return client_flow_id_; +} +inline int64_t ConnectionsLog_ClientSession::client_flow_id() const { + // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.ClientSession.client_flow_id) + return _internal_client_flow_id(); +} +inline void ConnectionsLog_ClientSession::_internal_set_client_flow_id(int64_t value) { + _has_bits_[0] |= 0x00000004u; + client_flow_id_ = value; +} +inline void ConnectionsLog_ClientSession::set_client_flow_id(int64_t value) { + _internal_set_client_flow_id(value); + // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.ClientSession.client_flow_id) +} + +// optional string connection_token = 4; +inline bool ConnectionsLog_ClientSession::_internal_has_connection_token() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ConnectionsLog_ClientSession::has_connection_token() const { + return _internal_has_connection_token(); +} +inline void ConnectionsLog_ClientSession::clear_connection_token() { + connection_token_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ConnectionsLog_ClientSession::connection_token() const { + // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.ClientSession.connection_token) + return _internal_connection_token(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ConnectionsLog_ClientSession::set_connection_token(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + connection_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.ClientSession.connection_token) +} +inline std::string* ConnectionsLog_ClientSession::mutable_connection_token() { + std::string* _s = _internal_mutable_connection_token(); + // @@protoc_insertion_point(field_mutable:location.nearby.analytics.proto.ConnectionsLog.ClientSession.connection_token) + return _s; +} +inline const std::string& ConnectionsLog_ClientSession::_internal_connection_token() const { + return connection_token_.Get(); +} +inline void ConnectionsLog_ClientSession::_internal_set_connection_token(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + connection_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* ConnectionsLog_ClientSession::_internal_mutable_connection_token() { + _has_bits_[0] |= 0x00000001u; + return connection_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* ConnectionsLog_ClientSession::release_connection_token() { + // @@protoc_insertion_point(field_release:location.nearby.analytics.proto.ConnectionsLog.ClientSession.connection_token) + if (!_internal_has_connection_token()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = connection_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (connection_token_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + connection_token_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ConnectionsLog_ClientSession::set_allocated_connection_token(std::string* connection_token) { + if (connection_token != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + connection_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), connection_token, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (connection_token_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + connection_token_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.analytics.proto.ConnectionsLog.ClientSession.connection_token) +} + // ------------------------------------------------------------------- // ConnectionsLog_StrategySession @@ -6902,6 +7064,34 @@ inline void ConnectionsLog_Payload::set_status(::location::nearby::proto::connec // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.Payload.status) } +// optional int32 num_successful_auto_resume = 7; +inline bool ConnectionsLog_Payload::_internal_has_num_successful_auto_resume() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool ConnectionsLog_Payload::has_num_successful_auto_resume() const { + return _internal_has_num_successful_auto_resume(); +} +inline void ConnectionsLog_Payload::clear_num_successful_auto_resume() { + num_successful_auto_resume_ = 0; + _has_bits_[0] &= ~0x00000040u; +} +inline int32_t ConnectionsLog_Payload::_internal_num_successful_auto_resume() const { + return num_successful_auto_resume_; +} +inline int32_t ConnectionsLog_Payload::num_successful_auto_resume() const { + // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.Payload.num_successful_auto_resume) + return _internal_num_successful_auto_resume(); +} +inline void ConnectionsLog_Payload::_internal_set_num_successful_auto_resume(int32_t value) { + _has_bits_[0] |= 0x00000040u; + num_successful_auto_resume_ = value; +} +inline void ConnectionsLog_Payload::set_num_successful_auto_resume(int32_t value) { + _internal_set_num_successful_auto_resume(value); + // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.Payload.num_successful_auto_resume) +} + // ------------------------------------------------------------------- // ConnectionsLog_BandwidthUpgradeAttempt @@ -8135,7 +8325,7 @@ inline void ConnectionsLog_AdvertisingMetadata::set_multiple_advertisement_suppo // optional .location.nearby.proto.connections.PowerLevel power_level = 5; inline bool ConnectionsLog_AdvertisingMetadata::_internal_has_power_level() const { - bool value = (_has_bits_[0] & 0x00000010u) != 0; + bool value = (_has_bits_[0] & 0x00000020u) != 0; return value; } inline bool ConnectionsLog_AdvertisingMetadata::has_power_level() const { @@ -8143,7 +8333,7 @@ inline bool ConnectionsLog_AdvertisingMetadata::has_power_level() const { } inline void ConnectionsLog_AdvertisingMetadata::clear_power_level() { power_level_ = -1; - _has_bits_[0] &= ~0x00000010u; + _has_bits_[0] &= ~0x00000020u; } inline ::location::nearby::proto::connections::PowerLevel ConnectionsLog_AdvertisingMetadata::_internal_power_level() const { return static_cast< ::location::nearby::proto::connections::PowerLevel >(power_level_); @@ -8154,7 +8344,7 @@ inline ::location::nearby::proto::connections::PowerLevel ConnectionsLog_Adverti } inline void ConnectionsLog_AdvertisingMetadata::_internal_set_power_level(::location::nearby::proto::connections::PowerLevel value) { assert(::location::nearby::proto::connections::PowerLevel_IsValid(value)); - _has_bits_[0] |= 0x00000010u; + _has_bits_[0] |= 0x00000020u; power_level_ = value; } inline void ConnectionsLog_AdvertisingMetadata::set_power_level(::location::nearby::proto::connections::PowerLevel value) { @@ -8162,6 +8352,34 @@ inline void ConnectionsLog_AdvertisingMetadata::set_power_level(::location::near // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.AdvertisingMetadata.power_level) } +// optional bool supports_dual_band = 6; +inline bool ConnectionsLog_AdvertisingMetadata::_internal_has_supports_dual_band() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ConnectionsLog_AdvertisingMetadata::has_supports_dual_band() const { + return _internal_has_supports_dual_band(); +} +inline void ConnectionsLog_AdvertisingMetadata::clear_supports_dual_band() { + supports_dual_band_ = false; + _has_bits_[0] &= ~0x00000010u; +} +inline bool ConnectionsLog_AdvertisingMetadata::_internal_supports_dual_band() const { + return supports_dual_band_; +} +inline bool ConnectionsLog_AdvertisingMetadata::supports_dual_band() const { + // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.AdvertisingMetadata.supports_dual_band) + return _internal_supports_dual_band(); +} +inline void ConnectionsLog_AdvertisingMetadata::_internal_set_supports_dual_band(bool value) { + _has_bits_[0] |= 0x00000010u; + supports_dual_band_ = value; +} +inline void ConnectionsLog_AdvertisingMetadata::set_supports_dual_band(bool value) { + _internal_set_supports_dual_band(value); + // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.AdvertisingMetadata.supports_dual_band) +} + // ------------------------------------------------------------------- // ConnectionsLog_DiscoveryMetadata diff --git a/compiled_proto/proto/connections_enums.pb.cc b/compiled_proto/proto/connections_enums.pb.cc index 76d86f05..5796844a 100644 --- a/compiled_proto/proto/connections_enums.pb.cc +++ b/compiled_proto/proto/connections_enums.pb.cc @@ -720,15 +720,17 @@ bool DisconnectionReason_IsValid(int value) { case 5: case 6: case 7: + case 8: return true; default: return false; } } -static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed DisconnectionReason_strings[8] = {}; +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed DisconnectionReason_strings[9] = {}; static const char DisconnectionReason_names[] = + "AUTHENTICATION_FAILURE" "IO_ERROR" "LOCAL_DISCONNECTION" "PREV_CHANNEL_DISCONNECTION_IN_RECONNECT" @@ -739,25 +741,27 @@ static const char DisconnectionReason_names[] = "UPGRADED"; static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DisconnectionReason_entries[] = { - { {DisconnectionReason_names + 0, 8}, 3 }, - { {DisconnectionReason_names + 8, 19}, 1 }, - { {DisconnectionReason_names + 27, 39}, 7 }, - { {DisconnectionReason_names + 66, 20}, 2 }, - { {DisconnectionReason_names + 86, 8}, 5 }, - { {DisconnectionReason_names + 94, 10}, 6 }, - { {DisconnectionReason_names + 104, 28}, 0 }, - { {DisconnectionReason_names + 132, 8}, 4 }, + { {DisconnectionReason_names + 0, 22}, 8 }, + { {DisconnectionReason_names + 22, 8}, 3 }, + { {DisconnectionReason_names + 30, 19}, 1 }, + { {DisconnectionReason_names + 49, 39}, 7 }, + { {DisconnectionReason_names + 88, 20}, 2 }, + { {DisconnectionReason_names + 108, 8}, 5 }, + { {DisconnectionReason_names + 116, 10}, 6 }, + { {DisconnectionReason_names + 126, 28}, 0 }, + { {DisconnectionReason_names + 154, 8}, 4 }, }; static const int DisconnectionReason_entries_by_number[] = { - 6, // 0 -> UNKNOWN_DISCONNECTION_REASON - 1, // 1 -> LOCAL_DISCONNECTION - 3, // 2 -> REMOTE_DISCONNECTION - 0, // 3 -> IO_ERROR - 7, // 4 -> UPGRADED - 4, // 5 -> SHUTDOWN - 5, // 6 -> UNFINISHED - 2, // 7 -> PREV_CHANNEL_DISCONNECTION_IN_RECONNECT + 7, // 0 -> UNKNOWN_DISCONNECTION_REASON + 2, // 1 -> LOCAL_DISCONNECTION + 4, // 2 -> REMOTE_DISCONNECTION + 1, // 3 -> IO_ERROR + 8, // 4 -> UPGRADED + 5, // 5 -> SHUTDOWN + 6, // 6 -> UNFINISHED + 3, // 7 -> PREV_CHANNEL_DISCONNECTION_IN_RECONNECT + 0, // 8 -> AUTHENTICATION_FAILURE }; const std::string& DisconnectionReason_Name( @@ -766,12 +770,12 @@ const std::string& DisconnectionReason_Name( ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( DisconnectionReason_entries, DisconnectionReason_entries_by_number, - 8, DisconnectionReason_strings); + 9, DisconnectionReason_strings); (void) dummy; int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( DisconnectionReason_entries, DisconnectionReason_entries_by_number, - 8, value); + 9, value); return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : DisconnectionReason_strings[idx].get(); } @@ -779,7 +783,7 @@ bool DisconnectionReason_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DisconnectionReason* value) { int int_value; bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( - DisconnectionReason_entries, 8, name, &int_value); + DisconnectionReason_entries, 9, name, &int_value); if (success) { *value = static_cast(int_value); } @@ -1505,7 +1509,7 @@ bool OperationResultCategory_Parse( } return success; } -bool OperationResultDetail_IsValid(int value) { +bool OperationResultCode_IsValid(int value) { switch (value) { case 0: case 1: @@ -1678,6 +1682,8 @@ bool OperationResultDetail_IsValid(int value) { case 3553: case 3554: case 3555: + case 3556: + case 3557: case 4500: case 4501: case 4502: @@ -1751,9 +1757,9 @@ bool OperationResultDetail_IsValid(int value) { } } -static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed OperationResultDetail_strings[238] = {}; +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed OperationResultCode_strings[240] = {}; -static const char OperationResultDetail_names[] = +static const char OperationResultCode_names[] = "CLIENT_CANCELLATION_BT_SERVER_SOCKET_CREATION" "CLIENT_CANCELLATION_CANCEL_BLE_OUTGOING_CONNECTION" "CLIENT_CANCELLATION_CANCEL_BT_OUTGOING_CONNECTION" @@ -1809,6 +1815,7 @@ static const char OperationResultDetail_names[] = "CONNECTIVITY_GENERIC_WRITING_CHANNEL_IO_ERROR" "CONNECTIVITY_L2CAP_CLIENT_OBTAIN_FAIURE" "CONNECTIVITY_L2CAP_CLIENT_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_L2CAP_CLIENT_SOCKET_CREATION_TIMEOUT_FAILURE" "CONNECTIVITY_L2CAP_DATA_CONNECTION_FAILURE" "CONNECTIVITY_L2CAP_SERVER_SOCKET_CREATION_FAILURE" "CONNECTIVITY_L2CAP_SERVER_SOCKET_CREATION_SECURITY_EXCEPTION_FAILURE" @@ -1823,6 +1830,7 @@ static const char OperationResultDetail_names[] = "CONNECTIVITY_WEB_RTC_CONNECT_TO_TACHYON_FAILURE" "CONNECTIVITY_WEB_RTC_INVALID_CREDENTIAL" "CONNECTIVITY_WEB_RTC_SERVER_SOCKET_CREATION_FAILURE" + "CONNECTIVITY_WEB_RTC_UNSATISFIED_LINK_ERROR" "CONNECTIVITY_WIFI_AWARE_ATTACH_FAILURE" "CONNECTIVITY_WIFI_AWARE_CLIENT_SOCKET_CREATION_FAILURE" "CONNECTIVITY_WIFI_AWARE_DISCOVERED_PEER_NULL" @@ -1859,8 +1867,8 @@ static const char OperationResultDetail_names[] = "DEVICE_STATE_RADIO_DISABLING_FAILURE" "DEVICE_STATE_RADIO_ENABLING_FAILURE" "IO_ENDPOINT_IO_ERROR_ON_BLE" + "IO_ENDPOINT_IO_ERROR_ON_BLE_L2CAP" "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" @@ -1993,250 +2001,252 @@ static const char OperationResultDetail_names[] = "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 ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry OperationResultCode_entries[] = { + { {OperationResultCode_names + 0, 45}, 519 }, + { {OperationResultCode_names + 45, 50}, 504 }, + { {OperationResultCode_names + 95, 49}, 505 }, + { {OperationResultCode_names + 144, 46}, 515 }, + { {OperationResultCode_names + 190, 52}, 506 }, + { {OperationResultCode_names + 242, 50}, 507 }, + { {OperationResultCode_names + 292, 50}, 508 }, + { {OperationResultCode_names + 342, 46}, 514 }, + { {OperationResultCode_names + 388, 50}, 509 }, + { {OperationResultCode_names + 438, 54}, 513 }, + { {OperationResultCode_names + 492, 57}, 510 }, + { {OperationResultCode_names + 549, 58}, 511 }, + { {OperationResultCode_names + 607, 59}, 512 }, + { {OperationResultCode_names + 666, 40}, 501 }, + { {OperationResultCode_names + 706, 36}, 522 }, + { {OperationResultCode_names + 742, 41}, 502 }, + { {OperationResultCode_names + 783, 37}, 523 }, + { {OperationResultCode_names + 820, 44}, 500 }, + { {OperationResultCode_names + 864, 46}, 503 }, + { {OperationResultCode_names + 910, 50}, 520 }, + { {OperationResultCode_names + 960, 53}, 516 }, + { {OperationResultCode_names + 1013, 54}, 517 }, + { {OperationResultCode_names + 1067, 55}, 518 }, + { {OperationResultCode_names + 1122, 51}, 521 }, + { {OperationResultCode_names + 1173, 49}, 2002 }, + { {OperationResultCode_names + 1222, 48}, 2004 }, + { {OperationResultCode_names + 1270, 51}, 2003 }, + { {OperationResultCode_names + 1321, 49}, 2005 }, + { {OperationResultCode_names + 1370, 49}, 2006 }, + { {OperationResultCode_names + 1419, 49}, 2011 }, + { {OperationResultCode_names + 1468, 53}, 2007 }, + { {OperationResultCode_names + 1521, 56}, 2008 }, + { {OperationResultCode_names + 1577, 57}, 2010 }, + { {OperationResultCode_names + 1634, 58}, 2009 }, + { {OperationResultCode_names + 1692, 46}, 2012 }, + { {OperationResultCode_names + 1738, 47}, 2015 }, + { {OperationResultCode_names + 1785, 47}, 2013 }, + { {OperationResultCode_names + 1832, 48}, 2014 }, + { {OperationResultCode_names + 1880, 43}, 2016 }, + { {OperationResultCode_names + 1923, 63}, 2000 }, + { {OperationResultCode_names + 1986, 59}, 2001 }, + { {OperationResultCode_names + 2045, 47}, 3502 }, + { {OperationResultCode_names + 2092, 47}, 3513 }, + { {OperationResultCode_names + 2139, 47}, 3539 }, + { {OperationResultCode_names + 2186, 44}, 3501 }, + { {OperationResultCode_names + 2230, 41}, 3518 }, + { {OperationResultCode_names + 2271, 46}, 3504 }, + { {OperationResultCode_names + 2317, 46}, 3541 }, + { {OperationResultCode_names + 2363, 65}, 3555 }, + { {OperationResultCode_names + 2428, 37}, 3538 }, + { {OperationResultCode_names + 2465, 39}, 3553 }, + { {OperationResultCode_names + 2504, 59}, 3551 }, + { {OperationResultCode_names + 2563, 45}, 3550 }, + { {OperationResultCode_names + 2608, 39}, 3525 }, + { {OperationResultCode_names + 2647, 49}, 3503 }, + { {OperationResultCode_names + 2696, 57}, 3556 }, + { {OperationResultCode_names + 2753, 42}, 3526 }, + { {OperationResultCode_names + 2795, 49}, 3540 }, + { {OperationResultCode_names + 2844, 68}, 3554 }, + { {OperationResultCode_names + 2912, 47}, 3505 }, + { {OperationResultCode_names + 2959, 47}, 3531 }, + { {OperationResultCode_names + 3006, 47}, 3542 }, + { {OperationResultCode_names + 3053, 28}, 3529 }, + { {OperationResultCode_names + 3081, 47}, 3506 }, + { {OperationResultCode_names + 3128, 47}, 3547 }, + { {OperationResultCode_names + 3175, 47}, 3511 }, + { {OperationResultCode_names + 3222, 51}, 3507 }, + { {OperationResultCode_names + 3273, 47}, 3512 }, + { {OperationResultCode_names + 3320, 39}, 3523 }, + { {OperationResultCode_names + 3359, 51}, 3543 }, + { {OperationResultCode_names + 3410, 43}, 3557 }, + { {OperationResultCode_names + 3453, 38}, 3500 }, + { {OperationResultCode_names + 3491, 54}, 3508 }, + { {OperationResultCode_names + 3545, 44}, 3552 }, + { {OperationResultCode_names + 3589, 53}, 3515 }, + { {OperationResultCode_names + 3642, 51}, 3514 }, + { {OperationResultCode_names + 3693, 42}, 3522 }, + { {OperationResultCode_names + 3735, 62}, 3527 }, + { {OperationResultCode_names + 3797, 65}, 3528 }, + { {OperationResultCode_names + 3862, 54}, 3544 }, + { {OperationResultCode_names + 3916, 46}, 3549 }, + { {OperationResultCode_names + 3962, 55}, 3510 }, + { {OperationResultCode_names + 4017, 55}, 3532 }, + { {OperationResultCode_names + 4072, 54}, 3516 }, + { {OperationResultCode_names + 4126, 43}, 3520 }, + { {OperationResultCode_names + 4169, 55}, 3535 }, + { {OperationResultCode_names + 4224, 51}, 3537 }, + { {OperationResultCode_names + 4275, 55}, 3546 }, + { {OperationResultCode_names + 4330, 56}, 3509 }, + { {OperationResultCode_names + 4386, 56}, 3533 }, + { {OperationResultCode_names + 4442, 55}, 3517 }, + { {OperationResultCode_names + 4497, 44}, 3521 }, + { {OperationResultCode_names + 4541, 47}, 3530 }, + { {OperationResultCode_names + 4588, 56}, 3534 }, + { {OperationResultCode_names + 4644, 52}, 3536 }, + { {OperationResultCode_names + 4696, 56}, 3545 }, + { {OperationResultCode_names + 4752, 50}, 3548 }, + { {OperationResultCode_names + 4802, 40}, 3519 }, + { {OperationResultCode_names + 4842, 38}, 3524 }, + { {OperationResultCode_names + 4880, 14}, 1 }, + { {OperationResultCode_names + 4894, 14}, 0 }, + { {OperationResultCode_names + 4908, 46}, 1000 }, + { {OperationResultCode_names + 4954, 39}, 1001 }, + { {OperationResultCode_names + 4993, 30}, 1002 }, + { {OperationResultCode_names + 5023, 36}, 1003 }, + { {OperationResultCode_names + 5059, 35}, 1004 }, + { {OperationResultCode_names + 5094, 27}, 3005 }, + { {OperationResultCode_names + 5121, 33}, 3006 }, + { {OperationResultCode_names + 5154, 26}, 3007 }, + { {OperationResultCode_names + 5180, 27}, 3009 }, + { {OperationResultCode_names + 5207, 27}, 3013 }, + { {OperationResultCode_names + 5234, 27}, 3014 }, + { {OperationResultCode_names + 5261, 31}, 3008 }, + { {OperationResultCode_names + 5292, 34}, 3012 }, + { {OperationResultCode_names + 5326, 35}, 3010 }, + { {OperationResultCode_names + 5361, 36}, 3011 }, + { {OperationResultCode_names + 5397, 21}, 3000 }, + { {OperationResultCode_names + 5418, 21}, 3001 }, + { {OperationResultCode_names + 5439, 21}, 3002 }, + { {OperationResultCode_names + 5460, 24}, 3003 }, + { {OperationResultCode_names + 5484, 29}, 3004 }, + { {OperationResultCode_names + 5513, 51}, 1534 }, + { {OperationResultCode_names + 5564, 60}, 1535 }, + { {OperationResultCode_names + 5624, 47}, 1515 }, + { {OperationResultCode_names + 5671, 36}, 1505 }, + { {OperationResultCode_names + 5707, 42}, 1507 }, + { {OperationResultCode_names + 5749, 46}, 1516 }, + { {OperationResultCode_names + 5795, 45}, 1501 }, + { {OperationResultCode_names + 5840, 38}, 1506 }, + { {OperationResultCode_names + 5878, 47}, 1517 }, + { {OperationResultCode_names + 5925, 36}, 1513 }, + { {OperationResultCode_names + 5961, 54}, 1532 }, + { {OperationResultCode_names + 6015, 49}, 1503 }, + { {OperationResultCode_names + 6064, 52}, 1504 }, + { {OperationResultCode_names + 6116, 47}, 1518 }, + { {OperationResultCode_names + 6163, 36}, 1512 }, + { {OperationResultCode_names + 6199, 60}, 1536 }, + { {OperationResultCode_names + 6259, 43}, 1533 }, + { {OperationResultCode_names + 6302, 38}, 1502 }, + { {OperationResultCode_names + 6340, 41}, 1537 }, + { {OperationResultCode_names + 6381, 55}, 1526 }, + { {OperationResultCode_names + 6436, 54}, 1530 }, + { {OperationResultCode_names + 6490, 57}, 1527 }, + { {OperationResultCode_names + 6547, 55}, 1529 }, + { {OperationResultCode_names + 6602, 55}, 1531 }, + { {OperationResultCode_names + 6657, 59}, 1528 }, + { {OperationResultCode_names + 6716, 47}, 1519 }, + { {OperationResultCode_names + 6763, 36}, 1514 }, + { {OperationResultCode_names + 6799, 51}, 1520 }, + { {OperationResultCode_names + 6850, 40}, 1508 }, + { {OperationResultCode_names + 6890, 38}, 1538 }, + { {OperationResultCode_names + 6928, 54}, 1521 }, + { {OperationResultCode_names + 6982, 43}, 1509 }, + { {OperationResultCode_names + 7025, 52}, 1500 }, + { {OperationResultCode_names + 7077, 55}, 1523 }, + { {OperationResultCode_names + 7132, 44}, 1511 }, + { {OperationResultCode_names + 7176, 57}, 1525 }, + { {OperationResultCode_names + 7233, 56}, 1522 }, + { {OperationResultCode_names + 7289, 45}, 1510 }, + { {OperationResultCode_names + 7334, 58}, 1524 }, + { {OperationResultCode_names + 7392, 38}, 2503 }, + { {OperationResultCode_names + 7430, 41}, 2500 }, + { {OperationResultCode_names + 7471, 59}, 2510 }, + { {OperationResultCode_names + 7530, 37}, 2505 }, + { {OperationResultCode_names + 7567, 40}, 2504 }, + { {OperationResultCode_names + 7607, 33}, 2501 }, + { {OperationResultCode_names + 7640, 52}, 2511 }, + { {OperationResultCode_names + 7692, 55}, 2512 }, + { {OperationResultCode_names + 7747, 45}, 2506 }, + { {OperationResultCode_names + 7792, 46}, 2507 }, + { {OperationResultCode_names + 7838, 56}, 2502 }, + { {OperationResultCode_names + 7894, 47}, 2509 }, + { {OperationResultCode_names + 7941, 43}, 2508 }, + { {OperationResultCode_names + 7984, 45}, 4500 }, + { {OperationResultCode_names + 8029, 44}, 4504 }, + { {OperationResultCode_names + 8073, 49}, 4515 }, + { {OperationResultCode_names + 8122, 29}, 4518 }, + { {OperationResultCode_names + 8151, 38}, 4536 }, + { {OperationResultCode_names + 8189, 48}, 4501 }, + { {OperationResultCode_names + 8237, 43}, 4506 }, + { {OperationResultCode_names + 8280, 35}, 4530 }, + { {OperationResultCode_names + 8315, 23}, 4520 }, + { {OperationResultCode_names + 8338, 37}, 4538 }, + { {OperationResultCode_names + 8375, 41}, 4563 }, + { {OperationResultCode_names + 8416, 32}, 4503 }, + { {OperationResultCode_names + 8448, 35}, 4514 }, + { {OperationResultCode_names + 8483, 45}, 4552 }, + { {OperationResultCode_names + 8528, 40}, 4532 }, + { {OperationResultCode_names + 8568, 40}, 4535 }, + { {OperationResultCode_names + 8608, 48}, 4547 }, + { {OperationResultCode_names + 8656, 60}, 4556 }, + { {OperationResultCode_names + 8716, 56}, 4558 }, + { {OperationResultCode_names + 8772, 60}, 4557 }, + { {OperationResultCode_names + 8832, 56}, 4553 }, + { {OperationResultCode_names + 8888, 52}, 4555 }, + { {OperationResultCode_names + 8940, 56}, 4554 }, + { {OperationResultCode_names + 8996, 43}, 4559 }, + { {OperationResultCode_names + 9039, 43}, 4560 }, + { {OperationResultCode_names + 9082, 37}, 4561 }, + { {OperationResultCode_names + 9119, 41}, 4562 }, + { {OperationResultCode_names + 9160, 46}, 4505 }, + { {OperationResultCode_names + 9206, 26}, 4519 }, + { {OperationResultCode_names + 9232, 40}, 4537 }, + { {OperationResultCode_names + 9272, 29}, 4566 }, + { {OperationResultCode_names + 9301, 44}, 4507 }, + { {OperationResultCode_names + 9345, 36}, 4531 }, + { {OperationResultCode_names + 9381, 24}, 4525 }, + { {OperationResultCode_names + 9405, 38}, 4539 }, + { {OperationResultCode_names + 9443, 42}, 4564 }, + { {OperationResultCode_names + 9485, 44}, 4508 }, + { {OperationResultCode_names + 9529, 24}, 4522 }, + { {OperationResultCode_names + 9553, 44}, 4513 }, + { {OperationResultCode_names + 9597, 24}, 4521 }, + { {OperationResultCode_names + 9621, 35}, 4502 }, + { {OperationResultCode_names + 9656, 48}, 4512 }, + { {OperationResultCode_names + 9704, 28}, 4524 }, + { {OperationResultCode_names + 9732, 42}, 4540 }, + { {OperationResultCode_names + 9774, 51}, 4509 }, + { {OperationResultCode_names + 9825, 31}, 4523 }, + { {OperationResultCode_names + 9856, 45}, 4541 }, + { {OperationResultCode_names + 9901, 52}, 4511 }, + { {OperationResultCode_names + 9953, 39}, 4516 }, + { {OperationResultCode_names + 9992, 41}, 4533 }, + { {OperationResultCode_names + 10033, 32}, 4527 }, + { {OperationResultCode_names + 10065, 32}, 4529 }, + { {OperationResultCode_names + 10097, 28}, 4528 }, + { {OperationResultCode_names + 10125, 46}, 4546 }, + { {OperationResultCode_names + 10171, 48}, 4549 }, + { {OperationResultCode_names + 10219, 48}, 4551 }, + { {OperationResultCode_names + 10267, 54}, 4545 }, + { {OperationResultCode_names + 10321, 54}, 4542 }, + { {OperationResultCode_names + 10375, 53}, 4510 }, + { {OperationResultCode_names + 10428, 40}, 4517 }, + { {OperationResultCode_names + 10468, 52}, 4544 }, + { {OperationResultCode_names + 10520, 44}, 4534 }, + { {OperationResultCode_names + 10564, 33}, 4526 }, + { {OperationResultCode_names + 10597, 49}, 4548 }, + { {OperationResultCode_names + 10646, 49}, 4550 }, + { {OperationResultCode_names + 10695, 55}, 4543 }, + { {OperationResultCode_names + 10750, 32}, 4565 }, }; -static const int OperationResultDetail_entries_by_number[] = { - 98, // 0 -> DETAIL_UNKNOWN - 97, // 1 -> DETAIL_SUCCESS +static const int OperationResultCode_entries_by_number[] = { + 100, // 0 -> DETAIL_UNKNOWN + 99, // 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 @@ -2261,50 +2271,50 @@ static const int OperationResultDetail_entries_by_number[] = { 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 + 101, // 1000 -> DEVICE_STATE_ERROR_UNFINISHED_UPGRADE_ATTEMPTS + 102, // 1001 -> DEVICE_STATE_ERROR_USER_HOTSPOT_ENABLED + 103, // 1002 -> DEVICE_STATE_LOCATION_DISABLED + 104, // 1003 -> DEVICE_STATE_RADIO_DISABLING_FAILURE + 105, // 1004 -> DEVICE_STATE_RADIO_ENABLING_FAILURE + 153, // 1500 -> MEDIUM_UNAVAILABLE_WIFI_AWARE_RESOURCE_NOT_AVAILABLE + 127, // 1501 -> MEDIUM_UNAVAILABLE_DIRECT_HOTSPOT_NOT_SUPPORT + 138, // 1502 -> MEDIUM_UNAVAILABLE_SOFT_AP_NOT_SUPPORT + 132, // 1503 -> MEDIUM_UNAVAILABLE_LOCAL_ONLY_HOTSPOT_NOT_SUPPORT + 133, // 1504 -> MEDIUM_UNAVAILABLE_LOCAL_ONLY_HOTSPOT_NOT_SUPPORT_5G + 124, // 1505 -> MEDIUM_UNAVAILABLE_BLE_NOT_AVAILABLE + 128, // 1506 -> MEDIUM_UNAVAILABLE_L2CAP_NOT_AVAILABLE + 125, // 1507 -> MEDIUM_UNAVAILABLE_BLUETOOTH_NOT_AVAILABLE + 149, // 1508 -> MEDIUM_UNAVAILABLE_WEB_RTC_NOT_AVAILABLE + 152, // 1509 -> MEDIUM_UNAVAILABLE_WIFI_AWARE_NOT_AVAILABLE + 158, // 1510 -> MEDIUM_UNAVAILABLE_WIFI_HOTSPOT_NOT_AVAILABLE + 155, // 1511 -> MEDIUM_UNAVAILABLE_WIFI_DIRECT_NOT_AVAILABLE + 135, // 1512 -> MEDIUM_UNAVAILABLE_NFC_NOT_AVAILABLE + 130, // 1513 -> MEDIUM_UNAVAILABLE_LAN_NOT_AVAILABLE + 147, // 1514 -> MEDIUM_UNAVAILABLE_USB_NOT_AVAILABLE + 123, // 1515 -> MEDIUM_UNAVAILABLE_BLE_NC_LOGICAL_NOT_AVAILABLE + 126, // 1516 -> MEDIUM_UNAVAILABLE_BT_NC_LOGICAL_NOT_AVAILABLE + 129, // 1517 -> MEDIUM_UNAVAILABLE_LAN_NC_LOGICAL_NOT_AVAILABLE + 134, // 1518 -> MEDIUM_UNAVAILABLE_NFC_NC_LOGICAL_NOT_AVAILABLE + 146, // 1519 -> MEDIUM_UNAVAILABLE_USB_NC_LOGICAL_NOT_AVAILABLE + 148, // 1520 -> MEDIUM_UNAVAILABLE_WEB_RTC_NC_LOGICAL_NOT_AVAILABLE + 151, // 1521 -> MEDIUM_UNAVAILABLE_WIFI_AWARE_NC_LOGICAL_NOT_AVAILABLE + 157, // 1522 -> MEDIUM_UNAVAILABLE_WIFI_HOTSPOT_NC_LOGICAL_NOT_AVAILABLE + 154, // 1523 -> MEDIUM_UNAVAILABLE_WIFI_DIRECT_NC_LOGICAL_NOT_AVAILABLE + 159, // 1524 -> MEDIUM_UNAVAILABLE_WIFI_HOTSPOT_P2P_RESOURCE_NOT_AVAILABLE + 156, // 1525 -> MEDIUM_UNAVAILABLE_WIFI_DIRECT_P2P_RESOURCE_NOT_AVAILABLE + 140, // 1526 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_BLE_LOW_QUALITY_MEDIUMS + 142, // 1527 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_L2CAP_LOW_QUALITY_MEDIUMS + 145, // 1528 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_WEB_RTC_LOW_QUALITY_MEDIUMS + 143, // 1529 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_LAN_LOW_QUALITY_MEDIUMS + 141, // 1530 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_BT_LOW_QUALITY_MEDIUMS + 144, // 1531 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_USB_LOW_QUALITY_MEDIUMS + 131, // 1532 -> MEDIUM_UNAVAILABLE_LOCAL_ONLY_HOTSPOT_DISRUPTIVE_FALSE + 137, // 1533 -> MEDIUM_UNAVAILABLE_SOFT_AP_DISRUPTIVE_FALSE + 121, // 1534 -> MEDIUM_UNAVAILABLE_ALREADY_HAVE_A_WIFI_DIRECT_GROUP + 122, // 1535 -> MEDIUM_UNAVAILABLE_ALREADY_HOSTING_HOTSPOT_FOR_OTHER_CLIENTS + 136, // 1536 -> MEDIUM_UNAVAILABLE_REJECT_L2CAP_ON_GATT_MULTIPLEX_CONNECTION + 139, // 1537 -> MEDIUM_UNAVAILABLE_UPGRADE_ON_SAME_MEDIUM + 150, // 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 @@ -2322,181 +2332,183 @@ static const int OperationResultDetail_entries_by_number[] = { 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 + 161, // 2500 -> MISCELLEANEOUS_BLUETOOTH_MAC_ADDRESS_NULL + 165, // 2501 -> MISCELLEANEOUS_MOVE_TO_NEW_MEDIUM + 170, // 2502 -> MISCELLEANEOUS_WIFI_HOTSPOT_SOFT_AP_BLOCKED_BY_PROVISION + 160, // 2503 -> MISCELLEANEOUS_BLE_SYSTEM_SERVICE_NULL + 164, // 2504 -> MISCELLEANEOUS_L2CAP_SYSTEM_SERVICE_NULL + 163, // 2505 -> MISCELLEANEOUS_BT_SYSTEM_SERVICE_NULL + 168, // 2506 -> MISCELLEANEOUS_WIFI_AWARE_SYSTEM_SERVICE_NULL + 169, // 2507 -> MISCELLEANEOUS_WIFI_DIRECT_SYSTEM_SERVICE_NULL + 172, // 2508 -> MISCELLEANEOUS_WIFI_LAN_SYSTEM_SERVICE_NULL + 171, // 2509 -> MISCELLEANEOUS_WIFI_HOTSPOT_SYSTEM_SERVICE_NULL + 162, // 2510 -> MISCELLEANEOUS_BT_NOT_ACCEPTING_CONNECTION_FOR_WORK_PROFILE + 166, // 2511 -> MISCELLEANEOUS_WEB_RTC_GET_DROIDGUARD_RESULT_FAILURE + 167, // 2512 -> MISCELLEANEOUS_WEB_RTC_TACHYON_SIGNALING_MESSENGER_NULL + 116, // 3000 -> IO_FILE_OPENING_ERROR + 117, // 3001 -> IO_FILE_READING_ERROR + 118, // 3002 -> IO_FILE_WRITING_ERROR + 119, // 3003 -> IO_FOLDER_CREATION_ERROR + 120, // 3004 -> IO_STREAM_CREATE_PIPE_FAILURE + 106, // 3005 -> IO_ENDPOINT_IO_ERROR_ON_BLE + 107, // 3006 -> IO_ENDPOINT_IO_ERROR_ON_BLE_L2CAP + 108, // 3007 -> IO_ENDPOINT_IO_ERROR_ON_BT + 112, // 3008 -> IO_ENDPOINT_IO_ERROR_ON_WEB_RTC + 109, // 3009 -> IO_ENDPOINT_IO_ERROR_ON_LAN + 114, // 3010 -> IO_ENDPOINT_IO_ERROR_ON_WIFI_DIRECT + 115, // 3011 -> IO_ENDPOINT_IO_ERROR_ON_WIFI_HOTSPOT + 113, // 3012 -> IO_ENDPOINT_IO_ERROR_ON_WIFI_AWARE + 110, // 3013 -> IO_ENDPOINT_IO_ERROR_ON_NFC + 111, // 3014 -> IO_ENDPOINT_IO_ERROR_ON_USB + 71, // 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 + 59, // 3505 -> CONNECTIVITY_LAN_CLIENT_SOCKET_CREATION_FAILURE + 63, // 3506 -> CONNECTIVITY_NFC_CLIENT_SOCKET_CREATION_FAILURE + 66, // 3507 -> CONNECTIVITY_WEB_RTC_CLIENT_SOCKET_CREATION_FAILURE + 72, // 3508 -> CONNECTIVITY_WIFI_AWARE_CLIENT_SOCKET_CREATION_FAILURE + 88, // 3509 -> CONNECTIVITY_WIFI_HOTSPOT_CLIENT_SOCKET_CREATION_FAILURE + 81, // 3510 -> CONNECTIVITY_WIFI_DIRECT_CLIENT_SOCKET_CREATION_FAILURE + 65, // 3511 -> CONNECTIVITY_USB_CLIENT_SOCKET_CREATION_FAILURE + 67, // 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 + 75, // 3514 -> CONNECTIVITY_WIFI_AWARE_GET_REMOTE_IP_FRAME_FAILURE + 74, // 3515 -> CONNECTIVITY_WIFI_AWARE_GET_REMOTE_IP_ADDRESS_FAILURE + 83, // 3516 -> CONNECTIVITY_WIFI_DIRECT_INCONSISTENT_HOSTED_WIFI_BAND + 90, // 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 + 97, // 3519 -> CONNECTIVITY_WIFI_LAN_INVALID_CREDENTIAL + 84, // 3520 -> CONNECTIVITY_WIFI_DIRECT_INVALID_CREDENTIAL + 91, // 3521 -> CONNECTIVITY_WIFI_HOTSPOT_INVALID_CREDENTIAL + 76, // 3522 -> CONNECTIVITY_WIFI_AWARE_INVALID_CREDENTIAL + 68, // 3523 -> CONNECTIVITY_WEB_RTC_INVALID_CREDENTIAL + 98, // 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 + 56, // 3526 -> CONNECTIVITY_L2CAP_DATA_CONNECTION_FAILURE + 77, // 3527 -> CONNECTIVITY_WIFI_AWARE_L2MESSAGE_NETWORK_AVAILABLE_FRAME_NULL + 78, // 3528 -> CONNECTIVITY_WIFI_AWARE_L2MESSAGE_SEND_HOST_NETWORK_FRAME_FAILURE + 62, // 3529 -> CONNECTIVITY_LAN_UNREACHABLE + 92, // 3530 -> CONNECTIVITY_WIFI_HOTSPOT_LOHS_CREATION_FAILURE + 60, // 3531 -> CONNECTIVITY_LAN_GET_NETWORK_INTERFACES_FAILURE + 82, // 3532 -> CONNECTIVITY_WIFI_DIRECT_GET_NETWORK_INTERFACES_FAILURE + 89, // 3533 -> CONNECTIVITY_WIFI_HOTSPOT_GET_NETWORK_INTERFACES_FAILURE + 93, // 3534 -> CONNECTIVITY_WIFI_HOTSPOT_P2P_CHANNEL_INITIALIZE_FAILURE + 85, // 3535 -> CONNECTIVITY_WIFI_DIRECT_P2P_CHANNEL_INITIALIZE_FAILURE + 94, // 3536 -> CONNECTIVITY_WIFI_HOTSPOT_P2P_GROUP_CREATION_FAILURE + 86, // 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 + 57, // 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 + 61, // 3542 -> CONNECTIVITY_LAN_SERVER_SOCKET_CREATION_FAILURE + 69, // 3543 -> CONNECTIVITY_WEB_RTC_SERVER_SOCKET_CREATION_FAILURE + 79, // 3544 -> CONNECTIVITY_WIFI_AWARE_SERVER_SOCKET_CREATION_FAILURE + 95, // 3545 -> CONNECTIVITY_WIFI_HOTSPOT_SERVER_SOCKET_CREATION_FAILURE + 87, // 3546 -> CONNECTIVITY_WIFI_DIRECT_SERVER_SOCKET_CREATION_FAILURE + 64, // 3547 -> CONNECTIVITY_NFC_SERVER_SOCKET_CREATION_FAILURE + 96, // 3548 -> CONNECTIVITY_WIFI_HOTSPOT_SOFT_AP_CREATION_FAILURE + 80, // 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 + 73, // 3552 -> CONNECTIVITY_WIFI_AWARE_DISCOVERED_PEER_NULL 50, // 3553 -> CONNECTIVITY_GENERIC_PAYLOAD_SENT_ERROR - 57, // 3554 -> CONNECTIVITY_L2CAP_SERVER_SOCKET_CREATION_SECURITY_EXCEPTION_FAILURE + 58, // 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 + 55, // 3556 -> CONNECTIVITY_L2CAP_CLIENT_SOCKET_CREATION_TIMEOUT_FAILURE + 70, // 3557 -> CONNECTIVITY_WEB_RTC_UNSATISFIED_LINK_ERROR + 173, // 4500 -> NEARBY_BLE_ADVERTISEMENT_MAPPING_TO_MAC_ERROR + 178, // 4501 -> NEARBY_BLUETOOTH_MAC_ADDRESS_INVALID_FOR_CONNECT + 213, // 4502 -> NEARBY_WEB_RTC_CONNECTION_FLOW_NULL + 184, // 4503 -> NEARBY_GENERIC_CONNECTION_CLOSED + 174, // 4504 -> NEARBY_BLE_ENDPOINT_CHANNEL_CREATION_FAILURE + 200, // 4505 -> NEARBY_L2CAP_ENDPOINT_CHANNEL_CREATION_FAILURE + 179, // 4506 -> NEARBY_BT_ENDPOINT_CHANNEL_CREATION_FAILURE + 204, // 4507 -> NEARBY_LAN_ENDPOINT_CHANNEL_CREATION_FAILURE + 209, // 4508 -> NEARBY_NFC_ENDPOINT_CHANNEL_CREATION_FAILURE + 217, // 4509 -> NEARBY_WIFI_AWARE_ENDPOINT_CHANNEL_CREATION_FAILURE + 231, // 4510 -> NEARBY_WIFI_HOTSPOT_ENDPOINT_CHANNEL_CREATION_FAILURE + 220, // 4511 -> NEARBY_WIFI_DIRECT_ENDPOINT_CHANNEL_CREATION_FAILURE + 214, // 4512 -> NEARBY_WEB_RTC_ENDPOINT_CHANNEL_CREATION_FAILURE + 211, // 4513 -> NEARBY_USB_ENDPOINT_CHANNEL_CREATION_FAILURE + 185, // 4514 -> NEARBY_GENERIC_ENDPOINT_UNENCRYPTED + 175, // 4515 -> NEARBY_BLE_GATT_ADVERTISEMENT_NULL_FOR_CONNECTION + 221, // 4516 -> NEARBY_WIFI_DIRECT_HOST_ON_SRD_CHANNELS + 232, // 4517 -> NEARBY_WIFI_HOTSPOT_HOST_ON_SRD_CHANNELS + 176, // 4518 -> NEARBY_BLE_GATT_NULL_CALLBACK + 201, // 4519 -> NEARBY_L2CAP_NULL_CALLBACK + 181, // 4520 -> NEARBY_BT_NULL_CALLBACK + 212, // 4521 -> NEARBY_USB_NULL_CALLBACK + 210, // 4522 -> NEARBY_NFC_NULL_CALLBACK + 218, // 4523 -> NEARBY_WIFI_AWARE_NULL_CALLBACK + 215, // 4524 -> NEARBY_WEB_RTC_NULL_CALLBACK + 206, // 4525 -> NEARBY_LAN_NULL_CALLBACK + 235, // 4526 -> NEARBY_WIFI_HOTSPOT_NULL_CALLBACK + 223, // 4527 -> NEARBY_WIFI_DIRECT_NULL_CALLBACK + 225, // 4528 -> NEARBY_WIFI_DIRECT_NULL_SSID + 224, // 4529 -> NEARBY_WIFI_DIRECT_NULL_PASSWORD + 180, // 4530 -> NEARBY_BT_MULTIPLEX_SOCKET_DISABLED + 205, // 4531 -> NEARBY_LAN_MULTIPLEX_SOCKET_DISABLED + 187, // 4532 -> NEARBY_GENERIC_NEW_ENDPOINT_CHANNEL_NULL + 222, // 4533 -> NEARBY_WIFI_DIRECT_NO_GROUP_FOR_LISTENING + 234, // 4534 -> NEARBY_WIFI_HOTSPOT_NO_HOTSPOT_FOR_LISTENING + 188, // 4535 -> NEARBY_GENERIC_OLD_ENDPOINT_CHANNEL_NULL + 177, // 4536 -> NEARBY_BLE_OPERATION_REGISTERED_FAILED + 202, // 4537 -> NEARBY_L2CAP_OPERATION_REGISTERED_FAILED + 182, // 4538 -> NEARBY_BT_OPERATION_REGISTERED_FAILED + 207, // 4539 -> NEARBY_LAN_OPERATION_REGISTERED_FAILED + 216, // 4540 -> NEARBY_WEB_RTC_OPERATION_REGISTERED_FAILED + 219, // 4541 -> NEARBY_WIFI_AWARE_OPERATION_REGISTERED_FAILED + 230, // 4542 -> NEARBY_WIFI_HOTSPOT_DIRECT_OPERATION_REGISTERED_FAILED + 238, // 4543 -> NEARBY_WIFI_HOTSPOT_SOFT_AP_OPERATION_REGISTERED_FAILED + 233, // 4544 -> NEARBY_WIFI_HOTSPOT_LOHS_OPERATION_REGISTERED_FAILED + 229, // 4545 -> NEARBY_WIFI_HOTSPOT_CLIENT_OPERATION_REGISTERED_FAILED + 226, // 4546 -> NEARBY_WIFI_DIRECT_OPERATION_REGISTERED_FAILED + 189, // 4547 -> NEARBY_GENERIC_OUTGOING_PAYLOAD_CREATION_FAILURE + 236, // 4548 -> NEARBY_WIFI_HOTSPOT_P2P_NON_DBS_WANT_2G_BUT_AP_5G + 227, // 4549 -> NEARBY_WIFI_DIRECT_P2P_NON_DBS_WANT_2G_BUT_AP_5G + 237, // 4550 -> NEARBY_WIFI_HOTSPOT_P2P_NON_DBS_WANT_5G_BUT_AP_2G + 228, // 4551 -> NEARBY_WIFI_DIRECT_P2P_NON_DBS_WANT_5G_BUT_AP_2G + 186, // 4552 -> NEARBY_GENERIC_INCOMING_PAYLOAD_NOT_DATA_TYPE + 193, // 4553 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_EVENT_TYPE_ERROR + 195, // 4554 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_FRAME_TYPE_ERROR + 194, // 4555 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_FORMAT_ERROR + 190, // 4556 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_EVENT_TYPE_ERROR + 192, // 4557 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_FRAME_TYPE_ERROR + 191, // 4558 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_FORMAT_ERROR + 196, // 4559 -> NEARBY_GENERIC_REMOTE_ENDPOINT_STATUS_ERROR + 197, // 4560 -> NEARBY_GENERIC_REMOTE_REPORT_PAYLOADS_ERROR + 198, // 4561 -> NEARBY_GENERIC_REMOTE_UPGRADE_FAILURE + 199, // 4562 -> NEARBY_GENERIC_SEND_PAYLOAD_EXECUTOR_NULL + 183, // 4563 -> NEARBY_BT_VIRTUAL_SOCKET_CREATION_FAILURE + 208, // 4564 -> NEARBY_LAN_VIRTUAL_SOCKET_CREATION_FAILURE + 239, // 4565 -> NEARBY_WIFI_LAN_IP_ADDRESS_ERROR + 203, // 4566 -> NEARBY_L2CAP_PSM_NOT_POSITIVE }; -const std::string& OperationResultDetail_Name( - OperationResultDetail value) { +const std::string& OperationResultCode_Name( + OperationResultCode value) { static const bool dummy = ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( - OperationResultDetail_entries, - OperationResultDetail_entries_by_number, - 238, OperationResultDetail_strings); + OperationResultCode_entries, + OperationResultCode_entries_by_number, + 240, OperationResultCode_strings); (void) dummy; int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( - OperationResultDetail_entries, - OperationResultDetail_entries_by_number, - 238, value); + OperationResultCode_entries, + OperationResultCode_entries_by_number, + 240, value); return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : - OperationResultDetail_strings[idx].get(); + OperationResultCode_strings[idx].get(); } -bool OperationResultDetail_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OperationResultDetail* value) { +bool OperationResultCode_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OperationResultCode* value) { int int_value; bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( - OperationResultDetail_entries, 238, name, &int_value); + OperationResultCode_entries, 240, name, &int_value); if (success) { - *value = static_cast(int_value); + *value = static_cast(int_value); } return success; } diff --git a/compiled_proto/proto/connections_enums.pb.h b/compiled_proto/proto/connections_enums.pb.h index c7023f89..8a173350 100644 --- a/compiled_proto/proto/connections_enums.pb.h +++ b/compiled_proto/proto/connections_enums.pb.h @@ -299,11 +299,12 @@ enum DisconnectionReason : int { UPGRADED = 4, SHUTDOWN = 5, UNFINISHED = 6, - PREV_CHANNEL_DISCONNECTION_IN_RECONNECT = 7 + PREV_CHANNEL_DISCONNECTION_IN_RECONNECT = 7, + AUTHENTICATION_FAILURE = 8 }; bool DisconnectionReason_IsValid(int value); constexpr DisconnectionReason DisconnectionReason_MIN = UNKNOWN_DISCONNECTION_REASON; -constexpr DisconnectionReason DisconnectionReason_MAX = PREV_CHANNEL_DISCONNECTION_IN_RECONNECT; +constexpr DisconnectionReason DisconnectionReason_MAX = AUTHENTICATION_FAILURE; constexpr int DisconnectionReason_ARRAYSIZE = DisconnectionReason_MAX + 1; const std::string& DisconnectionReason_Name(DisconnectionReason value); @@ -546,7 +547,7 @@ inline const std::string& OperationResultCategory_Name(T enum_t_value) { } bool OperationResultCategory_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OperationResultCategory* value); -enum OperationResultDetail : int { +enum OperationResultCode : int { DETAIL_UNKNOWN = 0, DETAIL_SUCCESS = 1, CLIENT_CANCELLATION_REMOTE_IN_CANCELED_STATE = 500, @@ -653,7 +654,7 @@ enum OperationResultDetail : int { 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_BLE_L2CAP = 3006, IO_ENDPOINT_IO_ERROR_ON_BT = 3007, IO_ENDPOINT_IO_ERROR_ON_WEB_RTC = 3008, IO_ENDPOINT_IO_ERROR_ON_LAN = 3009, @@ -718,6 +719,8 @@ enum OperationResultDetail : int { CONNECTIVITY_GENERIC_PAYLOAD_SENT_ERROR = 3553, CONNECTIVITY_L2CAP_SERVER_SOCKET_CREATION_SECURITY_EXCEPTION_FAILURE = 3554, CONNECTIVITY_BT_SERVER_SOCKET_CREATION_SECURITY_EXCEPTION_FAILURE = 3555, + CONNECTIVITY_L2CAP_CLIENT_SOCKET_CREATION_TIMEOUT_FAILURE = 3556, + CONNECTIVITY_WEB_RTC_UNSATISFIED_LINK_ERROR = 3557, NEARBY_BLE_ADVERTISEMENT_MAPPING_TO_MAC_ERROR = 4500, NEARBY_BLUETOOTH_MAC_ADDRESS_INVALID_FOR_CONNECT = 4501, NEARBY_WEB_RTC_CONNECTION_FLOW_NULL = 4502, @@ -786,21 +789,21 @@ enum OperationResultDetail : int { 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; +bool OperationResultCode_IsValid(int value); +constexpr OperationResultCode OperationResultCode_MIN = DETAIL_UNKNOWN; +constexpr OperationResultCode OperationResultCode_MAX = NEARBY_L2CAP_PSM_NOT_POSITIVE; +constexpr int OperationResultCode_ARRAYSIZE = OperationResultCode_MAX + 1; -const std::string& OperationResultDetail_Name(OperationResultDetail value); +const std::string& OperationResultCode_Name(OperationResultCode value); template -inline const std::string& OperationResultDetail_Name(T enum_t_value) { - static_assert(::std::is_same::value || +inline const std::string& OperationResultCode_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)); + "Incorrect type passed to function OperationResultCode_Name."); + return OperationResultCode_Name(static_cast(enum_t_value)); } -bool OperationResultDetail_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OperationResultDetail* value); +bool OperationResultCode_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OperationResultCode* value); // =================================================================== @@ -845,7 +848,7 @@ template <> struct is_proto_enum< ::location::nearby::proto::connections::Bandwi 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 {}; +template <> struct is_proto_enum< ::location::nearby::proto::connections::OperationResultCode> : ::std::true_type {}; PROTOBUF_NAMESPACE_CLOSE