mirror of
https://github.com/kidfromjupiter/nearby.git
synced 2026-09-14 22:56:12 -04:00
2974 lines
114 KiB
C++
2974 lines
114 KiB
C++
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// NO CHECKED-IN PROTOBUF GENCODE
|
|
// source: proto/sharing_enums.proto
|
|
// Protobuf C++ Version: 6.33.3
|
|
|
|
#include "proto/sharing_enums.pb.h"
|
|
|
|
#include <algorithm>
|
|
#include <type_traits>
|
|
#include "google/protobuf/io/coded_stream.h"
|
|
#include "google/protobuf/generated_message_tctable_impl.h"
|
|
#include "google/protobuf/extension_set.h"
|
|
#include "google/protobuf/generated_message_util.h"
|
|
#include "google/protobuf/wire_format_lite.h"
|
|
// @@protoc_insertion_point(includes)
|
|
|
|
// Must be included last.
|
|
#include "google/protobuf/port_def.inc"
|
|
PROTOBUF_PRAGMA_INIT_SEG
|
|
namespace _pb = ::google::protobuf;
|
|
namespace _pbi = ::google::protobuf::internal;
|
|
namespace _fl = ::google::protobuf::internal::field_layout;
|
|
namespace location {
|
|
namespace nearby {
|
|
namespace proto {
|
|
namespace sharing {
|
|
} // namespace sharing
|
|
} // namespace proto
|
|
} // namespace nearby
|
|
} // namespace location
|
|
namespace location {
|
|
namespace nearby {
|
|
namespace proto {
|
|
namespace sharing {
|
|
PROTOBUF_CONSTINIT const uint32_t EventType_internal_data_[] = {
|
|
5308416u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
EventType_strings[81] = {};
|
|
|
|
static const char EventType_names[] = {
|
|
"ACCEPT_AGREEMENTS"
|
|
"ACCEPT_FAST_INITIALIZATION"
|
|
"ADD_CONTACT"
|
|
"ADD_QUICK_SETTINGS_TILE"
|
|
"ADVERTISE_DEVICE_PRESENCE_END"
|
|
"ADVERTISE_DEVICE_PRESENCE_START"
|
|
"APP_CRASH"
|
|
"AUTO_DISMISS_FAST_INITIALIZATION"
|
|
"CANCEL_CONNECTION"
|
|
"CANCEL_RECEIVING_ATTACHMENTS"
|
|
"CANCEL_SENDING_ATTACHMENTS"
|
|
"CLOUD_CREATE_SHARING_REQUEST"
|
|
"CLOUD_DOWNLOAD_END"
|
|
"CLOUD_DOWNLOAD_START"
|
|
"CLOUD_REGISTER_RECEIVER"
|
|
"CLOUD_SHARING_RPC_RESULT"
|
|
"CLOUD_UPLOAD_END"
|
|
"CLOUD_UPLOAD_START"
|
|
"DECLINE_AGREEMENTS"
|
|
"DECRYPT_CERTIFICATE_FAILURE"
|
|
"DEFAULT_OPT_IN"
|
|
"DESCRIBE_ATTACHMENTS"
|
|
"DEVICE_SETTINGS"
|
|
"DISCOVER_SHARE_TARGET"
|
|
"DISMISS_FAST_INITIALIZATION"
|
|
"DISMISS_PRIVACY_NOTIFICATION"
|
|
"DISPLAY_PHONE_CONSENT"
|
|
"DISPLAY_PRIVACY_NOTIFICATION"
|
|
"ENABLE_NEARBY_SHARING"
|
|
"ESTABLISH_CONNECTION"
|
|
"FAST_INIT_DISCOVER_DEVICE"
|
|
"FAST_SHARE_SERVER_RESPONSE"
|
|
"HATS_JOINT_EVENT"
|
|
"HIGH_QUALITY_MEDIUM_SETUP"
|
|
"INSTALL_APK"
|
|
"LAUNCH_ACTIVITY"
|
|
"LAUNCH_CONSENT"
|
|
"LAUNCH_PHONE_CONSENT"
|
|
"LAUNCH_SETUP_ACTIVITY"
|
|
"OPEN_RECEIVED_ATTACHMENTS"
|
|
"PARSING_FAILED_ENDPOINT_ID"
|
|
"PREFERENCES_USAGE"
|
|
"PROCESS_RECEIVED_ATTACHMENTS_END"
|
|
"QR_CODE_LINK_SHOWN"
|
|
"QR_CODE_OPENED_IN_WEB_CLIENT"
|
|
"RECEIVE_ATTACHMENTS_END"
|
|
"RECEIVE_ATTACHMENTS_START"
|
|
"RECEIVE_FAST_INITIALIZATION"
|
|
"RECEIVE_INTRODUCTION"
|
|
"RECEIVE_PREVIEWS"
|
|
"REMOVE_CONTACT"
|
|
"REMOVE_QUICK_SETTINGS_TILE"
|
|
"REQUEST_SETTING_PERMISSIONS"
|
|
"RESPOND_TO_INTRODUCTION"
|
|
"RPC_CALL_STATUS"
|
|
"SCAN_FOR_SHARE_TARGETS_END"
|
|
"SCAN_FOR_SHARE_TARGETS_START"
|
|
"SEND_ATTACHMENTS_END"
|
|
"SEND_ATTACHMENTS_START"
|
|
"SEND_DESKTOP_NOTIFICATION"
|
|
"SEND_DESKTOP_TRANSFER_EVENT"
|
|
"SEND_FAST_INITIALIZATION"
|
|
"SEND_INTRODUCTION"
|
|
"SEND_START"
|
|
"SETUP_WIZARD"
|
|
"SET_ACCOUNT"
|
|
"SET_DATA_USAGE"
|
|
"SET_DEVICE_NAME"
|
|
"SET_VISIBILITY"
|
|
"SHOW_ALLOW_PERMISSION_AUTO_ACCESS"
|
|
"START_QR_CODE_SESSION"
|
|
"TAP_FEEDBACK"
|
|
"TAP_HELP"
|
|
"TAP_PRIVACY_NOTIFICATION"
|
|
"TAP_QR_CODE"
|
|
"TAP_QUICK_SETTINGS_FILE_SHARE"
|
|
"TAP_QUICK_SETTINGS_TILE"
|
|
"TOGGLE_SHOW_NOTIFICATION"
|
|
"UNKNOWN_EVENT_TYPE"
|
|
"VERIFY_APK"
|
|
"WAITING_FOR_ACCEPT"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry EventType_entries[] = {
|
|
{{&EventType_names[0], 17}, 1},
|
|
{{&EventType_names[17], 26}, 27},
|
|
{{&EventType_names[43], 11}, 23},
|
|
{{&EventType_names[54], 23}, 36},
|
|
{{&EventType_names[77], 29}, 8},
|
|
{{&EventType_names[106], 31}, 7},
|
|
{{&EventType_names[137], 9}, 51},
|
|
{{&EventType_names[146], 32}, 50},
|
|
{{&EventType_names[178], 17}, 30},
|
|
{{&EventType_names[195], 28}, 20},
|
|
{{&EventType_names[223], 26}, 19},
|
|
{{&EventType_names[249], 28}, 74},
|
|
{{&EventType_names[277], 18}, 79},
|
|
{{&EventType_names[295], 20}, 78},
|
|
{{&EventType_names[315], 23}, 75},
|
|
{{&EventType_names[338], 24}, 80},
|
|
{{&EventType_names[362], 16}, 77},
|
|
{{&EventType_names[378], 18}, 76},
|
|
{{&EventType_names[396], 18}, 46},
|
|
{{&EventType_names[414], 27}, 64},
|
|
{{&EventType_names[441], 14}, 56},
|
|
{{&EventType_names[455], 20}, 4},
|
|
{{&EventType_names[475], 15}, 49},
|
|
{{&EventType_names[490], 21}, 11},
|
|
{{&EventType_names[511], 27}, 29},
|
|
{{&EventType_names[538], 28}, 32},
|
|
{{&EventType_names[566], 21}, 54},
|
|
{{&EventType_names[587], 28}, 53},
|
|
{{&EventType_names[615], 21}, 2},
|
|
{{&EventType_names[636], 20}, 48},
|
|
{{&EventType_names[656], 25}, 61},
|
|
{{&EventType_names[681], 26}, 25},
|
|
{{&EventType_names[707], 16}, 72},
|
|
{{&EventType_names[723], 25}, 68},
|
|
{{&EventType_names[748], 11}, 40},
|
|
{{&EventType_names[759], 15}, 31},
|
|
{{&EventType_names[774], 14}, 42},
|
|
{{&EventType_names[788], 20}, 38},
|
|
{{&EventType_names[808], 21}, 22},
|
|
{{&EventType_names[829], 25}, 21},
|
|
{{&EventType_names[854], 26}, 60},
|
|
{{&EventType_names[880], 17}, 55},
|
|
{{&EventType_names[897], 32}, 43},
|
|
{{&EventType_names[929], 18}, 59},
|
|
{{&EventType_names[947], 28}, 71},
|
|
{{&EventType_names[975], 23}, 18},
|
|
{{&EventType_names[998], 25}, 17},
|
|
{{&EventType_names[1023], 27}, 10},
|
|
{{&EventType_names[1050], 20}, 13},
|
|
{{&EventType_names[1070], 16}, 73},
|
|
{{&EventType_names[1086], 14}, 24},
|
|
{{&EventType_names[1100], 26}, 37},
|
|
{{&EventType_names[1126], 27}, 47},
|
|
{{&EventType_names[1153], 23}, 14},
|
|
{{&EventType_names[1176], 15}, 69},
|
|
{{&EventType_names[1191], 26}, 6},
|
|
{{&EventType_names[1217], 28}, 5},
|
|
{{&EventType_names[1245], 20}, 16},
|
|
{{&EventType_names[1265], 22}, 15},
|
|
{{&EventType_names[1287], 25}, 62},
|
|
{{&EventType_names[1312], 27}, 66},
|
|
{{&EventType_names[1339], 24}, 9},
|
|
{{&EventType_names[1363], 17}, 12},
|
|
{{&EventType_names[1380], 10}, 26},
|
|
{{&EventType_names[1390], 12}, 57},
|
|
{{&EventType_names[1402], 11}, 63},
|
|
{{&EventType_names[1413], 14}, 28},
|
|
{{&EventType_names[1427], 15}, 45},
|
|
{{&EventType_names[1442], 14}, 3},
|
|
{{&EventType_names[1456], 33}, 65},
|
|
{{&EventType_names[1489], 21}, 70},
|
|
{{&EventType_names[1510], 12}, 35},
|
|
{{&EventType_names[1522], 8}, 34},
|
|
{{&EventType_names[1530], 24}, 33},
|
|
{{&EventType_names[1554], 11}, 58},
|
|
{{&EventType_names[1565], 29}, 52},
|
|
{{&EventType_names[1594], 23}, 39},
|
|
{{&EventType_names[1617], 24}, 44},
|
|
{{&EventType_names[1641], 18}, 0},
|
|
{{&EventType_names[1659], 10}, 41},
|
|
{{&EventType_names[1669], 18}, 67},
|
|
};
|
|
|
|
static const int EventType_entries_by_number[] = {
|
|
78, // 0 -> UNKNOWN_EVENT_TYPE
|
|
0, // 1 -> ACCEPT_AGREEMENTS
|
|
28, // 2 -> ENABLE_NEARBY_SHARING
|
|
68, // 3 -> SET_VISIBILITY
|
|
21, // 4 -> DESCRIBE_ATTACHMENTS
|
|
56, // 5 -> SCAN_FOR_SHARE_TARGETS_START
|
|
55, // 6 -> SCAN_FOR_SHARE_TARGETS_END
|
|
5, // 7 -> ADVERTISE_DEVICE_PRESENCE_START
|
|
4, // 8 -> ADVERTISE_DEVICE_PRESENCE_END
|
|
61, // 9 -> SEND_FAST_INITIALIZATION
|
|
47, // 10 -> RECEIVE_FAST_INITIALIZATION
|
|
23, // 11 -> DISCOVER_SHARE_TARGET
|
|
62, // 12 -> SEND_INTRODUCTION
|
|
48, // 13 -> RECEIVE_INTRODUCTION
|
|
53, // 14 -> RESPOND_TO_INTRODUCTION
|
|
58, // 15 -> SEND_ATTACHMENTS_START
|
|
57, // 16 -> SEND_ATTACHMENTS_END
|
|
46, // 17 -> RECEIVE_ATTACHMENTS_START
|
|
45, // 18 -> RECEIVE_ATTACHMENTS_END
|
|
10, // 19 -> CANCEL_SENDING_ATTACHMENTS
|
|
9, // 20 -> CANCEL_RECEIVING_ATTACHMENTS
|
|
39, // 21 -> OPEN_RECEIVED_ATTACHMENTS
|
|
38, // 22 -> LAUNCH_SETUP_ACTIVITY
|
|
2, // 23 -> ADD_CONTACT
|
|
50, // 24 -> REMOVE_CONTACT
|
|
31, // 25 -> FAST_SHARE_SERVER_RESPONSE
|
|
63, // 26 -> SEND_START
|
|
1, // 27 -> ACCEPT_FAST_INITIALIZATION
|
|
66, // 28 -> SET_DATA_USAGE
|
|
24, // 29 -> DISMISS_FAST_INITIALIZATION
|
|
8, // 30 -> CANCEL_CONNECTION
|
|
35, // 31 -> LAUNCH_ACTIVITY
|
|
25, // 32 -> DISMISS_PRIVACY_NOTIFICATION
|
|
73, // 33 -> TAP_PRIVACY_NOTIFICATION
|
|
72, // 34 -> TAP_HELP
|
|
71, // 35 -> TAP_FEEDBACK
|
|
3, // 36 -> ADD_QUICK_SETTINGS_TILE
|
|
51, // 37 -> REMOVE_QUICK_SETTINGS_TILE
|
|
37, // 38 -> LAUNCH_PHONE_CONSENT
|
|
76, // 39 -> TAP_QUICK_SETTINGS_TILE
|
|
34, // 40 -> INSTALL_APK
|
|
79, // 41 -> VERIFY_APK
|
|
36, // 42 -> LAUNCH_CONSENT
|
|
42, // 43 -> PROCESS_RECEIVED_ATTACHMENTS_END
|
|
77, // 44 -> TOGGLE_SHOW_NOTIFICATION
|
|
67, // 45 -> SET_DEVICE_NAME
|
|
18, // 46 -> DECLINE_AGREEMENTS
|
|
52, // 47 -> REQUEST_SETTING_PERMISSIONS
|
|
29, // 48 -> ESTABLISH_CONNECTION
|
|
22, // 49 -> DEVICE_SETTINGS
|
|
7, // 50 -> AUTO_DISMISS_FAST_INITIALIZATION
|
|
6, // 51 -> APP_CRASH
|
|
75, // 52 -> TAP_QUICK_SETTINGS_FILE_SHARE
|
|
27, // 53 -> DISPLAY_PRIVACY_NOTIFICATION
|
|
26, // 54 -> DISPLAY_PHONE_CONSENT
|
|
41, // 55 -> PREFERENCES_USAGE
|
|
20, // 56 -> DEFAULT_OPT_IN
|
|
64, // 57 -> SETUP_WIZARD
|
|
74, // 58 -> TAP_QR_CODE
|
|
43, // 59 -> QR_CODE_LINK_SHOWN
|
|
40, // 60 -> PARSING_FAILED_ENDPOINT_ID
|
|
30, // 61 -> FAST_INIT_DISCOVER_DEVICE
|
|
59, // 62 -> SEND_DESKTOP_NOTIFICATION
|
|
65, // 63 -> SET_ACCOUNT
|
|
19, // 64 -> DECRYPT_CERTIFICATE_FAILURE
|
|
69, // 65 -> SHOW_ALLOW_PERMISSION_AUTO_ACCESS
|
|
60, // 66 -> SEND_DESKTOP_TRANSFER_EVENT
|
|
80, // 67 -> WAITING_FOR_ACCEPT
|
|
33, // 68 -> HIGH_QUALITY_MEDIUM_SETUP
|
|
54, // 69 -> RPC_CALL_STATUS
|
|
70, // 70 -> START_QR_CODE_SESSION
|
|
44, // 71 -> QR_CODE_OPENED_IN_WEB_CLIENT
|
|
32, // 72 -> HATS_JOINT_EVENT
|
|
49, // 73 -> RECEIVE_PREVIEWS
|
|
11, // 74 -> CLOUD_CREATE_SHARING_REQUEST
|
|
14, // 75 -> CLOUD_REGISTER_RECEIVER
|
|
17, // 76 -> CLOUD_UPLOAD_START
|
|
16, // 77 -> CLOUD_UPLOAD_END
|
|
13, // 78 -> CLOUD_DOWNLOAD_START
|
|
12, // 79 -> CLOUD_DOWNLOAD_END
|
|
15, // 80 -> CLOUD_SHARING_RPC_RESULT
|
|
};
|
|
|
|
const ::std::string& EventType_Name(EventType value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
EventType_entries, EventType_entries_by_number, 81,
|
|
EventType_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(EventType_entries,
|
|
EventType_entries_by_number,
|
|
81, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : EventType_strings[idx].get();
|
|
}
|
|
|
|
bool EventType_Parse(::absl::string_view name, EventType* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
EventType_entries, 81, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<EventType>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t EventCategory_internal_data_[] = {
|
|
327680u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
EventCategory_strings[5] = {};
|
|
|
|
static const char EventCategory_names[] = {
|
|
"RECEIVING_EVENT"
|
|
"RPC_EVENT"
|
|
"SENDING_EVENT"
|
|
"SETTINGS_EVENT"
|
|
"UNKNOWN_EVENT_CATEGORY"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry EventCategory_entries[] = {
|
|
{{&EventCategory_names[0], 15}, 2},
|
|
{{&EventCategory_names[15], 9}, 4},
|
|
{{&EventCategory_names[24], 13}, 1},
|
|
{{&EventCategory_names[37], 14}, 3},
|
|
{{&EventCategory_names[51], 22}, 0},
|
|
};
|
|
|
|
static const int EventCategory_entries_by_number[] = {
|
|
4, // 0 -> UNKNOWN_EVENT_CATEGORY
|
|
2, // 1 -> SENDING_EVENT
|
|
0, // 2 -> RECEIVING_EVENT
|
|
3, // 3 -> SETTINGS_EVENT
|
|
1, // 4 -> RPC_EVENT
|
|
};
|
|
|
|
const ::std::string& EventCategory_Name(EventCategory value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
EventCategory_entries, EventCategory_entries_by_number, 5,
|
|
EventCategory_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(EventCategory_entries,
|
|
EventCategory_entries_by_number,
|
|
5, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : EventCategory_strings[idx].get();
|
|
}
|
|
|
|
bool EventCategory_Parse(::absl::string_view name, EventCategory* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
EventCategory_entries, 5, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<EventCategory>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t NearbySharingStatus_internal_data_[] = {
|
|
196608u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
NearbySharingStatus_strings[3] = {};
|
|
|
|
static const char NearbySharingStatus_names[] = {
|
|
"OFF"
|
|
"ON"
|
|
"UNKNOWN_NEARBY_SHARING_STATUS"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry NearbySharingStatus_entries[] = {
|
|
{{&NearbySharingStatus_names[0], 3}, 2},
|
|
{{&NearbySharingStatus_names[3], 2}, 1},
|
|
{{&NearbySharingStatus_names[5], 29}, 0},
|
|
};
|
|
|
|
static const int NearbySharingStatus_entries_by_number[] = {
|
|
2, // 0 -> UNKNOWN_NEARBY_SHARING_STATUS
|
|
1, // 1 -> ON
|
|
0, // 2 -> OFF
|
|
};
|
|
|
|
const ::std::string& NearbySharingStatus_Name(NearbySharingStatus value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
NearbySharingStatus_entries, NearbySharingStatus_entries_by_number, 3,
|
|
NearbySharingStatus_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(NearbySharingStatus_entries,
|
|
NearbySharingStatus_entries_by_number,
|
|
3, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : NearbySharingStatus_strings[idx].get();
|
|
}
|
|
|
|
bool NearbySharingStatus_Parse(::absl::string_view name, NearbySharingStatus* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
NearbySharingStatus_entries, 3, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<NearbySharingStatus>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t Visibility_internal_data_[] = {
|
|
393216u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
Visibility_strings[6] = {};
|
|
|
|
static const char Visibility_names[] = {
|
|
"CONTACTS_ONLY"
|
|
"EVERYONE"
|
|
"HIDDEN"
|
|
"SELECTED_CONTACTS_ONLY"
|
|
"SELF_SHARE"
|
|
"UNKNOWN_VISIBILITY"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry Visibility_entries[] = {
|
|
{{&Visibility_names[0], 13}, 1},
|
|
{{&Visibility_names[13], 8}, 2},
|
|
{{&Visibility_names[21], 6}, 4},
|
|
{{&Visibility_names[27], 22}, 3},
|
|
{{&Visibility_names[49], 10}, 5},
|
|
{{&Visibility_names[59], 18}, 0},
|
|
};
|
|
|
|
static const int Visibility_entries_by_number[] = {
|
|
5, // 0 -> UNKNOWN_VISIBILITY
|
|
0, // 1 -> CONTACTS_ONLY
|
|
1, // 2 -> EVERYONE
|
|
3, // 3 -> SELECTED_CONTACTS_ONLY
|
|
2, // 4 -> HIDDEN
|
|
4, // 5 -> SELF_SHARE
|
|
};
|
|
|
|
const ::std::string& Visibility_Name(Visibility value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
Visibility_entries, Visibility_entries_by_number, 6,
|
|
Visibility_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(Visibility_entries,
|
|
Visibility_entries_by_number,
|
|
6, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : Visibility_strings[idx].get();
|
|
}
|
|
|
|
bool Visibility_Parse(::absl::string_view name, Visibility* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
Visibility_entries, 6, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<Visibility>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t DataUsage_internal_data_[] = {
|
|
262144u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
DataUsage_strings[4] = {};
|
|
|
|
static const char DataUsage_names[] = {
|
|
"OFFLINE"
|
|
"ONLINE"
|
|
"UNKNOWN_DATA_USAGE"
|
|
"WIFI_ONLY"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry DataUsage_entries[] = {
|
|
{{&DataUsage_names[0], 7}, 3},
|
|
{{&DataUsage_names[7], 6}, 1},
|
|
{{&DataUsage_names[13], 18}, 0},
|
|
{{&DataUsage_names[31], 9}, 2},
|
|
};
|
|
|
|
static const int DataUsage_entries_by_number[] = {
|
|
2, // 0 -> UNKNOWN_DATA_USAGE
|
|
1, // 1 -> ONLINE
|
|
3, // 2 -> WIFI_ONLY
|
|
0, // 3 -> OFFLINE
|
|
};
|
|
|
|
const ::std::string& DataUsage_Name(DataUsage value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
DataUsage_entries, DataUsage_entries_by_number, 4,
|
|
DataUsage_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(DataUsage_entries,
|
|
DataUsage_entries_by_number,
|
|
4, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : DataUsage_strings[idx].get();
|
|
}
|
|
|
|
bool DataUsage_Parse(::absl::string_view name, DataUsage* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
DataUsage_entries, 4, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<DataUsage>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t EstablishConnectionStatus_internal_data_[] = {
|
|
720896u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
EstablishConnectionStatus_strings[11] = {};
|
|
|
|
static const char EstablishConnectionStatus_names[] = {
|
|
"CONNECTION_STATUS_CANCELLATION"
|
|
"CONNECTION_STATUS_FAILED_NO_TRANSFER_UPDATE_CALLBACK"
|
|
"CONNECTION_STATUS_FAILED_NULL_CONNECTION"
|
|
"CONNECTION_STATUS_FAILED_PAIRED_KEYHANDSHAKE"
|
|
"CONNECTION_STATUS_FAILED_WRITE_INTRODUCTION"
|
|
"CONNECTION_STATUS_FAILURE"
|
|
"CONNECTION_STATUS_INVALID_ADVERTISEMENT"
|
|
"CONNECTION_STATUS_LOST_CONNECTIVITY"
|
|
"CONNECTION_STATUS_MEDIA_UNAVAILABLE_ATTACHMENT"
|
|
"CONNECTION_STATUS_SUCCESS"
|
|
"CONNECTION_STATUS_UNKNOWN"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry EstablishConnectionStatus_entries[] = {
|
|
{{&EstablishConnectionStatus_names[0], 30}, 3},
|
|
{{&EstablishConnectionStatus_names[30], 52}, 8},
|
|
{{&EstablishConnectionStatus_names[82], 40}, 7},
|
|
{{&EstablishConnectionStatus_names[122], 44}, 5},
|
|
{{&EstablishConnectionStatus_names[166], 43}, 6},
|
|
{{&EstablishConnectionStatus_names[209], 25}, 2},
|
|
{{&EstablishConnectionStatus_names[234], 39}, 10},
|
|
{{&EstablishConnectionStatus_names[273], 35}, 9},
|
|
{{&EstablishConnectionStatus_names[308], 46}, 4},
|
|
{{&EstablishConnectionStatus_names[354], 25}, 1},
|
|
{{&EstablishConnectionStatus_names[379], 25}, 0},
|
|
};
|
|
|
|
static const int EstablishConnectionStatus_entries_by_number[] = {
|
|
10, // 0 -> CONNECTION_STATUS_UNKNOWN
|
|
9, // 1 -> CONNECTION_STATUS_SUCCESS
|
|
5, // 2 -> CONNECTION_STATUS_FAILURE
|
|
0, // 3 -> CONNECTION_STATUS_CANCELLATION
|
|
8, // 4 -> CONNECTION_STATUS_MEDIA_UNAVAILABLE_ATTACHMENT
|
|
3, // 5 -> CONNECTION_STATUS_FAILED_PAIRED_KEYHANDSHAKE
|
|
4, // 6 -> CONNECTION_STATUS_FAILED_WRITE_INTRODUCTION
|
|
2, // 7 -> CONNECTION_STATUS_FAILED_NULL_CONNECTION
|
|
1, // 8 -> CONNECTION_STATUS_FAILED_NO_TRANSFER_UPDATE_CALLBACK
|
|
7, // 9 -> CONNECTION_STATUS_LOST_CONNECTIVITY
|
|
6, // 10 -> CONNECTION_STATUS_INVALID_ADVERTISEMENT
|
|
};
|
|
|
|
const ::std::string& EstablishConnectionStatus_Name(EstablishConnectionStatus value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
EstablishConnectionStatus_entries, EstablishConnectionStatus_entries_by_number, 11,
|
|
EstablishConnectionStatus_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(EstablishConnectionStatus_entries,
|
|
EstablishConnectionStatus_entries_by_number,
|
|
11, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : EstablishConnectionStatus_strings[idx].get();
|
|
}
|
|
|
|
bool EstablishConnectionStatus_Parse(::absl::string_view name, EstablishConnectionStatus* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
EstablishConnectionStatus_entries, 11, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<EstablishConnectionStatus>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t AttachmentTransmissionStatus_internal_data_[] = {
|
|
2031616u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
AttachmentTransmissionStatus_strings[31] = {};
|
|
|
|
static const char AttachmentTransmissionStatus_names[] = {
|
|
"AWAITING_REMOTE_ACCEPTANCE_FAILED_ATTACHMENT"
|
|
"CANCELED_ATTACHMENT_TRANSMISSION_STATUS"
|
|
"COMPLETE_ATTACHMENT_TRANSMISSION_STATUS"
|
|
"FAILED_ATTACHMENT_TRANSMISSION_STATUS"
|
|
"FAILED_DISALLOWED_MEDIUM"
|
|
"FAILED_NO_PAYLOAD"
|
|
"FAILED_NO_SHARE_TARGET_ENDPOINT"
|
|
"FAILED_NO_TRANSFER_UPDATE_CALLBACK"
|
|
"FAILED_NULL_CONNECTION"
|
|
"FAILED_NULL_CONNECTION_DISCONNECTED"
|
|
"FAILED_NULL_CONNECTION_FAILURE"
|
|
"FAILED_NULL_CONNECTION_INIT_OUTGOING"
|
|
"FAILED_NULL_CONNECTION_LOST_CONNECTIVITY"
|
|
"FAILED_PAIRED_KEYHANDSHAKE"
|
|
"FAILED_UNKNOWN_REMOTE_RESPONSE"
|
|
"FAILED_UNKNOWN_REMOTE_RESPONSE_TRANSMISSION_STATUS"
|
|
"FAILED_WRITE_INTRODUCTION"
|
|
"LOST_CONNECTIVITY_TRANSMISSION_STATUS"
|
|
"MEDIA_UNAVAILABLE_ATTACHMENT"
|
|
"NOT_ENOUGH_SPACE_ATTACHMENT"
|
|
"NOT_ENOUGH_SPACE_ATTACHMENT_TRANSMISSION_STATUS"
|
|
"NO_ATTACHMENT_FOUND"
|
|
"NO_RESPONSE_FRAME_CONNECTION_CLOSED_LOST_CONNECTIVITY_TRANSMISSION_STATUS"
|
|
"NO_RESPONSE_FRAME_CONNECTION_CLOSED_TRANSMISSION_STATUS"
|
|
"REJECTED_ATTACHMENT"
|
|
"REJECTED_ATTACHMENT_TRANSMISSION_STATUS"
|
|
"TIMED_OUT_ATTACHMENT"
|
|
"TIMED_OUT_ATTACHMENT_TRANSMISSION_STATUS"
|
|
"UNKNOWN_ATTACHMENT_TRANSMISSION_STATUS"
|
|
"UNSUPPORTED_ATTACHMENT_TYPE_ATTACHMENT"
|
|
"UNSUPPORTED_ATTACHMENT_TYPE_ATTACHMENT_TRANSMISSION_STATUS"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry AttachmentTransmissionStatus_entries[] = {
|
|
{{&AttachmentTransmissionStatus_names[0], 44}, 6},
|
|
{{&AttachmentTransmissionStatus_names[44], 39}, 2},
|
|
{{&AttachmentTransmissionStatus_names[83], 39}, 1},
|
|
{{&AttachmentTransmissionStatus_names[122], 37}, 3},
|
|
{{&AttachmentTransmissionStatus_names[159], 24}, 30},
|
|
{{&AttachmentTransmissionStatus_names[183], 17}, 15},
|
|
{{&AttachmentTransmissionStatus_names[200], 31}, 12},
|
|
{{&AttachmentTransmissionStatus_names[231], 34}, 8},
|
|
{{&AttachmentTransmissionStatus_names[265], 22}, 14},
|
|
{{&AttachmentTransmissionStatus_names[287], 35}, 19},
|
|
{{&AttachmentTransmissionStatus_names[322], 30}, 21},
|
|
{{&AttachmentTransmissionStatus_names[352], 36}, 18},
|
|
{{&AttachmentTransmissionStatus_names[388], 40}, 20},
|
|
{{&AttachmentTransmissionStatus_names[428], 26}, 13},
|
|
{{&AttachmentTransmissionStatus_names[454], 30}, 17},
|
|
{{&AttachmentTransmissionStatus_names[484], 50}, 26},
|
|
{{&AttachmentTransmissionStatus_names[534], 25}, 16},
|
|
{{&AttachmentTransmissionStatus_names[559], 37}, 29},
|
|
{{&AttachmentTransmissionStatus_names[596], 28}, 9},
|
|
{{&AttachmentTransmissionStatus_names[624], 27}, 7},
|
|
{{&AttachmentTransmissionStatus_names[651], 47}, 24},
|
|
{{&AttachmentTransmissionStatus_names[698], 19}, 11},
|
|
{{&AttachmentTransmissionStatus_names[717], 73}, 27},
|
|
{{&AttachmentTransmissionStatus_names[790], 55}, 28},
|
|
{{&AttachmentTransmissionStatus_names[845], 19}, 4},
|
|
{{&AttachmentTransmissionStatus_names[864], 39}, 22},
|
|
{{&AttachmentTransmissionStatus_names[903], 20}, 5},
|
|
{{&AttachmentTransmissionStatus_names[923], 40}, 23},
|
|
{{&AttachmentTransmissionStatus_names[963], 38}, 0},
|
|
{{&AttachmentTransmissionStatus_names[1001], 38}, 10},
|
|
{{&AttachmentTransmissionStatus_names[1039], 58}, 25},
|
|
};
|
|
|
|
static const int AttachmentTransmissionStatus_entries_by_number[] = {
|
|
28, // 0 -> UNKNOWN_ATTACHMENT_TRANSMISSION_STATUS
|
|
2, // 1 -> COMPLETE_ATTACHMENT_TRANSMISSION_STATUS
|
|
1, // 2 -> CANCELED_ATTACHMENT_TRANSMISSION_STATUS
|
|
3, // 3 -> FAILED_ATTACHMENT_TRANSMISSION_STATUS
|
|
24, // 4 -> REJECTED_ATTACHMENT
|
|
26, // 5 -> TIMED_OUT_ATTACHMENT
|
|
0, // 6 -> AWAITING_REMOTE_ACCEPTANCE_FAILED_ATTACHMENT
|
|
19, // 7 -> NOT_ENOUGH_SPACE_ATTACHMENT
|
|
7, // 8 -> FAILED_NO_TRANSFER_UPDATE_CALLBACK
|
|
18, // 9 -> MEDIA_UNAVAILABLE_ATTACHMENT
|
|
29, // 10 -> UNSUPPORTED_ATTACHMENT_TYPE_ATTACHMENT
|
|
21, // 11 -> NO_ATTACHMENT_FOUND
|
|
6, // 12 -> FAILED_NO_SHARE_TARGET_ENDPOINT
|
|
13, // 13 -> FAILED_PAIRED_KEYHANDSHAKE
|
|
8, // 14 -> FAILED_NULL_CONNECTION
|
|
5, // 15 -> FAILED_NO_PAYLOAD
|
|
16, // 16 -> FAILED_WRITE_INTRODUCTION
|
|
14, // 17 -> FAILED_UNKNOWN_REMOTE_RESPONSE
|
|
11, // 18 -> FAILED_NULL_CONNECTION_INIT_OUTGOING
|
|
9, // 19 -> FAILED_NULL_CONNECTION_DISCONNECTED
|
|
12, // 20 -> FAILED_NULL_CONNECTION_LOST_CONNECTIVITY
|
|
10, // 21 -> FAILED_NULL_CONNECTION_FAILURE
|
|
25, // 22 -> REJECTED_ATTACHMENT_TRANSMISSION_STATUS
|
|
27, // 23 -> TIMED_OUT_ATTACHMENT_TRANSMISSION_STATUS
|
|
20, // 24 -> NOT_ENOUGH_SPACE_ATTACHMENT_TRANSMISSION_STATUS
|
|
30, // 25 -> UNSUPPORTED_ATTACHMENT_TYPE_ATTACHMENT_TRANSMISSION_STATUS
|
|
15, // 26 -> FAILED_UNKNOWN_REMOTE_RESPONSE_TRANSMISSION_STATUS
|
|
22, // 27 -> NO_RESPONSE_FRAME_CONNECTION_CLOSED_LOST_CONNECTIVITY_TRANSMISSION_STATUS
|
|
23, // 28 -> NO_RESPONSE_FRAME_CONNECTION_CLOSED_TRANSMISSION_STATUS
|
|
17, // 29 -> LOST_CONNECTIVITY_TRANSMISSION_STATUS
|
|
4, // 30 -> FAILED_DISALLOWED_MEDIUM
|
|
};
|
|
|
|
const ::std::string& AttachmentTransmissionStatus_Name(AttachmentTransmissionStatus value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
AttachmentTransmissionStatus_entries, AttachmentTransmissionStatus_entries_by_number, 31,
|
|
AttachmentTransmissionStatus_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(AttachmentTransmissionStatus_entries,
|
|
AttachmentTransmissionStatus_entries_by_number,
|
|
31, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : AttachmentTransmissionStatus_strings[idx].get();
|
|
}
|
|
|
|
bool AttachmentTransmissionStatus_Parse(::absl::string_view name, AttachmentTransmissionStatus* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
AttachmentTransmissionStatus_entries, 31, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<AttachmentTransmissionStatus>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t ConnectionLayerStatus_internal_data_[] = {
|
|
1245184u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
ConnectionLayerStatus_strings[19] = {};
|
|
|
|
static const char ConnectionLayerStatus_names[] = {
|
|
"CONNECTION_LAYER_STATUS_ALREADY_ADVERTISING"
|
|
"CONNECTION_LAYER_STATUS_ALREADY_CONNECTED_TO_END_POINT"
|
|
"CONNECTION_LAYER_STATUS_ALREADY_DISCOVERING"
|
|
"CONNECTION_LAYER_STATUS_ALREADY_HAVE_ACTIVE_STRATEGY"
|
|
"CONNECTION_LAYER_STATUS_ALREADY_LISTENING"
|
|
"CONNECTION_LAYER_STATUS_BLE_ERROR"
|
|
"CONNECTION_LAYER_STATUS_BLUETOOTH_ERROR"
|
|
"CONNECTION_LAYER_STATUS_CONNECTION_REJECTED"
|
|
"CONNECTION_LAYER_STATUS_END_POINT_IO_ERROR"
|
|
"CONNECTION_LAYER_STATUS_END_POINT_UNKNOWN"
|
|
"CONNECTION_LAYER_STATUS_ERROR"
|
|
"CONNECTION_LAYER_STATUS_NOT_CONNECTED_TO_END_POINT"
|
|
"CONNECTION_LAYER_STATUS_OUT_OF_ORDER_API_CALL"
|
|
"CONNECTION_LAYER_STATUS_PAYLOAD_UNKNOWN"
|
|
"CONNECTION_LAYER_STATUS_RESET"
|
|
"CONNECTION_LAYER_STATUS_SUCCESS"
|
|
"CONNECTION_LAYER_STATUS_TIMEOUT"
|
|
"CONNECTION_LAYER_STATUS_UNKNOWN"
|
|
"CONNECTION_LAYER_STATUS_WIFI_LAN_ERROR"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry ConnectionLayerStatus_entries[] = {
|
|
{{&ConnectionLayerStatus_names[0], 43}, 5},
|
|
{{&ConnectionLayerStatus_names[43], 54}, 11},
|
|
{{&ConnectionLayerStatus_names[97], 43}, 6},
|
|
{{&ConnectionLayerStatus_names[140], 52}, 4},
|
|
{{&ConnectionLayerStatus_names[192], 41}, 7},
|
|
{{&ConnectionLayerStatus_names[233], 33}, 14},
|
|
{{&ConnectionLayerStatus_names[266], 39}, 13},
|
|
{{&ConnectionLayerStatus_names[305], 43}, 10},
|
|
{{&ConnectionLayerStatus_names[348], 42}, 8},
|
|
{{&ConnectionLayerStatus_names[390], 41}, 9},
|
|
{{&ConnectionLayerStatus_names[431], 29}, 2},
|
|
{{&ConnectionLayerStatus_names[460], 50}, 12},
|
|
{{&ConnectionLayerStatus_names[510], 45}, 3},
|
|
{{&ConnectionLayerStatus_names[555], 39}, 16},
|
|
{{&ConnectionLayerStatus_names[594], 29}, 17},
|
|
{{&ConnectionLayerStatus_names[623], 31}, 1},
|
|
{{&ConnectionLayerStatus_names[654], 31}, 18},
|
|
{{&ConnectionLayerStatus_names[685], 31}, 0},
|
|
{{&ConnectionLayerStatus_names[716], 38}, 15},
|
|
};
|
|
|
|
static const int ConnectionLayerStatus_entries_by_number[] = {
|
|
17, // 0 -> CONNECTION_LAYER_STATUS_UNKNOWN
|
|
15, // 1 -> CONNECTION_LAYER_STATUS_SUCCESS
|
|
10, // 2 -> CONNECTION_LAYER_STATUS_ERROR
|
|
12, // 3 -> CONNECTION_LAYER_STATUS_OUT_OF_ORDER_API_CALL
|
|
3, // 4 -> CONNECTION_LAYER_STATUS_ALREADY_HAVE_ACTIVE_STRATEGY
|
|
0, // 5 -> CONNECTION_LAYER_STATUS_ALREADY_ADVERTISING
|
|
2, // 6 -> CONNECTION_LAYER_STATUS_ALREADY_DISCOVERING
|
|
4, // 7 -> CONNECTION_LAYER_STATUS_ALREADY_LISTENING
|
|
8, // 8 -> CONNECTION_LAYER_STATUS_END_POINT_IO_ERROR
|
|
9, // 9 -> CONNECTION_LAYER_STATUS_END_POINT_UNKNOWN
|
|
7, // 10 -> CONNECTION_LAYER_STATUS_CONNECTION_REJECTED
|
|
1, // 11 -> CONNECTION_LAYER_STATUS_ALREADY_CONNECTED_TO_END_POINT
|
|
11, // 12 -> CONNECTION_LAYER_STATUS_NOT_CONNECTED_TO_END_POINT
|
|
6, // 13 -> CONNECTION_LAYER_STATUS_BLUETOOTH_ERROR
|
|
5, // 14 -> CONNECTION_LAYER_STATUS_BLE_ERROR
|
|
18, // 15 -> CONNECTION_LAYER_STATUS_WIFI_LAN_ERROR
|
|
13, // 16 -> CONNECTION_LAYER_STATUS_PAYLOAD_UNKNOWN
|
|
14, // 17 -> CONNECTION_LAYER_STATUS_RESET
|
|
16, // 18 -> CONNECTION_LAYER_STATUS_TIMEOUT
|
|
};
|
|
|
|
const ::std::string& ConnectionLayerStatus_Name(ConnectionLayerStatus value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
ConnectionLayerStatus_entries, ConnectionLayerStatus_entries_by_number, 19,
|
|
ConnectionLayerStatus_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(ConnectionLayerStatus_entries,
|
|
ConnectionLayerStatus_entries_by_number,
|
|
19, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ConnectionLayerStatus_strings[idx].get();
|
|
}
|
|
|
|
bool ConnectionLayerStatus_Parse(::absl::string_view name, ConnectionLayerStatus* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
ConnectionLayerStatus_entries, 19, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<ConnectionLayerStatus>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t ProcessReceivedAttachmentsStatus_internal_data_[] = {
|
|
393216u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
ProcessReceivedAttachmentsStatus_strings[6] = {};
|
|
|
|
static const char ProcessReceivedAttachmentsStatus_names[] = {
|
|
"PROCESSING_STATUS_COMPLETE_PROCESSING_ATTACHMENTS"
|
|
"PROCESSING_STATUS_FAILED_MOVING_FILES"
|
|
"PROCESSING_STATUS_FAILED_RECEIVING_APK"
|
|
"PROCESSING_STATUS_FAILED_RECEIVING_TEXT"
|
|
"PROCESSING_STATUS_FAILED_RECEIVING_WIFI_CREDENTIALS"
|
|
"PROCESSING_STATUS_UNKNOWN"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry ProcessReceivedAttachmentsStatus_entries[] = {
|
|
{{&ProcessReceivedAttachmentsStatus_names[0], 49}, 1},
|
|
{{&ProcessReceivedAttachmentsStatus_names[49], 37}, 2},
|
|
{{&ProcessReceivedAttachmentsStatus_names[86], 38}, 3},
|
|
{{&ProcessReceivedAttachmentsStatus_names[124], 39}, 4},
|
|
{{&ProcessReceivedAttachmentsStatus_names[163], 51}, 5},
|
|
{{&ProcessReceivedAttachmentsStatus_names[214], 25}, 0},
|
|
};
|
|
|
|
static const int ProcessReceivedAttachmentsStatus_entries_by_number[] = {
|
|
5, // 0 -> PROCESSING_STATUS_UNKNOWN
|
|
0, // 1 -> PROCESSING_STATUS_COMPLETE_PROCESSING_ATTACHMENTS
|
|
1, // 2 -> PROCESSING_STATUS_FAILED_MOVING_FILES
|
|
2, // 3 -> PROCESSING_STATUS_FAILED_RECEIVING_APK
|
|
3, // 4 -> PROCESSING_STATUS_FAILED_RECEIVING_TEXT
|
|
4, // 5 -> PROCESSING_STATUS_FAILED_RECEIVING_WIFI_CREDENTIALS
|
|
};
|
|
|
|
const ::std::string& ProcessReceivedAttachmentsStatus_Name(ProcessReceivedAttachmentsStatus value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
ProcessReceivedAttachmentsStatus_entries, ProcessReceivedAttachmentsStatus_entries_by_number, 6,
|
|
ProcessReceivedAttachmentsStatus_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(ProcessReceivedAttachmentsStatus_entries,
|
|
ProcessReceivedAttachmentsStatus_entries_by_number,
|
|
6, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ProcessReceivedAttachmentsStatus_strings[idx].get();
|
|
}
|
|
|
|
bool ProcessReceivedAttachmentsStatus_Parse(::absl::string_view name, ProcessReceivedAttachmentsStatus* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
ProcessReceivedAttachmentsStatus_entries, 6, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<ProcessReceivedAttachmentsStatus>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t SessionStatus_internal_data_[] = {
|
|
196608u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
SessionStatus_strings[3] = {};
|
|
|
|
static const char SessionStatus_names[] = {
|
|
"FAILED_SESSION_STATUS"
|
|
"SUCCEEDED_SESSION_STATUS"
|
|
"UNKNOWN_SESSION_STATUS"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry SessionStatus_entries[] = {
|
|
{{&SessionStatus_names[0], 21}, 2},
|
|
{{&SessionStatus_names[21], 24}, 1},
|
|
{{&SessionStatus_names[45], 22}, 0},
|
|
};
|
|
|
|
static const int SessionStatus_entries_by_number[] = {
|
|
2, // 0 -> UNKNOWN_SESSION_STATUS
|
|
1, // 1 -> SUCCEEDED_SESSION_STATUS
|
|
0, // 2 -> FAILED_SESSION_STATUS
|
|
};
|
|
|
|
const ::std::string& SessionStatus_Name(SessionStatus value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
SessionStatus_entries, SessionStatus_entries_by_number, 3,
|
|
SessionStatus_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(SessionStatus_entries,
|
|
SessionStatus_entries_by_number,
|
|
3, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SessionStatus_strings[idx].get();
|
|
}
|
|
|
|
bool SessionStatus_Parse(::absl::string_view name, SessionStatus* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
SessionStatus_entries, 3, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<SessionStatus>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t ResponseToIntroduction_internal_data_[] = {
|
|
262144u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
ResponseToIntroduction_strings[4] = {};
|
|
|
|
static const char ResponseToIntroduction_names[] = {
|
|
"ACCEPT_INTRODUCTION"
|
|
"FAIL_INTRODUCTION"
|
|
"REJECT_INTRODUCTION"
|
|
"UNKNOWN_RESPONSE_TO_INTRODUCTION"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry ResponseToIntroduction_entries[] = {
|
|
{{&ResponseToIntroduction_names[0], 19}, 1},
|
|
{{&ResponseToIntroduction_names[19], 17}, 3},
|
|
{{&ResponseToIntroduction_names[36], 19}, 2},
|
|
{{&ResponseToIntroduction_names[55], 32}, 0},
|
|
};
|
|
|
|
static const int ResponseToIntroduction_entries_by_number[] = {
|
|
3, // 0 -> UNKNOWN_RESPONSE_TO_INTRODUCTION
|
|
0, // 1 -> ACCEPT_INTRODUCTION
|
|
2, // 2 -> REJECT_INTRODUCTION
|
|
1, // 3 -> FAIL_INTRODUCTION
|
|
};
|
|
|
|
const ::std::string& ResponseToIntroduction_Name(ResponseToIntroduction value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
ResponseToIntroduction_entries, ResponseToIntroduction_entries_by_number, 4,
|
|
ResponseToIntroduction_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(ResponseToIntroduction_entries,
|
|
ResponseToIntroduction_entries_by_number,
|
|
4, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ResponseToIntroduction_strings[idx].get();
|
|
}
|
|
|
|
bool ResponseToIntroduction_Parse(::absl::string_view name, ResponseToIntroduction* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
ResponseToIntroduction_entries, 4, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<ResponseToIntroduction>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t DeviceType_internal_data_[] = {
|
|
458752u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
DeviceType_strings[7] = {};
|
|
|
|
static const char DeviceType_names[] = {
|
|
"CAR"
|
|
"FOLDABLE"
|
|
"LAPTOP"
|
|
"PHONE"
|
|
"TABLET"
|
|
"UNKNOWN_DEVICE_TYPE"
|
|
"XR"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry DeviceType_entries[] = {
|
|
{{&DeviceType_names[0], 3}, 4},
|
|
{{&DeviceType_names[3], 8}, 5},
|
|
{{&DeviceType_names[11], 6}, 3},
|
|
{{&DeviceType_names[17], 5}, 1},
|
|
{{&DeviceType_names[22], 6}, 2},
|
|
{{&DeviceType_names[28], 19}, 0},
|
|
{{&DeviceType_names[47], 2}, 6},
|
|
};
|
|
|
|
static const int DeviceType_entries_by_number[] = {
|
|
5, // 0 -> UNKNOWN_DEVICE_TYPE
|
|
3, // 1 -> PHONE
|
|
4, // 2 -> TABLET
|
|
2, // 3 -> LAPTOP
|
|
0, // 4 -> CAR
|
|
1, // 5 -> FOLDABLE
|
|
6, // 6 -> XR
|
|
};
|
|
|
|
const ::std::string& DeviceType_Name(DeviceType value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
DeviceType_entries, DeviceType_entries_by_number, 7,
|
|
DeviceType_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(DeviceType_entries,
|
|
DeviceType_entries_by_number,
|
|
7, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : DeviceType_strings[idx].get();
|
|
}
|
|
|
|
bool DeviceType_Parse(::absl::string_view name, DeviceType* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
DeviceType_entries, 7, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<DeviceType>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t OSType_internal_data_[] = {
|
|
393216u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
OSType_strings[6] = {};
|
|
|
|
static const char OSType_names[] = {
|
|
"ANDROID"
|
|
"CHROME_OS"
|
|
"IOS"
|
|
"MACOS"
|
|
"UNKNOWN_OS_TYPE"
|
|
"WINDOWS"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry OSType_entries[] = {
|
|
{{&OSType_names[0], 7}, 1},
|
|
{{&OSType_names[7], 9}, 2},
|
|
{{&OSType_names[16], 3}, 3},
|
|
{{&OSType_names[19], 5}, 5},
|
|
{{&OSType_names[24], 15}, 0},
|
|
{{&OSType_names[39], 7}, 4},
|
|
};
|
|
|
|
static const int OSType_entries_by_number[] = {
|
|
4, // 0 -> UNKNOWN_OS_TYPE
|
|
0, // 1 -> ANDROID
|
|
1, // 2 -> CHROME_OS
|
|
2, // 3 -> IOS
|
|
5, // 4 -> WINDOWS
|
|
3, // 5 -> MACOS
|
|
};
|
|
|
|
const ::std::string& OSType_Name(OSType value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
OSType_entries, OSType_entries_by_number, 6,
|
|
OSType_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(OSType_entries,
|
|
OSType_entries_by_number,
|
|
6, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : OSType_strings[idx].get();
|
|
}
|
|
|
|
bool OSType_Parse(::absl::string_view name, OSType* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
OSType_entries, 6, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<OSType>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t DeviceRelationship_internal_data_[] = {
|
|
262144u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
DeviceRelationship_strings[4] = {};
|
|
|
|
static const char DeviceRelationship_names[] = {
|
|
"IS_CONTACT"
|
|
"IS_SELF"
|
|
"IS_STRANGER"
|
|
"UNKNOWN_DEVICE_RELATIONSHIP"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry DeviceRelationship_entries[] = {
|
|
{{&DeviceRelationship_names[0], 10}, 2},
|
|
{{&DeviceRelationship_names[10], 7}, 1},
|
|
{{&DeviceRelationship_names[17], 11}, 3},
|
|
{{&DeviceRelationship_names[28], 27}, 0},
|
|
};
|
|
|
|
static const int DeviceRelationship_entries_by_number[] = {
|
|
3, // 0 -> UNKNOWN_DEVICE_RELATIONSHIP
|
|
1, // 1 -> IS_SELF
|
|
0, // 2 -> IS_CONTACT
|
|
2, // 3 -> IS_STRANGER
|
|
};
|
|
|
|
const ::std::string& DeviceRelationship_Name(DeviceRelationship value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
DeviceRelationship_entries, DeviceRelationship_entries_by_number, 4,
|
|
DeviceRelationship_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(DeviceRelationship_entries,
|
|
DeviceRelationship_entries_by_number,
|
|
4, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : DeviceRelationship_strings[idx].get();
|
|
}
|
|
|
|
bool DeviceRelationship_Parse(::absl::string_view name, DeviceRelationship* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
DeviceRelationship_entries, 4, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<DeviceRelationship>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t LogSource_internal_data_[] = {
|
|
655360u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
LogSource_strings[10] = {};
|
|
|
|
static const char LogSource_names[] = {
|
|
"BETA_TESTER_DEVICES"
|
|
"BETO_DOGFOOD_DEVICES"
|
|
"DEBUG_DEVICES"
|
|
"INTERNAL_DEVICES"
|
|
"LAB_DEVICES"
|
|
"NEARBY_DOGFOOD_DEVICES"
|
|
"NEARBY_MODULE_FOOD_DEVICES"
|
|
"NEARBY_TEAMFOOD_DEVICES"
|
|
"OEM_DEVICES"
|
|
"UNSPECIFIED_SOURCE"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry LogSource_entries[] = {
|
|
{{&LogSource_names[0], 19}, 3},
|
|
{{&LogSource_names[19], 20}, 7},
|
|
{{&LogSource_names[39], 13}, 5},
|
|
{{&LogSource_names[52], 16}, 2},
|
|
{{&LogSource_names[68], 11}, 1},
|
|
{{&LogSource_names[79], 22}, 8},
|
|
{{&LogSource_names[101], 26}, 6},
|
|
{{&LogSource_names[127], 23}, 9},
|
|
{{&LogSource_names[150], 11}, 4},
|
|
{{&LogSource_names[161], 18}, 0},
|
|
};
|
|
|
|
static const int LogSource_entries_by_number[] = {
|
|
9, // 0 -> UNSPECIFIED_SOURCE
|
|
4, // 1 -> LAB_DEVICES
|
|
3, // 2 -> INTERNAL_DEVICES
|
|
0, // 3 -> BETA_TESTER_DEVICES
|
|
8, // 4 -> OEM_DEVICES
|
|
2, // 5 -> DEBUG_DEVICES
|
|
6, // 6 -> NEARBY_MODULE_FOOD_DEVICES
|
|
1, // 7 -> BETO_DOGFOOD_DEVICES
|
|
5, // 8 -> NEARBY_DOGFOOD_DEVICES
|
|
7, // 9 -> NEARBY_TEAMFOOD_DEVICES
|
|
};
|
|
|
|
const ::std::string& LogSource_Name(LogSource value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
LogSource_entries, LogSource_entries_by_number, 10,
|
|
LogSource_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(LogSource_entries,
|
|
LogSource_entries_by_number,
|
|
10, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : LogSource_strings[idx].get();
|
|
}
|
|
|
|
bool LogSource_Parse(::absl::string_view name, LogSource* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
LogSource_entries, 10, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<LogSource>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t ServerActionName_internal_data_[] = {
|
|
851968u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
ServerActionName_strings[13] = {};
|
|
|
|
static const char ServerActionName_names[] = {
|
|
"CHECK_REACHABILITY"
|
|
"DOWNLOAD_CERTIFICATES"
|
|
"DOWNLOAD_CERTIFICATES_INFO"
|
|
"DOWNLOAD_SENDER_CERTIFICATES"
|
|
"LIST_CONTACT_PEOPLE"
|
|
"LIST_MY_DEVICES"
|
|
"LIST_REACHABLE_PHONE_NUMBERS"
|
|
"UNKNOWN_SERVER_ACTION"
|
|
"UPDATE_DEVICE_NAME"
|
|
"UPLOAD_CERTIFICATES"
|
|
"UPLOAD_CONTACTS"
|
|
"UPLOAD_CONTACTS_AND_CERTIFICATES"
|
|
"UPLOAD_SENDER_CERTIFICATES"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry ServerActionName_entries[] = {
|
|
{{&ServerActionName_names[0], 18}, 3},
|
|
{{&ServerActionName_names[18], 21}, 2},
|
|
{{&ServerActionName_names[39], 26}, 12},
|
|
{{&ServerActionName_names[65], 28}, 7},
|
|
{{&ServerActionName_names[93], 19}, 11},
|
|
{{&ServerActionName_names[112], 15}, 10},
|
|
{{&ServerActionName_names[127], 28}, 9},
|
|
{{&ServerActionName_names[155], 21}, 0},
|
|
{{&ServerActionName_names[176], 18}, 5},
|
|
{{&ServerActionName_names[194], 19}, 1},
|
|
{{&ServerActionName_names[213], 15}, 4},
|
|
{{&ServerActionName_names[228], 32}, 8},
|
|
{{&ServerActionName_names[260], 26}, 6},
|
|
};
|
|
|
|
static const int ServerActionName_entries_by_number[] = {
|
|
7, // 0 -> UNKNOWN_SERVER_ACTION
|
|
9, // 1 -> UPLOAD_CERTIFICATES
|
|
1, // 2 -> DOWNLOAD_CERTIFICATES
|
|
0, // 3 -> CHECK_REACHABILITY
|
|
10, // 4 -> UPLOAD_CONTACTS
|
|
8, // 5 -> UPDATE_DEVICE_NAME
|
|
12, // 6 -> UPLOAD_SENDER_CERTIFICATES
|
|
3, // 7 -> DOWNLOAD_SENDER_CERTIFICATES
|
|
11, // 8 -> UPLOAD_CONTACTS_AND_CERTIFICATES
|
|
6, // 9 -> LIST_REACHABLE_PHONE_NUMBERS
|
|
5, // 10 -> LIST_MY_DEVICES
|
|
4, // 11 -> LIST_CONTACT_PEOPLE
|
|
2, // 12 -> DOWNLOAD_CERTIFICATES_INFO
|
|
};
|
|
|
|
const ::std::string& ServerActionName_Name(ServerActionName value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
ServerActionName_entries, ServerActionName_entries_by_number, 13,
|
|
ServerActionName_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(ServerActionName_entries,
|
|
ServerActionName_entries_by_number,
|
|
13, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ServerActionName_strings[idx].get();
|
|
}
|
|
|
|
bool ServerActionName_Parse(::absl::string_view name, ServerActionName* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
ServerActionName_entries, 13, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<ServerActionName>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t ServerResponseState_internal_data_[] = {
|
|
720896u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
ServerResponseState_strings[11] = {};
|
|
|
|
static const char ServerResponseState_names[] = {
|
|
"SERVER_RESPONSE_GOOGLE_AUTH_FAILURE"
|
|
"SERVER_RESPONSE_NOT_CONNECTED_TO_INTERNET"
|
|
"SERVER_RESPONSE_STATUS_DEADLINE_EXCEEDED"
|
|
"SERVER_RESPONSE_STATUS_INVALID_ARGUMENT"
|
|
"SERVER_RESPONSE_STATUS_OTHER_FAILURE"
|
|
"SERVER_RESPONSE_STATUS_PERMISSION_DENIED"
|
|
"SERVER_RESPONSE_STATUS_UNAUTHENTICATED"
|
|
"SERVER_RESPONSE_STATUS_UNAVAILABLE"
|
|
"SERVER_RESPONSE_SUCCESS"
|
|
"SERVER_RESPONSE_UNKNOWN_FAILURE"
|
|
"UNKNOWN_SERVER_RESPONSE_STATE"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry ServerResponseState_entries[] = {
|
|
{{&ServerResponseState_names[0], 35}, 8},
|
|
{{&ServerResponseState_names[35], 41}, 10},
|
|
{{&ServerResponseState_names[76], 40}, 4},
|
|
{{&ServerResponseState_names[116], 39}, 9},
|
|
{{&ServerResponseState_names[155], 36}, 3},
|
|
{{&ServerResponseState_names[191], 40}, 5},
|
|
{{&ServerResponseState_names[231], 38}, 7},
|
|
{{&ServerResponseState_names[269], 34}, 6},
|
|
{{&ServerResponseState_names[303], 23}, 1},
|
|
{{&ServerResponseState_names[326], 31}, 2},
|
|
{{&ServerResponseState_names[357], 29}, 0},
|
|
};
|
|
|
|
static const int ServerResponseState_entries_by_number[] = {
|
|
10, // 0 -> UNKNOWN_SERVER_RESPONSE_STATE
|
|
8, // 1 -> SERVER_RESPONSE_SUCCESS
|
|
9, // 2 -> SERVER_RESPONSE_UNKNOWN_FAILURE
|
|
4, // 3 -> SERVER_RESPONSE_STATUS_OTHER_FAILURE
|
|
2, // 4 -> SERVER_RESPONSE_STATUS_DEADLINE_EXCEEDED
|
|
5, // 5 -> SERVER_RESPONSE_STATUS_PERMISSION_DENIED
|
|
7, // 6 -> SERVER_RESPONSE_STATUS_UNAVAILABLE
|
|
6, // 7 -> SERVER_RESPONSE_STATUS_UNAUTHENTICATED
|
|
0, // 8 -> SERVER_RESPONSE_GOOGLE_AUTH_FAILURE
|
|
3, // 9 -> SERVER_RESPONSE_STATUS_INVALID_ARGUMENT
|
|
1, // 10 -> SERVER_RESPONSE_NOT_CONNECTED_TO_INTERNET
|
|
};
|
|
|
|
const ::std::string& ServerResponseState_Name(ServerResponseState value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
ServerResponseState_entries, ServerResponseState_entries_by_number, 11,
|
|
ServerResponseState_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(ServerResponseState_entries,
|
|
ServerResponseState_entries_by_number,
|
|
11, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ServerResponseState_strings[idx].get();
|
|
}
|
|
|
|
bool ServerResponseState_Parse(::absl::string_view name, ServerResponseState* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
ServerResponseState_entries, 11, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<ServerResponseState>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t SyncPurpose_internal_data_[] = {
|
|
1310720u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
SyncPurpose_strings[20] = {};
|
|
|
|
static const char SyncPurpose_names[] = {
|
|
"SYNC_EXHAUST_SALT"
|
|
"SYNC_PURPOSE_ACCOUNT_CHANGE"
|
|
"SYNC_PURPOSE_CHECK_DEFAULT_OPT_IN"
|
|
"SYNC_PURPOSE_CHIME_NOTIFICATION"
|
|
"SYNC_PURPOSE_CONTACT_LIST_CHANGE"
|
|
"SYNC_PURPOSE_DAILY_SYNC"
|
|
"SYNC_PURPOSE_DEVICE_CONTACTS_CONSENT_CHANGE"
|
|
"SYNC_PURPOSE_NEARBY_SHARE_ENABLED"
|
|
"SYNC_PURPOSE_ON_DEMAND_SYNC"
|
|
"SYNC_PURPOSE_OPT_IN_FIRST_SYNC"
|
|
"SYNC_PURPOSE_REGENERATE_CERTIFICATES"
|
|
"SYNC_PURPOSE_REGULAR_CHECK_CONTACT_REACHABILITY"
|
|
"SYNC_PURPOSE_SHOW_C11N_VIEW"
|
|
"SYNC_PURPOSE_SYNC_AT_ADVERTISEMENT"
|
|
"SYNC_PURPOSE_SYNC_AT_DISCOVERY"
|
|
"SYNC_PURPOSE_SYNC_AT_FAST_INIT"
|
|
"SYNC_PURPOSE_SYNC_AT_LOAD_PRIVATE_CERTIFICATE"
|
|
"SYNC_PURPOSE_UNKNOWN"
|
|
"SYNC_PURPOSE_VISIBILITY_SELECTED_CONTACT_CHANGE"
|
|
"SYNC_QUICKSHARE_IDENTITY_PROVIDER_QUERY"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry SyncPurpose_entries[] = {
|
|
{{&SyncPurpose_names[0], 17}, 18},
|
|
{{&SyncPurpose_names[17], 27}, 15},
|
|
{{&SyncPurpose_names[44], 33}, 5},
|
|
{{&SyncPurpose_names[77], 31}, 2},
|
|
{{&SyncPurpose_names[108], 32}, 11},
|
|
{{&SyncPurpose_names[140], 23}, 3},
|
|
{{&SyncPurpose_names[163], 43}, 17},
|
|
{{&SyncPurpose_names[206], 33}, 6},
|
|
{{&SyncPurpose_names[239], 27}, 1},
|
|
{{&SyncPurpose_names[266], 30}, 4},
|
|
{{&SyncPurpose_names[296], 36}, 16},
|
|
{{&SyncPurpose_names[332], 47}, 13},
|
|
{{&SyncPurpose_names[379], 27}, 12},
|
|
{{&SyncPurpose_names[406], 34}, 10},
|
|
{{&SyncPurpose_names[440], 30}, 8},
|
|
{{&SyncPurpose_names[470], 30}, 7},
|
|
{{&SyncPurpose_names[500], 45}, 9},
|
|
{{&SyncPurpose_names[545], 20}, 0},
|
|
{{&SyncPurpose_names[565], 47}, 14},
|
|
{{&SyncPurpose_names[612], 39}, 19},
|
|
};
|
|
|
|
static const int SyncPurpose_entries_by_number[] = {
|
|
17, // 0 -> SYNC_PURPOSE_UNKNOWN
|
|
8, // 1 -> SYNC_PURPOSE_ON_DEMAND_SYNC
|
|
3, // 2 -> SYNC_PURPOSE_CHIME_NOTIFICATION
|
|
5, // 3 -> SYNC_PURPOSE_DAILY_SYNC
|
|
9, // 4 -> SYNC_PURPOSE_OPT_IN_FIRST_SYNC
|
|
2, // 5 -> SYNC_PURPOSE_CHECK_DEFAULT_OPT_IN
|
|
7, // 6 -> SYNC_PURPOSE_NEARBY_SHARE_ENABLED
|
|
15, // 7 -> SYNC_PURPOSE_SYNC_AT_FAST_INIT
|
|
14, // 8 -> SYNC_PURPOSE_SYNC_AT_DISCOVERY
|
|
16, // 9 -> SYNC_PURPOSE_SYNC_AT_LOAD_PRIVATE_CERTIFICATE
|
|
13, // 10 -> SYNC_PURPOSE_SYNC_AT_ADVERTISEMENT
|
|
4, // 11 -> SYNC_PURPOSE_CONTACT_LIST_CHANGE
|
|
12, // 12 -> SYNC_PURPOSE_SHOW_C11N_VIEW
|
|
11, // 13 -> SYNC_PURPOSE_REGULAR_CHECK_CONTACT_REACHABILITY
|
|
18, // 14 -> SYNC_PURPOSE_VISIBILITY_SELECTED_CONTACT_CHANGE
|
|
1, // 15 -> SYNC_PURPOSE_ACCOUNT_CHANGE
|
|
10, // 16 -> SYNC_PURPOSE_REGENERATE_CERTIFICATES
|
|
6, // 17 -> SYNC_PURPOSE_DEVICE_CONTACTS_CONSENT_CHANGE
|
|
0, // 18 -> SYNC_EXHAUST_SALT
|
|
19, // 19 -> SYNC_QUICKSHARE_IDENTITY_PROVIDER_QUERY
|
|
};
|
|
|
|
const ::std::string& SyncPurpose_Name(SyncPurpose value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
SyncPurpose_entries, SyncPurpose_entries_by_number, 20,
|
|
SyncPurpose_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(SyncPurpose_entries,
|
|
SyncPurpose_entries_by_number,
|
|
20, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SyncPurpose_strings[idx].get();
|
|
}
|
|
|
|
bool SyncPurpose_Parse(::absl::string_view name, SyncPurpose* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
SyncPurpose_entries, 20, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<SyncPurpose>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t ClientRole_internal_data_[] = {
|
|
196608u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
ClientRole_strings[3] = {};
|
|
|
|
static const char ClientRole_names[] = {
|
|
"CLIENT_ROLE_RECEIVER"
|
|
"CLIENT_ROLE_SENDER"
|
|
"CLIENT_ROLE_UNKNOWN"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry ClientRole_entries[] = {
|
|
{{&ClientRole_names[0], 20}, 2},
|
|
{{&ClientRole_names[20], 18}, 1},
|
|
{{&ClientRole_names[38], 19}, 0},
|
|
};
|
|
|
|
static const int ClientRole_entries_by_number[] = {
|
|
2, // 0 -> CLIENT_ROLE_UNKNOWN
|
|
1, // 1 -> CLIENT_ROLE_SENDER
|
|
0, // 2 -> CLIENT_ROLE_RECEIVER
|
|
};
|
|
|
|
const ::std::string& ClientRole_Name(ClientRole value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
ClientRole_entries, ClientRole_entries_by_number, 3,
|
|
ClientRole_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(ClientRole_entries,
|
|
ClientRole_entries_by_number,
|
|
3, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ClientRole_strings[idx].get();
|
|
}
|
|
|
|
bool ClientRole_Parse(::absl::string_view name, ClientRole* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
ClientRole_entries, 3, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<ClientRole>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t ScanType_internal_data_[] = {
|
|
327680u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
ScanType_strings[5] = {};
|
|
|
|
static const char ScanType_names[] = {
|
|
"BACKGROUND_SCAN"
|
|
"DIRECT_SHARE_SCAN"
|
|
"FOREGROUND_RETRY_SCAN"
|
|
"FOREGROUND_SCAN"
|
|
"UNKNOWN_SCAN_TYPE"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry ScanType_entries[] = {
|
|
{{&ScanType_names[0], 15}, 4},
|
|
{{&ScanType_names[15], 17}, 3},
|
|
{{&ScanType_names[32], 21}, 2},
|
|
{{&ScanType_names[53], 15}, 1},
|
|
{{&ScanType_names[68], 17}, 0},
|
|
};
|
|
|
|
static const int ScanType_entries_by_number[] = {
|
|
4, // 0 -> UNKNOWN_SCAN_TYPE
|
|
3, // 1 -> FOREGROUND_SCAN
|
|
2, // 2 -> FOREGROUND_RETRY_SCAN
|
|
1, // 3 -> DIRECT_SHARE_SCAN
|
|
0, // 4 -> BACKGROUND_SCAN
|
|
};
|
|
|
|
const ::std::string& ScanType_Name(ScanType value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
ScanType_entries, ScanType_entries_by_number, 5,
|
|
ScanType_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(ScanType_entries,
|
|
ScanType_entries_by_number,
|
|
5, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ScanType_strings[idx].get();
|
|
}
|
|
|
|
bool ScanType_Parse(::absl::string_view name, ScanType* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
ScanType_entries, 5, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<ScanType>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t ParsingFailedType_internal_data_[] = {
|
|
196608u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
ParsingFailedType_strings[3] = {};
|
|
|
|
static const char ParsingFailedType_names[] = {
|
|
"FAILED_CONVERT_SHARE_TARGET"
|
|
"FAILED_PARSE_ADVERTISEMENT"
|
|
"FAILED_UNKNOWN_TYPE"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry ParsingFailedType_entries[] = {
|
|
{{&ParsingFailedType_names[0], 27}, 2},
|
|
{{&ParsingFailedType_names[27], 26}, 1},
|
|
{{&ParsingFailedType_names[53], 19}, 0},
|
|
};
|
|
|
|
static const int ParsingFailedType_entries_by_number[] = {
|
|
2, // 0 -> FAILED_UNKNOWN_TYPE
|
|
1, // 1 -> FAILED_PARSE_ADVERTISEMENT
|
|
0, // 2 -> FAILED_CONVERT_SHARE_TARGET
|
|
};
|
|
|
|
const ::std::string& ParsingFailedType_Name(ParsingFailedType value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
ParsingFailedType_entries, ParsingFailedType_entries_by_number, 3,
|
|
ParsingFailedType_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(ParsingFailedType_entries,
|
|
ParsingFailedType_entries_by_number,
|
|
3, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ParsingFailedType_strings[idx].get();
|
|
}
|
|
|
|
bool ParsingFailedType_Parse(::absl::string_view name, ParsingFailedType* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
ParsingFailedType_entries, 3, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<ParsingFailedType>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t AdvertisingMode_internal_data_[] = {
|
|
393216u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
AdvertisingMode_strings[6] = {};
|
|
|
|
static const char AdvertisingMode_names[] = {
|
|
"BACKGROUND_ADVERTISING_MODE"
|
|
"FOREGROUND_ADVERTISING_MODE"
|
|
"MIDGROUND_ADVERTISING_MODE"
|
|
"SCREEN_OFF_ADVERTISING_MODE"
|
|
"SUSPENDED_ADVERTISING_MODE"
|
|
"UNKNOWN_ADVERTISING_MODE"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry AdvertisingMode_entries[] = {
|
|
{{&AdvertisingMode_names[0], 27}, 2},
|
|
{{&AdvertisingMode_names[27], 27}, 4},
|
|
{{&AdvertisingMode_names[54], 26}, 3},
|
|
{{&AdvertisingMode_names[80], 27}, 1},
|
|
{{&AdvertisingMode_names[107], 26}, 5},
|
|
{{&AdvertisingMode_names[133], 24}, 0},
|
|
};
|
|
|
|
static const int AdvertisingMode_entries_by_number[] = {
|
|
5, // 0 -> UNKNOWN_ADVERTISING_MODE
|
|
3, // 1 -> SCREEN_OFF_ADVERTISING_MODE
|
|
0, // 2 -> BACKGROUND_ADVERTISING_MODE
|
|
2, // 3 -> MIDGROUND_ADVERTISING_MODE
|
|
1, // 4 -> FOREGROUND_ADVERTISING_MODE
|
|
4, // 5 -> SUSPENDED_ADVERTISING_MODE
|
|
};
|
|
|
|
const ::std::string& AdvertisingMode_Name(AdvertisingMode value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
AdvertisingMode_entries, AdvertisingMode_entries_by_number, 6,
|
|
AdvertisingMode_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(AdvertisingMode_entries,
|
|
AdvertisingMode_entries_by_number,
|
|
6, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : AdvertisingMode_strings[idx].get();
|
|
}
|
|
|
|
bool AdvertisingMode_Parse(::absl::string_view name, AdvertisingMode* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
AdvertisingMode_entries, 6, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<AdvertisingMode>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t DiscoveryMode_internal_data_[] = {
|
|
393216u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
DiscoveryMode_strings[6] = {};
|
|
|
|
static const char DiscoveryMode_names[] = {
|
|
"BACKGROUND_DISCOVERY_MODE"
|
|
"FOREGROUND_DISCOVERY_MODE"
|
|
"MIDGROUND_DISCOVERY_MODE"
|
|
"SCREEN_OFF_DISCOVERY_MODE"
|
|
"SUSPENDED_DISCOVERY_MODE"
|
|
"UNKNOWN_DISCOVERY_MODE"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry DiscoveryMode_entries[] = {
|
|
{{&DiscoveryMode_names[0], 25}, 2},
|
|
{{&DiscoveryMode_names[25], 25}, 4},
|
|
{{&DiscoveryMode_names[50], 24}, 3},
|
|
{{&DiscoveryMode_names[74], 25}, 1},
|
|
{{&DiscoveryMode_names[99], 24}, 5},
|
|
{{&DiscoveryMode_names[123], 22}, 0},
|
|
};
|
|
|
|
static const int DiscoveryMode_entries_by_number[] = {
|
|
5, // 0 -> UNKNOWN_DISCOVERY_MODE
|
|
3, // 1 -> SCREEN_OFF_DISCOVERY_MODE
|
|
0, // 2 -> BACKGROUND_DISCOVERY_MODE
|
|
2, // 3 -> MIDGROUND_DISCOVERY_MODE
|
|
1, // 4 -> FOREGROUND_DISCOVERY_MODE
|
|
4, // 5 -> SUSPENDED_DISCOVERY_MODE
|
|
};
|
|
|
|
const ::std::string& DiscoveryMode_Name(DiscoveryMode value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
DiscoveryMode_entries, DiscoveryMode_entries_by_number, 6,
|
|
DiscoveryMode_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(DiscoveryMode_entries,
|
|
DiscoveryMode_entries_by_number,
|
|
6, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : DiscoveryMode_strings[idx].get();
|
|
}
|
|
|
|
bool DiscoveryMode_Parse(::absl::string_view name, DiscoveryMode* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
DiscoveryMode_entries, 6, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<DiscoveryMode>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t ActivityName_internal_data_[] = {
|
|
851968u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
ActivityName_strings[13] = {};
|
|
|
|
static const char ActivityName_names[] = {
|
|
"CONSENTS_ACTIVITY"
|
|
"DEVICE_VISIBILITY_ACTIVITY"
|
|
"QUICK_SETTINGS_ACTIVITY"
|
|
"RECEIVE_SURFACE_ACTIVITY"
|
|
"REMOTE_COPY_SHARE_SHEET_ACTIVITY"
|
|
"SETTINGS_ACTIVITY"
|
|
"SETTINGS_REVIEW_ACTIVITY"
|
|
"SETUP_ACTIVITY"
|
|
"SETUP_WIZARD_ACTIVITY"
|
|
"SET_DATA_USAGE_DIALOG"
|
|
"SET_DEVICE_NAME_DIALOG"
|
|
"SHARE_SHEET_ACTIVITY"
|
|
"UNKNOWN_ACTIVITY"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry ActivityName_entries[] = {
|
|
{{&ActivityName_names[0], 17}, 6},
|
|
{{&ActivityName_names[17], 26}, 5},
|
|
{{&ActivityName_names[43], 23}, 9},
|
|
{{&ActivityName_names[66], 24}, 3},
|
|
{{&ActivityName_names[90], 32}, 10},
|
|
{{&ActivityName_names[122], 17}, 2},
|
|
{{&ActivityName_names[139], 24}, 12},
|
|
{{&ActivityName_names[163], 14}, 4},
|
|
{{&ActivityName_names[177], 21}, 11},
|
|
{{&ActivityName_names[198], 21}, 8},
|
|
{{&ActivityName_names[219], 22}, 7},
|
|
{{&ActivityName_names[241], 20}, 1},
|
|
{{&ActivityName_names[261], 16}, 0},
|
|
};
|
|
|
|
static const int ActivityName_entries_by_number[] = {
|
|
12, // 0 -> UNKNOWN_ACTIVITY
|
|
11, // 1 -> SHARE_SHEET_ACTIVITY
|
|
5, // 2 -> SETTINGS_ACTIVITY
|
|
3, // 3 -> RECEIVE_SURFACE_ACTIVITY
|
|
7, // 4 -> SETUP_ACTIVITY
|
|
1, // 5 -> DEVICE_VISIBILITY_ACTIVITY
|
|
0, // 6 -> CONSENTS_ACTIVITY
|
|
10, // 7 -> SET_DEVICE_NAME_DIALOG
|
|
9, // 8 -> SET_DATA_USAGE_DIALOG
|
|
2, // 9 -> QUICK_SETTINGS_ACTIVITY
|
|
4, // 10 -> REMOTE_COPY_SHARE_SHEET_ACTIVITY
|
|
8, // 11 -> SETUP_WIZARD_ACTIVITY
|
|
6, // 12 -> SETTINGS_REVIEW_ACTIVITY
|
|
};
|
|
|
|
const ::std::string& ActivityName_Name(ActivityName value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
ActivityName_entries, ActivityName_entries_by_number, 13,
|
|
ActivityName_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(ActivityName_entries,
|
|
ActivityName_entries_by_number,
|
|
13, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ActivityName_strings[idx].get();
|
|
}
|
|
|
|
bool ActivityName_Parse(::absl::string_view name, ActivityName* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
ActivityName_entries, 13, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<ActivityName>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t ConsentType_internal_data_[] = {
|
|
196608u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
ConsentType_strings[3] = {};
|
|
|
|
static const char ConsentType_names[] = {
|
|
"CONSENT_TYPE_C11N"
|
|
"CONSENT_TYPE_DEVICE_CONTACT"
|
|
"CONSENT_TYPE_UNKNOWN"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry ConsentType_entries[] = {
|
|
{{&ConsentType_names[0], 17}, 1},
|
|
{{&ConsentType_names[17], 27}, 2},
|
|
{{&ConsentType_names[44], 20}, 0},
|
|
};
|
|
|
|
static const int ConsentType_entries_by_number[] = {
|
|
2, // 0 -> CONSENT_TYPE_UNKNOWN
|
|
0, // 1 -> CONSENT_TYPE_C11N
|
|
1, // 2 -> CONSENT_TYPE_DEVICE_CONTACT
|
|
};
|
|
|
|
const ::std::string& ConsentType_Name(ConsentType value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
ConsentType_entries, ConsentType_entries_by_number, 3,
|
|
ConsentType_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(ConsentType_entries,
|
|
ConsentType_entries_by_number,
|
|
3, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ConsentType_strings[idx].get();
|
|
}
|
|
|
|
bool ConsentType_Parse(::absl::string_view name, ConsentType* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
ConsentType_entries, 3, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<ConsentType>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t ConsentAcceptanceStatus_internal_data_[] = {
|
|
262144u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
ConsentAcceptanceStatus_strings[4] = {};
|
|
|
|
static const char ConsentAcceptanceStatus_names[] = {
|
|
"CONSENT_ACCEPTED"
|
|
"CONSENT_DECLINED"
|
|
"CONSENT_UNABLE_TO_ENABLE"
|
|
"CONSENT_UNKNOWN_ACCEPT_STATUS"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry ConsentAcceptanceStatus_entries[] = {
|
|
{{&ConsentAcceptanceStatus_names[0], 16}, 1},
|
|
{{&ConsentAcceptanceStatus_names[16], 16}, 2},
|
|
{{&ConsentAcceptanceStatus_names[32], 24}, 3},
|
|
{{&ConsentAcceptanceStatus_names[56], 29}, 0},
|
|
};
|
|
|
|
static const int ConsentAcceptanceStatus_entries_by_number[] = {
|
|
3, // 0 -> CONSENT_UNKNOWN_ACCEPT_STATUS
|
|
0, // 1 -> CONSENT_ACCEPTED
|
|
1, // 2 -> CONSENT_DECLINED
|
|
2, // 3 -> CONSENT_UNABLE_TO_ENABLE
|
|
};
|
|
|
|
const ::std::string& ConsentAcceptanceStatus_Name(ConsentAcceptanceStatus value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
ConsentAcceptanceStatus_entries, ConsentAcceptanceStatus_entries_by_number, 4,
|
|
ConsentAcceptanceStatus_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(ConsentAcceptanceStatus_entries,
|
|
ConsentAcceptanceStatus_entries_by_number,
|
|
4, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ConsentAcceptanceStatus_strings[idx].get();
|
|
}
|
|
|
|
bool ConsentAcceptanceStatus_Parse(::absl::string_view name, ConsentAcceptanceStatus* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
ConsentAcceptanceStatus_entries, 4, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<ConsentAcceptanceStatus>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t ApkSource_internal_data_[] = {
|
|
196608u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
ApkSource_strings[3] = {};
|
|
|
|
static const char ApkSource_names[] = {
|
|
"APK_FROM_SD_CARD"
|
|
"INSTALLED_APP"
|
|
"UNKNOWN_APK_SOURCE"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry ApkSource_entries[] = {
|
|
{{&ApkSource_names[0], 16}, 1},
|
|
{{&ApkSource_names[16], 13}, 2},
|
|
{{&ApkSource_names[29], 18}, 0},
|
|
};
|
|
|
|
static const int ApkSource_entries_by_number[] = {
|
|
2, // 0 -> UNKNOWN_APK_SOURCE
|
|
0, // 1 -> APK_FROM_SD_CARD
|
|
1, // 2 -> INSTALLED_APP
|
|
};
|
|
|
|
const ::std::string& ApkSource_Name(ApkSource value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
ApkSource_entries, ApkSource_entries_by_number, 3,
|
|
ApkSource_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(ApkSource_entries,
|
|
ApkSource_entries_by_number,
|
|
3, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ApkSource_strings[idx].get();
|
|
}
|
|
|
|
bool ApkSource_Parse(::absl::string_view name, ApkSource* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
ApkSource_entries, 3, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<ApkSource>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t InstallAPKStatus_internal_data_[] = {
|
|
196608u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
InstallAPKStatus_strings[3] = {};
|
|
|
|
static const char InstallAPKStatus_names[] = {
|
|
"FAIL_INSTALLATION"
|
|
"SUCCESS_INSTALLATION"
|
|
"UNKNOWN_INSTALL_APK_STATUS"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry InstallAPKStatus_entries[] = {
|
|
{{&InstallAPKStatus_names[0], 17}, 1},
|
|
{{&InstallAPKStatus_names[17], 20}, 2},
|
|
{{&InstallAPKStatus_names[37], 26}, 0},
|
|
};
|
|
|
|
static const int InstallAPKStatus_entries_by_number[] = {
|
|
2, // 0 -> UNKNOWN_INSTALL_APK_STATUS
|
|
0, // 1 -> FAIL_INSTALLATION
|
|
1, // 2 -> SUCCESS_INSTALLATION
|
|
};
|
|
|
|
const ::std::string& InstallAPKStatus_Name(InstallAPKStatus value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
InstallAPKStatus_entries, InstallAPKStatus_entries_by_number, 3,
|
|
InstallAPKStatus_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(InstallAPKStatus_entries,
|
|
InstallAPKStatus_entries_by_number,
|
|
3, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : InstallAPKStatus_strings[idx].get();
|
|
}
|
|
|
|
bool InstallAPKStatus_Parse(::absl::string_view name, InstallAPKStatus* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
InstallAPKStatus_entries, 3, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<InstallAPKStatus>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t VerifyAPKStatus_internal_data_[] = {
|
|
262144u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
VerifyAPKStatus_strings[4] = {};
|
|
|
|
static const char VerifyAPKStatus_names[] = {
|
|
"ALREADY_INSTALLED"
|
|
"INSTALLABLE"
|
|
"NOT_INSTALLABLE"
|
|
"UNKNOWN_VERIFY_APK_STATUS"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry VerifyAPKStatus_entries[] = {
|
|
{{&VerifyAPKStatus_names[0], 17}, 3},
|
|
{{&VerifyAPKStatus_names[17], 11}, 2},
|
|
{{&VerifyAPKStatus_names[28], 15}, 1},
|
|
{{&VerifyAPKStatus_names[43], 25}, 0},
|
|
};
|
|
|
|
static const int VerifyAPKStatus_entries_by_number[] = {
|
|
3, // 0 -> UNKNOWN_VERIFY_APK_STATUS
|
|
2, // 1 -> NOT_INSTALLABLE
|
|
1, // 2 -> INSTALLABLE
|
|
0, // 3 -> ALREADY_INSTALLED
|
|
};
|
|
|
|
const ::std::string& VerifyAPKStatus_Name(VerifyAPKStatus value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
VerifyAPKStatus_entries, VerifyAPKStatus_entries_by_number, 4,
|
|
VerifyAPKStatus_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(VerifyAPKStatus_entries,
|
|
VerifyAPKStatus_entries_by_number,
|
|
4, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : VerifyAPKStatus_strings[idx].get();
|
|
}
|
|
|
|
bool VerifyAPKStatus_Parse(::absl::string_view name, VerifyAPKStatus* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
VerifyAPKStatus_entries, 4, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<VerifyAPKStatus>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t ShowNotificationStatus_internal_data_[] = {
|
|
196608u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
ShowNotificationStatus_strings[3] = {};
|
|
|
|
static const char ShowNotificationStatus_names[] = {
|
|
"NOT_SHOW"
|
|
"SHOW"
|
|
"UNKNOWN_SHOW_NOTIFICATION_STATUS"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry ShowNotificationStatus_entries[] = {
|
|
{{&ShowNotificationStatus_names[0], 8}, 2},
|
|
{{&ShowNotificationStatus_names[8], 4}, 1},
|
|
{{&ShowNotificationStatus_names[12], 32}, 0},
|
|
};
|
|
|
|
static const int ShowNotificationStatus_entries_by_number[] = {
|
|
2, // 0 -> UNKNOWN_SHOW_NOTIFICATION_STATUS
|
|
1, // 1 -> SHOW
|
|
0, // 2 -> NOT_SHOW
|
|
};
|
|
|
|
const ::std::string& ShowNotificationStatus_Name(ShowNotificationStatus value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
ShowNotificationStatus_entries, ShowNotificationStatus_entries_by_number, 3,
|
|
ShowNotificationStatus_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(ShowNotificationStatus_entries,
|
|
ShowNotificationStatus_entries_by_number,
|
|
3, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ShowNotificationStatus_strings[idx].get();
|
|
}
|
|
|
|
bool ShowNotificationStatus_Parse(::absl::string_view name, ShowNotificationStatus* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
ShowNotificationStatus_entries, 3, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<ShowNotificationStatus>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t PermissionRequestResult_internal_data_[] = {
|
|
262144u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
PermissionRequestResult_strings[4] = {};
|
|
|
|
static const char PermissionRequestResult_names[] = {
|
|
"PERMISSION_GRANTED"
|
|
"PERMISSION_REJECTED"
|
|
"PERMISSION_UNABLE_TO_GRANT"
|
|
"PERMISSION_UNKNOWN_REQUEST_RESULT"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry PermissionRequestResult_entries[] = {
|
|
{{&PermissionRequestResult_names[0], 18}, 1},
|
|
{{&PermissionRequestResult_names[18], 19}, 2},
|
|
{{&PermissionRequestResult_names[37], 26}, 3},
|
|
{{&PermissionRequestResult_names[63], 33}, 0},
|
|
};
|
|
|
|
static const int PermissionRequestResult_entries_by_number[] = {
|
|
3, // 0 -> PERMISSION_UNKNOWN_REQUEST_RESULT
|
|
0, // 1 -> PERMISSION_GRANTED
|
|
1, // 2 -> PERMISSION_REJECTED
|
|
2, // 3 -> PERMISSION_UNABLE_TO_GRANT
|
|
};
|
|
|
|
const ::std::string& PermissionRequestResult_Name(PermissionRequestResult value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
PermissionRequestResult_entries, PermissionRequestResult_entries_by_number, 4,
|
|
PermissionRequestResult_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(PermissionRequestResult_entries,
|
|
PermissionRequestResult_entries_by_number,
|
|
4, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : PermissionRequestResult_strings[idx].get();
|
|
}
|
|
|
|
bool PermissionRequestResult_Parse(::absl::string_view name, PermissionRequestResult* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
PermissionRequestResult_entries, 4, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<PermissionRequestResult>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t PermissionRequestType_internal_data_[] = {
|
|
393216u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
PermissionRequestType_strings[6] = {};
|
|
|
|
static const char PermissionRequestType_names[] = {
|
|
"PERMISSION_AIRPLANE_MODE_OFF"
|
|
"PERMISSION_BLUETOOTH"
|
|
"PERMISSION_LOCATION"
|
|
"PERMISSION_UNKNOWN_TYPE"
|
|
"PERMISSION_WIFI"
|
|
"PERMISSION_WIFI_HOTSPOT"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry PermissionRequestType_entries[] = {
|
|
{{&PermissionRequestType_names[0], 28}, 1},
|
|
{{&PermissionRequestType_names[28], 20}, 3},
|
|
{{&PermissionRequestType_names[48], 19}, 4},
|
|
{{&PermissionRequestType_names[67], 23}, 0},
|
|
{{&PermissionRequestType_names[90], 15}, 2},
|
|
{{&PermissionRequestType_names[105], 23}, 5},
|
|
};
|
|
|
|
static const int PermissionRequestType_entries_by_number[] = {
|
|
3, // 0 -> PERMISSION_UNKNOWN_TYPE
|
|
0, // 1 -> PERMISSION_AIRPLANE_MODE_OFF
|
|
4, // 2 -> PERMISSION_WIFI
|
|
1, // 3 -> PERMISSION_BLUETOOTH
|
|
2, // 4 -> PERMISSION_LOCATION
|
|
5, // 5 -> PERMISSION_WIFI_HOTSPOT
|
|
};
|
|
|
|
const ::std::string& PermissionRequestType_Name(PermissionRequestType value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
PermissionRequestType_entries, PermissionRequestType_entries_by_number, 6,
|
|
PermissionRequestType_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(PermissionRequestType_entries,
|
|
PermissionRequestType_entries_by_number,
|
|
6, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : PermissionRequestType_strings[idx].get();
|
|
}
|
|
|
|
bool PermissionRequestType_Parse(::absl::string_view name, PermissionRequestType* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
PermissionRequestType_entries, 6, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<PermissionRequestType>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t SharingUseCase_internal_data_[] = {
|
|
589824u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
SharingUseCase_strings[9] = {};
|
|
|
|
static const char SharingUseCase_names[] = {
|
|
"USE_CASE_APP_SHARE"
|
|
"USE_CASE_NEARBY_SHARE"
|
|
"USE_CASE_NEARBY_SHARE_WITH_QR_CODE"
|
|
"USE_CASE_QUICK_SETTING_FILE_SHARE"
|
|
"USE_CASE_REDIRECTED_FROM_BLUETOOTH_SHARE"
|
|
"USE_CASE_REMOTE_COPY_PASTE"
|
|
"USE_CASE_SETUP_WIZARD"
|
|
"USE_CASE_UNKNOWN"
|
|
"USE_CASE_WIFI_CREDENTIAL"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry SharingUseCase_entries[] = {
|
|
{{&SharingUseCase_names[0], 18}, 4},
|
|
{{&SharingUseCase_names[18], 21}, 1},
|
|
{{&SharingUseCase_names[39], 34}, 7},
|
|
{{&SharingUseCase_names[73], 33}, 5},
|
|
{{&SharingUseCase_names[106], 40}, 8},
|
|
{{&SharingUseCase_names[146], 26}, 2},
|
|
{{&SharingUseCase_names[172], 21}, 6},
|
|
{{&SharingUseCase_names[193], 16}, 0},
|
|
{{&SharingUseCase_names[209], 24}, 3},
|
|
};
|
|
|
|
static const int SharingUseCase_entries_by_number[] = {
|
|
7, // 0 -> USE_CASE_UNKNOWN
|
|
1, // 1 -> USE_CASE_NEARBY_SHARE
|
|
5, // 2 -> USE_CASE_REMOTE_COPY_PASTE
|
|
8, // 3 -> USE_CASE_WIFI_CREDENTIAL
|
|
0, // 4 -> USE_CASE_APP_SHARE
|
|
3, // 5 -> USE_CASE_QUICK_SETTING_FILE_SHARE
|
|
6, // 6 -> USE_CASE_SETUP_WIZARD
|
|
2, // 7 -> USE_CASE_NEARBY_SHARE_WITH_QR_CODE
|
|
4, // 8 -> USE_CASE_REDIRECTED_FROM_BLUETOOTH_SHARE
|
|
};
|
|
|
|
const ::std::string& SharingUseCase_Name(SharingUseCase value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
SharingUseCase_entries, SharingUseCase_entries_by_number, 9,
|
|
SharingUseCase_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(SharingUseCase_entries,
|
|
SharingUseCase_entries_by_number,
|
|
9, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : SharingUseCase_strings[idx].get();
|
|
}
|
|
|
|
bool SharingUseCase_Parse(::absl::string_view name, SharingUseCase* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
SharingUseCase_entries, 9, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<SharingUseCase>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t AppCrashReason_internal_data_[] = {
|
|
65536u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
AppCrashReason_strings[1] = {};
|
|
|
|
static const char AppCrashReason_names[] = {
|
|
"APP_CRASH_REASON_UNKNOWN"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry AppCrashReason_entries[] = {
|
|
{{&AppCrashReason_names[0], 24}, 0},
|
|
};
|
|
|
|
static const int AppCrashReason_entries_by_number[] = {
|
|
0, // 0 -> APP_CRASH_REASON_UNKNOWN
|
|
};
|
|
|
|
const ::std::string& AppCrashReason_Name(AppCrashReason value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
AppCrashReason_entries, AppCrashReason_entries_by_number, 1,
|
|
AppCrashReason_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(AppCrashReason_entries,
|
|
AppCrashReason_entries_by_number,
|
|
1, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : AppCrashReason_strings[idx].get();
|
|
}
|
|
|
|
bool AppCrashReason_Parse(::absl::string_view name, AppCrashReason* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
AppCrashReason_entries, 1, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<AppCrashReason>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t AttachmentSourceType_internal_data_[] = {
|
|
458752u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
AttachmentSourceType_strings[7] = {};
|
|
|
|
static const char AttachmentSourceType_names[] = {
|
|
"ATTACHMENT_SOURCE_CONTEXT_MENU"
|
|
"ATTACHMENT_SOURCE_DRAG_AND_DROP"
|
|
"ATTACHMENT_SOURCE_PASTE"
|
|
"ATTACHMENT_SOURCE_SELECT_FILES_BUTTON"
|
|
"ATTACHMENT_SOURCE_SELECT_FOLDERS_BUTTON"
|
|
"ATTACHMENT_SOURCE_SHARE_ACTIVATION"
|
|
"ATTACHMENT_SOURCE_UNKNOWN"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry AttachmentSourceType_entries[] = {
|
|
{{&AttachmentSourceType_names[0], 30}, 1},
|
|
{{&AttachmentSourceType_names[30], 31}, 2},
|
|
{{&AttachmentSourceType_names[61], 23}, 4},
|
|
{{&AttachmentSourceType_names[84], 37}, 3},
|
|
{{&AttachmentSourceType_names[121], 39}, 5},
|
|
{{&AttachmentSourceType_names[160], 34}, 6},
|
|
{{&AttachmentSourceType_names[194], 25}, 0},
|
|
};
|
|
|
|
static const int AttachmentSourceType_entries_by_number[] = {
|
|
6, // 0 -> ATTACHMENT_SOURCE_UNKNOWN
|
|
0, // 1 -> ATTACHMENT_SOURCE_CONTEXT_MENU
|
|
1, // 2 -> ATTACHMENT_SOURCE_DRAG_AND_DROP
|
|
3, // 3 -> ATTACHMENT_SOURCE_SELECT_FILES_BUTTON
|
|
2, // 4 -> ATTACHMENT_SOURCE_PASTE
|
|
4, // 5 -> ATTACHMENT_SOURCE_SELECT_FOLDERS_BUTTON
|
|
5, // 6 -> ATTACHMENT_SOURCE_SHARE_ACTIVATION
|
|
};
|
|
|
|
const ::std::string& AttachmentSourceType_Name(AttachmentSourceType value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
AttachmentSourceType_entries, AttachmentSourceType_entries_by_number, 7,
|
|
AttachmentSourceType_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(AttachmentSourceType_entries,
|
|
AttachmentSourceType_entries_by_number,
|
|
7, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : AttachmentSourceType_strings[idx].get();
|
|
}
|
|
|
|
bool AttachmentSourceType_Parse(::absl::string_view name, AttachmentSourceType* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
AttachmentSourceType_entries, 7, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<AttachmentSourceType>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t PreferencesAction_internal_data_[] = {
|
|
786432u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
PreferencesAction_strings[12] = {};
|
|
|
|
static const char PreferencesAction_names[] = {
|
|
"PREFERENCES_ACTION_ATTEMPT_LOAD"
|
|
"PREFERENCES_ACTION_CHECK_IF_PREFERENCES_BACKUP_FILE_EXISTS"
|
|
"PREFERENCES_ACTION_CHECK_IF_PREFERENCES_FILE_IS_CORRUPTED"
|
|
"PREFERENCES_ACTION_CHECK_IF_PREFERENCES_INPUT_STREAM_STATUS"
|
|
"PREFERENCES_ACTION_CHECK_IF_PREFERENCES_PATH_EXISTS"
|
|
"PREFERENCES_ACTION_CREATE_PREFERENCES_PATH"
|
|
"PREFERENCES_ACTION_LOAD_PREFERENCES"
|
|
"PREFERENCES_ACTION_MAKE_PREFERENCES_BACKUP_FILE"
|
|
"PREFERENCES_ACTION_NO_ACTION"
|
|
"PREFERENCES_ACTION_RESTORE_FROM_BACKUP"
|
|
"PREFERENCES_ACTION_SAVE_PREFERENCESS"
|
|
"PREFERENCES_ACTION_UNKNOWN"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry PreferencesAction_entries[] = {
|
|
{{&PreferencesAction_names[0], 31}, 4},
|
|
{{&PreferencesAction_names[31], 58}, 11},
|
|
{{&PreferencesAction_names[89], 57}, 10},
|
|
{{&PreferencesAction_names[146], 59}, 9},
|
|
{{&PreferencesAction_names[205], 51}, 8},
|
|
{{&PreferencesAction_names[256], 42}, 6},
|
|
{{&PreferencesAction_names[298], 35}, 2},
|
|
{{&PreferencesAction_names[333], 47}, 7},
|
|
{{&PreferencesAction_names[380], 28}, 1},
|
|
{{&PreferencesAction_names[408], 38}, 5},
|
|
{{&PreferencesAction_names[446], 36}, 3},
|
|
{{&PreferencesAction_names[482], 26}, 0},
|
|
};
|
|
|
|
static const int PreferencesAction_entries_by_number[] = {
|
|
11, // 0 -> PREFERENCES_ACTION_UNKNOWN
|
|
8, // 1 -> PREFERENCES_ACTION_NO_ACTION
|
|
6, // 2 -> PREFERENCES_ACTION_LOAD_PREFERENCES
|
|
10, // 3 -> PREFERENCES_ACTION_SAVE_PREFERENCESS
|
|
0, // 4 -> PREFERENCES_ACTION_ATTEMPT_LOAD
|
|
9, // 5 -> PREFERENCES_ACTION_RESTORE_FROM_BACKUP
|
|
5, // 6 -> PREFERENCES_ACTION_CREATE_PREFERENCES_PATH
|
|
7, // 7 -> PREFERENCES_ACTION_MAKE_PREFERENCES_BACKUP_FILE
|
|
4, // 8 -> PREFERENCES_ACTION_CHECK_IF_PREFERENCES_PATH_EXISTS
|
|
3, // 9 -> PREFERENCES_ACTION_CHECK_IF_PREFERENCES_INPUT_STREAM_STATUS
|
|
2, // 10 -> PREFERENCES_ACTION_CHECK_IF_PREFERENCES_FILE_IS_CORRUPTED
|
|
1, // 11 -> PREFERENCES_ACTION_CHECK_IF_PREFERENCES_BACKUP_FILE_EXISTS
|
|
};
|
|
|
|
const ::std::string& PreferencesAction_Name(PreferencesAction value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
PreferencesAction_entries, PreferencesAction_entries_by_number, 12,
|
|
PreferencesAction_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(PreferencesAction_entries,
|
|
PreferencesAction_entries_by_number,
|
|
12, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : PreferencesAction_strings[idx].get();
|
|
}
|
|
|
|
bool PreferencesAction_Parse(::absl::string_view name, PreferencesAction* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
PreferencesAction_entries, 12, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<PreferencesAction>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t PreferencesActionStatus_internal_data_[] = {
|
|
196608u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
PreferencesActionStatus_strings[3] = {};
|
|
|
|
static const char PreferencesActionStatus_names[] = {
|
|
"PREFERENCES_ACTION_STATUS_FAIL"
|
|
"PREFERENCES_ACTION_STATUS_SUCCESS"
|
|
"PREFERENCES_ACTION_STATUS_UNKNOWN"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry PreferencesActionStatus_entries[] = {
|
|
{{&PreferencesActionStatus_names[0], 30}, 2},
|
|
{{&PreferencesActionStatus_names[30], 33}, 1},
|
|
{{&PreferencesActionStatus_names[63], 33}, 0},
|
|
};
|
|
|
|
static const int PreferencesActionStatus_entries_by_number[] = {
|
|
2, // 0 -> PREFERENCES_ACTION_STATUS_UNKNOWN
|
|
1, // 1 -> PREFERENCES_ACTION_STATUS_SUCCESS
|
|
0, // 2 -> PREFERENCES_ACTION_STATUS_FAIL
|
|
};
|
|
|
|
const ::std::string& PreferencesActionStatus_Name(PreferencesActionStatus value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
PreferencesActionStatus_entries, PreferencesActionStatus_entries_by_number, 3,
|
|
PreferencesActionStatus_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(PreferencesActionStatus_entries,
|
|
PreferencesActionStatus_entries_by_number,
|
|
3, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : PreferencesActionStatus_strings[idx].get();
|
|
}
|
|
|
|
bool PreferencesActionStatus_Parse(::absl::string_view name, PreferencesActionStatus* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
PreferencesActionStatus_entries, 3, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<PreferencesActionStatus>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t FastInitState_internal_data_[] = {
|
|
262144u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
FastInitState_strings[4] = {};
|
|
|
|
static const char FastInitState_names[] = {
|
|
"FAST_INIT_CLOSE_STATE"
|
|
"FAST_INIT_FAR_STATE"
|
|
"FAST_INIT_LOST_STATE"
|
|
"FAST_INIT_UNKNOWN_STATE"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry FastInitState_entries[] = {
|
|
{{&FastInitState_names[0], 21}, 1},
|
|
{{&FastInitState_names[21], 19}, 2},
|
|
{{&FastInitState_names[40], 20}, 3},
|
|
{{&FastInitState_names[60], 23}, 0},
|
|
};
|
|
|
|
static const int FastInitState_entries_by_number[] = {
|
|
3, // 0 -> FAST_INIT_UNKNOWN_STATE
|
|
0, // 1 -> FAST_INIT_CLOSE_STATE
|
|
1, // 2 -> FAST_INIT_FAR_STATE
|
|
2, // 3 -> FAST_INIT_LOST_STATE
|
|
};
|
|
|
|
const ::std::string& FastInitState_Name(FastInitState value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
FastInitState_entries, FastInitState_entries_by_number, 4,
|
|
FastInitState_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(FastInitState_entries,
|
|
FastInitState_entries_by_number,
|
|
4, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : FastInitState_strings[idx].get();
|
|
}
|
|
|
|
bool FastInitState_Parse(::absl::string_view name, FastInitState* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
FastInitState_entries, 4, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<FastInitState>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t FastInitType_internal_data_[] = {
|
|
196608u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
FastInitType_strings[3] = {};
|
|
|
|
static const char FastInitType_names[] = {
|
|
"FAST_INIT_NOTIFY_TYPE"
|
|
"FAST_INIT_SILENT_TYPE"
|
|
"FAST_INIT_UNKNOWN_TYPE"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry FastInitType_entries[] = {
|
|
{{&FastInitType_names[0], 21}, 1},
|
|
{{&FastInitType_names[21], 21}, 2},
|
|
{{&FastInitType_names[42], 22}, 0},
|
|
};
|
|
|
|
static const int FastInitType_entries_by_number[] = {
|
|
2, // 0 -> FAST_INIT_UNKNOWN_TYPE
|
|
0, // 1 -> FAST_INIT_NOTIFY_TYPE
|
|
1, // 2 -> FAST_INIT_SILENT_TYPE
|
|
};
|
|
|
|
const ::std::string& FastInitType_Name(FastInitType value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
FastInitType_entries, FastInitType_entries_by_number, 3,
|
|
FastInitType_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(FastInitType_entries,
|
|
FastInitType_entries_by_number,
|
|
3, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : FastInitType_strings[idx].get();
|
|
}
|
|
|
|
bool FastInitType_Parse(::absl::string_view name, FastInitType* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
FastInitType_entries, 3, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<FastInitType>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t DesktopNotification_internal_data_[] = {
|
|
393216u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
DesktopNotification_strings[6] = {};
|
|
|
|
static const char DesktopNotification_names[] = {
|
|
"DESKTOP_NOTIFICATION_ACCEPT"
|
|
"DESKTOP_NOTIFICATION_CONNECTING"
|
|
"DESKTOP_NOTIFICATION_ERROR"
|
|
"DESKTOP_NOTIFICATION_PROGRESS"
|
|
"DESKTOP_NOTIFICATION_RECEIVED"
|
|
"DESKTOP_NOTIFICATION_UNKNOWN"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry DesktopNotification_entries[] = {
|
|
{{&DesktopNotification_names[0], 27}, 3},
|
|
{{&DesktopNotification_names[27], 31}, 1},
|
|
{{&DesktopNotification_names[58], 26}, 5},
|
|
{{&DesktopNotification_names[84], 29}, 2},
|
|
{{&DesktopNotification_names[113], 29}, 4},
|
|
{{&DesktopNotification_names[142], 28}, 0},
|
|
};
|
|
|
|
static const int DesktopNotification_entries_by_number[] = {
|
|
5, // 0 -> DESKTOP_NOTIFICATION_UNKNOWN
|
|
1, // 1 -> DESKTOP_NOTIFICATION_CONNECTING
|
|
3, // 2 -> DESKTOP_NOTIFICATION_PROGRESS
|
|
0, // 3 -> DESKTOP_NOTIFICATION_ACCEPT
|
|
4, // 4 -> DESKTOP_NOTIFICATION_RECEIVED
|
|
2, // 5 -> DESKTOP_NOTIFICATION_ERROR
|
|
};
|
|
|
|
const ::std::string& DesktopNotification_Name(DesktopNotification value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
DesktopNotification_entries, DesktopNotification_entries_by_number, 6,
|
|
DesktopNotification_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(DesktopNotification_entries,
|
|
DesktopNotification_entries_by_number,
|
|
6, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : DesktopNotification_strings[idx].get();
|
|
}
|
|
|
|
bool DesktopNotification_Parse(::absl::string_view name, DesktopNotification* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
DesktopNotification_entries, 6, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<DesktopNotification>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t DesktopTransferEventType_internal_data_[] = {
|
|
655360u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
DesktopTransferEventType_strings[10] = {};
|
|
|
|
static const char DesktopTransferEventType_names[] = {
|
|
"DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_ACCEPT"
|
|
"DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_ERROR"
|
|
"DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_PROGRESS"
|
|
"DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_RECEIVED"
|
|
"DESKTOP_TRANSFER_EVENT_SEND_TYPE_ERROR"
|
|
"DESKTOP_TRANSFER_EVENT_SEND_TYPE_PROGRESS"
|
|
"DESKTOP_TRANSFER_EVENT_SEND_TYPE_SELECT_A_DEVICE"
|
|
"DESKTOP_TRANSFER_EVENT_SEND_TYPE_SENT"
|
|
"DESKTOP_TRANSFER_EVENT_SEND_TYPE_START"
|
|
"DESKTOP_TRANSFER_EVENT_TYPE_UNKNOWN"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry DesktopTransferEventType_entries[] = {
|
|
{{&DesktopTransferEventType_names[0], 42}, 1},
|
|
{{&DesktopTransferEventType_names[42], 41}, 4},
|
|
{{&DesktopTransferEventType_names[83], 44}, 2},
|
|
{{&DesktopTransferEventType_names[127], 44}, 3},
|
|
{{&DesktopTransferEventType_names[171], 38}, 9},
|
|
{{&DesktopTransferEventType_names[209], 41}, 7},
|
|
{{&DesktopTransferEventType_names[250], 48}, 6},
|
|
{{&DesktopTransferEventType_names[298], 37}, 8},
|
|
{{&DesktopTransferEventType_names[335], 38}, 5},
|
|
{{&DesktopTransferEventType_names[373], 35}, 0},
|
|
};
|
|
|
|
static const int DesktopTransferEventType_entries_by_number[] = {
|
|
9, // 0 -> DESKTOP_TRANSFER_EVENT_TYPE_UNKNOWN
|
|
0, // 1 -> DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_ACCEPT
|
|
2, // 2 -> DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_PROGRESS
|
|
3, // 3 -> DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_RECEIVED
|
|
1, // 4 -> DESKTOP_TRANSFER_EVENT_RECEIVE_TYPE_ERROR
|
|
8, // 5 -> DESKTOP_TRANSFER_EVENT_SEND_TYPE_START
|
|
6, // 6 -> DESKTOP_TRANSFER_EVENT_SEND_TYPE_SELECT_A_DEVICE
|
|
5, // 7 -> DESKTOP_TRANSFER_EVENT_SEND_TYPE_PROGRESS
|
|
7, // 8 -> DESKTOP_TRANSFER_EVENT_SEND_TYPE_SENT
|
|
4, // 9 -> DESKTOP_TRANSFER_EVENT_SEND_TYPE_ERROR
|
|
};
|
|
|
|
const ::std::string& DesktopTransferEventType_Name(DesktopTransferEventType value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
DesktopTransferEventType_entries, DesktopTransferEventType_entries_by_number, 10,
|
|
DesktopTransferEventType_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(DesktopTransferEventType_entries,
|
|
DesktopTransferEventType_entries_by_number,
|
|
10, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : DesktopTransferEventType_strings[idx].get();
|
|
}
|
|
|
|
bool DesktopTransferEventType_Parse(::absl::string_view name, DesktopTransferEventType* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
DesktopTransferEventType_entries, 10, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<DesktopTransferEventType>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t DecryptCertificateFailureStatus_internal_data_[] = {
|
|
458752u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
DecryptCertificateFailureStatus_strings[7] = {};
|
|
|
|
static const char DecryptCertificateFailureStatus_names[] = {
|
|
"DECRYPT_CERT_BAD_PADDING_FAILURE"
|
|
"DECRYPT_CERT_ILLEGAL_BLOCK_SIZE_FAILURE"
|
|
"DECRYPT_CERT_INVALID_ALGORITHM_PARAMETER_FAILURE"
|
|
"DECRYPT_CERT_INVALID_KEY_FAILURE"
|
|
"DECRYPT_CERT_NO_SUCH_ALGORITHM_FAILURE"
|
|
"DECRYPT_CERT_NO_SUCH_PADDING_FAILURE"
|
|
"DECRYPT_CERT_UNKNOWN_FAILURE"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry DecryptCertificateFailureStatus_entries[] = {
|
|
{{&DecryptCertificateFailureStatus_names[0], 32}, 6},
|
|
{{&DecryptCertificateFailureStatus_names[32], 39}, 5},
|
|
{{&DecryptCertificateFailureStatus_names[71], 48}, 4},
|
|
{{&DecryptCertificateFailureStatus_names[119], 32}, 3},
|
|
{{&DecryptCertificateFailureStatus_names[151], 38}, 1},
|
|
{{&DecryptCertificateFailureStatus_names[189], 36}, 2},
|
|
{{&DecryptCertificateFailureStatus_names[225], 28}, 0},
|
|
};
|
|
|
|
static const int DecryptCertificateFailureStatus_entries_by_number[] = {
|
|
6, // 0 -> DECRYPT_CERT_UNKNOWN_FAILURE
|
|
4, // 1 -> DECRYPT_CERT_NO_SUCH_ALGORITHM_FAILURE
|
|
5, // 2 -> DECRYPT_CERT_NO_SUCH_PADDING_FAILURE
|
|
3, // 3 -> DECRYPT_CERT_INVALID_KEY_FAILURE
|
|
2, // 4 -> DECRYPT_CERT_INVALID_ALGORITHM_PARAMETER_FAILURE
|
|
1, // 5 -> DECRYPT_CERT_ILLEGAL_BLOCK_SIZE_FAILURE
|
|
0, // 6 -> DECRYPT_CERT_BAD_PADDING_FAILURE
|
|
};
|
|
|
|
const ::std::string& DecryptCertificateFailureStatus_Name(DecryptCertificateFailureStatus value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
DecryptCertificateFailureStatus_entries, DecryptCertificateFailureStatus_entries_by_number, 7,
|
|
DecryptCertificateFailureStatus_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(DecryptCertificateFailureStatus_entries,
|
|
DecryptCertificateFailureStatus_entries_by_number,
|
|
7, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : DecryptCertificateFailureStatus_strings[idx].get();
|
|
}
|
|
|
|
bool DecryptCertificateFailureStatus_Parse(::absl::string_view name, DecryptCertificateFailureStatus* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
DecryptCertificateFailureStatus_entries, 7, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<DecryptCertificateFailureStatus>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t ContactAccess_internal_data_[] = {
|
|
327680u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
ContactAccess_strings[5] = {};
|
|
|
|
static const char ContactAccess_names[] = {
|
|
"CONTACT_ACCESS_NO_CONTACT_UPLOADED"
|
|
"CONTACT_ACCESS_ONLY_UPLOAD_GOOGLE_CONTACT"
|
|
"CONTACT_ACCESS_UNKNOWN"
|
|
"CONTACT_ACCESS_UPLOAD_CONTACT_FOR_DEVICE_CONTACT_CONSENT"
|
|
"CONTACT_ACCESS_UPLOAD_CONTACT_FOR_QUICK_SHARE_CONSENT"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry ContactAccess_entries[] = {
|
|
{{&ContactAccess_names[0], 34}, 1},
|
|
{{&ContactAccess_names[34], 41}, 2},
|
|
{{&ContactAccess_names[75], 22}, 0},
|
|
{{&ContactAccess_names[97], 56}, 3},
|
|
{{&ContactAccess_names[153], 53}, 4},
|
|
};
|
|
|
|
static const int ContactAccess_entries_by_number[] = {
|
|
2, // 0 -> CONTACT_ACCESS_UNKNOWN
|
|
0, // 1 -> CONTACT_ACCESS_NO_CONTACT_UPLOADED
|
|
1, // 2 -> CONTACT_ACCESS_ONLY_UPLOAD_GOOGLE_CONTACT
|
|
3, // 3 -> CONTACT_ACCESS_UPLOAD_CONTACT_FOR_DEVICE_CONTACT_CONSENT
|
|
4, // 4 -> CONTACT_ACCESS_UPLOAD_CONTACT_FOR_QUICK_SHARE_CONSENT
|
|
};
|
|
|
|
const ::std::string& ContactAccess_Name(ContactAccess value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
ContactAccess_entries, ContactAccess_entries_by_number, 5,
|
|
ContactAccess_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(ContactAccess_entries,
|
|
ContactAccess_entries_by_number,
|
|
5, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ContactAccess_strings[idx].get();
|
|
}
|
|
|
|
bool ContactAccess_Parse(::absl::string_view name, ContactAccess* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
ContactAccess_entries, 5, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<ContactAccess>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t IdentityVerification_internal_data_[] = {
|
|
262144u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
IdentityVerification_strings[4] = {};
|
|
|
|
static const char IdentityVerification_names[] = {
|
|
"IDENTITY_VERIFICATION_NO_PHONE_NUMBER_VERIFIED"
|
|
"IDENTITY_VERIFICATION_PHONE_NUMBER_VERIFIED_LINKED_TO_QS_GAIA"
|
|
"IDENTITY_VERIFICATION_PHONE_NUMBER_VERIFIED_NOT_LINKED_TO_GAIA"
|
|
"IDENTITY_VERIFICATION_UNKNOWN"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry IdentityVerification_entries[] = {
|
|
{{&IdentityVerification_names[0], 46}, 1},
|
|
{{&IdentityVerification_names[46], 61}, 3},
|
|
{{&IdentityVerification_names[107], 62}, 2},
|
|
{{&IdentityVerification_names[169], 29}, 0},
|
|
};
|
|
|
|
static const int IdentityVerification_entries_by_number[] = {
|
|
3, // 0 -> IDENTITY_VERIFICATION_UNKNOWN
|
|
0, // 1 -> IDENTITY_VERIFICATION_NO_PHONE_NUMBER_VERIFIED
|
|
2, // 2 -> IDENTITY_VERIFICATION_PHONE_NUMBER_VERIFIED_NOT_LINKED_TO_GAIA
|
|
1, // 3 -> IDENTITY_VERIFICATION_PHONE_NUMBER_VERIFIED_LINKED_TO_QS_GAIA
|
|
};
|
|
|
|
const ::std::string& IdentityVerification_Name(IdentityVerification value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
IdentityVerification_entries, IdentityVerification_entries_by_number, 4,
|
|
IdentityVerification_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(IdentityVerification_entries,
|
|
IdentityVerification_entries_by_number,
|
|
4, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : IdentityVerification_strings[idx].get();
|
|
}
|
|
|
|
bool IdentityVerification_Parse(::absl::string_view name, IdentityVerification* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
IdentityVerification_entries, 4, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<IdentityVerification>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t ButtonStatus_internal_data_[] = {
|
|
262144u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
ButtonStatus_strings[4] = {};
|
|
|
|
static const char ButtonStatus_names[] = {
|
|
"BUTTON_STATUS_CLICK_ACCEPT"
|
|
"BUTTON_STATUS_CLICK_REJECT"
|
|
"BUTTON_STATUS_IGNORE"
|
|
"BUTTON_STATUS_UNKNOWN"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry ButtonStatus_entries[] = {
|
|
{{&ButtonStatus_names[0], 26}, 1},
|
|
{{&ButtonStatus_names[26], 26}, 2},
|
|
{{&ButtonStatus_names[52], 20}, 3},
|
|
{{&ButtonStatus_names[72], 21}, 0},
|
|
};
|
|
|
|
static const int ButtonStatus_entries_by_number[] = {
|
|
3, // 0 -> BUTTON_STATUS_UNKNOWN
|
|
0, // 1 -> BUTTON_STATUS_CLICK_ACCEPT
|
|
1, // 2 -> BUTTON_STATUS_CLICK_REJECT
|
|
2, // 3 -> BUTTON_STATUS_IGNORE
|
|
};
|
|
|
|
const ::std::string& ButtonStatus_Name(ButtonStatus value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
ButtonStatus_entries, ButtonStatus_entries_by_number, 4,
|
|
ButtonStatus_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(ButtonStatus_entries,
|
|
ButtonStatus_entries_by_number,
|
|
4, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : ButtonStatus_strings[idx].get();
|
|
}
|
|
|
|
bool ButtonStatus_Parse(::absl::string_view name, ButtonStatus* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
ButtonStatus_entries, 4, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<ButtonStatus>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t CloudCreateSharingResult_internal_data_[] = {
|
|
720896u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
CloudCreateSharingResult_strings[11] = {};
|
|
|
|
static const char CloudCreateSharingResult_names[] = {
|
|
"CLOUD_CREATE_SHARING_RESULT_ALREADY_EXIST"
|
|
"CLOUD_CREATE_SHARING_RESULT_ALREADY_STARTED"
|
|
"CLOUD_CREATE_SHARING_RESULT_FILE_LIMIT_EXCEED_COUNT"
|
|
"CLOUD_CREATE_SHARING_RESULT_FILE_LIMIT_EXCEED_SIZE"
|
|
"CLOUD_CREATE_SHARING_RESULT_INVALID_ARGUMENT"
|
|
"CLOUD_CREATE_SHARING_RESULT_NETWORK_ERROR"
|
|
"CLOUD_CREATE_SHARING_RESULT_REMOTE_ERROR"
|
|
"CLOUD_CREATE_SHARING_RESULT_SIGN_IN_REQUIRE"
|
|
"CLOUD_CREATE_SHARING_RESULT_SUCCESS"
|
|
"CLOUD_CREATE_SHARING_RESULT_SUCCESS_NO_NOTIFICATION"
|
|
"CLOUD_CREATE_SHARING_RESULT_UNKNOWN"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry CloudCreateSharingResult_entries[] = {
|
|
{{&CloudCreateSharingResult_names[0], 41}, 3},
|
|
{{&CloudCreateSharingResult_names[41], 43}, 4},
|
|
{{&CloudCreateSharingResult_names[84], 51}, 8},
|
|
{{&CloudCreateSharingResult_names[135], 50}, 9},
|
|
{{&CloudCreateSharingResult_names[185], 44}, 6},
|
|
{{&CloudCreateSharingResult_names[229], 41}, 5},
|
|
{{&CloudCreateSharingResult_names[270], 40}, 7},
|
|
{{&CloudCreateSharingResult_names[310], 43}, 2},
|
|
{{&CloudCreateSharingResult_names[353], 35}, 1},
|
|
{{&CloudCreateSharingResult_names[388], 51}, 10},
|
|
{{&CloudCreateSharingResult_names[439], 35}, 0},
|
|
};
|
|
|
|
static const int CloudCreateSharingResult_entries_by_number[] = {
|
|
10, // 0 -> CLOUD_CREATE_SHARING_RESULT_UNKNOWN
|
|
8, // 1 -> CLOUD_CREATE_SHARING_RESULT_SUCCESS
|
|
7, // 2 -> CLOUD_CREATE_SHARING_RESULT_SIGN_IN_REQUIRE
|
|
0, // 3 -> CLOUD_CREATE_SHARING_RESULT_ALREADY_EXIST
|
|
1, // 4 -> CLOUD_CREATE_SHARING_RESULT_ALREADY_STARTED
|
|
5, // 5 -> CLOUD_CREATE_SHARING_RESULT_NETWORK_ERROR
|
|
4, // 6 -> CLOUD_CREATE_SHARING_RESULT_INVALID_ARGUMENT
|
|
6, // 7 -> CLOUD_CREATE_SHARING_RESULT_REMOTE_ERROR
|
|
2, // 8 -> CLOUD_CREATE_SHARING_RESULT_FILE_LIMIT_EXCEED_COUNT
|
|
3, // 9 -> CLOUD_CREATE_SHARING_RESULT_FILE_LIMIT_EXCEED_SIZE
|
|
9, // 10 -> CLOUD_CREATE_SHARING_RESULT_SUCCESS_NO_NOTIFICATION
|
|
};
|
|
|
|
const ::std::string& CloudCreateSharingResult_Name(CloudCreateSharingResult value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
CloudCreateSharingResult_entries, CloudCreateSharingResult_entries_by_number, 11,
|
|
CloudCreateSharingResult_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(CloudCreateSharingResult_entries,
|
|
CloudCreateSharingResult_entries_by_number,
|
|
11, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : CloudCreateSharingResult_strings[idx].get();
|
|
}
|
|
|
|
bool CloudCreateSharingResult_Parse(::absl::string_view name, CloudCreateSharingResult* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
CloudCreateSharingResult_entries, 11, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<CloudCreateSharingResult>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t CloudRegisterReceiverResult_internal_data_[] = {
|
|
1114112u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
CloudRegisterReceiverResult_strings[17] = {};
|
|
|
|
static const char CloudRegisterReceiverResult_names[] = {
|
|
"CLOUD_REGISTER_RECEIVER_RESULT_ABORTED"
|
|
"CLOUD_REGISTER_RECEIVER_RESULT_ALREADY_EXISTS"
|
|
"CLOUD_REGISTER_RECEIVER_RESULT_CANCELLED"
|
|
"CLOUD_REGISTER_RECEIVER_RESULT_DATA_LOSS"
|
|
"CLOUD_REGISTER_RECEIVER_RESULT_DEADLINE_EXCEEDED"
|
|
"CLOUD_REGISTER_RECEIVER_RESULT_FAILED_PRECONDITION"
|
|
"CLOUD_REGISTER_RECEIVER_RESULT_INTERNAL"
|
|
"CLOUD_REGISTER_RECEIVER_RESULT_INVALID_ARGUMENT"
|
|
"CLOUD_REGISTER_RECEIVER_RESULT_NOT_FOUND"
|
|
"CLOUD_REGISTER_RECEIVER_RESULT_OUT_OF_RANGE"
|
|
"CLOUD_REGISTER_RECEIVER_RESULT_PERMISSION_DENIED"
|
|
"CLOUD_REGISTER_RECEIVER_RESULT_RESOURCE_EXHAUSTED"
|
|
"CLOUD_REGISTER_RECEIVER_RESULT_SUCCESS"
|
|
"CLOUD_REGISTER_RECEIVER_RESULT_UNAUTHENTICATED"
|
|
"CLOUD_REGISTER_RECEIVER_RESULT_UNAVAILABLE"
|
|
"CLOUD_REGISTER_RECEIVER_RESULT_UNIMPLEMENTED"
|
|
"CLOUD_REGISTER_RECEIVER_RESULT_UNKNOWN"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry CloudRegisterReceiverResult_entries[] = {
|
|
{{&CloudRegisterReceiverResult_names[0], 38}, 13},
|
|
{{&CloudRegisterReceiverResult_names[38], 45}, 9},
|
|
{{&CloudRegisterReceiverResult_names[83], 40}, 11},
|
|
{{&CloudRegisterReceiverResult_names[123], 40}, 16},
|
|
{{&CloudRegisterReceiverResult_names[163], 48}, 3},
|
|
{{&CloudRegisterReceiverResult_names[211], 50}, 12},
|
|
{{&CloudRegisterReceiverResult_names[261], 39}, 4},
|
|
{{&CloudRegisterReceiverResult_names[300], 47}, 2},
|
|
{{&CloudRegisterReceiverResult_names[347], 40}, 8},
|
|
{{&CloudRegisterReceiverResult_names[387], 43}, 14},
|
|
{{&CloudRegisterReceiverResult_names[430], 48}, 7},
|
|
{{&CloudRegisterReceiverResult_names[478], 49}, 5},
|
|
{{&CloudRegisterReceiverResult_names[527], 38}, 1},
|
|
{{&CloudRegisterReceiverResult_names[565], 46}, 10},
|
|
{{&CloudRegisterReceiverResult_names[611], 42}, 6},
|
|
{{&CloudRegisterReceiverResult_names[653], 44}, 15},
|
|
{{&CloudRegisterReceiverResult_names[697], 38}, 0},
|
|
};
|
|
|
|
static const int CloudRegisterReceiverResult_entries_by_number[] = {
|
|
16, // 0 -> CLOUD_REGISTER_RECEIVER_RESULT_UNKNOWN
|
|
12, // 1 -> CLOUD_REGISTER_RECEIVER_RESULT_SUCCESS
|
|
7, // 2 -> CLOUD_REGISTER_RECEIVER_RESULT_INVALID_ARGUMENT
|
|
4, // 3 -> CLOUD_REGISTER_RECEIVER_RESULT_DEADLINE_EXCEEDED
|
|
6, // 4 -> CLOUD_REGISTER_RECEIVER_RESULT_INTERNAL
|
|
11, // 5 -> CLOUD_REGISTER_RECEIVER_RESULT_RESOURCE_EXHAUSTED
|
|
14, // 6 -> CLOUD_REGISTER_RECEIVER_RESULT_UNAVAILABLE
|
|
10, // 7 -> CLOUD_REGISTER_RECEIVER_RESULT_PERMISSION_DENIED
|
|
8, // 8 -> CLOUD_REGISTER_RECEIVER_RESULT_NOT_FOUND
|
|
1, // 9 -> CLOUD_REGISTER_RECEIVER_RESULT_ALREADY_EXISTS
|
|
13, // 10 -> CLOUD_REGISTER_RECEIVER_RESULT_UNAUTHENTICATED
|
|
2, // 11 -> CLOUD_REGISTER_RECEIVER_RESULT_CANCELLED
|
|
5, // 12 -> CLOUD_REGISTER_RECEIVER_RESULT_FAILED_PRECONDITION
|
|
0, // 13 -> CLOUD_REGISTER_RECEIVER_RESULT_ABORTED
|
|
9, // 14 -> CLOUD_REGISTER_RECEIVER_RESULT_OUT_OF_RANGE
|
|
15, // 15 -> CLOUD_REGISTER_RECEIVER_RESULT_UNIMPLEMENTED
|
|
3, // 16 -> CLOUD_REGISTER_RECEIVER_RESULT_DATA_LOSS
|
|
};
|
|
|
|
const ::std::string& CloudRegisterReceiverResult_Name(CloudRegisterReceiverResult value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
CloudRegisterReceiverResult_entries, CloudRegisterReceiverResult_entries_by_number, 17,
|
|
CloudRegisterReceiverResult_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(CloudRegisterReceiverResult_entries,
|
|
CloudRegisterReceiverResult_entries_by_number,
|
|
17, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : CloudRegisterReceiverResult_strings[idx].get();
|
|
}
|
|
|
|
bool CloudRegisterReceiverResult_Parse(::absl::string_view name, CloudRegisterReceiverResult* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
CloudRegisterReceiverResult_entries, 17, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<CloudRegisterReceiverResult>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
PROTOBUF_CONSTINIT const uint32_t CloudActionType_internal_data_[] = {
|
|
196608u, 0u, };
|
|
static ::google::protobuf::internal::ExplicitlyConstructed<::std::string>
|
|
CloudActionType_strings[3] = {};
|
|
|
|
static const char CloudActionType_names[] = {
|
|
"CLOUD_ACTION_TYPE_NORMAL"
|
|
"CLOUD_ACTION_TYPE_RETRY"
|
|
"CLOUD_ACTION_TYPE_UNKNOWN"
|
|
};
|
|
|
|
static const ::google::protobuf::internal::EnumEntry CloudActionType_entries[] = {
|
|
{{&CloudActionType_names[0], 24}, 1},
|
|
{{&CloudActionType_names[24], 23}, 2},
|
|
{{&CloudActionType_names[47], 25}, 0},
|
|
};
|
|
|
|
static const int CloudActionType_entries_by_number[] = {
|
|
2, // 0 -> CLOUD_ACTION_TYPE_UNKNOWN
|
|
0, // 1 -> CLOUD_ACTION_TYPE_NORMAL
|
|
1, // 2 -> CLOUD_ACTION_TYPE_RETRY
|
|
};
|
|
|
|
const ::std::string& CloudActionType_Name(CloudActionType value) {
|
|
static const bool kDummy = ::google::protobuf::internal::InitializeEnumStrings(
|
|
CloudActionType_entries, CloudActionType_entries_by_number, 3,
|
|
CloudActionType_strings);
|
|
(void)kDummy;
|
|
|
|
int idx = ::google::protobuf::internal::LookUpEnumName(CloudActionType_entries,
|
|
CloudActionType_entries_by_number,
|
|
3, value);
|
|
return idx == -1 ? ::google::protobuf::internal::GetEmptyString() : CloudActionType_strings[idx].get();
|
|
}
|
|
|
|
bool CloudActionType_Parse(::absl::string_view name, CloudActionType* PROTOBUF_NONNULL value) {
|
|
int int_value;
|
|
bool success = ::google::protobuf::internal::LookUpEnumValue(
|
|
CloudActionType_entries, 3, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<CloudActionType>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
// @@protoc_insertion_point(namespace_scope)
|
|
} // namespace sharing
|
|
} // namespace proto
|
|
} // namespace nearby
|
|
} // namespace location
|
|
namespace google {
|
|
namespace protobuf {
|
|
} // namespace protobuf
|
|
} // namespace google
|
|
// @@protoc_insertion_point(global_scope)
|
|
#include "google/protobuf/port_undef.inc"
|