mirror of
https://github.com/kidfromjupiter/nearby.git
synced 2026-09-14 14:46:12 -04:00
Create sharing_enums.pb.h
This commit is contained in:
suetfei
@@ -0,0 +1,739 @@
|
||||
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
||||
// source: proto/sharing_enums.proto
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_INCLUDED_proto_2fsharing_5fenums_2eproto
|
||||
#define GOOGLE_PROTOBUF_INCLUDED_proto_2fsharing_5fenums_2eproto
|
||||
|
||||
#include <limits>
|
||||
#include <string>
|
||||
|
||||
#include <google/protobuf/port_def.inc>
|
||||
#if PROTOBUF_VERSION < 3019000
|
||||
#error This file was generated by a newer version of protoc which is
|
||||
#error incompatible with your Protocol Buffer headers. Please update
|
||||
#error your headers.
|
||||
#endif
|
||||
#if 3019004 < PROTOBUF_MIN_PROTOC_VERSION
|
||||
#error This file was generated by an older version of protoc which is
|
||||
#error incompatible with your Protocol Buffer headers. Please
|
||||
#error regenerate this file with a newer version of protoc.
|
||||
#endif
|
||||
|
||||
#include <google/protobuf/port_undef.inc>
|
||||
#include <google/protobuf/io/coded_stream.h>
|
||||
#include <google/protobuf/arena.h>
|
||||
#include <google/protobuf/arenastring.h>
|
||||
#include <google/protobuf/generated_message_table_driven.h>
|
||||
#include <google/protobuf/generated_message_util.h>
|
||||
#include <google/protobuf/metadata_lite.h>
|
||||
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
|
||||
#include <google/protobuf/extension_set.h> // IWYU pragma: export
|
||||
#include <google/protobuf/generated_enum_util.h>
|
||||
// @@protoc_insertion_point(includes)
|
||||
#include <google/protobuf/port_def.inc>
|
||||
#define PROTOBUF_INTERNAL_EXPORT_proto_2fsharing_5fenums_2eproto
|
||||
PROTOBUF_NAMESPACE_OPEN
|
||||
namespace internal {
|
||||
class AnyMetadata;
|
||||
} // namespace internal
|
||||
PROTOBUF_NAMESPACE_CLOSE
|
||||
|
||||
// Internal implementation detail -- do not use these members.
|
||||
struct TableStruct_proto_2fsharing_5fenums_2eproto {
|
||||
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
|
||||
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[1]
|
||||
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
|
||||
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
|
||||
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
|
||||
static const uint32_t offsets[];
|
||||
};
|
||||
PROTOBUF_NAMESPACE_OPEN
|
||||
PROTOBUF_NAMESPACE_CLOSE
|
||||
namespace location {
|
||||
namespace nearby {
|
||||
namespace proto {
|
||||
namespace sharing {
|
||||
|
||||
enum EventType : int {
|
||||
UNKNOWN_EVENT_TYPE = 0,
|
||||
ACCEPT_AGREEMENTS = 1,
|
||||
ENABLE_NEARBY_SHARING = 2,
|
||||
SET_VISIBILITY = 3,
|
||||
DESCRIBE_ATTACHMENTS = 4,
|
||||
SCAN_FOR_SHARE_TARGETS_START = 5,
|
||||
SCAN_FOR_SHARE_TARGETS_END = 6,
|
||||
ADVERTISE_DEVICE_PRESENCE_START = 7,
|
||||
ADVERTISE_DEVICE_PRESENCE_END = 8,
|
||||
SEND_FAST_INITIALIZATION = 9,
|
||||
RECEIVE_FAST_INITIALIZATION = 10,
|
||||
DISCOVER_SHARE_TARGET = 11,
|
||||
SEND_INTRODUCTION = 12,
|
||||
RECEIVE_INTRODUCTION = 13,
|
||||
RESPOND_TO_INTRODUCTION = 14,
|
||||
SEND_ATTACHMENTS_START = 15,
|
||||
SEND_ATTACHMENTS_END = 16,
|
||||
RECEIVE_ATTACHMENTS_START = 17,
|
||||
RECEIVE_ATTACHMENTS_END = 18,
|
||||
CANCEL_SENDING_ATTACHMENTS = 19,
|
||||
CANCEL_RECEIVING_ATTACHMENTS = 20,
|
||||
OPEN_RECEIVED_ATTACHMENTS = 21,
|
||||
LAUNCH_SETUP_ACTIVITY PROTOBUF_DEPRECATED_ENUM = 22,
|
||||
ADD_CONTACT = 23,
|
||||
REMOVE_CONTACT = 24,
|
||||
FAST_SHARE_SERVER_RESPONSE = 25,
|
||||
SEND_START = 26,
|
||||
ACCEPT_FAST_INITIALIZATION = 27,
|
||||
SET_DATA_USAGE = 28,
|
||||
DISMISS_FAST_INITIALIZATION = 29,
|
||||
CANCEL_CONNECTION = 30,
|
||||
LAUNCH_ACTIVITY = 31,
|
||||
DISMISS_PRIVACY_NOTIFICATION = 32,
|
||||
TAP_PRIVACY_NOTIFICATION = 33,
|
||||
TAP_HELP = 34,
|
||||
TAP_FEEDBACK = 35,
|
||||
ADD_QUICK_SETTINGS_TILE = 36,
|
||||
REMOVE_QUICK_SETTINGS_TILE = 37,
|
||||
LAUNCH_PHONE_CONSENT = 38,
|
||||
TAP_QUICK_SETTINGS_TILE = 39,
|
||||
INSTALL_APK = 40,
|
||||
VERIFY_APK = 41,
|
||||
LAUNCH_CONSENT = 42,
|
||||
PROCESS_RECEIVED_ATTACHMENTS_END = 43,
|
||||
TOGGLE_SHOW_NOTIFICATION = 44,
|
||||
SET_DEVICE_NAME = 45,
|
||||
DECLINE_AGREEMENTS = 46,
|
||||
REQUEST_SETTING_PERMISSIONS = 47,
|
||||
ESTABLISH_CONNECTION = 48,
|
||||
DEVICE_SETTINGS = 49
|
||||
};
|
||||
bool EventType_IsValid(int value);
|
||||
constexpr EventType EventType_MIN = UNKNOWN_EVENT_TYPE;
|
||||
constexpr EventType EventType_MAX = DEVICE_SETTINGS;
|
||||
constexpr int EventType_ARRAYSIZE = EventType_MAX + 1;
|
||||
|
||||
const std::string& EventType_Name(EventType value);
|
||||
template<typename T>
|
||||
inline const std::string& EventType_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, EventType>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function EventType_Name.");
|
||||
return EventType_Name(static_cast<EventType>(enum_t_value));
|
||||
}
|
||||
bool EventType_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EventType* value);
|
||||
enum EventCategory : int {
|
||||
UNKNOWN_EVENT_CATEGORY = 0,
|
||||
SENDING_EVENT = 1,
|
||||
RECEIVING_EVENT = 2,
|
||||
SETTINGS_EVENT = 3
|
||||
};
|
||||
bool EventCategory_IsValid(int value);
|
||||
constexpr EventCategory EventCategory_MIN = UNKNOWN_EVENT_CATEGORY;
|
||||
constexpr EventCategory EventCategory_MAX = SETTINGS_EVENT;
|
||||
constexpr int EventCategory_ARRAYSIZE = EventCategory_MAX + 1;
|
||||
|
||||
const std::string& EventCategory_Name(EventCategory value);
|
||||
template<typename T>
|
||||
inline const std::string& EventCategory_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, EventCategory>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function EventCategory_Name.");
|
||||
return EventCategory_Name(static_cast<EventCategory>(enum_t_value));
|
||||
}
|
||||
bool EventCategory_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EventCategory* value);
|
||||
enum NearbySharingStatus : int {
|
||||
UNKNOWN_NEARBY_SHARING_STATUS = 0,
|
||||
ON = 1,
|
||||
OFF = 2
|
||||
};
|
||||
bool NearbySharingStatus_IsValid(int value);
|
||||
constexpr NearbySharingStatus NearbySharingStatus_MIN = UNKNOWN_NEARBY_SHARING_STATUS;
|
||||
constexpr NearbySharingStatus NearbySharingStatus_MAX = OFF;
|
||||
constexpr int NearbySharingStatus_ARRAYSIZE = NearbySharingStatus_MAX + 1;
|
||||
|
||||
const std::string& NearbySharingStatus_Name(NearbySharingStatus value);
|
||||
template<typename T>
|
||||
inline const std::string& NearbySharingStatus_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, NearbySharingStatus>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function NearbySharingStatus_Name.");
|
||||
return NearbySharingStatus_Name(static_cast<NearbySharingStatus>(enum_t_value));
|
||||
}
|
||||
bool NearbySharingStatus_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NearbySharingStatus* value);
|
||||
enum Visibility : int {
|
||||
UNKNOWN_VISIBILITY = 0,
|
||||
CONTACTS_ONLY = 1,
|
||||
EVERYONE = 2,
|
||||
SELECTED_CONTACTS_ONLY = 3,
|
||||
HIDDEN = 4,
|
||||
SELF_SHARE = 5
|
||||
};
|
||||
bool Visibility_IsValid(int value);
|
||||
constexpr Visibility Visibility_MIN = UNKNOWN_VISIBILITY;
|
||||
constexpr Visibility Visibility_MAX = SELF_SHARE;
|
||||
constexpr int Visibility_ARRAYSIZE = Visibility_MAX + 1;
|
||||
|
||||
const std::string& Visibility_Name(Visibility value);
|
||||
template<typename T>
|
||||
inline const std::string& Visibility_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, Visibility>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function Visibility_Name.");
|
||||
return Visibility_Name(static_cast<Visibility>(enum_t_value));
|
||||
}
|
||||
bool Visibility_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Visibility* value);
|
||||
enum DataUsage : int {
|
||||
UNKNOWN_DATA_USAGE = 0,
|
||||
ONLINE = 1,
|
||||
WIFI_ONLY = 2,
|
||||
OFFLINE = 3
|
||||
};
|
||||
bool DataUsage_IsValid(int value);
|
||||
constexpr DataUsage DataUsage_MIN = UNKNOWN_DATA_USAGE;
|
||||
constexpr DataUsage DataUsage_MAX = OFFLINE;
|
||||
constexpr int DataUsage_ARRAYSIZE = DataUsage_MAX + 1;
|
||||
|
||||
const std::string& DataUsage_Name(DataUsage value);
|
||||
template<typename T>
|
||||
inline const std::string& DataUsage_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, DataUsage>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function DataUsage_Name.");
|
||||
return DataUsage_Name(static_cast<DataUsage>(enum_t_value));
|
||||
}
|
||||
bool DataUsage_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DataUsage* value);
|
||||
enum EstablishConnectionStatus : int {
|
||||
CONNECTION_STATUS_UNKNOWN = 0,
|
||||
CONNECTION_STATUS_SUCCESS = 1,
|
||||
CONNECTION_STATUS_FAILURE = 2,
|
||||
CONNECTION_STATUS_CANCELLATION = 3
|
||||
};
|
||||
bool EstablishConnectionStatus_IsValid(int value);
|
||||
constexpr EstablishConnectionStatus EstablishConnectionStatus_MIN = CONNECTION_STATUS_UNKNOWN;
|
||||
constexpr EstablishConnectionStatus EstablishConnectionStatus_MAX = CONNECTION_STATUS_CANCELLATION;
|
||||
constexpr int EstablishConnectionStatus_ARRAYSIZE = EstablishConnectionStatus_MAX + 1;
|
||||
|
||||
const std::string& EstablishConnectionStatus_Name(EstablishConnectionStatus value);
|
||||
template<typename T>
|
||||
inline const std::string& EstablishConnectionStatus_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, EstablishConnectionStatus>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function EstablishConnectionStatus_Name.");
|
||||
return EstablishConnectionStatus_Name(static_cast<EstablishConnectionStatus>(enum_t_value));
|
||||
}
|
||||
bool EstablishConnectionStatus_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EstablishConnectionStatus* value);
|
||||
enum AttachmentTransmissionStatus : int {
|
||||
UNKNOWN_ATTACHMENT_TRANSMISSION_STATUS = 0,
|
||||
COMPLETE_ATTACHMENT_TRANSMISSION_STATUS = 1,
|
||||
CANCELED_ATTACHMENT_TRANSMISSION_STATUS = 2,
|
||||
FAILED_ATTACHMENT_TRANSMISSION_STATUS = 3,
|
||||
REJECTED_ATTACHMENT = 4,
|
||||
TIMED_OUT_ATTACHMENT = 5,
|
||||
AWAITING_REMOTE_ACCEPTANCE_FAILED_ATTACHMENT PROTOBUF_DEPRECATED_ENUM = 6,
|
||||
NOT_ENOUGH_SPACE_ATTACHMENT = 7,
|
||||
FAILED_NO_TRANSFER_UPDATE_CALLBACK = 8,
|
||||
MEDIA_UNAVAILABLE_ATTACHMENT = 9,
|
||||
UNSUPPORTED_ATTACHMENT_TYPE_ATTACHMENT = 10,
|
||||
NO_ATTACHMENT_FOUND = 11,
|
||||
FAILED_NO_SHARE_TARGET_ENDPOINT = 12,
|
||||
FAILED_PAIRED_KEYHANDSHAKE = 13,
|
||||
FAILED_NULL_CONNECTION = 14,
|
||||
FAILED_NO_PAYLOAD = 15,
|
||||
FAILED_WRITE_INTRODUCTION = 16,
|
||||
FAILED_UNKNOWN_REMOTE_RESPONSE = 17
|
||||
};
|
||||
bool AttachmentTransmissionStatus_IsValid(int value);
|
||||
constexpr AttachmentTransmissionStatus AttachmentTransmissionStatus_MIN = UNKNOWN_ATTACHMENT_TRANSMISSION_STATUS;
|
||||
constexpr AttachmentTransmissionStatus AttachmentTransmissionStatus_MAX = FAILED_UNKNOWN_REMOTE_RESPONSE;
|
||||
constexpr int AttachmentTransmissionStatus_ARRAYSIZE = AttachmentTransmissionStatus_MAX + 1;
|
||||
|
||||
const std::string& AttachmentTransmissionStatus_Name(AttachmentTransmissionStatus value);
|
||||
template<typename T>
|
||||
inline const std::string& AttachmentTransmissionStatus_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, AttachmentTransmissionStatus>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function AttachmentTransmissionStatus_Name.");
|
||||
return AttachmentTransmissionStatus_Name(static_cast<AttachmentTransmissionStatus>(enum_t_value));
|
||||
}
|
||||
bool AttachmentTransmissionStatus_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AttachmentTransmissionStatus* value);
|
||||
enum ProcessReceivedAttachmentsStatus : int {
|
||||
PROCESSING_STATUS_UNKNOWN = 0,
|
||||
PROCESSING_STATUS_COMPLETE_PROCESSING_ATTACHMENTS = 1,
|
||||
PROCESSING_STATUS_FAILED_MOVING_FILES = 2,
|
||||
PROCESSING_STATUS_FAILED_RECEIVING_APK = 3,
|
||||
PROCESSING_STATUS_FAILED_RECEIVING_TEXT = 4,
|
||||
PROCESSING_STATUS_FAILED_RECEIVING_WIFI_CREDENTIALS = 5
|
||||
};
|
||||
bool ProcessReceivedAttachmentsStatus_IsValid(int value);
|
||||
constexpr ProcessReceivedAttachmentsStatus ProcessReceivedAttachmentsStatus_MIN = PROCESSING_STATUS_UNKNOWN;
|
||||
constexpr ProcessReceivedAttachmentsStatus ProcessReceivedAttachmentsStatus_MAX = PROCESSING_STATUS_FAILED_RECEIVING_WIFI_CREDENTIALS;
|
||||
constexpr int ProcessReceivedAttachmentsStatus_ARRAYSIZE = ProcessReceivedAttachmentsStatus_MAX + 1;
|
||||
|
||||
const std::string& ProcessReceivedAttachmentsStatus_Name(ProcessReceivedAttachmentsStatus value);
|
||||
template<typename T>
|
||||
inline const std::string& ProcessReceivedAttachmentsStatus_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, ProcessReceivedAttachmentsStatus>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function ProcessReceivedAttachmentsStatus_Name.");
|
||||
return ProcessReceivedAttachmentsStatus_Name(static_cast<ProcessReceivedAttachmentsStatus>(enum_t_value));
|
||||
}
|
||||
bool ProcessReceivedAttachmentsStatus_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ProcessReceivedAttachmentsStatus* value);
|
||||
enum SessionStatus : int {
|
||||
UNKNOWN_SESSION_STATUS = 0,
|
||||
SUCCEEDED_SESSION_STATUS = 1,
|
||||
FAILED_SESSION_STATUS = 2
|
||||
};
|
||||
bool SessionStatus_IsValid(int value);
|
||||
constexpr SessionStatus SessionStatus_MIN = UNKNOWN_SESSION_STATUS;
|
||||
constexpr SessionStatus SessionStatus_MAX = FAILED_SESSION_STATUS;
|
||||
constexpr int SessionStatus_ARRAYSIZE = SessionStatus_MAX + 1;
|
||||
|
||||
const std::string& SessionStatus_Name(SessionStatus value);
|
||||
template<typename T>
|
||||
inline const std::string& SessionStatus_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, SessionStatus>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function SessionStatus_Name.");
|
||||
return SessionStatus_Name(static_cast<SessionStatus>(enum_t_value));
|
||||
}
|
||||
bool SessionStatus_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SessionStatus* value);
|
||||
enum ResponseToIntroduction : int {
|
||||
UNKNOWN_RESPONSE_TO_INTRODUCTION = 0,
|
||||
ACCEPT_INTRODUCTION = 1,
|
||||
REJECT_INTRODUCTION = 2,
|
||||
FAIL_INTRODUCTION = 3
|
||||
};
|
||||
bool ResponseToIntroduction_IsValid(int value);
|
||||
constexpr ResponseToIntroduction ResponseToIntroduction_MIN = UNKNOWN_RESPONSE_TO_INTRODUCTION;
|
||||
constexpr ResponseToIntroduction ResponseToIntroduction_MAX = FAIL_INTRODUCTION;
|
||||
constexpr int ResponseToIntroduction_ARRAYSIZE = ResponseToIntroduction_MAX + 1;
|
||||
|
||||
const std::string& ResponseToIntroduction_Name(ResponseToIntroduction value);
|
||||
template<typename T>
|
||||
inline const std::string& ResponseToIntroduction_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, ResponseToIntroduction>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function ResponseToIntroduction_Name.");
|
||||
return ResponseToIntroduction_Name(static_cast<ResponseToIntroduction>(enum_t_value));
|
||||
}
|
||||
bool ResponseToIntroduction_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ResponseToIntroduction* value);
|
||||
enum DeviceType : int {
|
||||
UNKNOWN_DEVICE_TYPE = 0,
|
||||
PHONE = 1,
|
||||
TABLET = 2,
|
||||
LAPTOP = 3
|
||||
};
|
||||
bool DeviceType_IsValid(int value);
|
||||
constexpr DeviceType DeviceType_MIN = UNKNOWN_DEVICE_TYPE;
|
||||
constexpr DeviceType DeviceType_MAX = LAPTOP;
|
||||
constexpr int DeviceType_ARRAYSIZE = DeviceType_MAX + 1;
|
||||
|
||||
const std::string& DeviceType_Name(DeviceType value);
|
||||
template<typename T>
|
||||
inline const std::string& DeviceType_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, DeviceType>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function DeviceType_Name.");
|
||||
return DeviceType_Name(static_cast<DeviceType>(enum_t_value));
|
||||
}
|
||||
bool DeviceType_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceType* value);
|
||||
enum OSType : int {
|
||||
UNKNOWN_OS_TYPE = 0,
|
||||
ANDROID = 1,
|
||||
CHROME_OS = 2,
|
||||
IOS = 3
|
||||
};
|
||||
bool OSType_IsValid(int value);
|
||||
constexpr OSType OSType_MIN = UNKNOWN_OS_TYPE;
|
||||
constexpr OSType OSType_MAX = IOS;
|
||||
constexpr int OSType_ARRAYSIZE = OSType_MAX + 1;
|
||||
|
||||
const std::string& OSType_Name(OSType value);
|
||||
template<typename T>
|
||||
inline const std::string& OSType_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, OSType>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function OSType_Name.");
|
||||
return OSType_Name(static_cast<OSType>(enum_t_value));
|
||||
}
|
||||
bool OSType_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OSType* value);
|
||||
enum DeviceRelationship : int {
|
||||
UNKNOWN_DEVICE_RELATIONSHIP = 0,
|
||||
IS_SELF = 1,
|
||||
IS_CONTACT = 2,
|
||||
IS_STRANGER = 3
|
||||
};
|
||||
bool DeviceRelationship_IsValid(int value);
|
||||
constexpr DeviceRelationship DeviceRelationship_MIN = UNKNOWN_DEVICE_RELATIONSHIP;
|
||||
constexpr DeviceRelationship DeviceRelationship_MAX = IS_STRANGER;
|
||||
constexpr int DeviceRelationship_ARRAYSIZE = DeviceRelationship_MAX + 1;
|
||||
|
||||
const std::string& DeviceRelationship_Name(DeviceRelationship value);
|
||||
template<typename T>
|
||||
inline const std::string& DeviceRelationship_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, DeviceRelationship>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function DeviceRelationship_Name.");
|
||||
return DeviceRelationship_Name(static_cast<DeviceRelationship>(enum_t_value));
|
||||
}
|
||||
bool DeviceRelationship_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceRelationship* value);
|
||||
enum LogSource : int {
|
||||
UNSPECIFIED_SOURCE = 0,
|
||||
LAB_DEVICES = 1,
|
||||
INTERNAL_DEVICES = 2,
|
||||
BETA_TESTER_DEVICES = 3,
|
||||
OEM_DEVICES = 4,
|
||||
DEBUG_DEVICES = 5
|
||||
};
|
||||
bool LogSource_IsValid(int value);
|
||||
constexpr LogSource LogSource_MIN = UNSPECIFIED_SOURCE;
|
||||
constexpr LogSource LogSource_MAX = DEBUG_DEVICES;
|
||||
constexpr int LogSource_ARRAYSIZE = LogSource_MAX + 1;
|
||||
|
||||
const std::string& LogSource_Name(LogSource value);
|
||||
template<typename T>
|
||||
inline const std::string& LogSource_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, LogSource>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function LogSource_Name.");
|
||||
return LogSource_Name(static_cast<LogSource>(enum_t_value));
|
||||
}
|
||||
bool LogSource_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LogSource* value);
|
||||
enum ServerActionName : int {
|
||||
UNKNOWN_SERVER_ACTION = 0,
|
||||
UPLOAD_CERTIFICATES = 1,
|
||||
DOWNLOAD_CERTIFICATES = 2,
|
||||
CHECK_REACHABILITY = 3,
|
||||
UPLOAD_CONTACTS = 4,
|
||||
UPDATE_DEVICE_NAME = 5,
|
||||
UPLOAD_SENDER_CERTIFICATES = 6,
|
||||
DOWNLOAD_SENDER_CERTIFICATES = 7
|
||||
};
|
||||
bool ServerActionName_IsValid(int value);
|
||||
constexpr ServerActionName ServerActionName_MIN = UNKNOWN_SERVER_ACTION;
|
||||
constexpr ServerActionName ServerActionName_MAX = DOWNLOAD_SENDER_CERTIFICATES;
|
||||
constexpr int ServerActionName_ARRAYSIZE = ServerActionName_MAX + 1;
|
||||
|
||||
const std::string& ServerActionName_Name(ServerActionName value);
|
||||
template<typename T>
|
||||
inline const std::string& ServerActionName_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, ServerActionName>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function ServerActionName_Name.");
|
||||
return ServerActionName_Name(static_cast<ServerActionName>(enum_t_value));
|
||||
}
|
||||
bool ServerActionName_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ServerActionName* value);
|
||||
enum ServerResponseState : int {
|
||||
UNKNOWN_SERVER_RESPONSE_STATE = 0,
|
||||
SERVER_RESPONSE_SUCCESS = 1,
|
||||
SERVER_RESPONSE_UNKNOWN_FAILURE = 2,
|
||||
SERVER_RESPONSE_STATUS_OTHER_FAILURE = 3,
|
||||
SERVER_RESPONSE_STATUS_DEADLINE_EXCEEDED = 4,
|
||||
SERVER_RESPONSE_STATUS_PERMISSION_DENIED = 5,
|
||||
SERVER_RESPONSE_STATUS_UNAVAILABLE = 6,
|
||||
SERVER_RESPONSE_STATUS_UNAUTHENTICATED = 7,
|
||||
SERVER_RESPONSE_STATUS_INVALID_ARGUMENT = 9,
|
||||
SERVER_RESPONSE_GOOGLE_AUTH_FAILURE = 8
|
||||
};
|
||||
bool ServerResponseState_IsValid(int value);
|
||||
constexpr ServerResponseState ServerResponseState_MIN = UNKNOWN_SERVER_RESPONSE_STATE;
|
||||
constexpr ServerResponseState ServerResponseState_MAX = SERVER_RESPONSE_STATUS_INVALID_ARGUMENT;
|
||||
constexpr int ServerResponseState_ARRAYSIZE = ServerResponseState_MAX + 1;
|
||||
|
||||
const std::string& ServerResponseState_Name(ServerResponseState value);
|
||||
template<typename T>
|
||||
inline const std::string& ServerResponseState_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, ServerResponseState>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function ServerResponseState_Name.");
|
||||
return ServerResponseState_Name(static_cast<ServerResponseState>(enum_t_value));
|
||||
}
|
||||
bool ServerResponseState_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ServerResponseState* value);
|
||||
enum ScanType : int {
|
||||
UNKNOWN_SCAN_TYPE = 0,
|
||||
FOREGROUND_SCAN = 1,
|
||||
FOREGROUND_RETRY_SCAN = 2,
|
||||
DIRECT_SHARE_SCAN = 3
|
||||
};
|
||||
bool ScanType_IsValid(int value);
|
||||
constexpr ScanType ScanType_MIN = UNKNOWN_SCAN_TYPE;
|
||||
constexpr ScanType ScanType_MAX = DIRECT_SHARE_SCAN;
|
||||
constexpr int ScanType_ARRAYSIZE = ScanType_MAX + 1;
|
||||
|
||||
const std::string& ScanType_Name(ScanType value);
|
||||
template<typename T>
|
||||
inline const std::string& ScanType_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, ScanType>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function ScanType_Name.");
|
||||
return ScanType_Name(static_cast<ScanType>(enum_t_value));
|
||||
}
|
||||
bool ScanType_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ScanType* value);
|
||||
enum ActivityName : int {
|
||||
UNKNOWN_ACTIVITY = 0,
|
||||
SHARE_SHEET_ACTIVITY = 1,
|
||||
SETTINGS_ACTIVITY = 2,
|
||||
RECEIVE_SURFACE_ACTIVITY = 3,
|
||||
SETUP_ACTIVITY = 4,
|
||||
DEVICE_VISIBILITY_ACTIVITY = 5,
|
||||
CONSENTS_ACTIVITY = 6,
|
||||
SET_DEVICE_NAME_DIALOG = 7,
|
||||
SET_DATA_USAGE_DIALOG = 8
|
||||
};
|
||||
bool ActivityName_IsValid(int value);
|
||||
constexpr ActivityName ActivityName_MIN = UNKNOWN_ACTIVITY;
|
||||
constexpr ActivityName ActivityName_MAX = SET_DATA_USAGE_DIALOG;
|
||||
constexpr int ActivityName_ARRAYSIZE = ActivityName_MAX + 1;
|
||||
|
||||
const std::string& ActivityName_Name(ActivityName value);
|
||||
template<typename T>
|
||||
inline const std::string& ActivityName_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, ActivityName>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function ActivityName_Name.");
|
||||
return ActivityName_Name(static_cast<ActivityName>(enum_t_value));
|
||||
}
|
||||
bool ActivityName_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ActivityName* value);
|
||||
enum ConsentType : int {
|
||||
CONSENT_TYPE_UNKNOWN = 0,
|
||||
CONSENT_TYPE_C11N = 1,
|
||||
CONSENT_TYPE_DEVICE_CONTACT = 2
|
||||
};
|
||||
bool ConsentType_IsValid(int value);
|
||||
constexpr ConsentType ConsentType_MIN = CONSENT_TYPE_UNKNOWN;
|
||||
constexpr ConsentType ConsentType_MAX = CONSENT_TYPE_DEVICE_CONTACT;
|
||||
constexpr int ConsentType_ARRAYSIZE = ConsentType_MAX + 1;
|
||||
|
||||
const std::string& ConsentType_Name(ConsentType value);
|
||||
template<typename T>
|
||||
inline const std::string& ConsentType_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, ConsentType>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function ConsentType_Name.");
|
||||
return ConsentType_Name(static_cast<ConsentType>(enum_t_value));
|
||||
}
|
||||
bool ConsentType_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConsentType* value);
|
||||
enum ConsentAcceptanceStatus : int {
|
||||
CONSENT_UNKNOWN_ACCEPT_STATUS = 0,
|
||||
CONSENT_ACCEPTED = 1,
|
||||
CONSENT_DECLINED = 2,
|
||||
CONSENT_UNABLE_TO_ENABLE = 3
|
||||
};
|
||||
bool ConsentAcceptanceStatus_IsValid(int value);
|
||||
constexpr ConsentAcceptanceStatus ConsentAcceptanceStatus_MIN = CONSENT_UNKNOWN_ACCEPT_STATUS;
|
||||
constexpr ConsentAcceptanceStatus ConsentAcceptanceStatus_MAX = CONSENT_UNABLE_TO_ENABLE;
|
||||
constexpr int ConsentAcceptanceStatus_ARRAYSIZE = ConsentAcceptanceStatus_MAX + 1;
|
||||
|
||||
const std::string& ConsentAcceptanceStatus_Name(ConsentAcceptanceStatus value);
|
||||
template<typename T>
|
||||
inline const std::string& ConsentAcceptanceStatus_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, ConsentAcceptanceStatus>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function ConsentAcceptanceStatus_Name.");
|
||||
return ConsentAcceptanceStatus_Name(static_cast<ConsentAcceptanceStatus>(enum_t_value));
|
||||
}
|
||||
bool ConsentAcceptanceStatus_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConsentAcceptanceStatus* value);
|
||||
enum ApkSource : int {
|
||||
UNKNOWN_APK_SOURCE = 0,
|
||||
APK_FROM_SD_CARD = 1,
|
||||
INSTALLED_APP = 2
|
||||
};
|
||||
bool ApkSource_IsValid(int value);
|
||||
constexpr ApkSource ApkSource_MIN = UNKNOWN_APK_SOURCE;
|
||||
constexpr ApkSource ApkSource_MAX = INSTALLED_APP;
|
||||
constexpr int ApkSource_ARRAYSIZE = ApkSource_MAX + 1;
|
||||
|
||||
const std::string& ApkSource_Name(ApkSource value);
|
||||
template<typename T>
|
||||
inline const std::string& ApkSource_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, ApkSource>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function ApkSource_Name.");
|
||||
return ApkSource_Name(static_cast<ApkSource>(enum_t_value));
|
||||
}
|
||||
bool ApkSource_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ApkSource* value);
|
||||
enum InstallAPKStatus : int {
|
||||
UNKNOWN_INSTALL_APK_STATUS = 0,
|
||||
FAIL_INSTALLATION = 1,
|
||||
SUCCESS_INSTALLATION = 2
|
||||
};
|
||||
bool InstallAPKStatus_IsValid(int value);
|
||||
constexpr InstallAPKStatus InstallAPKStatus_MIN = UNKNOWN_INSTALL_APK_STATUS;
|
||||
constexpr InstallAPKStatus InstallAPKStatus_MAX = SUCCESS_INSTALLATION;
|
||||
constexpr int InstallAPKStatus_ARRAYSIZE = InstallAPKStatus_MAX + 1;
|
||||
|
||||
const std::string& InstallAPKStatus_Name(InstallAPKStatus value);
|
||||
template<typename T>
|
||||
inline const std::string& InstallAPKStatus_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, InstallAPKStatus>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function InstallAPKStatus_Name.");
|
||||
return InstallAPKStatus_Name(static_cast<InstallAPKStatus>(enum_t_value));
|
||||
}
|
||||
bool InstallAPKStatus_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, InstallAPKStatus* value);
|
||||
enum VerifyAPKStatus : int {
|
||||
UNKNOWN_VERIFY_APK_STATUS = 0,
|
||||
NOT_INSTALLABLE = 1,
|
||||
INSTALLABLE = 2,
|
||||
ALREADY_INSTALLED = 3
|
||||
};
|
||||
bool VerifyAPKStatus_IsValid(int value);
|
||||
constexpr VerifyAPKStatus VerifyAPKStatus_MIN = UNKNOWN_VERIFY_APK_STATUS;
|
||||
constexpr VerifyAPKStatus VerifyAPKStatus_MAX = ALREADY_INSTALLED;
|
||||
constexpr int VerifyAPKStatus_ARRAYSIZE = VerifyAPKStatus_MAX + 1;
|
||||
|
||||
const std::string& VerifyAPKStatus_Name(VerifyAPKStatus value);
|
||||
template<typename T>
|
||||
inline const std::string& VerifyAPKStatus_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, VerifyAPKStatus>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function VerifyAPKStatus_Name.");
|
||||
return VerifyAPKStatus_Name(static_cast<VerifyAPKStatus>(enum_t_value));
|
||||
}
|
||||
bool VerifyAPKStatus_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VerifyAPKStatus* value);
|
||||
enum ShowNotificationStatus : int {
|
||||
UNKNOWN_SHOW_NOTIFICATION_STATUS = 0,
|
||||
SHOW = 1,
|
||||
NOT_SHOW = 2
|
||||
};
|
||||
bool ShowNotificationStatus_IsValid(int value);
|
||||
constexpr ShowNotificationStatus ShowNotificationStatus_MIN = UNKNOWN_SHOW_NOTIFICATION_STATUS;
|
||||
constexpr ShowNotificationStatus ShowNotificationStatus_MAX = NOT_SHOW;
|
||||
constexpr int ShowNotificationStatus_ARRAYSIZE = ShowNotificationStatus_MAX + 1;
|
||||
|
||||
const std::string& ShowNotificationStatus_Name(ShowNotificationStatus value);
|
||||
template<typename T>
|
||||
inline const std::string& ShowNotificationStatus_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, ShowNotificationStatus>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function ShowNotificationStatus_Name.");
|
||||
return ShowNotificationStatus_Name(static_cast<ShowNotificationStatus>(enum_t_value));
|
||||
}
|
||||
bool ShowNotificationStatus_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ShowNotificationStatus* value);
|
||||
enum PermissionRequestResult : int {
|
||||
PERMISSION_UNKNOWN_REQUEST_RESULT = 0,
|
||||
PERMISSION_GRANTED = 1,
|
||||
PERMISSION_REJECTED = 2,
|
||||
PERMISSION_UNABLE_TO_GRANT = 3
|
||||
};
|
||||
bool PermissionRequestResult_IsValid(int value);
|
||||
constexpr PermissionRequestResult PermissionRequestResult_MIN = PERMISSION_UNKNOWN_REQUEST_RESULT;
|
||||
constexpr PermissionRequestResult PermissionRequestResult_MAX = PERMISSION_UNABLE_TO_GRANT;
|
||||
constexpr int PermissionRequestResult_ARRAYSIZE = PermissionRequestResult_MAX + 1;
|
||||
|
||||
const std::string& PermissionRequestResult_Name(PermissionRequestResult value);
|
||||
template<typename T>
|
||||
inline const std::string& PermissionRequestResult_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, PermissionRequestResult>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function PermissionRequestResult_Name.");
|
||||
return PermissionRequestResult_Name(static_cast<PermissionRequestResult>(enum_t_value));
|
||||
}
|
||||
bool PermissionRequestResult_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PermissionRequestResult* value);
|
||||
enum PermissionRequestType : int {
|
||||
PERMISSION_UNKNOWN_TYPE = 0,
|
||||
PERMISSION_AIRPLANE_MODE_OFF = 1,
|
||||
PERMISSION_WIFI = 2,
|
||||
PERMISSION_BLUETOOTH = 3,
|
||||
PERMISSION_LOCATION = 4
|
||||
};
|
||||
bool PermissionRequestType_IsValid(int value);
|
||||
constexpr PermissionRequestType PermissionRequestType_MIN = PERMISSION_UNKNOWN_TYPE;
|
||||
constexpr PermissionRequestType PermissionRequestType_MAX = PERMISSION_LOCATION;
|
||||
constexpr int PermissionRequestType_ARRAYSIZE = PermissionRequestType_MAX + 1;
|
||||
|
||||
const std::string& PermissionRequestType_Name(PermissionRequestType value);
|
||||
template<typename T>
|
||||
inline const std::string& PermissionRequestType_Name(T enum_t_value) {
|
||||
static_assert(::std::is_same<T, PermissionRequestType>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function PermissionRequestType_Name.");
|
||||
return PermissionRequestType_Name(static_cast<PermissionRequestType>(enum_t_value));
|
||||
}
|
||||
bool PermissionRequestType_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PermissionRequestType* value);
|
||||
// ===================================================================
|
||||
|
||||
|
||||
// ===================================================================
|
||||
|
||||
|
||||
// ===================================================================
|
||||
|
||||
#ifdef __GNUC__
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
|
||||
#endif // __GNUC__
|
||||
#ifdef __GNUC__
|
||||
#pragma GCC diagnostic pop
|
||||
#endif // __GNUC__
|
||||
|
||||
// @@protoc_insertion_point(namespace_scope)
|
||||
|
||||
} // namespace sharing
|
||||
} // namespace proto
|
||||
} // namespace nearby
|
||||
} // namespace location
|
||||
|
||||
PROTOBUF_NAMESPACE_OPEN
|
||||
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::EventType> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::EventCategory> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::NearbySharingStatus> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::Visibility> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::DataUsage> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::EstablishConnectionStatus> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::AttachmentTransmissionStatus> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::ProcessReceivedAttachmentsStatus> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::SessionStatus> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::ResponseToIntroduction> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::DeviceType> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::OSType> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::DeviceRelationship> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::LogSource> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::ServerActionName> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::ServerResponseState> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::ScanType> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::ActivityName> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::ConsentType> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::ConsentAcceptanceStatus> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::ApkSource> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::InstallAPKStatus> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::VerifyAPKStatus> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::ShowNotificationStatus> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::PermissionRequestResult> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::proto::sharing::PermissionRequestType> : ::std::true_type {};
|
||||
|
||||
PROTOBUF_NAMESPACE_CLOSE
|
||||
|
||||
// @@protoc_insertion_point(global_scope)
|
||||
|
||||
#include <google/protobuf/port_undef.inc>
|
||||
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_proto_2fsharing_5fenums_2eproto
|
||||
Reference in New Issue
Block a user