mirror of
https://github.com/kidfromjupiter/nearby.git
synced 2026-09-15 15:16:12 -04:00
1602 lines
50 KiB
C++
1602 lines
50 KiB
C++
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: proto/errorcode/error_code_enums.proto
|
|
|
|
#include "proto/errorcode/error_code_enums.pb.h"
|
|
|
|
#include <algorithm>
|
|
|
|
#include <google/protobuf/io/coded_stream.h>
|
|
#include <google/protobuf/extension_set.h>
|
|
#include <google/protobuf/wire_format_lite.h>
|
|
// @@protoc_insertion_point(includes)
|
|
#include <google/protobuf/port_def.inc>
|
|
|
|
PROTOBUF_PRAGMA_INIT_SEG
|
|
namespace location {
|
|
namespace nearby {
|
|
namespace errorcode {
|
|
namespace proto {
|
|
} // namespace proto
|
|
} // namespace errorcode
|
|
} // namespace nearby
|
|
} // namespace location
|
|
namespace location {
|
|
namespace nearby {
|
|
namespace errorcode {
|
|
namespace proto {
|
|
bool ErrorType_IsValid(int value) {
|
|
switch (value) {
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ErrorType_strings[6] = {};
|
|
|
|
static const char ErrorType_names[] =
|
|
"DEVELOPING"
|
|
"DEVICE"
|
|
"NETWORK"
|
|
"OTHERS"
|
|
"SYSTEM"
|
|
"UNKNOWN_TYPE";
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ErrorType_entries[] = {
|
|
{ {ErrorType_names + 0, 10}, 1 },
|
|
{ {ErrorType_names + 10, 6}, 2 },
|
|
{ {ErrorType_names + 16, 7}, 4 },
|
|
{ {ErrorType_names + 23, 6}, 5 },
|
|
{ {ErrorType_names + 29, 6}, 3 },
|
|
{ {ErrorType_names + 35, 12}, 0 },
|
|
};
|
|
|
|
static const int ErrorType_entries_by_number[] = {
|
|
5, // 0 -> UNKNOWN_TYPE
|
|
0, // 1 -> DEVELOPING
|
|
1, // 2 -> DEVICE
|
|
4, // 3 -> SYSTEM
|
|
2, // 4 -> NETWORK
|
|
3, // 5 -> OTHERS
|
|
};
|
|
|
|
const std::string& ErrorType_Name(
|
|
ErrorType value) {
|
|
static const bool dummy =
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
|
|
ErrorType_entries,
|
|
ErrorType_entries_by_number,
|
|
6, ErrorType_strings);
|
|
(void) dummy;
|
|
int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
|
|
ErrorType_entries,
|
|
ErrorType_entries_by_number,
|
|
6, value);
|
|
return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
|
|
ErrorType_strings[idx].get();
|
|
}
|
|
bool ErrorType_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ErrorType* value) {
|
|
int int_value;
|
|
bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
|
|
ErrorType_entries, 6, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<ErrorType>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
bool Event_IsValid(int value) {
|
|
switch (value) {
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
case 9:
|
|
case 10:
|
|
case 11:
|
|
case 12:
|
|
case 13:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> Event_strings[14] = {};
|
|
|
|
static const char Event_names[] =
|
|
"ACCEPT_CONNECTION"
|
|
"CANCEL_PAYLOAD"
|
|
"CONNECT"
|
|
"DISCONNECT"
|
|
"RECEIVE_PAYLOAD"
|
|
"REJECT_CONNECTION"
|
|
"SEND_PAYLOAD"
|
|
"START_ADVERTISING"
|
|
"START_DISCOVERING"
|
|
"START_LISTENING_INCOMING_CONNECTION"
|
|
"STOP_ADVERTISING"
|
|
"STOP_DISCOVERING"
|
|
"STOP_LISTENING_INCOMING_CONNECTION"
|
|
"UNKNOWN_EVENT";
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry Event_entries[] = {
|
|
{ {Event_names + 0, 17}, 9 },
|
|
{ {Event_names + 17, 14}, 12 },
|
|
{ {Event_names + 31, 7}, 7 },
|
|
{ {Event_names + 38, 10}, 8 },
|
|
{ {Event_names + 48, 15}, 13 },
|
|
{ {Event_names + 63, 17}, 10 },
|
|
{ {Event_names + 80, 12}, 11 },
|
|
{ {Event_names + 92, 17}, 1 },
|
|
{ {Event_names + 109, 17}, 5 },
|
|
{ {Event_names + 126, 35}, 3 },
|
|
{ {Event_names + 161, 16}, 2 },
|
|
{ {Event_names + 177, 16}, 6 },
|
|
{ {Event_names + 193, 34}, 4 },
|
|
{ {Event_names + 227, 13}, 0 },
|
|
};
|
|
|
|
static const int Event_entries_by_number[] = {
|
|
13, // 0 -> UNKNOWN_EVENT
|
|
7, // 1 -> START_ADVERTISING
|
|
10, // 2 -> STOP_ADVERTISING
|
|
9, // 3 -> START_LISTENING_INCOMING_CONNECTION
|
|
12, // 4 -> STOP_LISTENING_INCOMING_CONNECTION
|
|
8, // 5 -> START_DISCOVERING
|
|
11, // 6 -> STOP_DISCOVERING
|
|
2, // 7 -> CONNECT
|
|
3, // 8 -> DISCONNECT
|
|
0, // 9 -> ACCEPT_CONNECTION
|
|
5, // 10 -> REJECT_CONNECTION
|
|
6, // 11 -> SEND_PAYLOAD
|
|
1, // 12 -> CANCEL_PAYLOAD
|
|
4, // 13 -> RECEIVE_PAYLOAD
|
|
};
|
|
|
|
const std::string& Event_Name(
|
|
Event value) {
|
|
static const bool dummy =
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
|
|
Event_entries,
|
|
Event_entries_by_number,
|
|
14, Event_strings);
|
|
(void) dummy;
|
|
int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
|
|
Event_entries,
|
|
Event_entries_by_number,
|
|
14, value);
|
|
return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
|
|
Event_strings[idx].get();
|
|
}
|
|
bool Event_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Event* value) {
|
|
int int_value;
|
|
bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
|
|
Event_entries, 14, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<Event>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
bool CommonError_IsValid(int value) {
|
|
switch (value) {
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> CommonError_strings[7] = {};
|
|
|
|
static const char CommonError_names[] =
|
|
"FLOW_CANCELED"
|
|
"INVALID_PARAMETER"
|
|
"MEDIUM_NOT_AVAILABLE"
|
|
"OUT_OF_RESOURCE"
|
|
"UNEXPECTED_CALL"
|
|
"UNEXPECTED_MEDIUM_STATE"
|
|
"UNKNOWN_ERROR";
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry CommonError_entries[] = {
|
|
{ {CommonError_names + 0, 13}, 5 },
|
|
{ {CommonError_names + 13, 17}, 1 },
|
|
{ {CommonError_names + 30, 20}, 2 },
|
|
{ {CommonError_names + 50, 15}, 4 },
|
|
{ {CommonError_names + 65, 15}, 6 },
|
|
{ {CommonError_names + 80, 23}, 3 },
|
|
{ {CommonError_names + 103, 13}, 0 },
|
|
};
|
|
|
|
static const int CommonError_entries_by_number[] = {
|
|
6, // 0 -> UNKNOWN_ERROR
|
|
1, // 1 -> INVALID_PARAMETER
|
|
2, // 2 -> MEDIUM_NOT_AVAILABLE
|
|
5, // 3 -> UNEXPECTED_MEDIUM_STATE
|
|
3, // 4 -> OUT_OF_RESOURCE
|
|
0, // 5 -> FLOW_CANCELED
|
|
4, // 6 -> UNEXPECTED_CALL
|
|
};
|
|
|
|
const std::string& CommonError_Name(
|
|
CommonError value) {
|
|
static const bool dummy =
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
|
|
CommonError_entries,
|
|
CommonError_entries_by_number,
|
|
7, CommonError_strings);
|
|
(void) dummy;
|
|
int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
|
|
CommonError_entries,
|
|
CommonError_entries_by_number,
|
|
7, value);
|
|
return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
|
|
CommonError_strings[idx].get();
|
|
}
|
|
bool CommonError_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CommonError* value) {
|
|
int int_value;
|
|
bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
|
|
CommonError_entries, 7, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<CommonError>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
bool StartAdvertisingError_IsValid(int value) {
|
|
switch (value) {
|
|
case 31:
|
|
case 32:
|
|
case 33:
|
|
case 34:
|
|
case 35:
|
|
case 36:
|
|
case 38:
|
|
case 40:
|
|
case 41:
|
|
case 42:
|
|
case 43:
|
|
case 44:
|
|
case 45:
|
|
case 46:
|
|
case 47:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> StartAdvertisingError_strings[15] = {};
|
|
|
|
static const char StartAdvertisingError_names[] =
|
|
"ACQUIRE_WIFI_AWARE_SESSION_FAILED"
|
|
"AWARE_UPDATE_PUBLISHING_FAILED"
|
|
"BLE_MAX_GATT_ADVERTISEMENT_SLOT_REACHED"
|
|
"BLUETOOTH_ALREADY_ADVERTISED"
|
|
"DUPLICATE_ADVERTISING_REQUESTED"
|
|
"FAST_ADVERTISEMENT_ALREADY_ADVERTISED"
|
|
"MODIFY_BLUETOOTH_NAME_FAILED"
|
|
"MULTIPLE_FAST_ADVERTISEMENT_NOT_ALLOWED"
|
|
"PERSIST_ORIGINAL_BLUETOOTH_NAME_FAILED"
|
|
"SHOULD_ACCEPT_CONNECTIONS_BEFORE_ADVERTISING_ON_WIFI_LAN"
|
|
"START_ADVERTISING_FAILED"
|
|
"START_EXTENDED_ADVERTISING_FAILED"
|
|
"START_GATT_SERVER_FAILED"
|
|
"START_LEGACY_ADVERTISING_FAILED"
|
|
"UNKNOWN_START_ADVERTISING_ERROR";
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry StartAdvertisingError_entries[] = {
|
|
{ {StartAdvertisingError_names + 0, 33}, 45 },
|
|
{ {StartAdvertisingError_names + 33, 30}, 47 },
|
|
{ {StartAdvertisingError_names + 63, 39}, 35 },
|
|
{ {StartAdvertisingError_names + 102, 28}, 40 },
|
|
{ {StartAdvertisingError_names + 130, 31}, 33 },
|
|
{ {StartAdvertisingError_names + 161, 37}, 32 },
|
|
{ {StartAdvertisingError_names + 198, 28}, 41 },
|
|
{ {StartAdvertisingError_names + 226, 39}, 31 },
|
|
{ {StartAdvertisingError_names + 265, 38}, 42 },
|
|
{ {StartAdvertisingError_names + 303, 56}, 44 },
|
|
{ {StartAdvertisingError_names + 359, 24}, 43 },
|
|
{ {StartAdvertisingError_names + 383, 33}, 38 },
|
|
{ {StartAdvertisingError_names + 416, 24}, 34 },
|
|
{ {StartAdvertisingError_names + 440, 31}, 36 },
|
|
{ {StartAdvertisingError_names + 471, 31}, 46 },
|
|
};
|
|
|
|
static const int StartAdvertisingError_entries_by_number[] = {
|
|
7, // 31 -> MULTIPLE_FAST_ADVERTISEMENT_NOT_ALLOWED
|
|
5, // 32 -> FAST_ADVERTISEMENT_ALREADY_ADVERTISED
|
|
4, // 33 -> DUPLICATE_ADVERTISING_REQUESTED
|
|
12, // 34 -> START_GATT_SERVER_FAILED
|
|
2, // 35 -> BLE_MAX_GATT_ADVERTISEMENT_SLOT_REACHED
|
|
13, // 36 -> START_LEGACY_ADVERTISING_FAILED
|
|
11, // 38 -> START_EXTENDED_ADVERTISING_FAILED
|
|
3, // 40 -> BLUETOOTH_ALREADY_ADVERTISED
|
|
6, // 41 -> MODIFY_BLUETOOTH_NAME_FAILED
|
|
8, // 42 -> PERSIST_ORIGINAL_BLUETOOTH_NAME_FAILED
|
|
10, // 43 -> START_ADVERTISING_FAILED
|
|
9, // 44 -> SHOULD_ACCEPT_CONNECTIONS_BEFORE_ADVERTISING_ON_WIFI_LAN
|
|
0, // 45 -> ACQUIRE_WIFI_AWARE_SESSION_FAILED
|
|
14, // 46 -> UNKNOWN_START_ADVERTISING_ERROR
|
|
1, // 47 -> AWARE_UPDATE_PUBLISHING_FAILED
|
|
};
|
|
|
|
const std::string& StartAdvertisingError_Name(
|
|
StartAdvertisingError value) {
|
|
static const bool dummy =
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
|
|
StartAdvertisingError_entries,
|
|
StartAdvertisingError_entries_by_number,
|
|
15, StartAdvertisingError_strings);
|
|
(void) dummy;
|
|
int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
|
|
StartAdvertisingError_entries,
|
|
StartAdvertisingError_entries_by_number,
|
|
15, value);
|
|
return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
|
|
StartAdvertisingError_strings[idx].get();
|
|
}
|
|
bool StartAdvertisingError_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StartAdvertisingError* value) {
|
|
int int_value;
|
|
bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
|
|
StartAdvertisingError_entries, 15, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<StartAdvertisingError>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
bool StopAdvertisingError_IsValid(int value) {
|
|
switch (value) {
|
|
case 31:
|
|
case 32:
|
|
case 33:
|
|
case 34:
|
|
case 35:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> StopAdvertisingError_strings[5] = {};
|
|
|
|
static const char StopAdvertisingError_names[] =
|
|
"RESTORE_BLUETOOTH_NAME_FAILED"
|
|
"STOP_ADVERTISING_FAILED"
|
|
"STOP_EXTENDED_ADVERTISING_FAILED"
|
|
"STOP_LEGACY_ADVERTISING_FAILED"
|
|
"UNKNOWN_STOP_ADVERTISING_ERROR";
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry StopAdvertisingError_entries[] = {
|
|
{ {StopAdvertisingError_names + 0, 29}, 32 },
|
|
{ {StopAdvertisingError_names + 29, 23}, 31 },
|
|
{ {StopAdvertisingError_names + 52, 32}, 34 },
|
|
{ {StopAdvertisingError_names + 84, 30}, 33 },
|
|
{ {StopAdvertisingError_names + 114, 30}, 35 },
|
|
};
|
|
|
|
static const int StopAdvertisingError_entries_by_number[] = {
|
|
1, // 31 -> STOP_ADVERTISING_FAILED
|
|
0, // 32 -> RESTORE_BLUETOOTH_NAME_FAILED
|
|
3, // 33 -> STOP_LEGACY_ADVERTISING_FAILED
|
|
2, // 34 -> STOP_EXTENDED_ADVERTISING_FAILED
|
|
4, // 35 -> UNKNOWN_STOP_ADVERTISING_ERROR
|
|
};
|
|
|
|
const std::string& StopAdvertisingError_Name(
|
|
StopAdvertisingError value) {
|
|
static const bool dummy =
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
|
|
StopAdvertisingError_entries,
|
|
StopAdvertisingError_entries_by_number,
|
|
5, StopAdvertisingError_strings);
|
|
(void) dummy;
|
|
int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
|
|
StopAdvertisingError_entries,
|
|
StopAdvertisingError_entries_by_number,
|
|
5, value);
|
|
return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
|
|
StopAdvertisingError_strings[idx].get();
|
|
}
|
|
bool StopAdvertisingError_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StopAdvertisingError* value) {
|
|
int int_value;
|
|
bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
|
|
StopAdvertisingError_entries, 5, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<StopAdvertisingError>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
bool StartDiscoveringError_IsValid(int value) {
|
|
switch (value) {
|
|
case 31:
|
|
case 32:
|
|
case 33:
|
|
case 34:
|
|
case 35:
|
|
case 36:
|
|
case 37:
|
|
case 38:
|
|
case 39:
|
|
case 40:
|
|
case 41:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> StartDiscoveringError_strings[11] = {};
|
|
|
|
static const char StartDiscoveringError_names[] =
|
|
"ACQUIRE_WIFI_AWARE_SESSION_FOR_DISCOVERING_FAILED"
|
|
"DUPLICATE_DISCOVERING_REQUESTED"
|
|
"FETCH_ADVERTISEMENT_FAILED"
|
|
"GATT_FETCH_ADVERTISEMENT_FAILED"
|
|
"INVALID_TARGET_INFO"
|
|
"L2CAP_FETCH_ADVERTISEMENT_FAILED"
|
|
"NOT_AVAILABLE_TO_FETCH_ADVERTISEMENT"
|
|
"START_DISCOVERING_FAILED"
|
|
"START_EXTENDED_DISCOVERING_FAILED"
|
|
"START_LEGACY_DISCOVERING_FAILED"
|
|
"UNKNOWN_START_DISCOVERING_ERROR";
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry StartDiscoveringError_entries[] = {
|
|
{ {StartDiscoveringError_names + 0, 49}, 40 },
|
|
{ {StartDiscoveringError_names + 49, 31}, 31 },
|
|
{ {StartDiscoveringError_names + 80, 26}, 36 },
|
|
{ {StartDiscoveringError_names + 106, 31}, 37 },
|
|
{ {StartDiscoveringError_names + 137, 19}, 35 },
|
|
{ {StartDiscoveringError_names + 156, 32}, 38 },
|
|
{ {StartDiscoveringError_names + 188, 36}, 39 },
|
|
{ {StartDiscoveringError_names + 224, 24}, 34 },
|
|
{ {StartDiscoveringError_names + 248, 33}, 33 },
|
|
{ {StartDiscoveringError_names + 281, 31}, 32 },
|
|
{ {StartDiscoveringError_names + 312, 31}, 41 },
|
|
};
|
|
|
|
static const int StartDiscoveringError_entries_by_number[] = {
|
|
1, // 31 -> DUPLICATE_DISCOVERING_REQUESTED
|
|
9, // 32 -> START_LEGACY_DISCOVERING_FAILED
|
|
8, // 33 -> START_EXTENDED_DISCOVERING_FAILED
|
|
7, // 34 -> START_DISCOVERING_FAILED
|
|
4, // 35 -> INVALID_TARGET_INFO
|
|
2, // 36 -> FETCH_ADVERTISEMENT_FAILED
|
|
3, // 37 -> GATT_FETCH_ADVERTISEMENT_FAILED
|
|
5, // 38 -> L2CAP_FETCH_ADVERTISEMENT_FAILED
|
|
6, // 39 -> NOT_AVAILABLE_TO_FETCH_ADVERTISEMENT
|
|
0, // 40 -> ACQUIRE_WIFI_AWARE_SESSION_FOR_DISCOVERING_FAILED
|
|
10, // 41 -> UNKNOWN_START_DISCOVERING_ERROR
|
|
};
|
|
|
|
const std::string& StartDiscoveringError_Name(
|
|
StartDiscoveringError value) {
|
|
static const bool dummy =
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
|
|
StartDiscoveringError_entries,
|
|
StartDiscoveringError_entries_by_number,
|
|
11, StartDiscoveringError_strings);
|
|
(void) dummy;
|
|
int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
|
|
StartDiscoveringError_entries,
|
|
StartDiscoveringError_entries_by_number,
|
|
11, value);
|
|
return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
|
|
StartDiscoveringError_strings[idx].get();
|
|
}
|
|
bool StartDiscoveringError_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StartDiscoveringError* value) {
|
|
int int_value;
|
|
bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
|
|
StartDiscoveringError_entries, 11, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<StartDiscoveringError>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
bool StopDiscoveringError_IsValid(int value) {
|
|
switch (value) {
|
|
case 31:
|
|
case 32:
|
|
case 33:
|
|
case 34:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> StopDiscoveringError_strings[4] = {};
|
|
|
|
static const char StopDiscoveringError_names[] =
|
|
"STOP_DISCOVERING_FAILED"
|
|
"STOP_EXTENDED_DISCOVERING_FAILED"
|
|
"STOP_LEGACY_DISCOVERING_FAILED"
|
|
"UNKNOWN_STOP_DISCOVERING_ERROR";
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry StopDiscoveringError_entries[] = {
|
|
{ {StopDiscoveringError_names + 0, 23}, 31 },
|
|
{ {StopDiscoveringError_names + 23, 32}, 33 },
|
|
{ {StopDiscoveringError_names + 55, 30}, 32 },
|
|
{ {StopDiscoveringError_names + 85, 30}, 34 },
|
|
};
|
|
|
|
static const int StopDiscoveringError_entries_by_number[] = {
|
|
0, // 31 -> STOP_DISCOVERING_FAILED
|
|
2, // 32 -> STOP_LEGACY_DISCOVERING_FAILED
|
|
1, // 33 -> STOP_EXTENDED_DISCOVERING_FAILED
|
|
3, // 34 -> UNKNOWN_STOP_DISCOVERING_ERROR
|
|
};
|
|
|
|
const std::string& StopDiscoveringError_Name(
|
|
StopDiscoveringError value) {
|
|
static const bool dummy =
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
|
|
StopDiscoveringError_entries,
|
|
StopDiscoveringError_entries_by_number,
|
|
4, StopDiscoveringError_strings);
|
|
(void) dummy;
|
|
int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
|
|
StopDiscoveringError_entries,
|
|
StopDiscoveringError_entries_by_number,
|
|
4, value);
|
|
return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
|
|
StopDiscoveringError_strings[idx].get();
|
|
}
|
|
bool StopDiscoveringError_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StopDiscoveringError* value) {
|
|
int int_value;
|
|
bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
|
|
StopDiscoveringError_entries, 4, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<StopDiscoveringError>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
bool StartListeningIncomingConnectionError_IsValid(int value) {
|
|
switch (value) {
|
|
case 31:
|
|
case 32:
|
|
case 33:
|
|
case 34:
|
|
case 35:
|
|
case 36:
|
|
case 37:
|
|
case 38:
|
|
case 39:
|
|
case 40:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> StartListeningIncomingConnectionError_strings[10] = {};
|
|
|
|
static const char StartListeningIncomingConnectionError_names[] =
|
|
"ACCEPT_CONNECTION_FAILED"
|
|
"ACCEPT_GATT_CONNECTION_FAILED"
|
|
"ACCEPT_L2CAP_CONNECTION_FAILED"
|
|
"ACCEPT_RECEIVE_AWARE_L2_MESSAGE_FAILED"
|
|
"ACCEPT_SEND_AWARE_L2_MESSAGE_FAILED"
|
|
"CREATE_GATT_SERVER_SOCKET_NOT_READY"
|
|
"CREATE_SERVER_SOCKET_FAILED"
|
|
"DUPLICATE_ACCEPTING_CONNECTION_REQUESTED"
|
|
"OPEN_GATT_SERVER_FAILED"
|
|
"UNKNOWN_START_LISTENING_INCOMING_CONNECTION_ERROR";
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry StartListeningIncomingConnectionError_entries[] = {
|
|
{ {StartListeningIncomingConnectionError_names + 0, 24}, 36 },
|
|
{ {StartListeningIncomingConnectionError_names + 24, 29}, 33 },
|
|
{ {StartListeningIncomingConnectionError_names + 53, 30}, 34 },
|
|
{ {StartListeningIncomingConnectionError_names + 83, 38}, 40 },
|
|
{ {StartListeningIncomingConnectionError_names + 121, 35}, 39 },
|
|
{ {StartListeningIncomingConnectionError_names + 156, 35}, 35 },
|
|
{ {StartListeningIncomingConnectionError_names + 191, 27}, 37 },
|
|
{ {StartListeningIncomingConnectionError_names + 218, 40}, 31 },
|
|
{ {StartListeningIncomingConnectionError_names + 258, 23}, 32 },
|
|
{ {StartListeningIncomingConnectionError_names + 281, 49}, 38 },
|
|
};
|
|
|
|
static const int StartListeningIncomingConnectionError_entries_by_number[] = {
|
|
7, // 31 -> DUPLICATE_ACCEPTING_CONNECTION_REQUESTED
|
|
8, // 32 -> OPEN_GATT_SERVER_FAILED
|
|
1, // 33 -> ACCEPT_GATT_CONNECTION_FAILED
|
|
2, // 34 -> ACCEPT_L2CAP_CONNECTION_FAILED
|
|
5, // 35 -> CREATE_GATT_SERVER_SOCKET_NOT_READY
|
|
0, // 36 -> ACCEPT_CONNECTION_FAILED
|
|
6, // 37 -> CREATE_SERVER_SOCKET_FAILED
|
|
9, // 38 -> UNKNOWN_START_LISTENING_INCOMING_CONNECTION_ERROR
|
|
4, // 39 -> ACCEPT_SEND_AWARE_L2_MESSAGE_FAILED
|
|
3, // 40 -> ACCEPT_RECEIVE_AWARE_L2_MESSAGE_FAILED
|
|
};
|
|
|
|
const std::string& StartListeningIncomingConnectionError_Name(
|
|
StartListeningIncomingConnectionError value) {
|
|
static const bool dummy =
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
|
|
StartListeningIncomingConnectionError_entries,
|
|
StartListeningIncomingConnectionError_entries_by_number,
|
|
10, StartListeningIncomingConnectionError_strings);
|
|
(void) dummy;
|
|
int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
|
|
StartListeningIncomingConnectionError_entries,
|
|
StartListeningIncomingConnectionError_entries_by_number,
|
|
10, value);
|
|
return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
|
|
StartListeningIncomingConnectionError_strings[idx].get();
|
|
}
|
|
bool StartListeningIncomingConnectionError_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StartListeningIncomingConnectionError* value) {
|
|
int int_value;
|
|
bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
|
|
StartListeningIncomingConnectionError_entries, 10, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<StartListeningIncomingConnectionError>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
bool StopListeningIncomingConnectionError_IsValid(int value) {
|
|
switch (value) {
|
|
case 31:
|
|
case 32:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> StopListeningIncomingConnectionError_strings[2] = {};
|
|
|
|
static const char StopListeningIncomingConnectionError_names[] =
|
|
"STOP_ACCEPTING_CONNECTION_FAILED"
|
|
"UNKNOWN_STOP_LISTENING_INCOMING_CONNECTION_ERROR";
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry StopListeningIncomingConnectionError_entries[] = {
|
|
{ {StopListeningIncomingConnectionError_names + 0, 32}, 31 },
|
|
{ {StopListeningIncomingConnectionError_names + 32, 48}, 32 },
|
|
};
|
|
|
|
static const int StopListeningIncomingConnectionError_entries_by_number[] = {
|
|
0, // 31 -> STOP_ACCEPTING_CONNECTION_FAILED
|
|
1, // 32 -> UNKNOWN_STOP_LISTENING_INCOMING_CONNECTION_ERROR
|
|
};
|
|
|
|
const std::string& StopListeningIncomingConnectionError_Name(
|
|
StopListeningIncomingConnectionError value) {
|
|
static const bool dummy =
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
|
|
StopListeningIncomingConnectionError_entries,
|
|
StopListeningIncomingConnectionError_entries_by_number,
|
|
2, StopListeningIncomingConnectionError_strings);
|
|
(void) dummy;
|
|
int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
|
|
StopListeningIncomingConnectionError_entries,
|
|
StopListeningIncomingConnectionError_entries_by_number,
|
|
2, value);
|
|
return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
|
|
StopListeningIncomingConnectionError_strings[idx].get();
|
|
}
|
|
bool StopListeningIncomingConnectionError_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StopListeningIncomingConnectionError* value) {
|
|
int int_value;
|
|
bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
|
|
StopListeningIncomingConnectionError_entries, 2, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<StopListeningIncomingConnectionError>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
bool ConnectError_IsValid(int value) {
|
|
switch (value) {
|
|
case 31:
|
|
case 32:
|
|
case 33:
|
|
case 34:
|
|
case 35:
|
|
case 36:
|
|
case 37:
|
|
case 38:
|
|
case 39:
|
|
case 40:
|
|
case 41:
|
|
case 42:
|
|
case 43:
|
|
case 44:
|
|
case 45:
|
|
case 46:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ConnectError_strings[16] = {};
|
|
|
|
static const char ConnectError_names[] =
|
|
"CONNECTION_LOST"
|
|
"CONNECT_READ_AWARE_L2_MESSAGE_FAILED"
|
|
"CONNECT_SEND_AWARE_L2_MESSAGE_FAILED"
|
|
"CONNECT_TO_NETWORK_FAILED"
|
|
"DUPLICATE_CONNECTION_REQUESTED"
|
|
"ESTABLISH_CONNECTION_FAILED"
|
|
"ESTABLISH_GATT_CONNECTION_FAILED"
|
|
"ESTABLISH_L2CAP_CONNECTION_FAILED"
|
|
"GATT_SWITCH_TO_DATA_TRANSFERRING_FAILED"
|
|
"INVALID_MAC_ADDRESS"
|
|
"L2CAP_SWITCH_TO_DATA_TRANSFERRING_FAILED"
|
|
"REQUEST_GATT_CONNECTION_PRIORITY_FAILED"
|
|
"SLEEP_AFTER_GATT_CONNECTED_INTERRUPTED"
|
|
"SLEEP_BEFORE_CONNECT_GATT_INTERRUPTED"
|
|
"UNEXPECT_TARGET_LOST"
|
|
"UNKNOWN_CONNECT_ERROR";
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ConnectError_entries[] = {
|
|
{ {ConnectError_names + 0, 15}, 42 },
|
|
{ {ConnectError_names + 15, 36}, 46 },
|
|
{ {ConnectError_names + 51, 36}, 45 },
|
|
{ {ConnectError_names + 87, 25}, 43 },
|
|
{ {ConnectError_names + 112, 30}, 41 },
|
|
{ {ConnectError_names + 142, 27}, 40 },
|
|
{ {ConnectError_names + 169, 32}, 32 },
|
|
{ {ConnectError_names + 201, 33}, 33 },
|
|
{ {ConnectError_names + 234, 39}, 39 },
|
|
{ {ConnectError_names + 273, 19}, 34 },
|
|
{ {ConnectError_names + 292, 40}, 38 },
|
|
{ {ConnectError_names + 332, 39}, 37 },
|
|
{ {ConnectError_names + 371, 38}, 36 },
|
|
{ {ConnectError_names + 409, 37}, 35 },
|
|
{ {ConnectError_names + 446, 20}, 31 },
|
|
{ {ConnectError_names + 466, 21}, 44 },
|
|
};
|
|
|
|
static const int ConnectError_entries_by_number[] = {
|
|
14, // 31 -> UNEXPECT_TARGET_LOST
|
|
6, // 32 -> ESTABLISH_GATT_CONNECTION_FAILED
|
|
7, // 33 -> ESTABLISH_L2CAP_CONNECTION_FAILED
|
|
9, // 34 -> INVALID_MAC_ADDRESS
|
|
13, // 35 -> SLEEP_BEFORE_CONNECT_GATT_INTERRUPTED
|
|
12, // 36 -> SLEEP_AFTER_GATT_CONNECTED_INTERRUPTED
|
|
11, // 37 -> REQUEST_GATT_CONNECTION_PRIORITY_FAILED
|
|
10, // 38 -> L2CAP_SWITCH_TO_DATA_TRANSFERRING_FAILED
|
|
8, // 39 -> GATT_SWITCH_TO_DATA_TRANSFERRING_FAILED
|
|
5, // 40 -> ESTABLISH_CONNECTION_FAILED
|
|
4, // 41 -> DUPLICATE_CONNECTION_REQUESTED
|
|
0, // 42 -> CONNECTION_LOST
|
|
3, // 43 -> CONNECT_TO_NETWORK_FAILED
|
|
15, // 44 -> UNKNOWN_CONNECT_ERROR
|
|
2, // 45 -> CONNECT_SEND_AWARE_L2_MESSAGE_FAILED
|
|
1, // 46 -> CONNECT_READ_AWARE_L2_MESSAGE_FAILED
|
|
};
|
|
|
|
const std::string& ConnectError_Name(
|
|
ConnectError value) {
|
|
static const bool dummy =
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
|
|
ConnectError_entries,
|
|
ConnectError_entries_by_number,
|
|
16, ConnectError_strings);
|
|
(void) dummy;
|
|
int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
|
|
ConnectError_entries,
|
|
ConnectError_entries_by_number,
|
|
16, value);
|
|
return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
|
|
ConnectError_strings[idx].get();
|
|
}
|
|
bool ConnectError_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectError* value) {
|
|
int int_value;
|
|
bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
|
|
ConnectError_entries, 16, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<ConnectError>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
bool DisconnectError_IsValid(int value) {
|
|
switch (value) {
|
|
case 31:
|
|
case 32:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> DisconnectError_strings[2] = {};
|
|
|
|
static const char DisconnectError_names[] =
|
|
"DISCONNECT_NETWORK_FAILED"
|
|
"UNKNOWN_DISCONNECT_ERROR";
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DisconnectError_entries[] = {
|
|
{ {DisconnectError_names + 0, 25}, 31 },
|
|
{ {DisconnectError_names + 25, 24}, 32 },
|
|
};
|
|
|
|
static const int DisconnectError_entries_by_number[] = {
|
|
0, // 31 -> DISCONNECT_NETWORK_FAILED
|
|
1, // 32 -> UNKNOWN_DISCONNECT_ERROR
|
|
};
|
|
|
|
const std::string& DisconnectError_Name(
|
|
DisconnectError value) {
|
|
static const bool dummy =
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
|
|
DisconnectError_entries,
|
|
DisconnectError_entries_by_number,
|
|
2, DisconnectError_strings);
|
|
(void) dummy;
|
|
int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
|
|
DisconnectError_entries,
|
|
DisconnectError_entries_by_number,
|
|
2, value);
|
|
return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
|
|
DisconnectError_strings[idx].get();
|
|
}
|
|
bool DisconnectError_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DisconnectError* value) {
|
|
int int_value;
|
|
bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
|
|
DisconnectError_entries, 2, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<DisconnectError>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
bool Description_IsValid(int value) {
|
|
switch (value) {
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
case 9:
|
|
case 10:
|
|
case 11:
|
|
case 12:
|
|
case 13:
|
|
case 14:
|
|
case 15:
|
|
case 16:
|
|
case 17:
|
|
case 18:
|
|
case 19:
|
|
case 20:
|
|
case 21:
|
|
case 22:
|
|
case 23:
|
|
case 24:
|
|
case 25:
|
|
case 26:
|
|
case 27:
|
|
case 30:
|
|
case 31:
|
|
case 32:
|
|
case 33:
|
|
case 34:
|
|
case 35:
|
|
case 36:
|
|
case 37:
|
|
case 38:
|
|
case 39:
|
|
case 40:
|
|
case 41:
|
|
case 42:
|
|
case 43:
|
|
case 44:
|
|
case 45:
|
|
case 46:
|
|
case 47:
|
|
case 48:
|
|
case 49:
|
|
case 50:
|
|
case 51:
|
|
case 52:
|
|
case 53:
|
|
case 54:
|
|
case 55:
|
|
case 56:
|
|
case 57:
|
|
case 58:
|
|
case 59:
|
|
case 60:
|
|
case 61:
|
|
case 62:
|
|
case 63:
|
|
case 64:
|
|
case 65:
|
|
case 66:
|
|
case 67:
|
|
case 68:
|
|
case 69:
|
|
case 70:
|
|
case 71:
|
|
case 72:
|
|
case 73:
|
|
case 74:
|
|
case 75:
|
|
case 76:
|
|
case 77:
|
|
case 78:
|
|
case 79:
|
|
case 80:
|
|
case 81:
|
|
case 82:
|
|
case 83:
|
|
case 84:
|
|
case 85:
|
|
case 86:
|
|
case 87:
|
|
case 88:
|
|
case 89:
|
|
case 90:
|
|
case 91:
|
|
case 92:
|
|
case 93:
|
|
case 94:
|
|
case 95:
|
|
case 96:
|
|
case 97:
|
|
case 98:
|
|
case 99:
|
|
case 100:
|
|
case 101:
|
|
case 102:
|
|
case 103:
|
|
case 104:
|
|
case 105:
|
|
case 106:
|
|
case 107:
|
|
case 108:
|
|
case 109:
|
|
case 110:
|
|
case 111:
|
|
case 112:
|
|
case 113:
|
|
case 114:
|
|
case 115:
|
|
case 116:
|
|
case 117:
|
|
case 118:
|
|
case 119:
|
|
case 120:
|
|
case 121:
|
|
case 122:
|
|
case 123:
|
|
case 124:
|
|
case 125:
|
|
case 126:
|
|
case 127:
|
|
case 128:
|
|
case 129:
|
|
case 130:
|
|
case 131:
|
|
case 132:
|
|
case 133:
|
|
case 134:
|
|
case 135:
|
|
case 136:
|
|
case 137:
|
|
case 138:
|
|
case 139:
|
|
case 140:
|
|
case 141:
|
|
case 142:
|
|
case 143:
|
|
case 144:
|
|
case 145:
|
|
case 146:
|
|
case 147:
|
|
case 148:
|
|
case 149:
|
|
case 150:
|
|
case 151:
|
|
case 152:
|
|
case 153:
|
|
case 154:
|
|
case 155:
|
|
case 156:
|
|
case 157:
|
|
case 158:
|
|
case 159:
|
|
case 160:
|
|
case 161:
|
|
case 162:
|
|
case 163:
|
|
case 164:
|
|
case 165:
|
|
case 166:
|
|
case 167:
|
|
case 168:
|
|
case 169:
|
|
case 170:
|
|
case 171:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> Description_strings[170] = {};
|
|
|
|
static const char Description_names[] =
|
|
"ACQUIRE_P2P_CHANNEL_FAILED"
|
|
"ADD_NETWORK_FAILED"
|
|
"ADVERTISE_FAILED_ALREADY_STARTED"
|
|
"ADVERTISE_FAILED_DATA_TOO_LARGE"
|
|
"ADVERTISE_FAILED_FEATURE_UNSUPPORTED"
|
|
"ADVERTISE_FAILED_INTERNAL_ERROR"
|
|
"ADVERTISE_FAILED_TOO_MANY_ADVERTISERS"
|
|
"ALREADY_HAS_GATT_CONNECTION"
|
|
"ALREADY_IN_PROGRESS"
|
|
"AWARE_DATA_PATH_RAN_OUT"
|
|
"AWARE_L2_MESSAGE_CANCELLATION_RECEIVED"
|
|
"AWARE_L2_MESSAGE_HOST_NETWORK_ERROR"
|
|
"AWARE_L2_MESSAGE_IP_AVAILABLE_ERROR"
|
|
"AWARE_L2_MESSAGE_NETWORK_AVAILABLE_ERROR"
|
|
"AWARE_PUBLISH_SESSION_RAN_OUT"
|
|
"AWARE_SUBSCRIBE_SESSION_RAN_OUT"
|
|
"AWARE_UNAVAILABLE"
|
|
"AWARE_UPDATE_PUBLISHING_CONFIG_FAILED"
|
|
"BIND_NFC_SERVICE_FAILED"
|
|
"BLUETOOTH_SCAN_REJUVENATE_FAILED"
|
|
"BLUETOOTH_SOCKET_CLOSED_AFTER_CONNECTED"
|
|
"BLUETOOTH_SOCKET_NOT_IN_LISTENING_STATE"
|
|
"BUSY"
|
|
"CLOSE_SERVER_SOCKET_FAILED"
|
|
"CONNECTIONS_FEATURE_DISABLED"
|
|
"CONNET_TO_SOCKET_CANCELLED"
|
|
"CREATE_OFFER_FAILED"
|
|
"EMPTY_TACHYON_ICE_SERVER"
|
|
"EMPTY_WORK_SOURCE_CACHE"
|
|
"EXECUTION_EXCEPTION"
|
|
"FAIL_TO_RECEIVE_L2CAP_PACKET"
|
|
"FEATURE_BLUETOOTH_LE_NOT_SUPPORTED"
|
|
"FEATURE_BLUETOOTH_NOT_SUPPORTED"
|
|
"FEATURE_NFC_HOST_CARD_EMULATION_NOT_SUPPORTED"
|
|
"FEATURE_NFC_NOT_SUPPORTED"
|
|
"FEATURE_WIFI_AWARE_NOT_SUPPORTED"
|
|
"FEATURE_WIFI_DIRECT_NOT_SUPPORTED"
|
|
"FEATURE_WIFI_NOT_SUPPORTED"
|
|
"GET_ADDRESS_FAILED"
|
|
"HOSTED_NETWORK_UNAVAILABLE"
|
|
"HOTSPOT_NOT_STARTED"
|
|
"INTERNAL_ERROR"
|
|
"INTERRUPTED_EXCEPTION"
|
|
"INVALID_ADVERTISEMENT_HEADER_DATA"
|
|
"INVALID_ARGS"
|
|
"INVALID_BLUETOOTH_CHANNEL"
|
|
"INVALID_BLUETOOTH_SOCKET_SIGNAL_SIZE"
|
|
"INVALID_BLUETOOTH_SOCKET_SIGNAL_STATUS"
|
|
"INVALID_BLUETOOTH_SOCKET_STATE_BEFORE_CONNECT"
|
|
"INVALID_FAST_ADVERTISEMENT_DATA"
|
|
"INVALID_FAST_PAIR_MODEL_ID"
|
|
"INVALID_IPV4_ADDRESS"
|
|
"INVALID_IPV6_ADDRESS"
|
|
"INVALID_NETWORK_ID"
|
|
"INVALID_PACKET_BYTES"
|
|
"INVALID_PACKET_LENGTH"
|
|
"INVALID_PORT_NUMBER"
|
|
"INVALID_REGULAR_ADVERTISEMENT_DATA"
|
|
"INVALID_REMOTE_ADDRESS"
|
|
"INVALID_VERSION"
|
|
"INVALID_WEBRTC_STATE"
|
|
"INVOKE_API_FAILED"
|
|
"IN_BLACK_LIST"
|
|
"IS_LOOPBACK_ADDRESS"
|
|
"JOIN_AWARE_NETWORK_CANCELLED"
|
|
"L2CAP_UNAVAILABLE"
|
|
"MULTICAST_NOT_SUPPORTED"
|
|
"NETWORK_ALREADY_JOINED"
|
|
"NETWORK_ERROR_EHOSTUNREACH"
|
|
"NETWORK_ERROR_ENETUNREACH"
|
|
"NETWORK_UNAVAILABLE"
|
|
"NFC_CREATE_SOCKET_FAILED"
|
|
"NFC_SERVICE_DIED"
|
|
"NFC_TECH_NOT_SUPPORTED"
|
|
"NOT_AUTHORIZED"
|
|
"NSD_NOT_ENABLED"
|
|
"NULL_ADDRESS"
|
|
"NULL_ADVERTISEMENT_BYTES"
|
|
"NULL_BLE_PERIPHERAL"
|
|
"NULL_BLUETOOTH_ADAPTER"
|
|
"NULL_BLUETOOTH_DEVICE"
|
|
"NULL_BLUETOOTH_DEVICE_NAME"
|
|
"NULL_BLUETOOTH_GATT"
|
|
"NULL_BLUETOOTH_LE_ADVERTISER_COMPAT"
|
|
"NULL_BLUETOOTH_LE_SCANNER_COMPAT"
|
|
"NULL_BLUETOOTH_MANAGER"
|
|
"NULL_BLUETOOTH_PROXY"
|
|
"NULL_CALLBACK"
|
|
"NULL_CONNECTIVITY_MANAGER"
|
|
"NULL_DATA_CHANNEL"
|
|
"NULL_DROID_GUARD_RESULT"
|
|
"NULL_LOCAL_ADDRESS"
|
|
"NULL_MESSAGE"
|
|
"NULL_NFC_TAG"
|
|
"NULL_PASSWORD"
|
|
"NULL_SERVICE_ID"
|
|
"NULL_SERVICE_INFO"
|
|
"NULL_SERVICE_NAME"
|
|
"NULL_SERVICE_TYPE"
|
|
"NULL_SSID"
|
|
"NULL_WIFI_AWARE_MANAGER"
|
|
"NULL_WIFI_AWARE_PEER"
|
|
"NULL_WIFI_MANAGER"
|
|
"NULL_WIFI_P2P_MANAGER"
|
|
"NULL_WORK_SOURCE"
|
|
"P2P_GROUP_FORMED"
|
|
"P2P_UNSUPPORTED"
|
|
"POTENTIAL_SRD_ISSUE"
|
|
"POTENTIAL_WEBRTC_LIB_LOADING_FAILURE"
|
|
"PUBLISH_EMPTY_ADVERTISEMENT_FAILED"
|
|
"READ_CHARACTERISTIC_FAILED"
|
|
"REFLECTION_ERROR"
|
|
"REMOTE_EXCEPTION"
|
|
"SCAN_FAILED_ALREADY_STARTED"
|
|
"SCAN_FAILED_APPLICATION_REGISTRATION_FAILED"
|
|
"SCAN_FAILED_BLUETOOTH_DISABLED"
|
|
"SCAN_FAILED_FEATURE_UNSUPPORTED"
|
|
"SCAN_FAILED_INTERNAL_ERROR"
|
|
"SCAN_FILTERS_NOT_ALLOWED_FOR_LOCATION"
|
|
"SERVER_SOCKET_UNAVAILABLE"
|
|
"SET_CONNECTION_PRIORITY_FAILED"
|
|
"SET_CONNECTION_PRIORITY_INTERRUPTED"
|
|
"SET_SCAN_MODE_FAILED"
|
|
"SOCKET_ALREADY_BOUND"
|
|
"SOCKET_ALREADY_CONNECTED"
|
|
"SOCKET_BIND_LISTEN_FAILED"
|
|
"SOCKET_CLOSED"
|
|
"SOCKET_CLOSED_OR_TIMEOUT"
|
|
"SOCKET_NOT_BOUND"
|
|
"STALE_ANDROID_VERSION"
|
|
"STALE_SDK_VERSION"
|
|
"TACHYON_ALREADY_START_RECEIVE_MESSAGE"
|
|
"TACHYON_GET_ICE_SERVER_AUTH_EXCEPTION"
|
|
"TACHYON_GET_ICE_SERVER_STATUS_EXCEPTION"
|
|
"TACHYON_RECEIVE_MESSAGE_AUTH_EXCEPTION"
|
|
"TACHYON_RECEIVE_MESSAGE_EXECUTION_EXCEPTION"
|
|
"TACHYON_RECEIVE_MESSAGE_FAILED"
|
|
"TACHYON_RECEIVE_MESSAGE_INTERRUPTED"
|
|
"TACHYON_RECEIVE_MESSAGE_STATUS_EXCEPTION"
|
|
"TACHYON_RECEIVE_MESSAGE_TIMEOUT"
|
|
"TACHYON_SEND_MESSAGE_AUTH_EXCEPTION"
|
|
"TACHYON_SEND_MESSAGE_STATUS_EXCEPTION"
|
|
"TACHYON_SIGNALING_MESSENGER_EXIST"
|
|
"TIE_BREAK_LOSER"
|
|
"TIMEOUT"
|
|
"UNEXPECTED_BLUETOOTH_STATE"
|
|
"UNEXPECTED_EOF_EXCEPTION"
|
|
"UNEXPECTED_GATT_DESCRIPTOR"
|
|
"UNEXPECTED_PACKET_CONTENT"
|
|
"UNKNOWN"
|
|
"UNKNOWN_IO_EXCEPTION"
|
|
"UNREGISTER_NSD_MANAGER_FAILED"
|
|
"UNSUPPORTED_DEVICE_TYPE"
|
|
"UNSUPPORTED_DEVICE_TYPE_AUTO"
|
|
"UNSUPPORTED_DEVICE_TYPE_CHROME_OS"
|
|
"UNSUPPORTED_DEVICE_TYPE_TV"
|
|
"UNSUPPORTED_DEVICE_TYPE_WEAR"
|
|
"UPDATE_NETWORK_FAILED"
|
|
"WEBRTC_ALREADY_INITIALIZED"
|
|
"WEBRTC_CONNECTION_FLOW_EXIST"
|
|
"WIFI_AWARE_STARTED"
|
|
"WIFI_HOTSPOT_ENABLED"
|
|
"WIFI_MANAGER_ENABLE_NETWORK_FAILED"
|
|
"WIFI_MANAGER_RECONNECT_FAILED"
|
|
"WIFI_SIGNAL_STRENGTH_POOR"
|
|
"WITHOUT_ACTIVE_AWARE_NETWORK"
|
|
"WITHOUT_ACTIVE_NETWORK"
|
|
"WITHOUT_CONNECTED_WIFI_NETWORK"
|
|
"WITHOUT_JOINED_AWARE_NETWORK"
|
|
"WITHOUT_PSM_VALUE";
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry Description_entries[] = {
|
|
{ {Description_names + 0, 26}, 96 },
|
|
{ {Description_names + 26, 18}, 103 },
|
|
{ {Description_names + 44, 32}, 14 },
|
|
{ {Description_names + 76, 31}, 15 },
|
|
{ {Description_names + 107, 36}, 16 },
|
|
{ {Description_names + 143, 31}, 17 },
|
|
{ {Description_names + 174, 37}, 18 },
|
|
{ {Description_names + 211, 27}, 165 },
|
|
{ {Description_names + 238, 19}, 105 },
|
|
{ {Description_names + 257, 23}, 153 },
|
|
{ {Description_names + 280, 38}, 159 },
|
|
{ {Description_names + 318, 35}, 156 },
|
|
{ {Description_names + 353, 35}, 158 },
|
|
{ {Description_names + 388, 40}, 157 },
|
|
{ {Description_names + 428, 29}, 151 },
|
|
{ {Description_names + 457, 31}, 152 },
|
|
{ {Description_names + 488, 17}, 74 },
|
|
{ {Description_names + 505, 37}, 163 },
|
|
{ {Description_names + 542, 23}, 82 },
|
|
{ {Description_names + 565, 32}, 51 },
|
|
{ {Description_names + 597, 39}, 57 },
|
|
{ {Description_names + 636, 39}, 135 },
|
|
{ {Description_names + 675, 4}, 99 },
|
|
{ {Description_names + 679, 26}, 149 },
|
|
{ {Description_names + 705, 28}, 3 },
|
|
{ {Description_names + 733, 26}, 90 },
|
|
{ {Description_names + 759, 19}, 148 },
|
|
{ {Description_names + 778, 24}, 126 },
|
|
{ {Description_names + 802, 23}, 44 },
|
|
{ {Description_names + 825, 19}, 20 },
|
|
{ {Description_names + 844, 28}, 129 },
|
|
{ {Description_names + 872, 34}, 6 },
|
|
{ {Description_names + 906, 31}, 5 },
|
|
{ {Description_names + 937, 45}, 27 },
|
|
{ {Description_names + 982, 25}, 26 },
|
|
{ {Description_names + 1007, 32}, 36 },
|
|
{ {Description_names + 1039, 33}, 93 },
|
|
{ {Description_names + 1072, 26}, 76 },
|
|
{ {Description_names + 1098, 18}, 138 },
|
|
{ {Description_names + 1116, 26}, 162 },
|
|
{ {Description_names + 1142, 19}, 144 },
|
|
{ {Description_names + 1161, 14}, 98 },
|
|
{ {Description_names + 1175, 21}, 19 },
|
|
{ {Description_names + 1196, 33}, 11 },
|
|
{ {Description_names + 1229, 12}, 106 },
|
|
{ {Description_names + 1241, 25}, 58 },
|
|
{ {Description_names + 1266, 36}, 136 },
|
|
{ {Description_names + 1302, 38}, 137 },
|
|
{ {Description_names + 1340, 45}, 56 },
|
|
{ {Description_names + 1385, 31}, 10 },
|
|
{ {Description_names + 1416, 26}, 9 },
|
|
{ {Description_names + 1442, 20}, 65 },
|
|
{ {Description_names + 1462, 20}, 66 },
|
|
{ {Description_names + 1482, 18}, 108 },
|
|
{ {Description_names + 1500, 20}, 62 },
|
|
{ {Description_names + 1520, 21}, 61 },
|
|
{ {Description_names + 1541, 19}, 32 },
|
|
{ {Description_names + 1560, 34}, 12 },
|
|
{ {Description_names + 1594, 22}, 142 },
|
|
{ {Description_names + 1616, 15}, 68 },
|
|
{ {Description_names + 1631, 20}, 146 },
|
|
{ {Description_names + 1651, 17}, 23 },
|
|
{ {Description_names + 1668, 13}, 75 },
|
|
{ {Description_names + 1681, 19}, 140 },
|
|
{ {Description_names + 1700, 28}, 86 },
|
|
{ {Description_names + 1728, 17}, 164 },
|
|
{ {Description_names + 1745, 23}, 30 },
|
|
{ {Description_names + 1768, 22}, 85 },
|
|
{ {Description_names + 1790, 26}, 101 },
|
|
{ {Description_names + 1816, 25}, 102 },
|
|
{ {Description_names + 1841, 19}, 87 },
|
|
{ {Description_names + 1860, 24}, 83 },
|
|
{ {Description_names + 1884, 16}, 81 },
|
|
{ {Description_names + 1900, 22}, 80 },
|
|
{ {Description_names + 1922, 14}, 107 },
|
|
{ {Description_names + 1936, 15}, 31 },
|
|
{ {Description_names + 1951, 12}, 67 },
|
|
{ {Description_names + 1963, 24}, 2 },
|
|
{ {Description_names + 1987, 19}, 52 },
|
|
{ {Description_names + 2006, 22}, 8 },
|
|
{ {Description_names + 2028, 21}, 59 },
|
|
{ {Description_names + 2049, 26}, 21 },
|
|
{ {Description_names + 2075, 19}, 53 },
|
|
{ {Description_names + 2094, 35}, 13 },
|
|
{ {Description_names + 2129, 32}, 43 },
|
|
{ {Description_names + 2161, 22}, 7 },
|
|
{ {Description_names + 2183, 20}, 60 },
|
|
{ {Description_names + 2203, 13}, 42 },
|
|
{ {Description_names + 2216, 25}, 37 },
|
|
{ {Description_names + 2241, 17}, 147 },
|
|
{ {Description_names + 2258, 23}, 113 },
|
|
{ {Description_names + 2281, 18}, 139 },
|
|
{ {Description_names + 2299, 12}, 171 },
|
|
{ {Description_names + 2311, 12}, 25 },
|
|
{ {Description_names + 2323, 13}, 92 },
|
|
{ {Description_names + 2336, 15}, 1 },
|
|
{ {Description_names + 2351, 17}, 40 },
|
|
{ {Description_names + 2368, 17}, 33 },
|
|
{ {Description_names + 2385, 17}, 34 },
|
|
{ {Description_names + 2402, 9}, 91 },
|
|
{ {Description_names + 2411, 23}, 38 },
|
|
{ {Description_names + 2434, 20}, 84 },
|
|
{ {Description_names + 2454, 17}, 77 },
|
|
{ {Description_names + 2471, 21}, 94 },
|
|
{ {Description_names + 2492, 16}, 41 },
|
|
{ {Description_names + 2508, 16}, 95 },
|
|
{ {Description_names + 2524, 15}, 97 },
|
|
{ {Description_names + 2539, 19}, 155 },
|
|
{ {Description_names + 2558, 36}, 127 },
|
|
{ {Description_names + 2594, 34}, 134 },
|
|
{ {Description_names + 2628, 26}, 72 },
|
|
{ {Description_names + 2654, 16}, 100 },
|
|
{ {Description_names + 2670, 16}, 55 },
|
|
{ {Description_names + 2686, 27}, 45 },
|
|
{ {Description_names + 2713, 43}, 46 },
|
|
{ {Description_names + 2756, 30}, 49 },
|
|
{ {Description_names + 2786, 31}, 48 },
|
|
{ {Description_names + 2817, 26}, 47 },
|
|
{ {Description_names + 2843, 37}, 50 },
|
|
{ {Description_names + 2880, 25}, 161 },
|
|
{ {Description_names + 2905, 30}, 69 },
|
|
{ {Description_names + 2935, 35}, 70 },
|
|
{ {Description_names + 2970, 20}, 22 },
|
|
{ {Description_names + 2990, 20}, 143 },
|
|
{ {Description_names + 3010, 24}, 79 },
|
|
{ {Description_names + 3034, 25}, 131 },
|
|
{ {Description_names + 3059, 13}, 78 },
|
|
{ {Description_names + 3072, 24}, 64 },
|
|
{ {Description_names + 3096, 16}, 141 },
|
|
{ {Description_names + 3112, 21}, 39 },
|
|
{ {Description_names + 3133, 17}, 4 },
|
|
{ {Description_names + 3150, 37}, 115 },
|
|
{ {Description_names + 3187, 37}, 124 },
|
|
{ {Description_names + 3224, 39}, 125 },
|
|
{ {Description_names + 3263, 38}, 120 },
|
|
{ {Description_names + 3301, 43}, 118 },
|
|
{ {Description_names + 3344, 30}, 116 },
|
|
{ {Description_names + 3374, 35}, 117 },
|
|
{ {Description_names + 3409, 40}, 121 },
|
|
{ {Description_names + 3449, 31}, 119 },
|
|
{ {Description_names + 3480, 35}, 122 },
|
|
{ {Description_names + 3515, 37}, 123 },
|
|
{ {Description_names + 3552, 33}, 114 },
|
|
{ {Description_names + 3585, 15}, 160 },
|
|
{ {Description_names + 3600, 7}, 24 },
|
|
{ {Description_names + 3607, 26}, 54 },
|
|
{ {Description_names + 3633, 24}, 63 },
|
|
{ {Description_names + 3657, 26}, 128 },
|
|
{ {Description_names + 3683, 25}, 132 },
|
|
{ {Description_names + 3708, 7}, 0 },
|
|
{ {Description_names + 3715, 20}, 71 },
|
|
{ {Description_names + 3735, 29}, 133 },
|
|
{ {Description_names + 3764, 23}, 166 },
|
|
{ {Description_names + 3787, 28}, 168 },
|
|
{ {Description_names + 3815, 33}, 167 },
|
|
{ {Description_names + 3848, 26}, 169 },
|
|
{ {Description_names + 3874, 28}, 170 },
|
|
{ {Description_names + 3902, 21}, 104 },
|
|
{ {Description_names + 3923, 26}, 145 },
|
|
{ {Description_names + 3949, 28}, 112 },
|
|
{ {Description_names + 3977, 18}, 150 },
|
|
{ {Description_names + 3995, 20}, 73 },
|
|
{ {Description_names + 4015, 34}, 109 },
|
|
{ {Description_names + 4049, 29}, 110 },
|
|
{ {Description_names + 4078, 25}, 154 },
|
|
{ {Description_names + 4103, 28}, 88 },
|
|
{ {Description_names + 4131, 22}, 111 },
|
|
{ {Description_names + 4153, 30}, 35 },
|
|
{ {Description_names + 4183, 28}, 89 },
|
|
{ {Description_names + 4211, 17}, 130 },
|
|
};
|
|
|
|
static const int Description_entries_by_number[] = {
|
|
149, // 0 -> UNKNOWN
|
|
95, // 1 -> NULL_SERVICE_ID
|
|
77, // 2 -> NULL_ADVERTISEMENT_BYTES
|
|
24, // 3 -> CONNECTIONS_FEATURE_DISABLED
|
|
130, // 4 -> STALE_SDK_VERSION
|
|
32, // 5 -> FEATURE_BLUETOOTH_NOT_SUPPORTED
|
|
31, // 6 -> FEATURE_BLUETOOTH_LE_NOT_SUPPORTED
|
|
85, // 7 -> NULL_BLUETOOTH_MANAGER
|
|
79, // 8 -> NULL_BLUETOOTH_ADAPTER
|
|
50, // 9 -> INVALID_FAST_PAIR_MODEL_ID
|
|
49, // 10 -> INVALID_FAST_ADVERTISEMENT_DATA
|
|
43, // 11 -> INVALID_ADVERTISEMENT_HEADER_DATA
|
|
57, // 12 -> INVALID_REGULAR_ADVERTISEMENT_DATA
|
|
83, // 13 -> NULL_BLUETOOTH_LE_ADVERTISER_COMPAT
|
|
2, // 14 -> ADVERTISE_FAILED_ALREADY_STARTED
|
|
3, // 15 -> ADVERTISE_FAILED_DATA_TOO_LARGE
|
|
4, // 16 -> ADVERTISE_FAILED_FEATURE_UNSUPPORTED
|
|
5, // 17 -> ADVERTISE_FAILED_INTERNAL_ERROR
|
|
6, // 18 -> ADVERTISE_FAILED_TOO_MANY_ADVERTISERS
|
|
42, // 19 -> INTERRUPTED_EXCEPTION
|
|
29, // 20 -> EXECUTION_EXCEPTION
|
|
81, // 21 -> NULL_BLUETOOTH_DEVICE_NAME
|
|
122, // 22 -> SET_SCAN_MODE_FAILED
|
|
61, // 23 -> INVOKE_API_FAILED
|
|
144, // 24 -> TIMEOUT
|
|
93, // 25 -> NULL_NFC_TAG
|
|
34, // 26 -> FEATURE_NFC_NOT_SUPPORTED
|
|
33, // 27 -> FEATURE_NFC_HOST_CARD_EMULATION_NOT_SUPPORTED
|
|
66, // 30 -> MULTICAST_NOT_SUPPORTED
|
|
75, // 31 -> NSD_NOT_ENABLED
|
|
56, // 32 -> INVALID_PORT_NUMBER
|
|
97, // 33 -> NULL_SERVICE_NAME
|
|
98, // 34 -> NULL_SERVICE_TYPE
|
|
167, // 35 -> WITHOUT_CONNECTED_WIFI_NETWORK
|
|
35, // 36 -> FEATURE_WIFI_AWARE_NOT_SUPPORTED
|
|
88, // 37 -> NULL_CONNECTIVITY_MANAGER
|
|
100, // 38 -> NULL_WIFI_AWARE_MANAGER
|
|
129, // 39 -> STALE_ANDROID_VERSION
|
|
96, // 40 -> NULL_SERVICE_INFO
|
|
104, // 41 -> NULL_WORK_SOURCE
|
|
87, // 42 -> NULL_CALLBACK
|
|
84, // 43 -> NULL_BLUETOOTH_LE_SCANNER_COMPAT
|
|
28, // 44 -> EMPTY_WORK_SOURCE_CACHE
|
|
113, // 45 -> SCAN_FAILED_ALREADY_STARTED
|
|
114, // 46 -> SCAN_FAILED_APPLICATION_REGISTRATION_FAILED
|
|
117, // 47 -> SCAN_FAILED_INTERNAL_ERROR
|
|
116, // 48 -> SCAN_FAILED_FEATURE_UNSUPPORTED
|
|
115, // 49 -> SCAN_FAILED_BLUETOOTH_DISABLED
|
|
118, // 50 -> SCAN_FILTERS_NOT_ALLOWED_FOR_LOCATION
|
|
19, // 51 -> BLUETOOTH_SCAN_REJUVENATE_FAILED
|
|
78, // 52 -> NULL_BLE_PERIPHERAL
|
|
82, // 53 -> NULL_BLUETOOTH_GATT
|
|
145, // 54 -> UNEXPECTED_BLUETOOTH_STATE
|
|
112, // 55 -> REMOTE_EXCEPTION
|
|
48, // 56 -> INVALID_BLUETOOTH_SOCKET_STATE_BEFORE_CONNECT
|
|
20, // 57 -> BLUETOOTH_SOCKET_CLOSED_AFTER_CONNECTED
|
|
45, // 58 -> INVALID_BLUETOOTH_CHANNEL
|
|
80, // 59 -> NULL_BLUETOOTH_DEVICE
|
|
86, // 60 -> NULL_BLUETOOTH_PROXY
|
|
55, // 61 -> INVALID_PACKET_LENGTH
|
|
54, // 62 -> INVALID_PACKET_BYTES
|
|
146, // 63 -> UNEXPECTED_EOF_EXCEPTION
|
|
127, // 64 -> SOCKET_CLOSED_OR_TIMEOUT
|
|
51, // 65 -> INVALID_IPV4_ADDRESS
|
|
52, // 66 -> INVALID_IPV6_ADDRESS
|
|
76, // 67 -> NULL_ADDRESS
|
|
59, // 68 -> INVALID_VERSION
|
|
120, // 69 -> SET_CONNECTION_PRIORITY_FAILED
|
|
121, // 70 -> SET_CONNECTION_PRIORITY_INTERRUPTED
|
|
150, // 71 -> UNKNOWN_IO_EXCEPTION
|
|
110, // 72 -> READ_CHARACTERISTIC_FAILED
|
|
161, // 73 -> WIFI_HOTSPOT_ENABLED
|
|
16, // 74 -> AWARE_UNAVAILABLE
|
|
62, // 75 -> IN_BLACK_LIST
|
|
37, // 76 -> FEATURE_WIFI_NOT_SUPPORTED
|
|
102, // 77 -> NULL_WIFI_MANAGER
|
|
126, // 78 -> SOCKET_CLOSED
|
|
124, // 79 -> SOCKET_ALREADY_CONNECTED
|
|
73, // 80 -> NFC_TECH_NOT_SUPPORTED
|
|
72, // 81 -> NFC_SERVICE_DIED
|
|
18, // 82 -> BIND_NFC_SERVICE_FAILED
|
|
71, // 83 -> NFC_CREATE_SOCKET_FAILED
|
|
101, // 84 -> NULL_WIFI_AWARE_PEER
|
|
67, // 85 -> NETWORK_ALREADY_JOINED
|
|
64, // 86 -> JOIN_AWARE_NETWORK_CANCELLED
|
|
70, // 87 -> NETWORK_UNAVAILABLE
|
|
165, // 88 -> WITHOUT_ACTIVE_AWARE_NETWORK
|
|
168, // 89 -> WITHOUT_JOINED_AWARE_NETWORK
|
|
25, // 90 -> CONNET_TO_SOCKET_CANCELLED
|
|
99, // 91 -> NULL_SSID
|
|
94, // 92 -> NULL_PASSWORD
|
|
36, // 93 -> FEATURE_WIFI_DIRECT_NOT_SUPPORTED
|
|
103, // 94 -> NULL_WIFI_P2P_MANAGER
|
|
105, // 95 -> P2P_GROUP_FORMED
|
|
0, // 96 -> ACQUIRE_P2P_CHANNEL_FAILED
|
|
106, // 97 -> P2P_UNSUPPORTED
|
|
41, // 98 -> INTERNAL_ERROR
|
|
22, // 99 -> BUSY
|
|
111, // 100 -> REFLECTION_ERROR
|
|
68, // 101 -> NETWORK_ERROR_EHOSTUNREACH
|
|
69, // 102 -> NETWORK_ERROR_ENETUNREACH
|
|
1, // 103 -> ADD_NETWORK_FAILED
|
|
157, // 104 -> UPDATE_NETWORK_FAILED
|
|
8, // 105 -> ALREADY_IN_PROGRESS
|
|
44, // 106 -> INVALID_ARGS
|
|
74, // 107 -> NOT_AUTHORIZED
|
|
53, // 108 -> INVALID_NETWORK_ID
|
|
162, // 109 -> WIFI_MANAGER_ENABLE_NETWORK_FAILED
|
|
163, // 110 -> WIFI_MANAGER_RECONNECT_FAILED
|
|
166, // 111 -> WITHOUT_ACTIVE_NETWORK
|
|
159, // 112 -> WEBRTC_CONNECTION_FLOW_EXIST
|
|
90, // 113 -> NULL_DROID_GUARD_RESULT
|
|
142, // 114 -> TACHYON_SIGNALING_MESSENGER_EXIST
|
|
131, // 115 -> TACHYON_ALREADY_START_RECEIVE_MESSAGE
|
|
136, // 116 -> TACHYON_RECEIVE_MESSAGE_FAILED
|
|
137, // 117 -> TACHYON_RECEIVE_MESSAGE_INTERRUPTED
|
|
135, // 118 -> TACHYON_RECEIVE_MESSAGE_EXECUTION_EXCEPTION
|
|
139, // 119 -> TACHYON_RECEIVE_MESSAGE_TIMEOUT
|
|
134, // 120 -> TACHYON_RECEIVE_MESSAGE_AUTH_EXCEPTION
|
|
138, // 121 -> TACHYON_RECEIVE_MESSAGE_STATUS_EXCEPTION
|
|
140, // 122 -> TACHYON_SEND_MESSAGE_AUTH_EXCEPTION
|
|
141, // 123 -> TACHYON_SEND_MESSAGE_STATUS_EXCEPTION
|
|
132, // 124 -> TACHYON_GET_ICE_SERVER_AUTH_EXCEPTION
|
|
133, // 125 -> TACHYON_GET_ICE_SERVER_STATUS_EXCEPTION
|
|
27, // 126 -> EMPTY_TACHYON_ICE_SERVER
|
|
108, // 127 -> POTENTIAL_WEBRTC_LIB_LOADING_FAILURE
|
|
147, // 128 -> UNEXPECTED_GATT_DESCRIPTOR
|
|
30, // 129 -> FAIL_TO_RECEIVE_L2CAP_PACKET
|
|
169, // 130 -> WITHOUT_PSM_VALUE
|
|
125, // 131 -> SOCKET_BIND_LISTEN_FAILED
|
|
148, // 132 -> UNEXPECTED_PACKET_CONTENT
|
|
151, // 133 -> UNREGISTER_NSD_MANAGER_FAILED
|
|
109, // 134 -> PUBLISH_EMPTY_ADVERTISEMENT_FAILED
|
|
21, // 135 -> BLUETOOTH_SOCKET_NOT_IN_LISTENING_STATE
|
|
46, // 136 -> INVALID_BLUETOOTH_SOCKET_SIGNAL_SIZE
|
|
47, // 137 -> INVALID_BLUETOOTH_SOCKET_SIGNAL_STATUS
|
|
38, // 138 -> GET_ADDRESS_FAILED
|
|
91, // 139 -> NULL_LOCAL_ADDRESS
|
|
63, // 140 -> IS_LOOPBACK_ADDRESS
|
|
128, // 141 -> SOCKET_NOT_BOUND
|
|
58, // 142 -> INVALID_REMOTE_ADDRESS
|
|
123, // 143 -> SOCKET_ALREADY_BOUND
|
|
40, // 144 -> HOTSPOT_NOT_STARTED
|
|
158, // 145 -> WEBRTC_ALREADY_INITIALIZED
|
|
60, // 146 -> INVALID_WEBRTC_STATE
|
|
89, // 147 -> NULL_DATA_CHANNEL
|
|
26, // 148 -> CREATE_OFFER_FAILED
|
|
23, // 149 -> CLOSE_SERVER_SOCKET_FAILED
|
|
160, // 150 -> WIFI_AWARE_STARTED
|
|
14, // 151 -> AWARE_PUBLISH_SESSION_RAN_OUT
|
|
15, // 152 -> AWARE_SUBSCRIBE_SESSION_RAN_OUT
|
|
9, // 153 -> AWARE_DATA_PATH_RAN_OUT
|
|
164, // 154 -> WIFI_SIGNAL_STRENGTH_POOR
|
|
107, // 155 -> POTENTIAL_SRD_ISSUE
|
|
11, // 156 -> AWARE_L2_MESSAGE_HOST_NETWORK_ERROR
|
|
13, // 157 -> AWARE_L2_MESSAGE_NETWORK_AVAILABLE_ERROR
|
|
12, // 158 -> AWARE_L2_MESSAGE_IP_AVAILABLE_ERROR
|
|
10, // 159 -> AWARE_L2_MESSAGE_CANCELLATION_RECEIVED
|
|
143, // 160 -> TIE_BREAK_LOSER
|
|
119, // 161 -> SERVER_SOCKET_UNAVAILABLE
|
|
39, // 162 -> HOSTED_NETWORK_UNAVAILABLE
|
|
17, // 163 -> AWARE_UPDATE_PUBLISHING_CONFIG_FAILED
|
|
65, // 164 -> L2CAP_UNAVAILABLE
|
|
7, // 165 -> ALREADY_HAS_GATT_CONNECTION
|
|
152, // 166 -> UNSUPPORTED_DEVICE_TYPE
|
|
154, // 167 -> UNSUPPORTED_DEVICE_TYPE_CHROME_OS
|
|
153, // 168 -> UNSUPPORTED_DEVICE_TYPE_AUTO
|
|
155, // 169 -> UNSUPPORTED_DEVICE_TYPE_TV
|
|
156, // 170 -> UNSUPPORTED_DEVICE_TYPE_WEAR
|
|
92, // 171 -> NULL_MESSAGE
|
|
};
|
|
|
|
const std::string& Description_Name(
|
|
Description value) {
|
|
static const bool dummy =
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
|
|
Description_entries,
|
|
Description_entries_by_number,
|
|
170, Description_strings);
|
|
(void) dummy;
|
|
int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
|
|
Description_entries,
|
|
Description_entries_by_number,
|
|
170, value);
|
|
return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
|
|
Description_strings[idx].get();
|
|
}
|
|
bool Description_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Description* value) {
|
|
int int_value;
|
|
bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
|
|
Description_entries, 170, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<Description>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
|
|
// @@protoc_insertion_point(namespace_scope)
|
|
} // namespace proto
|
|
} // namespace errorcode
|
|
} // namespace nearby
|
|
} // namespace location
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
|
|
// @@protoc_insertion_point(global_scope)
|
|
#include <google/protobuf/port_undef.inc>
|