From 79ff6ecee9d59b4ecb2b37f9136d6fc91970022e Mon Sep 17 00:00:00 2001 From: Kitae Kim Date: Wed, 8 Oct 2014 17:13:45 +0900 Subject: [PATCH] eventcast: rename tethering to eventcast naming tethering might be confusing to users. Change-Id: I154e59aefd932728cb3b73ece6c14d4223cc03de Signed-off-by: Kitae Kim --- tizen/src/Makefile.objs | 2 +- tizen/src/display/maru_sdl.c | 2 +- tizen/src/display/maru_shm.c | 2 +- tizen/src/ecs/Makefile.objs | 2 +- tizen/src/ecs/ecs.c | 6 +- tizen/src/ecs/ecs.h | 2 +- .../ecs/{ecs_tethering.c => ecs_eventcast.c} | 142 +- .../ecs/{ecs_tethering.h => ecs_eventcast.h} | 32 +- tizen/src/ecs/genmsg/ecs.pb-c.c | 250 +- tizen/src/ecs/genmsg/ecs.pb-c.h | 128 +- tizen/src/ecs/genmsg/ecs_ids.pb-c.c | 12 +- tizen/src/ecs/genmsg/ecs_ids.pb-c.h | 8 +- tizen/src/ecs/msg/ecs.proto | 12 +- tizen/src/ecs/msg/ecs_ids.proto | 10 +- tizen/src/{tethering => eventcast}/common.c | 346 ++- tizen/src/{tethering => eventcast}/common.h | 10 +- .../src/{tethering => eventcast}/encode_fb.c | 8 +- .../src/{tethering => eventcast}/encode_fb.h | 0 tizen/src/eventcast/genmsg/eventcast.pb-c.c | 2314 +++++++++++++++++ tizen/src/eventcast/genmsg/eventcast.pb-c.h | 798 ++++++ .../msg/eventcast.proto} | 8 +- tizen/src/{tethering => eventcast}/sensor.c | 90 +- tizen/src/{tethering => eventcast}/sensor.h | 6 +- tizen/src/{tethering => eventcast}/touch.c | 87 +- tizen/src/{tethering => eventcast}/touch.h | 6 +- tizen/src/tethering/Makefile.objs | 7 - tizen/src/tethering/genmsg/tethering.pb-c.c | 2314 ----------------- tizen/src/tethering/genmsg/tethering.pb-c.h | 798 ------ 28 files changed, 3697 insertions(+), 3705 deletions(-) rename tizen/src/ecs/{ecs_tethering.c => ecs_eventcast.c} (62%) rename tizen/src/ecs/{ecs_tethering.h => ecs_eventcast.h} (60%) rename tizen/src/{tethering => eventcast}/common.c (62%) rename tizen/src/{tethering => eventcast}/common.h (84%) rename tizen/src/{tethering => eventcast}/encode_fb.c (98%) rename tizen/src/{tethering => eventcast}/encode_fb.h (100%) create mode 100644 tizen/src/eventcast/genmsg/eventcast.pb-c.c create mode 100644 tizen/src/eventcast/genmsg/eventcast.pb-c.h rename tizen/src/{tethering/msg/tethering.proto => eventcast/msg/eventcast.proto} (96%) rename tizen/src/{tethering => eventcast}/sensor.c (66%) rename tizen/src/{tethering => eventcast}/sensor.h (88%) rename tizen/src/{tethering => eventcast}/touch.c (71%) rename tizen/src/{tethering => eventcast}/touch.h (89%) delete mode 100644 tizen/src/tethering/Makefile.objs delete mode 100644 tizen/src/tethering/genmsg/tethering.pb-c.c delete mode 100644 tizen/src/tethering/genmsg/tethering.pb-c.h diff --git a/tizen/src/Makefile.objs b/tizen/src/Makefile.objs index 508e120e7e..c3127b7e92 100644 --- a/tizen/src/Makefile.objs +++ b/tizen/src/Makefile.objs @@ -15,7 +15,7 @@ obj-y += display/ obj-y += ecs/ # tethering -obj-y += tethering/ +obj-y += eventcast/ # maru skin obj-y += skin/ diff --git a/tizen/src/display/maru_sdl.c b/tizen/src/display/maru_sdl.c index e0c177e0da..ac4ab296dd 100644 --- a/tizen/src/display/maru_sdl.c +++ b/tizen/src/display/maru_sdl.c @@ -39,7 +39,7 @@ #include "hw/pci/maru_brightness.h" #include "debug_ch.h" -#include "tethering/encode_fb.h" +#include "eventcast/encode_fb.h" #include #ifndef CONFIG_WIN32 diff --git a/tizen/src/display/maru_shm.c b/tizen/src/display/maru_shm.c index e2c00bae60..d7e1782297 100644 --- a/tizen/src/display/maru_shm.c +++ b/tizen/src/display/maru_shm.c @@ -41,7 +41,7 @@ #include "util/maru_err_table.h" #include "debug_ch.h" -#include "tethering/encode_fb.h" +#include "eventcast/encode_fb.h" MULTI_DEBUG_CHANNEL(tizen, maru_shm); diff --git a/tizen/src/ecs/Makefile.objs b/tizen/src/ecs/Makefile.objs index 6f68dfbc1c..658659cc62 100644 --- a/tizen/src/ecs/Makefile.objs +++ b/tizen/src/ecs/Makefile.objs @@ -1,4 +1,4 @@ obj-y += genmsg/ecs.pb-c.o genmsg/ecs_ids.pb-c.o ../../distrib/protobuf/protobuf-c.o obj-y += ecs_msg.o ecs.o ecs_sensor.o obj-y += ecs_mon.o ecs-json-streamer.o -obj-y += ecs_tethering.o +obj-y += ecs_eventcast.o diff --git a/tizen/src/ecs/ecs.c b/tizen/src/ecs/ecs.c index 11824323c1..85cf5b4761 100644 --- a/tizen/src/ecs/ecs.c +++ b/tizen/src/ecs/ecs.c @@ -845,12 +845,12 @@ bool handle_protobuf_msg(ECS_Client* cli, char* data, int len) goto fail; msgproc_keepalive_ans(cli, msg); } - else if (master->type == ECS__MASTER__TYPE__TETHERING_REQ) + else if (master->type == ECS__MASTER__TYPE__EVENTCAST_REQ) { - ECS__TetheringReq* msg = master->tethering_req; + ECS__EventCastReq* msg = master->eventcast_req; if (!msg) goto fail; - msgproc_tethering_req(cli, msg); + msgproc_eventcast_req(cli, msg); } ecs__master__free_unpacked(master, NULL); diff --git a/tizen/src/ecs/ecs.h b/tizen/src/ecs/ecs.h index abd4fd4275..46fbffd9a1 100644 --- a/tizen/src/ecs/ecs.h +++ b/tizen/src/ecs/ecs.h @@ -202,7 +202,7 @@ bool msgproc_device_req(ECS_Client* ccli, ECS__DeviceReq* msg); bool msgproc_nfc_req(ECS_Client* ccli, ECS__NfcReq* msg); void msgproc_checkversion_req(ECS_Client* ccli, ECS__CheckVersionReq* msg); void msgproc_keepalive_ans(ECS_Client* ccli, ECS__KeepAliveAns* msg); -bool msgproc_tethering_req(ECS_Client* ccli, ECS__TetheringReq* msg); +bool msgproc_eventcast_req(ECS_Client* ccli, ECS__EventCastReq* msg); char *get_tizen_sdk_data_path(void); diff --git a/tizen/src/ecs/ecs_tethering.c b/tizen/src/ecs/ecs_eventcast.c similarity index 62% rename from tizen/src/ecs/ecs_tethering.c rename to tizen/src/ecs/ecs_eventcast.c index cff88433db..385a5f5222 100644 --- a/tizen/src/ecs/ecs_tethering.c +++ b/tizen/src/ecs/ecs_eventcast.c @@ -30,16 +30,16 @@ #include "ui/console.h" #include "ecs.h" -#include "ecs_tethering.h" -#include "tethering/common.h" -#include "tethering/sensor.h" -#include "tethering/touch.h" +#include "ecs_eventcast.h" +#include "eventcast/common.h" +#include "eventcast/sensor.h" +#include "eventcast/touch.h" #include "hw/virtio/maru_virtio_touchscreen.h" #include "hw/virtio/maru_virtio_hwkey.h" #include "util/new_debug_ch.h" -DECLARE_DEBUG_CHANNEL(ecs_tethering); +DECLARE_DEBUG_CHANNEL(ecs_eventcast); #define MSG_BUF_SIZE 255 #define MSG_LEN_SIZE 4 @@ -47,37 +47,37 @@ DECLARE_DEBUG_CHANNEL(ecs_tethering); #define PRESSED 1 #define RELEASED 2 -static bool send_tethering_ntf(const char *data); -static void send_tethering_status_ntf(type_group group, type_action action); +static bool send_eventcast_ntf(const char *data); +static void send_eventcast_status_ntf(type_group group, type_action action); -static int tethering_port = 0; +static int eventcast_port = 0; -void send_tethering_sensor_status_ecp(void) +void send_eventcast_sensor_status_ecp(void) { - LOG_INFO(">> send tethering_event_status to ecp\n"); - send_tethering_status_ntf(ECS_TETHERING_MSG_GROUP_ECP, - ECS_TETHERING_MSG_ACTION_SENSOR_STATUS); + LOG_INFO(">> send eventcast_event_status to ecp\n"); + send_eventcast_status_ntf(ECS_EVENTCAST_MSG_GROUP_ECP, + ECS_EVENTCAST_MSG_ACTION_SENSOR_STATUS); } -void send_tethering_touch_status_ecp(void) +void send_eventcast_touch_status_ecp(void) { - send_tethering_status_ntf(ECS_TETHERING_MSG_GROUP_ECP, - ECS_TETHERING_MSG_ACTION_TOUCH_STATUS); + send_eventcast_status_ntf(ECS_EVENTCAST_MSG_GROUP_ECP, + ECS_EVENTCAST_MSG_ACTION_TOUCH_STATUS); } -void send_tethering_connection_status_ecp(void) +void send_eventcast_connection_status_ecp(void) { - LOG_INFO(">> send tethering_connection_status to ecp\n"); - send_tethering_status_ntf(ECS_TETHERING_MSG_GROUP_ECP, - ECS_TETHERING_MSG_ACTION_CONNECTION_STATUS); + LOG_INFO(">> send eventcast_connection_status to ecp\n"); + send_eventcast_status_ntf(ECS_EVENTCAST_MSG_GROUP_ECP, + ECS_EVENTCAST_MSG_ACTION_CONNECTION_STATUS); } #if 0 -static void send_tethering_port_ecp(void) +static void send_eventcast_port_ecp(void) { type_length length; - type_group group = ECS_TETHERING_MSG_GROUP_ECP; - type_action action = ECS_TETHERING_MSG_ACTION_CONNECT; + type_group group = ECS_EVENTCAST_MSG_GROUP_ECP; + type_action action = ECS_EVENTCAST_MSG_ACTION_CONNECT; uint8_t *msg = NULL; gchar data[12]; @@ -86,20 +86,20 @@ static void send_tethering_port_ecp(void) return; } - LOG_INFO(">> send port_num: %d\n", tethering_port); - g_snprintf(data, sizeof(data) - 1, "%d", tethering_port); + LOG_TRACE(">> send port_num: %d\n", eventcast_port); + g_snprintf(data, sizeof(data) - 1, "%d", eventcast_port); length = strlen(data); - memcpy(msg, ECS_TETHERING_MSG_CATEGORY, 10); + memcpy(msg, ECS_EVENTCAST_MSG_CATEGORY, 10); memcpy(msg + 10, &length, sizeof(unsigned short)); memcpy(msg + 12, &group, sizeof(unsigned char)); memcpy(msg + 13, &action, sizeof(unsigned char)); memcpy(msg + 14, data, length); - LOG_INFO(">> send tethering_ntf to ecp. action=%d, group=%d, data=%s\n", + LOG_TRACE(">> send eventcast_ntf to ecp. action=%d, group=%d, data=%s\n", action, group, data); - send_tethering_ntf((const char *)msg); + send_eventcast_ntf((const char *)msg); if (msg) { g_free(msg); @@ -107,11 +107,11 @@ static void send_tethering_port_ecp(void) } #endif -static void send_tethering_connection_info(void) +static void send_eventcast_connection_info(void) { type_length length; - type_group group = ECS_TETHERING_MSG_GROUP_ECP; - type_action action = ECS_TETHERING_MSG_ACTION_CONNECT; + type_group group = ECS_EVENTCAST_MSG_GROUP_ECP; + type_action action = ECS_EVENTCAST_MSG_ACTION_CONNECT; uint8_t *msg = NULL; gchar data[64]; @@ -121,10 +121,10 @@ static void send_tethering_connection_info(void) return; } - LOG_INFO(">> send port_num: %d\n", tethering_port); + LOG_INFO(">> send port_num: %d\n", eventcast_port); { - const char *ip = get_tethering_connected_ipaddr(); - int port = get_tethering_connected_port(); + const char *ip = get_eventcast_connected_ipaddr(); + int port = get_eventcast_connected_port(); if (!ip) { LOG_SEVERE("invalid connected ip\n"); @@ -140,7 +140,7 @@ static void send_tethering_connection_info(void) data[length] = '\0'; } - memcpy(msg, ECS_TETHERING_MSG_CATEGORY, 10); + memcpy(msg, ECS_EVENTCAST_MSG_CATEGORY, 10); memcpy(msg + 10, &length, sizeof(unsigned short)); memcpy(msg + 12, &group, sizeof(unsigned char)); memcpy(msg + 13, &action, sizeof(unsigned char)); @@ -150,12 +150,12 @@ static void send_tethering_connection_info(void) "action=%d, group=%d, data=%s length=%d\n", action, group, data, length); - send_tethering_ntf((const char *)msg); + send_eventcast_ntf((const char *)msg); g_free(msg); } -static void send_tethering_status_ntf(type_group group, type_action action) +static void send_eventcast_status_ntf(type_group group, type_action action) { type_length length = 1; int status = 0; @@ -163,17 +163,17 @@ static void send_tethering_status_ntf(type_group group, type_action action) gchar data[2]; switch (action) { - case ECS_TETHERING_MSG_ACTION_CONNECTION_STATUS: - status = get_tethering_connection_status(); + case ECS_EVENTCAST_MSG_ACTION_CONNECTION_STATUS: + status = get_eventcast_connection_status(); if (status == CONNECTED) { - send_tethering_connection_info(); + send_eventcast_connection_info(); } break; - case ECS_TETHERING_MSG_ACTION_SENSOR_STATUS: - status = get_tethering_sensor_status(); + case ECS_EVENTCAST_MSG_ACTION_SENSOR_STATUS: + status = get_eventcast_sensor_status(); break; - case ECS_TETHERING_MSG_ACTION_TOUCH_STATUS: - status = get_tethering_touch_status(); + case ECS_EVENTCAST_MSG_ACTION_TOUCH_STATUS: + status = get_eventcast_touch_status(); break; default: break; @@ -186,23 +186,23 @@ static void send_tethering_status_ntf(type_group group, type_action action) g_snprintf(data, sizeof(data), "%d", status); - memcpy(msg, ECS_TETHERING_MSG_CATEGORY, 10); + memcpy(msg, ECS_EVENTCAST_MSG_CATEGORY, 10); memcpy(msg + 10, &length, sizeof(unsigned short)); memcpy(msg + 12, &group, sizeof(unsigned char)); memcpy(msg + 13, &action, sizeof(unsigned char)); memcpy(msg + 14, data, 1); - LOG_INFO(">> send tethering_ntf to ecp. action=%d, group=%d, data=%s\n", + LOG_TRACE(">> send eventcast_ntf to ecp. action=%d, group=%d, data=%s\n", action, group, data); - send_tethering_ntf((const char *)msg); + send_eventcast_ntf((const char *)msg); if (msg) { g_free(msg); } } -static bool send_tethering_ntf(const char *data) +static bool send_eventcast_ntf(const char *data) { type_length length = 0; type_group group = 0; @@ -219,10 +219,10 @@ static bool send_tethering_ntf(const char *data) const char* ijdata = (data + catsize + 2 + 1 + 1); - LOG_INFO(">> header cat = %s, length = %d, action=%d, group=%d\n", cat, length,action, group); + LOG_TRACE(">> header cat = %s, length = %d, action=%d, group=%d\n", cat, length,action, group); ECS__Master master = ECS__MASTER__INIT; - ECS__TetheringNtf ntf = ECS__TETHERING_NTF__INIT; + ECS__EventCastNtf ntf = ECS__EVENT_CAST_NTF__INIT; ntf.category = (char*) g_malloc(catsize + 1); strncpy(ntf.category, cat, 10); @@ -238,11 +238,11 @@ static bool send_tethering_ntf(const char *data) ntf.data.len = length; memcpy(ntf.data.data, ijdata, length); - LOG_INFO("data = %s, length = %hu\n", ijdata, length); + LOG_TRACE("data = %s, length = %hu\n", ijdata, length); } - master.type = ECS__MASTER__TYPE__TETHERING_NTF; - master.tethering_ntf = &ntf; + master.type = ECS__MASTER__TYPE__EVENTCAST_NTF; + master.eventcast_ntf = &ntf; send_to_ecp(&master); @@ -257,24 +257,24 @@ static bool send_tethering_ntf(const char *data) return true; } -void send_tethering_sensor_data(const char *data, int len) +void send_eventcast_sensor_data(const char *data, int len) { set_injector_data(data); } -void send_tethering_touch_data(int x, int y, int index, int status) +void send_eventcast_touch_data(int x, int y, int index, int status) { virtio_touchscreen_event(x, y, index, status); } -void send_tethering_hwkey_data(int keycode) +void send_eventcast_hwkey_data(int keycode) { maru_hwkey_event(PRESSED, keycode); maru_hwkey_event(RELEASED, keycode); } -// handle tethering_req message -bool msgproc_tethering_req(ECS_Client* ccli, ECS__TetheringReq* msg) +// handle eventcast_req message +bool msgproc_eventcast_req(ECS_Client* ccli, ECS__EventCastReq* msg) { gchar cmd[10] = {0}; gchar **server_addr = NULL; @@ -286,11 +286,11 @@ bool msgproc_tethering_req(ECS_Client* ccli, ECS__TetheringReq* msg) type_group group = (type_group) (msg->group & 0xff); type_action action = (type_action) (msg->action & 0xff); - LOG_INFO("<< header = cmd = %s, length = %d, action = %d, group = %d\n", + LOG_TRACE("<< header = cmd = %s, length = %d, action=%d, group=%d\n", cmd, length, action, group); switch(action) { - case ECS_TETHERING_MSG_ACTION_CONNECT: + case ECS_EVENTCAST_MSG_ACTION_CONNECT: LOG_INFO("MSG_ACTION_CONNECT\n"); if (msg->data.data && msg->data.len > 0) { @@ -315,28 +315,28 @@ bool msgproc_tethering_req(ECS_Client* ccli, ECS__TetheringReq* msg) } else { LOG_SEVERE("failed to parse port number\n"); } - LOG_INFO("len = %zd, data\" %s\"", strlen(data), data); + LOG_TRACE("len = %zd, data\" %s\"", strlen(data), data); - connect_tethering_app(ip_address, port); - tethering_port = port; + connect_eventcast_app(ip_address, port); + eventcast_port = port; - LOG_INFO(">> port_num: %d, %d\n", port, tethering_port); + LOG_TRACE(">> port_num: %d, %d\n", port, eventcast_port); g_free(ip_address); g_strfreev(server_addr); } else { LOG_INFO("ip address and port value are null\n"); } break; - case ECS_TETHERING_MSG_ACTION_DISCONNECT: + case ECS_EVENTCAST_MSG_ACTION_DISCONNECT: LOG_INFO(">> MSG_ACTION_DISCONNECT\n"); - disconnect_tethering_app(); - tethering_port = 0; + disconnect_eventcast_app(); + eventcast_port = 0; break; - case ECS_TETHERING_MSG_ACTION_CONNECTION_STATUS: - case ECS_TETHERING_MSG_ACTION_SENSOR_STATUS: - case ECS_TETHERING_MSG_ACTION_TOUCH_STATUS: - LOG_INFO(">> get_status_action\n"); - send_tethering_status_ntf(group, action); + case ECS_EVENTCAST_MSG_ACTION_CONNECTION_STATUS: + case ECS_EVENTCAST_MSG_ACTION_SENSOR_STATUS: + case ECS_EVENTCAST_MSG_ACTION_TOUCH_STATUS: + LOG_TRACE(">> get_status_action\n"); + send_eventcast_status_ntf(group, action); break; default: break; diff --git a/tizen/src/ecs/ecs_tethering.h b/tizen/src/ecs/ecs_eventcast.h similarity index 60% rename from tizen/src/ecs/ecs_tethering.h rename to tizen/src/ecs/ecs_eventcast.h index 3d1b3afc98..a94f3f35cc 100644 --- a/tizen/src/ecs/ecs_tethering.h +++ b/tizen/src/ecs/ecs_eventcast.h @@ -29,27 +29,27 @@ */ /* - * define tethering messages between ecs and ecp + * define eventcast messages between ecs and ecp */ -#define ECS_TETHERING_MSG_CATEGORY "tethering" -#define ECS_TETHERING_MSG_GROUP_ECP 1 - -enum ECS_TETHERING_MSG_ACTION { - ECS_TETHERING_MSG_ACTION_CONNECT = 1, - ECS_TETHERING_MSG_ACTION_DISCONNECT, - ECS_TETHERING_MSG_ACTION_CONNECTION_STATUS, - ECS_TETHERING_MSG_ACTION_SENSOR_STATUS, - ECS_TETHERING_MSG_ACTION_TOUCH_STATUS, +#define ECS_EVENTCAST_MSG_CATEGORY "eventcast" +#define ECS_EVENTCAST_MSG_GROUP_ECP 1 + +enum ECS_EVENTCAST_MSG_ACTION { + ECS_EVENTCAST_MSG_ACTION_CONNECT = 1, + ECS_EVENTCAST_MSG_ACTION_DISCONNECT, + ECS_EVENTCAST_MSG_ACTION_CONNECTION_STATUS, + ECS_EVENTCAST_MSG_ACTION_SENSOR_STATUS, + ECS_EVENTCAST_MSG_ACTION_TOUCH_STATUS, }; -void send_tethering_sensor_status_ecp(void); +void send_eventcast_sensor_status_ecp(void); -void send_tethering_touch_status_ecp(void); +void send_eventcast_touch_status_ecp(void); -void send_tethering_connection_status_ecp(void); +void send_eventcast_connection_status_ecp(void); -void send_tethering_sensor_data(const char *data, int len); +void send_eventcast_sensor_data(const char *data, int len); -void send_tethering_touch_data(int x, int y, int index, int status); +void send_eventcast_touch_data(int x, int y, int index, int status); -void send_tethering_hwkey_data(int keycode); \ No newline at end of file +void send_eventcast_hwkey_data(int keycode); diff --git a/tizen/src/ecs/genmsg/ecs.pb-c.c b/tizen/src/ecs/genmsg/ecs.pb-c.c index 0871aecc43..a91167e4c1 100644 --- a/tizen/src/ecs/genmsg/ecs.pb-c.c +++ b/tizen/src/ecs/genmsg/ecs.pb-c.c @@ -651,133 +651,133 @@ void ecs__nfc_ntf__free_unpacked PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__nfc_ntf__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void ecs__tethering_req__init - (ECS__TetheringReq *message) +void ecs__event_cast_req__init + (ECS__EventCastReq *message) { - static ECS__TetheringReq init_value = ECS__TETHERING_REQ__INIT; + static ECS__EventCastReq init_value = ECS__EVENT_CAST_REQ__INIT; *message = init_value; } -size_t ecs__tethering_req__get_packed_size - (const ECS__TetheringReq *message) +size_t ecs__event_cast_req__get_packed_size + (const ECS__EventCastReq *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_req__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__event_cast_req__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t ecs__tethering_req__pack - (const ECS__TetheringReq *message, +size_t ecs__event_cast_req__pack + (const ECS__EventCastReq *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_req__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__event_cast_req__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t ecs__tethering_req__pack_to_buffer - (const ECS__TetheringReq *message, +size_t ecs__event_cast_req__pack_to_buffer + (const ECS__EventCastReq *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_req__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__event_cast_req__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -ECS__TetheringReq * - ecs__tethering_req__unpack +ECS__EventCastReq * + ecs__event_cast_req__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (ECS__TetheringReq *) - protobuf_c_message_unpack (&ecs__tethering_req__descriptor, + return (ECS__EventCastReq *) + protobuf_c_message_unpack (&ecs__event_cast_req__descriptor, allocator, len, data); } -void ecs__tethering_req__free_unpacked - (ECS__TetheringReq *message, +void ecs__event_cast_req__free_unpacked + (ECS__EventCastReq *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_req__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__event_cast_req__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void ecs__tethering_ans__init - (ECS__TetheringAns *message) +void ecs__event_cast_ans__init + (ECS__EventCastAns *message) { - static ECS__TetheringAns init_value = ECS__TETHERING_ANS__INIT; + static ECS__EventCastAns init_value = ECS__EVENT_CAST_ANS__INIT; *message = init_value; } -size_t ecs__tethering_ans__get_packed_size - (const ECS__TetheringAns *message) +size_t ecs__event_cast_ans__get_packed_size + (const ECS__EventCastAns *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_ans__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__event_cast_ans__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t ecs__tethering_ans__pack - (const ECS__TetheringAns *message, +size_t ecs__event_cast_ans__pack + (const ECS__EventCastAns *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_ans__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__event_cast_ans__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t ecs__tethering_ans__pack_to_buffer - (const ECS__TetheringAns *message, +size_t ecs__event_cast_ans__pack_to_buffer + (const ECS__EventCastAns *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_ans__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__event_cast_ans__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -ECS__TetheringAns * - ecs__tethering_ans__unpack +ECS__EventCastAns * + ecs__event_cast_ans__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (ECS__TetheringAns *) - protobuf_c_message_unpack (&ecs__tethering_ans__descriptor, + return (ECS__EventCastAns *) + protobuf_c_message_unpack (&ecs__event_cast_ans__descriptor, allocator, len, data); } -void ecs__tethering_ans__free_unpacked - (ECS__TetheringAns *message, +void ecs__event_cast_ans__free_unpacked + (ECS__EventCastAns *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_ans__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__event_cast_ans__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void ecs__tethering_ntf__init - (ECS__TetheringNtf *message) +void ecs__event_cast_ntf__init + (ECS__EventCastNtf *message) { - static ECS__TetheringNtf init_value = ECS__TETHERING_NTF__INIT; + static ECS__EventCastNtf init_value = ECS__EVENT_CAST_NTF__INIT; *message = init_value; } -size_t ecs__tethering_ntf__get_packed_size - (const ECS__TetheringNtf *message) +size_t ecs__event_cast_ntf__get_packed_size + (const ECS__EventCastNtf *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_ntf__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__event_cast_ntf__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t ecs__tethering_ntf__pack - (const ECS__TetheringNtf *message, +size_t ecs__event_cast_ntf__pack + (const ECS__EventCastNtf *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_ntf__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__event_cast_ntf__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t ecs__tethering_ntf__pack_to_buffer - (const ECS__TetheringNtf *message, +size_t ecs__event_cast_ntf__pack_to_buffer + (const ECS__EventCastNtf *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_ntf__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__event_cast_ntf__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -ECS__TetheringNtf * - ecs__tethering_ntf__unpack +ECS__EventCastNtf * + ecs__event_cast_ntf__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (ECS__TetheringNtf *) - protobuf_c_message_unpack (&ecs__tethering_ntf__descriptor, + return (ECS__EventCastNtf *) + protobuf_c_message_unpack (&ecs__event_cast_ntf__descriptor, allocator, len, data); } -void ecs__tethering_ntf__free_unpacked - (ECS__TetheringNtf *message, +void ecs__event_cast_ntf__free_unpacked + (ECS__EventCastNtf *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_ntf__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__event_cast_ntf__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } void ecs__master__init @@ -1796,7 +1796,7 @@ const ProtobufCMessageDescriptor ecs__nfc_ntf__descriptor = (ProtobufCMessageInit) ecs__nfc_ntf__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor ecs__tethering_req__field_descriptors[5] = +static const ProtobufCFieldDescriptor ecs__event_cast_req__field_descriptors[5] = { { "category", @@ -1804,7 +1804,7 @@ static const ProtobufCFieldDescriptor ecs__tethering_req__field_descriptors[5] = PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(ECS__TetheringReq, category), + PROTOBUF_C_OFFSETOF(ECS__EventCastReq, category), NULL, NULL, 0, /* packed */ @@ -1816,7 +1816,7 @@ static const ProtobufCFieldDescriptor ecs__tethering_req__field_descriptors[5] = PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(ECS__TetheringReq, length), + PROTOBUF_C_OFFSETOF(ECS__EventCastReq, length), NULL, NULL, 0, /* packed */ @@ -1828,7 +1828,7 @@ static const ProtobufCFieldDescriptor ecs__tethering_req__field_descriptors[5] = PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(ECS__TetheringReq, group), + PROTOBUF_C_OFFSETOF(ECS__EventCastReq, group), NULL, NULL, 0, /* packed */ @@ -1840,7 +1840,7 @@ static const ProtobufCFieldDescriptor ecs__tethering_req__field_descriptors[5] = PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(ECS__TetheringReq, action), + PROTOBUF_C_OFFSETOF(ECS__EventCastReq, action), NULL, NULL, 0, /* packed */ @@ -1851,42 +1851,42 @@ static const ProtobufCFieldDescriptor ecs__tethering_req__field_descriptors[5] = 5, PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_BYTES, - PROTOBUF_C_OFFSETOF(ECS__TetheringReq, has_data), - PROTOBUF_C_OFFSETOF(ECS__TetheringReq, data), + PROTOBUF_C_OFFSETOF(ECS__EventCastReq, has_data), + PROTOBUF_C_OFFSETOF(ECS__EventCastReq, data), NULL, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned ecs__tethering_req__field_indices_by_name[] = { +static const unsigned ecs__event_cast_req__field_indices_by_name[] = { 3, /* field[3] = action */ 0, /* field[0] = category */ 4, /* field[4] = data */ 2, /* field[2] = group */ 1, /* field[1] = length */ }; -static const ProtobufCIntRange ecs__tethering_req__number_ranges[1 + 1] = +static const ProtobufCIntRange ecs__event_cast_req__number_ranges[1 + 1] = { { 1, 0 }, { 0, 5 } }; -const ProtobufCMessageDescriptor ecs__tethering_req__descriptor = +const ProtobufCMessageDescriptor ecs__event_cast_req__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "ECS.TetheringReq", - "TetheringReq", - "ECS__TetheringReq", + "ECS.EventCastReq", + "EventCastReq", + "ECS__EventCastReq", "ECS", - sizeof(ECS__TetheringReq), + sizeof(ECS__EventCastReq), 5, - ecs__tethering_req__field_descriptors, - ecs__tethering_req__field_indices_by_name, - 1, ecs__tethering_req__number_ranges, - (ProtobufCMessageInit) ecs__tethering_req__init, + ecs__event_cast_req__field_descriptors, + ecs__event_cast_req__field_indices_by_name, + 1, ecs__event_cast_req__number_ranges, + (ProtobufCMessageInit) ecs__event_cast_req__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor ecs__tethering_ans__field_descriptors[7] = +static const ProtobufCFieldDescriptor ecs__event_cast_ans__field_descriptors[7] = { { "errcode", @@ -1894,7 +1894,7 @@ static const ProtobufCFieldDescriptor ecs__tethering_ans__field_descriptors[7] = PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(ECS__TetheringAns, errcode), + PROTOBUF_C_OFFSETOF(ECS__EventCastAns, errcode), NULL, NULL, 0, /* packed */ @@ -1906,7 +1906,7 @@ static const ProtobufCFieldDescriptor ecs__tethering_ans__field_descriptors[7] = PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(ECS__TetheringAns, errstr), + PROTOBUF_C_OFFSETOF(ECS__EventCastAns, errstr), NULL, NULL, 0, /* packed */ @@ -1918,7 +1918,7 @@ static const ProtobufCFieldDescriptor ecs__tethering_ans__field_descriptors[7] = PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(ECS__TetheringAns, category), + PROTOBUF_C_OFFSETOF(ECS__EventCastAns, category), NULL, NULL, 0, /* packed */ @@ -1930,7 +1930,7 @@ static const ProtobufCFieldDescriptor ecs__tethering_ans__field_descriptors[7] = PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(ECS__TetheringAns, length), + PROTOBUF_C_OFFSETOF(ECS__EventCastAns, length), NULL, NULL, 0, /* packed */ @@ -1942,7 +1942,7 @@ static const ProtobufCFieldDescriptor ecs__tethering_ans__field_descriptors[7] = PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(ECS__TetheringAns, group), + PROTOBUF_C_OFFSETOF(ECS__EventCastAns, group), NULL, NULL, 0, /* packed */ @@ -1954,7 +1954,7 @@ static const ProtobufCFieldDescriptor ecs__tethering_ans__field_descriptors[7] = PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(ECS__TetheringAns, action), + PROTOBUF_C_OFFSETOF(ECS__EventCastAns, action), NULL, NULL, 0, /* packed */ @@ -1965,15 +1965,15 @@ static const ProtobufCFieldDescriptor ecs__tethering_ans__field_descriptors[7] = 7, PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_BYTES, - PROTOBUF_C_OFFSETOF(ECS__TetheringAns, has_data), - PROTOBUF_C_OFFSETOF(ECS__TetheringAns, data), + PROTOBUF_C_OFFSETOF(ECS__EventCastAns, has_data), + PROTOBUF_C_OFFSETOF(ECS__EventCastAns, data), NULL, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned ecs__tethering_ans__field_indices_by_name[] = { +static const unsigned ecs__event_cast_ans__field_indices_by_name[] = { 5, /* field[5] = action */ 2, /* field[2] = category */ 6, /* field[6] = data */ @@ -1982,27 +1982,27 @@ static const unsigned ecs__tethering_ans__field_indices_by_name[] = { 4, /* field[4] = group */ 3, /* field[3] = length */ }; -static const ProtobufCIntRange ecs__tethering_ans__number_ranges[1 + 1] = +static const ProtobufCIntRange ecs__event_cast_ans__number_ranges[1 + 1] = { { 1, 0 }, { 0, 7 } }; -const ProtobufCMessageDescriptor ecs__tethering_ans__descriptor = +const ProtobufCMessageDescriptor ecs__event_cast_ans__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "ECS.TetheringAns", - "TetheringAns", - "ECS__TetheringAns", + "ECS.EventCastAns", + "EventCastAns", + "ECS__EventCastAns", "ECS", - sizeof(ECS__TetheringAns), + sizeof(ECS__EventCastAns), 7, - ecs__tethering_ans__field_descriptors, - ecs__tethering_ans__field_indices_by_name, - 1, ecs__tethering_ans__number_ranges, - (ProtobufCMessageInit) ecs__tethering_ans__init, + ecs__event_cast_ans__field_descriptors, + ecs__event_cast_ans__field_indices_by_name, + 1, ecs__event_cast_ans__number_ranges, + (ProtobufCMessageInit) ecs__event_cast_ans__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor ecs__tethering_ntf__field_descriptors[5] = +static const ProtobufCFieldDescriptor ecs__event_cast_ntf__field_descriptors[5] = { { "category", @@ -2010,7 +2010,7 @@ static const ProtobufCFieldDescriptor ecs__tethering_ntf__field_descriptors[5] = PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(ECS__TetheringNtf, category), + PROTOBUF_C_OFFSETOF(ECS__EventCastNtf, category), NULL, NULL, 0, /* packed */ @@ -2022,7 +2022,7 @@ static const ProtobufCFieldDescriptor ecs__tethering_ntf__field_descriptors[5] = PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(ECS__TetheringNtf, length), + PROTOBUF_C_OFFSETOF(ECS__EventCastNtf, length), NULL, NULL, 0, /* packed */ @@ -2034,7 +2034,7 @@ static const ProtobufCFieldDescriptor ecs__tethering_ntf__field_descriptors[5] = PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(ECS__TetheringNtf, group), + PROTOBUF_C_OFFSETOF(ECS__EventCastNtf, group), NULL, NULL, 0, /* packed */ @@ -2046,7 +2046,7 @@ static const ProtobufCFieldDescriptor ecs__tethering_ntf__field_descriptors[5] = PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(ECS__TetheringNtf, action), + PROTOBUF_C_OFFSETOF(ECS__EventCastNtf, action), NULL, NULL, 0, /* packed */ @@ -2057,39 +2057,39 @@ static const ProtobufCFieldDescriptor ecs__tethering_ntf__field_descriptors[5] = 5, PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_BYTES, - PROTOBUF_C_OFFSETOF(ECS__TetheringNtf, has_data), - PROTOBUF_C_OFFSETOF(ECS__TetheringNtf, data), + PROTOBUF_C_OFFSETOF(ECS__EventCastNtf, has_data), + PROTOBUF_C_OFFSETOF(ECS__EventCastNtf, data), NULL, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned ecs__tethering_ntf__field_indices_by_name[] = { +static const unsigned ecs__event_cast_ntf__field_indices_by_name[] = { 3, /* field[3] = action */ 0, /* field[0] = category */ 4, /* field[4] = data */ 2, /* field[2] = group */ 1, /* field[1] = length */ }; -static const ProtobufCIntRange ecs__tethering_ntf__number_ranges[1 + 1] = +static const ProtobufCIntRange ecs__event_cast_ntf__number_ranges[1 + 1] = { { 1, 0 }, { 0, 5 } }; -const ProtobufCMessageDescriptor ecs__tethering_ntf__descriptor = +const ProtobufCMessageDescriptor ecs__event_cast_ntf__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "ECS.TetheringNtf", - "TetheringNtf", - "ECS__TetheringNtf", + "ECS.EventCastNtf", + "EventCastNtf", + "ECS__EventCastNtf", "ECS", - sizeof(ECS__TetheringNtf), + sizeof(ECS__EventCastNtf), 5, - ecs__tethering_ntf__field_descriptors, - ecs__tethering_ntf__field_indices_by_name, - 1, ecs__tethering_ntf__number_ranges, - (ProtobufCMessageInit) ecs__tethering_ntf__init, + ecs__event_cast_ntf__field_descriptors, + ecs__event_cast_ntf__field_indices_by_name, + 1, ecs__event_cast_ntf__number_ranges, + (ProtobufCMessageInit) ecs__event_cast_ntf__init, NULL,NULL,NULL /* reserved[123] */ }; static const ProtobufCFieldDescriptor ecs__master__field_descriptors[19] = @@ -2287,37 +2287,37 @@ static const ProtobufCFieldDescriptor ecs__master__field_descriptors[19] = 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "tethering_req", + "eventcast_req", 103, PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(ECS__Master, tethering_req), - &ecs__tethering_req__descriptor, + PROTOBUF_C_OFFSETOF(ECS__Master, eventcast_req), + &ecs__event_cast_req__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "tethering_ans", + "eventcast_ans", 104, PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(ECS__Master, tethering_ans), - &ecs__tethering_ans__descriptor, + PROTOBUF_C_OFFSETOF(ECS__Master, eventcast_ans), + &ecs__event_cast_ans__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "tethering_ntf", + "eventcast_ntf", 105, PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(ECS__Master, tethering_ntf), - &ecs__tethering_ntf__descriptor, + PROTOBUF_C_OFFSETOF(ECS__Master, eventcast_ntf), + &ecs__event_cast_ntf__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -2329,6 +2329,9 @@ static const unsigned ecs__master__field_indices_by_name[] = { 9, /* field[9] = device_ans */ 10, /* field[10] = device_ntf */ 8, /* field[8] = device_req */ + 17, /* field[17] = eventcast_ans */ + 18, /* field[18] = eventcast_ntf */ + 16, /* field[16] = eventcast_req */ 6, /* field[6] = injector_ans */ 7, /* field[7] = injector_ntf */ 5, /* field[5] = injector_req */ @@ -2339,9 +2342,6 @@ static const unsigned ecs__master__field_indices_by_name[] = { 11, /* field[11] = monitor_req */ 15, /* field[15] = nfc_ntf */ 14, /* field[14] = nfc_req */ - 17, /* field[17] = tethering_ans */ - 18, /* field[18] = tethering_ntf */ - 16, /* field[16] = tethering_req */ 0, /* field[0] = type */ }; static const ProtobufCIntRange ecs__master__number_ranges[2 + 1] = diff --git a/tizen/src/ecs/genmsg/ecs.pb-c.h b/tizen/src/ecs/genmsg/ecs.pb-c.h index c81f5d3584..a809b64afc 100644 --- a/tizen/src/ecs/genmsg/ecs.pb-c.h +++ b/tizen/src/ecs/genmsg/ecs.pb-c.h @@ -3,7 +3,7 @@ #ifndef PROTOBUF_C_ecs_2eproto__INCLUDED #define PROTOBUF_C_ecs_2eproto__INCLUDED -#include "../../../distrib/protobuf/protobuf-c.h" +#include PROTOBUF_C_BEGIN_DECLS @@ -24,9 +24,9 @@ typedef struct _ECS__MonitorAns ECS__MonitorAns; typedef struct _ECS__MonitorNtf ECS__MonitorNtf; typedef struct _ECS__NfcReq ECS__NfcReq; typedef struct _ECS__NfcNtf ECS__NfcNtf; -typedef struct _ECS__TetheringReq ECS__TetheringReq; -typedef struct _ECS__TetheringAns ECS__TetheringAns; -typedef struct _ECS__TetheringNtf ECS__TetheringNtf; +typedef struct _ECS__EventCastReq ECS__EventCastReq; +typedef struct _ECS__EventCastAns ECS__EventCastAns; +typedef struct _ECS__EventCastNtf ECS__EventCastNtf; typedef struct _ECS__Master ECS__Master; @@ -225,7 +225,7 @@ struct _ECS__NfcNtf , NULL, 0,{0,NULL} } -struct _ECS__TetheringReq +struct _ECS__EventCastReq { ProtobufCMessage base; char *category; @@ -235,12 +235,12 @@ struct _ECS__TetheringReq protobuf_c_boolean has_data; ProtobufCBinaryData data; }; -#define ECS__TETHERING_REQ__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&ecs__tethering_req__descriptor) \ +#define ECS__EVENT_CAST_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&ecs__event_cast_req__descriptor) \ , NULL, 0, 0, 0, 0,{0,NULL} } -struct _ECS__TetheringAns +struct _ECS__EventCastAns { ProtobufCMessage base; int32_t errcode; @@ -252,12 +252,12 @@ struct _ECS__TetheringAns protobuf_c_boolean has_data; ProtobufCBinaryData data; }; -#define ECS__TETHERING_ANS__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&ecs__tethering_ans__descriptor) \ +#define ECS__EVENT_CAST_ANS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&ecs__event_cast_ans__descriptor) \ , 0, NULL, NULL, 0, 0, 0, 0,{0,NULL} } -struct _ECS__TetheringNtf +struct _ECS__EventCastNtf { ProtobufCMessage base; char *category; @@ -267,8 +267,8 @@ struct _ECS__TetheringNtf protobuf_c_boolean has_data; ProtobufCBinaryData data; }; -#define ECS__TETHERING_NTF__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&ecs__tethering_ntf__descriptor) \ +#define ECS__EVENT_CAST_NTF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&ecs__event_cast_ntf__descriptor) \ , NULL, 0, 0, 0, 0,{0,NULL} } @@ -291,9 +291,9 @@ struct _ECS__Master ECS__MonitorNtf *monitor_ntf; ECS__NfcReq *nfc_req; ECS__NfcNtf *nfc_ntf; - ECS__TetheringReq *tethering_req; - ECS__TetheringAns *tethering_ans; - ECS__TetheringNtf *tethering_ntf; + ECS__EventCastReq *eventcast_req; + ECS__EventCastAns *eventcast_ans; + ECS__EventCastNtf *eventcast_ntf; }; #define ECS__MASTER__INIT \ { PROTOBUF_C_MESSAGE_INIT (&ecs__master__descriptor) \ @@ -585,62 +585,62 @@ ECS__NfcNtf * void ecs__nfc_ntf__free_unpacked (ECS__NfcNtf *message, ProtobufCAllocator *allocator); -/* ECS__TetheringReq methods */ -void ecs__tethering_req__init - (ECS__TetheringReq *message); -size_t ecs__tethering_req__get_packed_size - (const ECS__TetheringReq *message); -size_t ecs__tethering_req__pack - (const ECS__TetheringReq *message, +/* ECS__EventCastReq methods */ +void ecs__event_cast_req__init + (ECS__EventCastReq *message); +size_t ecs__event_cast_req__get_packed_size + (const ECS__EventCastReq *message); +size_t ecs__event_cast_req__pack + (const ECS__EventCastReq *message, uint8_t *out); -size_t ecs__tethering_req__pack_to_buffer - (const ECS__TetheringReq *message, +size_t ecs__event_cast_req__pack_to_buffer + (const ECS__EventCastReq *message, ProtobufCBuffer *buffer); -ECS__TetheringReq * - ecs__tethering_req__unpack +ECS__EventCastReq * + ecs__event_cast_req__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void ecs__tethering_req__free_unpacked - (ECS__TetheringReq *message, +void ecs__event_cast_req__free_unpacked + (ECS__EventCastReq *message, ProtobufCAllocator *allocator); -/* ECS__TetheringAns methods */ -void ecs__tethering_ans__init - (ECS__TetheringAns *message); -size_t ecs__tethering_ans__get_packed_size - (const ECS__TetheringAns *message); -size_t ecs__tethering_ans__pack - (const ECS__TetheringAns *message, +/* ECS__EventCastAns methods */ +void ecs__event_cast_ans__init + (ECS__EventCastAns *message); +size_t ecs__event_cast_ans__get_packed_size + (const ECS__EventCastAns *message); +size_t ecs__event_cast_ans__pack + (const ECS__EventCastAns *message, uint8_t *out); -size_t ecs__tethering_ans__pack_to_buffer - (const ECS__TetheringAns *message, +size_t ecs__event_cast_ans__pack_to_buffer + (const ECS__EventCastAns *message, ProtobufCBuffer *buffer); -ECS__TetheringAns * - ecs__tethering_ans__unpack +ECS__EventCastAns * + ecs__event_cast_ans__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void ecs__tethering_ans__free_unpacked - (ECS__TetheringAns *message, +void ecs__event_cast_ans__free_unpacked + (ECS__EventCastAns *message, ProtobufCAllocator *allocator); -/* ECS__TetheringNtf methods */ -void ecs__tethering_ntf__init - (ECS__TetheringNtf *message); -size_t ecs__tethering_ntf__get_packed_size - (const ECS__TetheringNtf *message); -size_t ecs__tethering_ntf__pack - (const ECS__TetheringNtf *message, +/* ECS__EventCastNtf methods */ +void ecs__event_cast_ntf__init + (ECS__EventCastNtf *message); +size_t ecs__event_cast_ntf__get_packed_size + (const ECS__EventCastNtf *message); +size_t ecs__event_cast_ntf__pack + (const ECS__EventCastNtf *message, uint8_t *out); -size_t ecs__tethering_ntf__pack_to_buffer - (const ECS__TetheringNtf *message, +size_t ecs__event_cast_ntf__pack_to_buffer + (const ECS__EventCastNtf *message, ProtobufCBuffer *buffer); -ECS__TetheringNtf * - ecs__tethering_ntf__unpack +ECS__EventCastNtf * + ecs__event_cast_ntf__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void ecs__tethering_ntf__free_unpacked - (ECS__TetheringNtf *message, +void ecs__event_cast_ntf__free_unpacked + (ECS__EventCastNtf *message, ProtobufCAllocator *allocator); /* ECS__Master methods */ void ecs__master__init @@ -708,14 +708,14 @@ typedef void (*ECS__NfcReq_Closure) typedef void (*ECS__NfcNtf_Closure) (const ECS__NfcNtf *message, void *closure_data); -typedef void (*ECS__TetheringReq_Closure) - (const ECS__TetheringReq *message, +typedef void (*ECS__EventCastReq_Closure) + (const ECS__EventCastReq *message, void *closure_data); -typedef void (*ECS__TetheringAns_Closure) - (const ECS__TetheringAns *message, +typedef void (*ECS__EventCastAns_Closure) + (const ECS__EventCastAns *message, void *closure_data); -typedef void (*ECS__TetheringNtf_Closure) - (const ECS__TetheringNtf *message, +typedef void (*ECS__EventCastNtf_Closure) + (const ECS__EventCastNtf *message, void *closure_data); typedef void (*ECS__Master_Closure) (const ECS__Master *message, @@ -741,9 +741,9 @@ extern const ProtobufCMessageDescriptor ecs__monitor_ans__descriptor; extern const ProtobufCMessageDescriptor ecs__monitor_ntf__descriptor; extern const ProtobufCMessageDescriptor ecs__nfc_req__descriptor; extern const ProtobufCMessageDescriptor ecs__nfc_ntf__descriptor; -extern const ProtobufCMessageDescriptor ecs__tethering_req__descriptor; -extern const ProtobufCMessageDescriptor ecs__tethering_ans__descriptor; -extern const ProtobufCMessageDescriptor ecs__tethering_ntf__descriptor; +extern const ProtobufCMessageDescriptor ecs__event_cast_req__descriptor; +extern const ProtobufCMessageDescriptor ecs__event_cast_ans__descriptor; +extern const ProtobufCMessageDescriptor ecs__event_cast_ntf__descriptor; extern const ProtobufCMessageDescriptor ecs__master__descriptor; PROTOBUF_C_END_DECLS diff --git a/tizen/src/ecs/genmsg/ecs_ids.pb-c.c b/tizen/src/ecs/genmsg/ecs_ids.pb-c.c index 5f6451f794..97977afb23 100644 --- a/tizen/src/ecs/genmsg/ecs_ids.pb-c.c +++ b/tizen/src/ecs/genmsg/ecs_ids.pb-c.c @@ -23,9 +23,9 @@ const ProtobufCEnumValue ecs__master__type__enum_values_by_number[18] = { "MONITOR_NTF", "ECS__MASTER__TYPE__MONITOR_NTF", 14 }, { "NFC_REQ", "ECS__MASTER__TYPE__NFC_REQ", 101 }, { "NFC_NTF", "ECS__MASTER__TYPE__NFC_NTF", 102 }, - { "TETHERING_REQ", "ECS__MASTER__TYPE__TETHERING_REQ", 103 }, - { "TETHERING_ANS", "ECS__MASTER__TYPE__TETHERING_ANS", 104 }, - { "TETHERING_NTF", "ECS__MASTER__TYPE__TETHERING_NTF", 105 }, + { "EVENTCAST_REQ", "ECS__MASTER__TYPE__EVENTCAST_REQ", 103 }, + { "EVENTCAST_ANS", "ECS__MASTER__TYPE__EVENTCAST_ANS", 104 }, + { "EVENTCAST_NTF", "ECS__MASTER__TYPE__EVENTCAST_NTF", 105 }, }; static const ProtobufCIntRange ecs__master__type__value_ranges[] = { {2, 0},{101, 13},{0, 18} @@ -37,6 +37,9 @@ const ProtobufCEnumValueIndex ecs__master__type__enum_values_by_name[18] = { "DEVICE_ANS", 8 }, { "DEVICE_NTF", 9 }, { "DEVICE_REQ", 7 }, + { "EVENTCAST_ANS", 16 }, + { "EVENTCAST_NTF", 17 }, + { "EVENTCAST_REQ", 15 }, { "INJECTOR_ANS", 5 }, { "INJECTOR_NTF", 6 }, { "INJECTOR_REQ", 4 }, @@ -47,9 +50,6 @@ const ProtobufCEnumValueIndex ecs__master__type__enum_values_by_name[18] = { "MONITOR_REQ", 10 }, { "NFC_NTF", 14 }, { "NFC_REQ", 13 }, - { "TETHERING_ANS", 16 }, - { "TETHERING_NTF", 17 }, - { "TETHERING_REQ", 15 }, }; const ProtobufCEnumDescriptor ecs__master__type__descriptor = { diff --git a/tizen/src/ecs/genmsg/ecs_ids.pb-c.h b/tizen/src/ecs/genmsg/ecs_ids.pb-c.h index 5a11824060..59c0dec10c 100644 --- a/tizen/src/ecs/genmsg/ecs_ids.pb-c.h +++ b/tizen/src/ecs/genmsg/ecs_ids.pb-c.h @@ -3,7 +3,7 @@ #ifndef PROTOBUF_C_ecs_5fids_2eproto__INCLUDED #define PROTOBUF_C_ecs_5fids_2eproto__INCLUDED -#include "../../../distrib/protobuf/protobuf-c.h" +#include PROTOBUF_C_BEGIN_DECLS @@ -28,9 +28,9 @@ typedef enum _ECS__MasterType { ECS__MASTER__TYPE__MONITOR_NTF = 14, ECS__MASTER__TYPE__NFC_REQ = 101, ECS__MASTER__TYPE__NFC_NTF = 102, - ECS__MASTER__TYPE__TETHERING_REQ = 103, - ECS__MASTER__TYPE__TETHERING_ANS = 104, - ECS__MASTER__TYPE__TETHERING_NTF = 105 + ECS__MASTER__TYPE__EVENTCAST_REQ = 103, + ECS__MASTER__TYPE__EVENTCAST_ANS = 104, + ECS__MASTER__TYPE__EVENTCAST_NTF = 105 } ECS__MasterType; /* --- messages --- */ diff --git a/tizen/src/ecs/msg/ecs.proto b/tizen/src/ecs/msg/ecs.proto index 0f37f39960..dbeabab991 100644 --- a/tizen/src/ecs/msg/ecs.proto +++ b/tizen/src/ecs/msg/ecs.proto @@ -99,7 +99,7 @@ message NfcNtf { optional bytes data = 2; } -message TetheringReq { +message EventCastReq { required string category = 1; required int32 length = 2; required int32 group = 3; @@ -107,7 +107,7 @@ message TetheringReq { optional bytes data = 5; } -message TetheringAns { +message EventCastAns { required int32 errcode = 1; optional string errstr = 2; required string category = 3; @@ -117,7 +117,7 @@ message TetheringAns { optional bytes data = 7; } -message TetheringNtf { +message EventCastNtf { required string category = 1; required int32 length = 2; required int32 group = 3; @@ -152,9 +152,9 @@ message Master { optional NfcReq nfc_req = 101; optional NfcNtf nfc_ntf = 102; - optional TetheringReq tethering_req = 103; - optional TetheringAns tethering_ans = 104; - optional TetheringNtf tethering_ntf = 105; + optional EventCastReq eventcast_req = 103; + optional EventCastAns eventcast_ans = 104; + optional EventCastNtf eventcast_ntf = 105; } diff --git a/tizen/src/ecs/msg/ecs_ids.proto b/tizen/src/ecs/msg/ecs_ids.proto index c4b563c4c2..4b55f7c718 100644 --- a/tizen/src/ecs/msg/ecs_ids.proto +++ b/tizen/src/ecs/msg/ecs_ids.proto @@ -3,8 +3,8 @@ package ECS; option java_package = "org.tizen.ecp.msg.genmsg.ecs"; enum Master_Type { - CHECKVERSION_REQ = 2; - CHECKVERSION_ANS = 3; + CHECKVERSION_REQ = 2; + CHECKVERSION_ANS = 3; KEEPALIVE_REQ = 4; KEEPALIVE_ANS = 5; INJECTOR_REQ = 6; @@ -21,7 +21,7 @@ enum Master_Type { NFC_REQ = 101; NFC_NTF = 102; - TETHERING_REQ = 103; - TETHERING_ANS = 104; - TETHERING_NTF = 105; + EVENTCAST_REQ = 103; + EVENTCAST_ANS = 104; + EVENTCAST_NTF = 105; } diff --git a/tizen/src/tethering/common.c b/tizen/src/eventcast/common.c similarity index 62% rename from tizen/src/tethering/common.c rename to tizen/src/eventcast/common.c index 60ede59f28..f938c30114 100644 --- a/tizen/src/tethering/common.c +++ b/tizen/src/eventcast/common.c @@ -45,14 +45,14 @@ #include "sensor.h" #include "touch.h" #include "emul_state.h" -#include "ecs/ecs_tethering.h" -#include "genmsg/tethering.pb-c.h" +#include "ecs/ecs_eventcast.h" +#include "genmsg/eventcast.pb-c.h" #include "util/new_debug_ch.h" DECLARE_DEBUG_CHANNEL(app_tethering); -#define TETHERING_MSG_HANDSHAKE_KEY 100 +#define EVENTCAST_MSG_HANDSHAKE_KEY 100 #define MSG_BUF_SIZE 255 #define MSG_LEN_SIZE 4 @@ -69,13 +69,13 @@ enum connection_type { WIFI, }; -typedef struct tethering_recv_buf { +typedef struct eventcast_recv_buf { uint32_t len; uint32_t stack_size; char data[MSG_BUF_SIZE]; -} tethering_recv_buf; +} eventcast_recv_buf; -typedef struct _TetheringState { +typedef struct _EventcastState { int fd; // server address @@ -90,36 +90,34 @@ typedef struct _TetheringState { QemuThread thread; QemuMutex mutex; - tethering_recv_buf recv_buf; + eventcast_recv_buf recv_buf; // device state QTAILQ_HEAD(device, input_device_list) device; int device_node_cnt; -} TetheringState; +} EventcastState; -static TetheringState *tethering_client = NULL; -static tethering_recv_buf recv_buf; +static EventcastState *eventcast_client = NULL; +static eventcast_recv_buf recv_buf; -static void end_tethering_socket(int sockfd); -static void set_tethering_connection_status(int status); +static void end_eventcast_socket(int sockfd); +static void set_eventcast_connection_status(int status); #if 0 -static bool app_state = false; - -static void set_tethering_app_state(bool state); -static bool get_tethering_app_state(void); +static void set_eventcast_app_state(bool state); +static bool get_eventcast_app_state(void); #endif // create master message -static void *build_tethering_msg(Tethering__TetheringMsg* msg, int *payloadsize) +static void *build_eventcast_msg(Eventcast__EventCastMsg* msg, int *payloadsize) { void *buf = NULL; int msg_packed_size = 0; - msg_packed_size = tethering__tethering_msg__get_packed_size(msg); + msg_packed_size = eventcast__event_cast_msg__get_packed_size(msg); *payloadsize = msg_packed_size + MSG_LEN_SIZE; - LOG_TRACE("create tethering_msg. msg_packed_size %d, payloadsize %d\n", msg_packed_size, *payloadsize); + LOG_TRACE("create eventcast_msg. msg_packed_size %d, payloadsize %d\n", msg_packed_size, *payloadsize); buf = g_malloc(*payloadsize); if (!buf) { @@ -127,7 +125,7 @@ static void *build_tethering_msg(Tethering__TetheringMsg* msg, int *payloadsize) return NULL; } - tethering__tethering_msg__pack(msg, buf + MSG_LEN_SIZE); + eventcast__event_cast_msg__pack(msg, buf + MSG_LEN_SIZE); LOG_TRACE("msg_packed_size 1 %x\n", msg_packed_size); msg_packed_size = htonl(msg_packed_size); @@ -140,7 +138,7 @@ static void *build_tethering_msg(Tethering__TetheringMsg* msg, int *payloadsize) bool send_msg_to_controller(void *msg) { - Tethering__TetheringMsg * tetheringMsg = (Tethering__TetheringMsg *)msg; + Eventcast__EventCastMsg * eventcastMsg = (Eventcast__EventCastMsg *)msg; void *buf = NULL; int payload_size = 0, sent_size = 0; @@ -149,17 +147,17 @@ bool send_msg_to_controller(void *msg) bool ret = true; uint32_t buf_offset = 0; - buf = build_tethering_msg(tetheringMsg, &payload_size); + buf = build_eventcast_msg(eventcastMsg, &payload_size); if (!buf) { return false; } - if (!tethering_client) { - LOG_SEVERE("TetheringState is NULL\n"); + if (!eventcast_client) { + LOG_SEVERE("EventcastState is NULL\n"); g_free(buf); return false; } - sockfd = tethering_client->fd; + sockfd = eventcast_client->fd; total_buf_size = payload_size; do { @@ -208,14 +206,14 @@ bool send_msg_to_controller(void *msg) static bool send_handshake_req_msg(void) { - Tethering__TetheringMsg msg = TETHERING__TETHERING_MSG__INIT; - Tethering__HandShakeReq req = TETHERING__HAND_SHAKE_REQ__INIT; + Eventcast__EventCastMsg msg = EVENTCAST__EVENT_CAST_MSG__INIT; + Eventcast__HandShakeReq req = EVENTCAST__HAND_SHAKE_REQ__INIT; LOG_TRACE("enter: %s\n", __func__); - req.key = TETHERING_MSG_HANDSHAKE_KEY; + req.key = EVENTCAST_MSG_HANDSHAKE_KEY; - msg.type = TETHERING__TETHERING_MSG__TYPE__HANDSHAKE_REQ; + msg.type = EVENTCAST__EVENT_CAST_MSG__TYPE__HANDSHAKE_REQ; msg.handshakereq = &req; LOG_TRACE("send handshake_req message\n"); @@ -228,14 +226,14 @@ static bool send_handshake_req_msg(void) static bool send_emul_state_msg(void) { - Tethering__TetheringMsg msg = TETHERING__TETHERING_MSG__INIT; - Tethering__EmulatorState emul_state = TETHERING__EMULATOR_STATE__INIT; + Eventcast__EventCastMsg msg = EVENTCAST__EVENT_CAST_MSG__INIT; + Eventcast__EmulatorState emul_state = EVENTCAST__EMULATOR_STATE__INIT; LOG_TRACE("enter: %s\n", __func__); - emul_state.state = TETHERING__CONNECTION_STATE__DISCONNECTED; + emul_state.state = EVENTCAST__CONNECTION_STATE__DISCONNECTED; - msg.type = TETHERING__TETHERING_MSG__TYPE__EMUL_STATE; + msg.type = EVENTCAST__EVENT_CAST_MSG__TYPE__EMUL_STATE; msg.emulstate = &emul_state; LOG_INFO("send emulator_state message\n"); @@ -247,14 +245,14 @@ static bool send_emul_state_msg(void) } // event messages -static bool build_event_msg(Tethering__EventMsg *event) +static bool build_event_msg(Eventcast__EventMsg *event) { bool ret = false; - Tethering__TetheringMsg msg = TETHERING__TETHERING_MSG__INIT; + Eventcast__EventCastMsg msg = EVENTCAST__EVENT_CAST_MSG__INIT; LOG_TRACE("enter: %s\n", __func__); - msg.type = TETHERING__TETHERING_MSG__TYPE__EVENT_MSG; + msg.type = EVENTCAST__EVENT_CAST_MSG__TYPE__EVENT_MSG; msg.eventmsg = event; ret = send_msg_to_controller(&msg); @@ -264,17 +262,17 @@ static bool build_event_msg(Tethering__EventMsg *event) return ret; } -static bool send_event_start_ans_msg(Tethering__MessageResult result) +static bool send_event_start_ans_msg(Eventcast__MessageResult result) { bool ret = false; - Tethering__EventMsg event = TETHERING__EVENT_MSG__INIT; - Tethering__StartAns start_ans = TETHERING__START_ANS__INIT; + Eventcast__EventMsg event = EVENTCAST__EVENT_MSG__INIT; + Eventcast__StartAns start_ans = EVENTCAST__START_ANS__INIT; LOG_TRACE("enter: %s\n", __func__); start_ans.result = result; - event.type = TETHERING__EVENT_MSG__TYPE__START_ANS; + event.type = EVENTCAST__EVENT_MSG__TYPE__START_ANS; event.startans = &start_ans; LOG_TRACE("send event_start_ans message\n"); @@ -285,19 +283,19 @@ static bool send_event_start_ans_msg(Tethering__MessageResult result) return ret; } -static bool send_set_event_status_msg(Tethering__EventType event_type, - Tethering__State status) +static bool send_set_event_status_msg(Eventcast__EventType event_type, + Eventcast__State status) { bool ret = false; - Tethering__EventMsg event = TETHERING__EVENT_MSG__INIT; - Tethering__SetEventStatus event_status = TETHERING__SET_EVENT_STATUS__INIT; + Eventcast__EventMsg event = EVENTCAST__EVENT_MSG__INIT; + Eventcast__SetEventStatus event_status = EVENTCAST__SET_EVENT_STATUS__INIT; LOG_TRACE("enter: %s\n", __func__); event_status.type = event_type; event_status.state = status; - event.type = TETHERING__EVENT_MSG__TYPE__EVENT_STATUS; + event.type = EVENTCAST__EVENT_MSG__TYPE__EVENT_STATUS; event.setstatus = &event_status; LOG_TRACE("send event_set_event_status message\n"); @@ -309,61 +307,61 @@ static bool send_set_event_status_msg(Tethering__EventType event_type, } // message handlers -static void msgproc_tethering_handshake_ans(Tethering__HandShakeAns *msg) +static void msgproc_eventcast_handshake_ans(Eventcast__HandShakeAns *msg) { // handle handshake answer } -static void msgproc_app_state_msg(Tethering__AppState *msg) +static void msgproc_app_state_msg(Eventcast__AppState *msg) { - int status = TETHERING__STATE__DISABLED; + int status = EVENTCAST__STATE__DISABLED; - if (msg->state == TETHERING__CONNECTION_STATE__TERMINATED) { + if (msg->state == EVENTCAST__CONNECTION_STATE__TERMINATED) { LOG_INFO("app is terminated\n"); - // set_tethering_app_state(false); - set_tethering_sensor_status(status); - set_tethering_touch_status(status); + // set_eventcast_app_state(false); + set_eventcast_sensor_status(status); + set_eventcast_touch_status(status); - disconnect_tethering_app(); + disconnect_eventcast_app(); } } -static bool msgproc_tethering_event_msg(Tethering__EventMsg *msg) +static bool msgproc_eventcast_event_msg(Eventcast__EventMsg *msg) { bool ret = true; switch(msg->type) { - case TETHERING__EVENT_MSG__TYPE__START_REQ: + case EVENTCAST__EVENT_MSG__TYPE__START_REQ: { int touch_status = 0; LOG_TRACE("EVENT_MSG_TYPE_START_REQ\n"); - send_set_event_status_msg(TETHERING__EVENT_TYPE__SENSOR, - TETHERING__STATE__ENABLED); + send_set_event_status_msg(EVENTCAST__EVENT_TYPE__SENSOR, + EVENTCAST__STATE__ENABLED); // TODO: check sensor device whether it exists or not - set_tethering_sensor_status(TETHERING__STATE__ENABLED); + set_eventcast_sensor_status(EVENTCAST__STATE__ENABLED); if (is_emul_input_touch_enable()) { - touch_status = TETHERING__STATE__ENABLED; + touch_status = EVENTCAST__STATE__ENABLED; } else { - touch_status = TETHERING__STATE__DISABLED; + touch_status = EVENTCAST__STATE__DISABLED; } - set_tethering_touch_status(touch_status); + set_eventcast_touch_status(touch_status); LOG_TRACE("send touch event_status msg: %d\n", touch_status); - send_set_event_status_msg(TETHERING__EVENT_TYPE__TOUCH, touch_status); + send_set_event_status_msg(EVENTCAST__EVENT_TYPE__TOUCH, touch_status); LOG_TRACE("send event_start_ans msg: %d\n", touch_status); - send_event_start_ans_msg(TETHERING__MESSAGE_RESULT__SUCCESS); + send_event_start_ans_msg(EVENTCAST__MESSAGE_RESULT__SUCCESS); } break; - case TETHERING__EVENT_MSG__TYPE__TERMINATE: + case EVENTCAST__EVENT_MSG__TYPE__TERMINATE: break; default: - LOG_WARNING("invalid event_msg type\n"); + LOG_TRACE("invalid event_msg type\n"); ret = false; break; } @@ -371,37 +369,37 @@ static bool msgproc_tethering_event_msg(Tethering__EventMsg *msg) return ret; } -static bool handle_tethering_msg_from_controller(char *data, int len) +static bool handle_eventcast_msg_from_controller(char *data, int len) { - Tethering__TetheringMsg *tethering = NULL; + Eventcast__EventCastMsg *eventcast = NULL; bool ret = true; - tethering = tethering__tethering_msg__unpack(NULL, (size_t)len, + eventcast = eventcast__event_cast_msg__unpack(NULL, (size_t)len, (const uint8_t *)data); - if (!tethering) { - LOG_SEVERE("no tethering massage\n"); + if (!eventcast) { + LOG_SEVERE("no eventcast massage\n"); return false; } - switch (tethering->type) { - case TETHERING__TETHERING_MSG__TYPE__HANDSHAKE_ANS: + switch (eventcast->type) { + case EVENTCAST__EVENT_CAST_MSG__TYPE__HANDSHAKE_ANS: { // TODO: set the result of handshake_ans to - Tethering__HandShakeAns *msg = tethering->handshakeans; + Eventcast__HandShakeAns *msg = eventcast->handshakeans; if (!msg) { ret = false; } else { - msgproc_tethering_handshake_ans(msg); + msgproc_eventcast_handshake_ans(msg); LOG_TRACE("receive handshake answer\n"); - set_tethering_connection_status(CONNECTED); + set_eventcast_connection_status(CONNECTED); } } break; - case TETHERING__TETHERING_MSG__TYPE__APP_STATE: + case EVENTCAST__EVENT_CAST_MSG__TYPE__APP_STATE: { - Tethering__AppState *msg = tethering->appstate; + Eventcast__AppState *msg = eventcast->appstate; LOG_TRACE("receive app_state msg\n"); if (!msg) { @@ -411,39 +409,39 @@ static bool handle_tethering_msg_from_controller(char *data, int len) } } break; - case TETHERING__TETHERING_MSG__TYPE__EVENT_MSG: + case EVENTCAST__EVENT_CAST_MSG__TYPE__EVENT_MSG: { - Tethering__EventMsg *msg = tethering->eventmsg; + Eventcast__EventMsg *msg = eventcast->eventmsg; LOG_TRACE("receive event_msg\n"); if (!msg) { ret = false; } else { - msgproc_tethering_event_msg(msg); + msgproc_eventcast_event_msg(msg); } } break; - case TETHERING__TETHERING_MSG__TYPE__SENSOR_MSG: + case EVENTCAST__EVENT_CAST_MSG__TYPE__SENSOR_MSG: { - Tethering__SensorMsg *msg = tethering->sensormsg; + Eventcast__SensorMsg *msg = eventcast->sensormsg; LOG_TRACE("receive sensor_msg\n"); if (!msg) { ret = false; } else { - msgproc_tethering_sensor_msg(msg); + msgproc_eventcast_sensor_msg(msg); } } break; - case TETHERING__TETHERING_MSG__TYPE__TOUCH_MSG: + case EVENTCAST__EVENT_CAST_MSG__TYPE__TOUCH_MSG: { - Tethering__TouchMsg *msg = tethering->touchmsg; + Eventcast__TouchMsg *msg = eventcast->touchmsg; LOG_TRACE("receive touch_msg\n"); if (!msg) { ret = false; } else { - msgproc_tethering_touch_msg(msg); + msgproc_eventcast_touch_msg(msg); } } break; @@ -454,32 +452,32 @@ static bool handle_tethering_msg_from_controller(char *data, int len) break; } - tethering__tethering_msg__free_unpacked(tethering, NULL); + eventcast__event_cast_msg__free_unpacked(eventcast, NULL); return ret; } -static void reset_tethering_recv_buf(void *opaque) +static void reset_eventcast_recv_buf(void *opaque) { - memset(opaque, 0x00, sizeof(tethering_recv_buf)); + memset(opaque, 0x00, sizeof(eventcast_recv_buf)); } -// tethering client socket -static void tethering_io_handler(void *opaque) +// eventcast client socket +static void eventcast_io_handler(void *opaque) { int payloadsize = 0, read_size = 0; int to_read_bytes = 0; int sockfd = 0, ret = 0; - if (!tethering_client) { + if (!eventcast_client) { return; } - sockfd = tethering_client->fd; + sockfd = eventcast_client->fd; #ifndef CONFIG_WIN32 ret = ioctl(sockfd, FIONREAD, &to_read_bytes); if (ret < 0) { perror("invalid ioctl opertion\n"); - disconnect_tethering_app(); + disconnect_eventcast_app(); return; } @@ -488,7 +486,7 @@ static void tethering_io_handler(void *opaque) ret = ioctlsocket(sockfd, FIONREAD, &to_read_bytes_long); if (ret < 0) { perror("invalid ioctl opertion\n"); - disconnect_tethering_app(); + disconnect_eventcast_app(); return; } @@ -498,7 +496,7 @@ static void tethering_io_handler(void *opaque) LOG_TRACE("ioctl: ret: %d, FIONREAD: %d\n", ret, to_read_bytes); if (to_read_bytes == 0) { LOG_INFO("there is no read data\n"); - disconnect_tethering_app(); + disconnect_eventcast_app(); return; } @@ -533,7 +531,7 @@ static void tethering_io_handler(void *opaque) to_read_bytes, 0); if (read_size == 0) { LOG_SEVERE("failed to read data\n"); - disconnect_tethering_app(); + disconnect_eventcast_app(); return; } @@ -547,15 +545,15 @@ static void tethering_io_handler(void *opaque) return; } else { memcpy(snd_buf, recv_buf.data, recv_buf.stack_size); - handle_tethering_msg_from_controller(snd_buf, recv_buf.stack_size); + handle_eventcast_msg_from_controller(snd_buf, recv_buf.stack_size); g_free(snd_buf); - reset_tethering_recv_buf(&recv_buf); + reset_eventcast_recv_buf(&recv_buf); } } } // socket functions -static int start_tethering_socket(const char *ipaddress, int port) +static int start_eventcast_socket(const char *ipaddress, int port) { struct sockaddr_in addr; int sock = -1, ret = 0; @@ -566,27 +564,27 @@ static int start_tethering_socket(const char *ipaddress, int port) LOG_INFO("server ip address: %s, port: %d\n", ipaddress, port); ret = inet_aton(ipaddress, &addr.sin_addr); if (ret == 0) { - perror("inet_aton failure\n"); + LOG_SEVERE("inet_aton failure\n"); return -1; } sock = qemu_socket(PF_INET, SOCK_STREAM, 0); if (sock < 0) { - // set_tethering_connection_status(DISCONNECTED); - LOG_SEVERE("tethering socket creation is failed\n", sock); + // set_eventcast_connection_status(DISCONNECTED); + LOG_SEVERE("eventcast socket creation is failed\n", sock); return -1; } - LOG_INFO("tethering socket is created: %d\n", sock); + LOG_INFO("eventcast socket is created: %d\n", sock); qemu_set_nonblock(sock); - set_tethering_connection_status(CONNECTING); + set_eventcast_connection_status(CONNECTING); while (1) { ret = connect(sock, (struct sockaddr *)&addr, sizeof(addr)); if (ret == 0) { - LOG_INFO("tethering socket is connected.\n"); + LOG_INFO("eventcast socket is connected.\n"); break; } else { int connection_errno = socket_error(); @@ -636,19 +634,19 @@ static int start_tethering_socket(const char *ipaddress, int port) if (ret < 0) { if (ret == -ECONNREFUSED) { LOG_INFO("socket connection is refused\n"); - set_tethering_connection_status(CONNREFUSED); + set_eventcast_connection_status(CONNREFUSED); } - LOG_TRACE("close socket\n"); - end_tethering_socket(sock); + LOG_INFO("close socket\n"); + end_eventcast_socket(sock); sock = -1; } return sock; } -static void end_tethering_socket(int sockfd) +static void end_eventcast_socket(int sockfd) { - int status = TETHERING__STATE__DISABLED; + int status = EVENTCAST__STATE__DISABLED; LOG_TRACE("enter: %s\n", __func__); @@ -657,99 +655,99 @@ static void end_tethering_socket(int sockfd) return; } - tethering_client->fd = -1; + eventcast_client->fd = -1; - LOG_INFO("close tethering socket\n"); - set_tethering_connection_status(DISCONNECTED); - set_tethering_sensor_status(status); - set_tethering_touch_status(status); + LOG_INFO("close eventcast socket\n"); + set_eventcast_connection_status(DISCONNECTED); + set_eventcast_sensor_status(status); + set_eventcast_touch_status(status); LOG_TRACE("leave: %s\n", __func__); } #if 0 -static void set_tethering_app_state(bool state) +static void set_eventcast_app_state(bool state) { - LOG_TRACE("set tethering_app state: %d", state); + LOG_TRACE("set eventcast_app state: %d", state); app_state = state; } -static bool get_tethering_app_state(void) +static bool get_eventcast_app_state(void) { return app_state; } #endif -// ecs <-> tethering -int get_tethering_connection_status(void) +// ecs <-> eventcast +int get_eventcast_connection_status(void) { int status = 0; - if (!tethering_client) { - LOG_INFO("tethering_client is null\n"); + if (!eventcast_client) { + LOG_INFO("eventcast_client is null\n"); LOG_INFO("tetherging connection status: %d\n", status); return DISCONNECTED; } - qemu_mutex_lock(&tethering_client->mutex); - status = tethering_client->status; - qemu_mutex_unlock(&tethering_client->mutex); + qemu_mutex_lock(&eventcast_client->mutex); + status = eventcast_client->status; + qemu_mutex_unlock(&eventcast_client->mutex); LOG_INFO("tetherging connection status: %d\n", status); return status; } -int get_tethering_connected_port(void) +int get_eventcast_connected_port(void) { - if (!tethering_client) { - LOG_SEVERE("tethering_client is null\n"); + if (!eventcast_client) { + LOG_SEVERE("eventcast_client is null\n"); return 0; } - LOG_TRACE("connected port: %d\n", tethering_client->port); - return tethering_client->port; + LOG_TRACE("connected port: %d\n", eventcast_client->port); + return eventcast_client->port; } -const char *get_tethering_connected_ipaddr(void) +const char *get_eventcast_connected_ipaddr(void) { - if (!tethering_client) { - LOG_SEVERE("tethering client is null\n"); + if (!eventcast_client) { + LOG_SEVERE("eventcast client is null\n"); return NULL; } - LOG_TRACE("connected ip address: %s\n", tethering_client->ipaddress); - return tethering_client->ipaddress; + LOG_TRACE("connected ip address: %s\n", eventcast_client->ipaddress); + return eventcast_client->ipaddress; } -static void set_tethering_connection_status(int status) +static void set_eventcast_connection_status(int status) { - if (!tethering_client) { + if (!eventcast_client) { return; } - qemu_mutex_lock(&tethering_client->mutex); - tethering_client->status = status; - qemu_mutex_unlock(&tethering_client->mutex); + qemu_mutex_lock(&eventcast_client->mutex); + eventcast_client->status = status; + qemu_mutex_unlock(&eventcast_client->mutex); - send_tethering_connection_status_ecp(); + send_eventcast_connection_status_ecp(); } -static void tethering_notify_exit(Notifier *notifier, void *data) +static void eventcast_notify_exit(Notifier *notifier, void *data) { - LOG_INFO("tethering_notify_exit\n"); - disconnect_tethering_app(); + LOG_INFO("eventcast_notify_exit\n"); + disconnect_eventcast_app(); } -static Notifier tethering_exit = { .notify = tethering_notify_exit }; +static Notifier eventcast_exit = { .notify = eventcast_notify_exit }; -static void *initialize_tethering_socket(void *opaque); +static void *initialize_eventcast_socket(void *opaque); -int connect_tethering_app(const char *ipaddress, int port) +int connect_eventcast_app(const char *ipaddress, int port) { - TetheringState *client = NULL; + EventcastState *client = NULL; int ipaddr_len = 0; - client = g_malloc0(sizeof(TetheringState)); + client = g_malloc0(sizeof(EventcastState)); if (!client) { return -1; } @@ -771,44 +769,43 @@ int connect_tethering_app(const char *ipaddress, int port) g_free(client); return -1; } - g_strlcpy(client->ipaddress, ipaddress, ipaddr_len + 1); LOG_INFO("connection info. ip %s, port %d type %d\n", client->ipaddress, client->port, client->type); - tethering_client = client; + eventcast_client = client; - qemu_mutex_init(&tethering_client->mutex); - qemu_thread_create(&tethering_client->thread, "tethering-io-thread", - initialize_tethering_socket, client, + qemu_mutex_init(&eventcast_client->mutex); + qemu_thread_create(&eventcast_client->thread, "eventcast-io-thread", + initialize_eventcast_socket, client, QEMU_THREAD_DETACHED); return 0; } -int disconnect_tethering_app(void) +int disconnect_eventcast_app(void) { int sock = 0; - LOG_TRACE("disconnect app from ecp\n"); - if (!tethering_client) { - LOG_SEVERE("tethering client instance is NULL\n"); + LOG_INFO("disconnect app from ecp\n"); + if (!eventcast_client) { + LOG_SEVERE("eventcast client instance is NULL\n"); return -1; } - sock = tethering_client->fd; + sock = eventcast_client->fd; if (sock < 0) { - LOG_SEVERE("tethering socket is already terminated or not ready\n"); + LOG_SEVERE("eventcast socket is already terminated or not ready\n"); return -1; } else { send_emul_state_msg(); - end_tethering_socket(sock); + end_eventcast_socket(sock); } return 0; } -static int tethering_loop(int sockfd) +static int eventcast_loop(int sockfd) { int ret = 0; fd_set readfds; @@ -825,34 +822,33 @@ static int tethering_loop(int sockfd) if (ret > 0) { LOG_TRACE("ready for read operation!!\n"); - tethering_io_handler(socket); + eventcast_io_handler(socket); } return ret; } -static void *initialize_tethering_socket(void *opaque) +static void *initialize_eventcast_socket(void *opaque) { - TetheringState *client = (TetheringState *)opaque; - LOG_TRACE("callback function for tethering_thread\n"); + EventcastState *client = (EventcastState *)opaque; + LOG_TRACE("callback function for eventcast_thread\n"); if (!client) { - LOG_SEVERE("TetheringState is NULL\n"); + LOG_SEVERE("EventcastState is NULL\n"); return NULL; } - client->fd = start_tethering_socket(client->ipaddress, client->port); + client->fd = start_eventcast_socket(client->ipaddress, client->port); if (client->fd < 0) { - LOG_SEVERE("failed to start tethering_socket\n"); - // tethering_sock = -1; + LOG_SEVERE("failed to start eventcast_socket\n"); return NULL; } - LOG_TRACE("tethering_sock: %d\n", client->fd); + LOG_TRACE("eventcast_sock: %d\n", client->fd); - reset_tethering_recv_buf(&recv_buf); + reset_eventcast_recv_buf(&recv_buf); send_handshake_req_msg(); - emulator_add_exit_notifier(&tethering_exit); + emulator_add_exit_notifier(&eventcast_exit); while (1) { qemu_mutex_lock(&client->mutex); @@ -863,7 +859,7 @@ static void *initialize_tethering_socket(void *opaque) } qemu_mutex_unlock(&client->mutex); - tethering_loop(client->fd); + eventcast_loop(client->fd); } return client; diff --git a/tizen/src/tethering/common.h b/tizen/src/eventcast/common.h similarity index 84% rename from tizen/src/tethering/common.h rename to tizen/src/eventcast/common.h index a75fa7074f..14229913d7 100644 --- a/tizen/src/tethering/common.h +++ b/tizen/src/eventcast/common.h @@ -42,12 +42,12 @@ enum touch_status { bool send_msg_to_controller(void *msg); -int connect_tethering_app(const char *ipaddress, int port); +int connect_eventcast_app(const char *ipaddress, int port); -int disconnect_tethering_app(void); +int disconnect_eventcast_app(void); -int get_tethering_connection_status(void); +int get_eventcast_connection_status(void); -int get_tethering_connected_port(void); +int get_eventcast_connected_port(void); -const char *get_tethering_connected_ipaddr(void); +const char *get_eventcast_connected_ipaddr(void); diff --git a/tizen/src/tethering/encode_fb.c b/tizen/src/eventcast/encode_fb.c similarity index 98% rename from tizen/src/tethering/encode_fb.c rename to tizen/src/eventcast/encode_fb.c index 022fba13f5..c6391369ac 100644 --- a/tizen/src/tethering/encode_fb.c +++ b/tizen/src/eventcast/encode_fb.c @@ -263,14 +263,15 @@ void *encode_framebuffer(int encoder) { void *output = NULL; -#ifdef CONFIG_PNG #if defined(CONFIG_LINUX) && defined(ENCODE_DEBUG) struct timespec start, end; clock_gettime(CLOCK_MONOTONIC, &start); #endif +#ifdef CONFIG_PNG output = encode_png(); +#endif #if defined(CONFIG_LINUX) && defined(ENCODE_DEBUG) clock_gettime(CLOCK_MONOTONIC, &end); @@ -279,7 +280,8 @@ void *encode_framebuffer(int encoder) ((double)end.tv_sec + (1.0e-9 * end.tv_nsec)) - ((double)start.tv_sec + (1.0e-9 * start.tv_nsec))); #endif -#endif + + LOG_TRACE("encode framebuffer: %p\n", output); return output; } @@ -288,7 +290,7 @@ static bool display_dirty = false; void set_display_dirty(bool dirty) { - LOG_TRACE("qemu display update: %d\n", display_dirty); + // LOG_TRACE("qemu display update: %d\n", display_dirty); display_dirty = dirty; } diff --git a/tizen/src/tethering/encode_fb.h b/tizen/src/eventcast/encode_fb.h similarity index 100% rename from tizen/src/tethering/encode_fb.h rename to tizen/src/eventcast/encode_fb.h diff --git a/tizen/src/eventcast/genmsg/eventcast.pb-c.c b/tizen/src/eventcast/genmsg/eventcast.pb-c.c new file mode 100644 index 0000000000..bfc55e8503 --- /dev/null +++ b/tizen/src/eventcast/genmsg/eventcast.pb-c.c @@ -0,0 +1,2314 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C_NO_DEPRECATED +#define PROTOBUF_C_NO_DEPRECATED +#endif + +#include "eventcast.pb-c.h" +void eventcast__hand_shake_req__init + (Eventcast__HandShakeReq *message) +{ + static Eventcast__HandShakeReq init_value = EVENTCAST__HAND_SHAKE_REQ__INIT; + *message = init_value; +} +size_t eventcast__hand_shake_req__get_packed_size + (const Eventcast__HandShakeReq *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__hand_shake_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t eventcast__hand_shake_req__pack + (const Eventcast__HandShakeReq *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__hand_shake_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t eventcast__hand_shake_req__pack_to_buffer + (const Eventcast__HandShakeReq *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__hand_shake_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Eventcast__HandShakeReq * + eventcast__hand_shake_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Eventcast__HandShakeReq *) + protobuf_c_message_unpack (&eventcast__hand_shake_req__descriptor, + allocator, len, data); +} +void eventcast__hand_shake_req__free_unpacked + (Eventcast__HandShakeReq *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__hand_shake_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void eventcast__hand_shake_ans__init + (Eventcast__HandShakeAns *message) +{ + static Eventcast__HandShakeAns init_value = EVENTCAST__HAND_SHAKE_ANS__INIT; + *message = init_value; +} +size_t eventcast__hand_shake_ans__get_packed_size + (const Eventcast__HandShakeAns *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__hand_shake_ans__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t eventcast__hand_shake_ans__pack + (const Eventcast__HandShakeAns *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__hand_shake_ans__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t eventcast__hand_shake_ans__pack_to_buffer + (const Eventcast__HandShakeAns *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__hand_shake_ans__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Eventcast__HandShakeAns * + eventcast__hand_shake_ans__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Eventcast__HandShakeAns *) + protobuf_c_message_unpack (&eventcast__hand_shake_ans__descriptor, + allocator, len, data); +} +void eventcast__hand_shake_ans__free_unpacked + (Eventcast__HandShakeAns *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__hand_shake_ans__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void eventcast__emulator_state__init + (Eventcast__EmulatorState *message) +{ + static Eventcast__EmulatorState init_value = EVENTCAST__EMULATOR_STATE__INIT; + *message = init_value; +} +size_t eventcast__emulator_state__get_packed_size + (const Eventcast__EmulatorState *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__emulator_state__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t eventcast__emulator_state__pack + (const Eventcast__EmulatorState *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__emulator_state__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t eventcast__emulator_state__pack_to_buffer + (const Eventcast__EmulatorState *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__emulator_state__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Eventcast__EmulatorState * + eventcast__emulator_state__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Eventcast__EmulatorState *) + protobuf_c_message_unpack (&eventcast__emulator_state__descriptor, + allocator, len, data); +} +void eventcast__emulator_state__free_unpacked + (Eventcast__EmulatorState *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__emulator_state__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void eventcast__app_state__init + (Eventcast__AppState *message) +{ + static Eventcast__AppState init_value = EVENTCAST__APP_STATE__INIT; + *message = init_value; +} +size_t eventcast__app_state__get_packed_size + (const Eventcast__AppState *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__app_state__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t eventcast__app_state__pack + (const Eventcast__AppState *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__app_state__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t eventcast__app_state__pack_to_buffer + (const Eventcast__AppState *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__app_state__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Eventcast__AppState * + eventcast__app_state__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Eventcast__AppState *) + protobuf_c_message_unpack (&eventcast__app_state__descriptor, + allocator, len, data); +} +void eventcast__app_state__free_unpacked + (Eventcast__AppState *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__app_state__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void eventcast__start_req__init + (Eventcast__StartReq *message) +{ + static Eventcast__StartReq init_value = EVENTCAST__START_REQ__INIT; + *message = init_value; +} +size_t eventcast__start_req__get_packed_size + (const Eventcast__StartReq *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__start_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t eventcast__start_req__pack + (const Eventcast__StartReq *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__start_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t eventcast__start_req__pack_to_buffer + (const Eventcast__StartReq *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__start_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Eventcast__StartReq * + eventcast__start_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Eventcast__StartReq *) + protobuf_c_message_unpack (&eventcast__start_req__descriptor, + allocator, len, data); +} +void eventcast__start_req__free_unpacked + (Eventcast__StartReq *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__start_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void eventcast__start_ans__init + (Eventcast__StartAns *message) +{ + static Eventcast__StartAns init_value = EVENTCAST__START_ANS__INIT; + *message = init_value; +} +size_t eventcast__start_ans__get_packed_size + (const Eventcast__StartAns *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__start_ans__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t eventcast__start_ans__pack + (const Eventcast__StartAns *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__start_ans__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t eventcast__start_ans__pack_to_buffer + (const Eventcast__StartAns *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__start_ans__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Eventcast__StartAns * + eventcast__start_ans__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Eventcast__StartAns *) + protobuf_c_message_unpack (&eventcast__start_ans__descriptor, + allocator, len, data); +} +void eventcast__start_ans__free_unpacked + (Eventcast__StartAns *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__start_ans__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void eventcast__set_event_status__init + (Eventcast__SetEventStatus *message) +{ + static Eventcast__SetEventStatus init_value = EVENTCAST__SET_EVENT_STATUS__INIT; + *message = init_value; +} +size_t eventcast__set_event_status__get_packed_size + (const Eventcast__SetEventStatus *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__set_event_status__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t eventcast__set_event_status__pack + (const Eventcast__SetEventStatus *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__set_event_status__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t eventcast__set_event_status__pack_to_buffer + (const Eventcast__SetEventStatus *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__set_event_status__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Eventcast__SetEventStatus * + eventcast__set_event_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Eventcast__SetEventStatus *) + protobuf_c_message_unpack (&eventcast__set_event_status__descriptor, + allocator, len, data); +} +void eventcast__set_event_status__free_unpacked + (Eventcast__SetEventStatus *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__set_event_status__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void eventcast__event_msg__init + (Eventcast__EventMsg *message) +{ + static Eventcast__EventMsg init_value = EVENTCAST__EVENT_MSG__INIT; + *message = init_value; +} +size_t eventcast__event_msg__get_packed_size + (const Eventcast__EventMsg *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__event_msg__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t eventcast__event_msg__pack + (const Eventcast__EventMsg *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__event_msg__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t eventcast__event_msg__pack_to_buffer + (const Eventcast__EventMsg *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__event_msg__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Eventcast__EventMsg * + eventcast__event_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Eventcast__EventMsg *) + protobuf_c_message_unpack (&eventcast__event_msg__descriptor, + allocator, len, data); +} +void eventcast__event_msg__free_unpacked + (Eventcast__EventMsg *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__event_msg__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void eventcast__event_terminate__init + (Eventcast__EventTerminate *message) +{ + static Eventcast__EventTerminate init_value = EVENTCAST__EVENT_TERMINATE__INIT; + *message = init_value; +} +size_t eventcast__event_terminate__get_packed_size + (const Eventcast__EventTerminate *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__event_terminate__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t eventcast__event_terminate__pack + (const Eventcast__EventTerminate *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__event_terminate__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t eventcast__event_terminate__pack_to_buffer + (const Eventcast__EventTerminate *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__event_terminate__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Eventcast__EventTerminate * + eventcast__event_terminate__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Eventcast__EventTerminate *) + protobuf_c_message_unpack (&eventcast__event_terminate__descriptor, + allocator, len, data); +} +void eventcast__event_terminate__free_unpacked + (Eventcast__EventTerminate *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__event_terminate__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void eventcast__set_sensor_status__init + (Eventcast__SetSensorStatus *message) +{ + static Eventcast__SetSensorStatus init_value = EVENTCAST__SET_SENSOR_STATUS__INIT; + *message = init_value; +} +size_t eventcast__set_sensor_status__get_packed_size + (const Eventcast__SetSensorStatus *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__set_sensor_status__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t eventcast__set_sensor_status__pack + (const Eventcast__SetSensorStatus *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__set_sensor_status__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t eventcast__set_sensor_status__pack_to_buffer + (const Eventcast__SetSensorStatus *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__set_sensor_status__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Eventcast__SetSensorStatus * + eventcast__set_sensor_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Eventcast__SetSensorStatus *) + protobuf_c_message_unpack (&eventcast__set_sensor_status__descriptor, + allocator, len, data); +} +void eventcast__set_sensor_status__free_unpacked + (Eventcast__SetSensorStatus *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__set_sensor_status__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void eventcast__sensor_data__init + (Eventcast__SensorData *message) +{ + static Eventcast__SensorData init_value = EVENTCAST__SENSOR_DATA__INIT; + *message = init_value; +} +size_t eventcast__sensor_data__get_packed_size + (const Eventcast__SensorData *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__sensor_data__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t eventcast__sensor_data__pack + (const Eventcast__SensorData *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__sensor_data__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t eventcast__sensor_data__pack_to_buffer + (const Eventcast__SensorData *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__sensor_data__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Eventcast__SensorData * + eventcast__sensor_data__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Eventcast__SensorData *) + protobuf_c_message_unpack (&eventcast__sensor_data__descriptor, + allocator, len, data); +} +void eventcast__sensor_data__free_unpacked + (Eventcast__SensorData *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__sensor_data__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void eventcast__sensor_msg__init + (Eventcast__SensorMsg *message) +{ + static Eventcast__SensorMsg init_value = EVENTCAST__SENSOR_MSG__INIT; + *message = init_value; +} +size_t eventcast__sensor_msg__get_packed_size + (const Eventcast__SensorMsg *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__sensor_msg__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t eventcast__sensor_msg__pack + (const Eventcast__SensorMsg *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__sensor_msg__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t eventcast__sensor_msg__pack_to_buffer + (const Eventcast__SensorMsg *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__sensor_msg__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Eventcast__SensorMsg * + eventcast__sensor_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Eventcast__SensorMsg *) + protobuf_c_message_unpack (&eventcast__sensor_msg__descriptor, + allocator, len, data); +} +void eventcast__sensor_msg__free_unpacked + (Eventcast__SensorMsg *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__sensor_msg__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void eventcast__resolution__init + (Eventcast__Resolution *message) +{ + static Eventcast__Resolution init_value = EVENTCAST__RESOLUTION__INIT; + *message = init_value; +} +size_t eventcast__resolution__get_packed_size + (const Eventcast__Resolution *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__resolution__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t eventcast__resolution__pack + (const Eventcast__Resolution *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__resolution__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t eventcast__resolution__pack_to_buffer + (const Eventcast__Resolution *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__resolution__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Eventcast__Resolution * + eventcast__resolution__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Eventcast__Resolution *) + protobuf_c_message_unpack (&eventcast__resolution__descriptor, + allocator, len, data); +} +void eventcast__resolution__free_unpacked + (Eventcast__Resolution *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__resolution__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void eventcast__display_msg__init + (Eventcast__DisplayMsg *message) +{ + static Eventcast__DisplayMsg init_value = EVENTCAST__DISPLAY_MSG__INIT; + *message = init_value; +} +size_t eventcast__display_msg__get_packed_size + (const Eventcast__DisplayMsg *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__display_msg__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t eventcast__display_msg__pack + (const Eventcast__DisplayMsg *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__display_msg__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t eventcast__display_msg__pack_to_buffer + (const Eventcast__DisplayMsg *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__display_msg__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Eventcast__DisplayMsg * + eventcast__display_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Eventcast__DisplayMsg *) + protobuf_c_message_unpack (&eventcast__display_msg__descriptor, + allocator, len, data); +} +void eventcast__display_msg__free_unpacked + (Eventcast__DisplayMsg *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__display_msg__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void eventcast__touch_max_count__init + (Eventcast__TouchMaxCount *message) +{ + static Eventcast__TouchMaxCount init_value = EVENTCAST__TOUCH_MAX_COUNT__INIT; + *message = init_value; +} +size_t eventcast__touch_max_count__get_packed_size + (const Eventcast__TouchMaxCount *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__touch_max_count__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t eventcast__touch_max_count__pack + (const Eventcast__TouchMaxCount *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__touch_max_count__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t eventcast__touch_max_count__pack_to_buffer + (const Eventcast__TouchMaxCount *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__touch_max_count__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Eventcast__TouchMaxCount * + eventcast__touch_max_count__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Eventcast__TouchMaxCount *) + protobuf_c_message_unpack (&eventcast__touch_max_count__descriptor, + allocator, len, data); +} +void eventcast__touch_max_count__free_unpacked + (Eventcast__TouchMaxCount *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__touch_max_count__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void eventcast__touch_data__init + (Eventcast__TouchData *message) +{ + static Eventcast__TouchData init_value = EVENTCAST__TOUCH_DATA__INIT; + *message = init_value; +} +size_t eventcast__touch_data__get_packed_size + (const Eventcast__TouchData *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__touch_data__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t eventcast__touch_data__pack + (const Eventcast__TouchData *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__touch_data__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t eventcast__touch_data__pack_to_buffer + (const Eventcast__TouchData *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__touch_data__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Eventcast__TouchData * + eventcast__touch_data__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Eventcast__TouchData *) + protobuf_c_message_unpack (&eventcast__touch_data__descriptor, + allocator, len, data); +} +void eventcast__touch_data__free_unpacked + (Eventcast__TouchData *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__touch_data__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void eventcast__hwkey_msg__init + (Eventcast__HWKeyMsg *message) +{ + static Eventcast__HWKeyMsg init_value = EVENTCAST__HWKEY_MSG__INIT; + *message = init_value; +} +size_t eventcast__hwkey_msg__get_packed_size + (const Eventcast__HWKeyMsg *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__hwkey_msg__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t eventcast__hwkey_msg__pack + (const Eventcast__HWKeyMsg *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__hwkey_msg__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t eventcast__hwkey_msg__pack_to_buffer + (const Eventcast__HWKeyMsg *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__hwkey_msg__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Eventcast__HWKeyMsg * + eventcast__hwkey_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Eventcast__HWKeyMsg *) + protobuf_c_message_unpack (&eventcast__hwkey_msg__descriptor, + allocator, len, data); +} +void eventcast__hwkey_msg__free_unpacked + (Eventcast__HWKeyMsg *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__hwkey_msg__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void eventcast__touch_msg__init + (Eventcast__TouchMsg *message) +{ + static Eventcast__TouchMsg init_value = EVENTCAST__TOUCH_MSG__INIT; + *message = init_value; +} +size_t eventcast__touch_msg__get_packed_size + (const Eventcast__TouchMsg *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__touch_msg__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t eventcast__touch_msg__pack + (const Eventcast__TouchMsg *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__touch_msg__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t eventcast__touch_msg__pack_to_buffer + (const Eventcast__TouchMsg *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__touch_msg__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Eventcast__TouchMsg * + eventcast__touch_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Eventcast__TouchMsg *) + protobuf_c_message_unpack (&eventcast__touch_msg__descriptor, + allocator, len, data); +} +void eventcast__touch_msg__free_unpacked + (Eventcast__TouchMsg *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__touch_msg__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void eventcast__event_cast_msg__init + (Eventcast__EventCastMsg *message) +{ + static Eventcast__EventCastMsg init_value = EVENTCAST__EVENT_CAST_MSG__INIT; + *message = init_value; +} +size_t eventcast__event_cast_msg__get_packed_size + (const Eventcast__EventCastMsg *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__event_cast_msg__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t eventcast__event_cast_msg__pack + (const Eventcast__EventCastMsg *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__event_cast_msg__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t eventcast__event_cast_msg__pack_to_buffer + (const Eventcast__EventCastMsg *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__event_cast_msg__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Eventcast__EventCastMsg * + eventcast__event_cast_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Eventcast__EventCastMsg *) + protobuf_c_message_unpack (&eventcast__event_cast_msg__descriptor, + allocator, len, data); +} +void eventcast__event_cast_msg__free_unpacked + (Eventcast__EventCastMsg *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &eventcast__event_cast_msg__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor eventcast__hand_shake_req__field_descriptors[1] = +{ + { + "key", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__HandShakeReq, key), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned eventcast__hand_shake_req__field_indices_by_name[] = { + 0, /* field[0] = key */ +}; +static const ProtobufCIntRange eventcast__hand_shake_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor eventcast__hand_shake_req__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "eventcast.HandShakeReq", + "HandShakeReq", + "Eventcast__HandShakeReq", + "eventcast", + sizeof(Eventcast__HandShakeReq), + 1, + eventcast__hand_shake_req__field_descriptors, + eventcast__hand_shake_req__field_indices_by_name, + 1, eventcast__hand_shake_req__number_ranges, + (ProtobufCMessageInit) eventcast__hand_shake_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor eventcast__hand_shake_ans__field_descriptors[1] = +{ + { + "result", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__HandShakeAns, result), + &eventcast__message_result__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned eventcast__hand_shake_ans__field_indices_by_name[] = { + 0, /* field[0] = result */ +}; +static const ProtobufCIntRange eventcast__hand_shake_ans__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor eventcast__hand_shake_ans__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "eventcast.HandShakeAns", + "HandShakeAns", + "Eventcast__HandShakeAns", + "eventcast", + sizeof(Eventcast__HandShakeAns), + 1, + eventcast__hand_shake_ans__field_descriptors, + eventcast__hand_shake_ans__field_indices_by_name, + 1, eventcast__hand_shake_ans__number_ranges, + (ProtobufCMessageInit) eventcast__hand_shake_ans__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor eventcast__emulator_state__field_descriptors[1] = +{ + { + "state", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__EmulatorState, state), + &eventcast__connection_state__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned eventcast__emulator_state__field_indices_by_name[] = { + 0, /* field[0] = state */ +}; +static const ProtobufCIntRange eventcast__emulator_state__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor eventcast__emulator_state__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "eventcast.EmulatorState", + "EmulatorState", + "Eventcast__EmulatorState", + "eventcast", + sizeof(Eventcast__EmulatorState), + 1, + eventcast__emulator_state__field_descriptors, + eventcast__emulator_state__field_indices_by_name, + 1, eventcast__emulator_state__number_ranges, + (ProtobufCMessageInit) eventcast__emulator_state__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor eventcast__app_state__field_descriptors[1] = +{ + { + "state", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__AppState, state), + &eventcast__connection_state__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned eventcast__app_state__field_indices_by_name[] = { + 0, /* field[0] = state */ +}; +static const ProtobufCIntRange eventcast__app_state__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor eventcast__app_state__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "eventcast.AppState", + "AppState", + "Eventcast__AppState", + "eventcast", + sizeof(Eventcast__AppState), + 1, + eventcast__app_state__field_descriptors, + eventcast__app_state__field_indices_by_name, + 1, eventcast__app_state__number_ranges, + (ProtobufCMessageInit) eventcast__app_state__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define eventcast__start_req__field_descriptors NULL +#define eventcast__start_req__field_indices_by_name NULL +#define eventcast__start_req__number_ranges NULL +const ProtobufCMessageDescriptor eventcast__start_req__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "eventcast.StartReq", + "StartReq", + "Eventcast__StartReq", + "eventcast", + sizeof(Eventcast__StartReq), + 0, + eventcast__start_req__field_descriptors, + eventcast__start_req__field_indices_by_name, + 0, eventcast__start_req__number_ranges, + (ProtobufCMessageInit) eventcast__start_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor eventcast__start_ans__field_descriptors[1] = +{ + { + "result", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__StartAns, result), + &eventcast__message_result__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned eventcast__start_ans__field_indices_by_name[] = { + 0, /* field[0] = result */ +}; +static const ProtobufCIntRange eventcast__start_ans__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor eventcast__start_ans__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "eventcast.StartAns", + "StartAns", + "Eventcast__StartAns", + "eventcast", + sizeof(Eventcast__StartAns), + 1, + eventcast__start_ans__field_descriptors, + eventcast__start_ans__field_indices_by_name, + 1, eventcast__start_ans__number_ranges, + (ProtobufCMessageInit) eventcast__start_ans__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor eventcast__set_event_status__field_descriptors[2] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__SetEventStatus, type), + &eventcast__event_type__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "state", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__SetEventStatus, state), + &eventcast__state__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned eventcast__set_event_status__field_indices_by_name[] = { + 1, /* field[1] = state */ + 0, /* field[0] = type */ +}; +static const ProtobufCIntRange eventcast__set_event_status__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor eventcast__set_event_status__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "eventcast.SetEventStatus", + "SetEventStatus", + "Eventcast__SetEventStatus", + "eventcast", + sizeof(Eventcast__SetEventStatus), + 2, + eventcast__set_event_status__field_descriptors, + eventcast__set_event_status__field_indices_by_name, + 1, eventcast__set_event_status__number_ranges, + (ProtobufCMessageInit) eventcast__set_event_status__init, + NULL,NULL,NULL /* reserved[123] */ +}; +const ProtobufCEnumValue eventcast__event_msg__type__enum_values_by_number[4] = +{ + { "START_REQ", "EVENTCAST__EVENT_MSG__TYPE__START_REQ", 2 }, + { "START_ANS", "EVENTCAST__EVENT_MSG__TYPE__START_ANS", 3 }, + { "TERMINATE", "EVENTCAST__EVENT_MSG__TYPE__TERMINATE", 4 }, + { "EVENT_STATUS", "EVENTCAST__EVENT_MSG__TYPE__EVENT_STATUS", 5 }, +}; +static const ProtobufCIntRange eventcast__event_msg__type__value_ranges[] = { +{2, 0},{0, 4} +}; +const ProtobufCEnumValueIndex eventcast__event_msg__type__enum_values_by_name[4] = +{ + { "EVENT_STATUS", 3 }, + { "START_ANS", 1 }, + { "START_REQ", 0 }, + { "TERMINATE", 2 }, +}; +const ProtobufCEnumDescriptor eventcast__event_msg__type__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "eventcast.EventMsg.TYPE", + "TYPE", + "Eventcast__EventMsg__TYPE", + "eventcast", + 4, + eventcast__event_msg__type__enum_values_by_number, + 4, + eventcast__event_msg__type__enum_values_by_name, + 1, + eventcast__event_msg__type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCFieldDescriptor eventcast__event_msg__field_descriptors[5] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__EventMsg, type), + &eventcast__event_msg__type__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "startReq", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__EventMsg, startreq), + &eventcast__start_req__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "startAns", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__EventMsg, startans), + &eventcast__start_ans__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "terminate", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__EventMsg, terminate), + &eventcast__event_terminate__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "setStatus", + 5, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__EventMsg, setstatus), + &eventcast__set_event_status__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned eventcast__event_msg__field_indices_by_name[] = { + 4, /* field[4] = setStatus */ + 2, /* field[2] = startAns */ + 1, /* field[1] = startReq */ + 3, /* field[3] = terminate */ + 0, /* field[0] = type */ +}; +static const ProtobufCIntRange eventcast__event_msg__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor eventcast__event_msg__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "eventcast.EventMsg", + "EventMsg", + "Eventcast__EventMsg", + "eventcast", + sizeof(Eventcast__EventMsg), + 5, + eventcast__event_msg__field_descriptors, + eventcast__event_msg__field_indices_by_name, + 1, eventcast__event_msg__number_ranges, + (ProtobufCMessageInit) eventcast__event_msg__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define eventcast__event_terminate__field_descriptors NULL +#define eventcast__event_terminate__field_indices_by_name NULL +#define eventcast__event_terminate__number_ranges NULL +const ProtobufCMessageDescriptor eventcast__event_terminate__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "eventcast.EventTerminate", + "EventTerminate", + "Eventcast__EventTerminate", + "eventcast", + sizeof(Eventcast__EventTerminate), + 0, + eventcast__event_terminate__field_descriptors, + eventcast__event_terminate__field_indices_by_name, + 0, eventcast__event_terminate__number_ranges, + (ProtobufCMessageInit) eventcast__event_terminate__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor eventcast__set_sensor_status__field_descriptors[2] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__SetSensorStatus, type), + &eventcast__sensor_type__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "state", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__SetSensorStatus, state), + &eventcast__state__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned eventcast__set_sensor_status__field_indices_by_name[] = { + 1, /* field[1] = state */ + 0, /* field[0] = type */ +}; +static const ProtobufCIntRange eventcast__set_sensor_status__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor eventcast__set_sensor_status__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "eventcast.SetSensorStatus", + "SetSensorStatus", + "Eventcast__SetSensorStatus", + "eventcast", + sizeof(Eventcast__SetSensorStatus), + 2, + eventcast__set_sensor_status__field_descriptors, + eventcast__set_sensor_status__field_indices_by_name, + 1, eventcast__set_sensor_status__number_ranges, + (ProtobufCMessageInit) eventcast__set_sensor_status__init, + NULL,NULL,NULL /* reserved[123] */ +}; +char eventcast__sensor_data__x__default_value[] = "0"; +char eventcast__sensor_data__y__default_value[] = "0"; +char eventcast__sensor_data__z__default_value[] = "0"; +static const ProtobufCFieldDescriptor eventcast__sensor_data__field_descriptors[4] = +{ + { + "sensor", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__SensorData, sensor), + &eventcast__sensor_type__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "x", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__SensorData, x), + NULL, + &eventcast__sensor_data__x__default_value, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "y", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__SensorData, y), + NULL, + &eventcast__sensor_data__y__default_value, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "z", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__SensorData, z), + NULL, + &eventcast__sensor_data__z__default_value, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned eventcast__sensor_data__field_indices_by_name[] = { + 0, /* field[0] = sensor */ + 1, /* field[1] = x */ + 2, /* field[2] = y */ + 3, /* field[3] = z */ +}; +static const ProtobufCIntRange eventcast__sensor_data__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor eventcast__sensor_data__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "eventcast.SensorData", + "SensorData", + "Eventcast__SensorData", + "eventcast", + sizeof(Eventcast__SensorData), + 4, + eventcast__sensor_data__field_descriptors, + eventcast__sensor_data__field_indices_by_name, + 1, eventcast__sensor_data__number_ranges, + (ProtobufCMessageInit) eventcast__sensor_data__init, + NULL,NULL,NULL /* reserved[123] */ +}; +const ProtobufCEnumValue eventcast__sensor_msg__type__enum_values_by_number[5] = +{ + { "START_REQ", "EVENTCAST__SENSOR_MSG__TYPE__START_REQ", 2 }, + { "START_ANS", "EVENTCAST__SENSOR_MSG__TYPE__START_ANS", 3 }, + { "TERMINATE", "EVENTCAST__SENSOR_MSG__TYPE__TERMINATE", 4 }, + { "SENSOR_STATUS", "EVENTCAST__SENSOR_MSG__TYPE__SENSOR_STATUS", 5 }, + { "SENSOR_DATA", "EVENTCAST__SENSOR_MSG__TYPE__SENSOR_DATA", 6 }, +}; +static const ProtobufCIntRange eventcast__sensor_msg__type__value_ranges[] = { +{2, 0},{0, 5} +}; +const ProtobufCEnumValueIndex eventcast__sensor_msg__type__enum_values_by_name[5] = +{ + { "SENSOR_DATA", 4 }, + { "SENSOR_STATUS", 3 }, + { "START_ANS", 1 }, + { "START_REQ", 0 }, + { "TERMINATE", 2 }, +}; +const ProtobufCEnumDescriptor eventcast__sensor_msg__type__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "eventcast.SensorMsg.Type", + "Type", + "Eventcast__SensorMsg__Type", + "eventcast", + 5, + eventcast__sensor_msg__type__enum_values_by_number, + 5, + eventcast__sensor_msg__type__enum_values_by_name, + 1, + eventcast__sensor_msg__type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCFieldDescriptor eventcast__sensor_msg__field_descriptors[6] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__SensorMsg, type), + &eventcast__sensor_msg__type__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "startReq", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__SensorMsg, startreq), + &eventcast__start_req__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "startAns", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__SensorMsg, startans), + &eventcast__start_ans__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "terminate", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__SensorMsg, terminate), + &eventcast__event_terminate__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "setStatus", + 5, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__SensorMsg, setstatus), + &eventcast__set_sensor_status__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "data", + 6, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__SensorMsg, data), + &eventcast__sensor_data__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned eventcast__sensor_msg__field_indices_by_name[] = { + 5, /* field[5] = data */ + 4, /* field[4] = setStatus */ + 2, /* field[2] = startAns */ + 1, /* field[1] = startReq */ + 3, /* field[3] = terminate */ + 0, /* field[0] = type */ +}; +static const ProtobufCIntRange eventcast__sensor_msg__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 6 } +}; +const ProtobufCMessageDescriptor eventcast__sensor_msg__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "eventcast.SensorMsg", + "SensorMsg", + "Eventcast__SensorMsg", + "eventcast", + sizeof(Eventcast__SensorMsg), + 6, + eventcast__sensor_msg__field_descriptors, + eventcast__sensor_msg__field_indices_by_name, + 1, eventcast__sensor_msg__number_ranges, + (ProtobufCMessageInit) eventcast__sensor_msg__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor eventcast__resolution__field_descriptors[2] = +{ + { + "width", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__Resolution, width), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "height", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__Resolution, height), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned eventcast__resolution__field_indices_by_name[] = { + 1, /* field[1] = height */ + 0, /* field[0] = width */ +}; +static const ProtobufCIntRange eventcast__resolution__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor eventcast__resolution__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "eventcast.Resolution", + "Resolution", + "Eventcast__Resolution", + "eventcast", + sizeof(Eventcast__Resolution), + 2, + eventcast__resolution__field_descriptors, + eventcast__resolution__field_indices_by_name, + 1, eventcast__resolution__number_ranges, + (ProtobufCMessageInit) eventcast__resolution__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor eventcast__display_msg__field_descriptors[2] = +{ + { + "frameRate", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + PROTOBUF_C_OFFSETOF(Eventcast__DisplayMsg, has_framerate), + PROTOBUF_C_OFFSETOF(Eventcast__DisplayMsg, framerate), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "imageData", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BYTES, + PROTOBUF_C_OFFSETOF(Eventcast__DisplayMsg, has_imagedata), + PROTOBUF_C_OFFSETOF(Eventcast__DisplayMsg, imagedata), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned eventcast__display_msg__field_indices_by_name[] = { + 0, /* field[0] = frameRate */ + 1, /* field[1] = imageData */ +}; +static const ProtobufCIntRange eventcast__display_msg__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor eventcast__display_msg__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "eventcast.DisplayMsg", + "DisplayMsg", + "Eventcast__DisplayMsg", + "eventcast", + sizeof(Eventcast__DisplayMsg), + 2, + eventcast__display_msg__field_descriptors, + eventcast__display_msg__field_indices_by_name, + 1, eventcast__display_msg__number_ranges, + (ProtobufCMessageInit) eventcast__display_msg__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const int32_t eventcast__touch_max_count__max__default_value = 10; +static const ProtobufCFieldDescriptor eventcast__touch_max_count__field_descriptors[1] = +{ + { + "max", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + PROTOBUF_C_OFFSETOF(Eventcast__TouchMaxCount, has_max), + PROTOBUF_C_OFFSETOF(Eventcast__TouchMaxCount, max), + NULL, + &eventcast__touch_max_count__max__default_value, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned eventcast__touch_max_count__field_indices_by_name[] = { + 0, /* field[0] = max */ +}; +static const ProtobufCIntRange eventcast__touch_max_count__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor eventcast__touch_max_count__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "eventcast.TouchMaxCount", + "TouchMaxCount", + "Eventcast__TouchMaxCount", + "eventcast", + sizeof(Eventcast__TouchMaxCount), + 1, + eventcast__touch_max_count__field_descriptors, + eventcast__touch_max_count__field_indices_by_name, + 1, eventcast__touch_max_count__number_ranges, + (ProtobufCMessageInit) eventcast__touch_max_count__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const int32_t eventcast__touch_data__index__default_value = 0; +static const float eventcast__touch_data__x_point__default_value = 0; +static const float eventcast__touch_data__y_point__default_value = 0; +static const ProtobufCFieldDescriptor eventcast__touch_data__field_descriptors[4] = +{ + { + "index", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + PROTOBUF_C_OFFSETOF(Eventcast__TouchData, has_index), + PROTOBUF_C_OFFSETOF(Eventcast__TouchData, index), + NULL, + &eventcast__touch_data__index__default_value, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "xPoint", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_FLOAT, + PROTOBUF_C_OFFSETOF(Eventcast__TouchData, has_xpoint), + PROTOBUF_C_OFFSETOF(Eventcast__TouchData, xpoint), + NULL, + &eventcast__touch_data__x_point__default_value, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "yPoint", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_FLOAT, + PROTOBUF_C_OFFSETOF(Eventcast__TouchData, has_ypoint), + PROTOBUF_C_OFFSETOF(Eventcast__TouchData, ypoint), + NULL, + &eventcast__touch_data__y_point__default_value, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "state", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_ENUM, + PROTOBUF_C_OFFSETOF(Eventcast__TouchData, has_state), + PROTOBUF_C_OFFSETOF(Eventcast__TouchData, state), + &eventcast__touch_state__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned eventcast__touch_data__field_indices_by_name[] = { + 0, /* field[0] = index */ + 3, /* field[3] = state */ + 1, /* field[1] = xPoint */ + 2, /* field[2] = yPoint */ +}; +static const ProtobufCIntRange eventcast__touch_data__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor eventcast__touch_data__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "eventcast.TouchData", + "TouchData", + "Eventcast__TouchData", + "eventcast", + sizeof(Eventcast__TouchData), + 4, + eventcast__touch_data__field_descriptors, + eventcast__touch_data__field_indices_by_name, + 1, eventcast__touch_data__number_ranges, + (ProtobufCMessageInit) eventcast__touch_data__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor eventcast__hwkey_msg__field_descriptors[1] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__HWKeyMsg, type), + &eventcast__hwkey_type__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned eventcast__hwkey_msg__field_indices_by_name[] = { + 0, /* field[0] = type */ +}; +static const ProtobufCIntRange eventcast__hwkey_msg__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor eventcast__hwkey_msg__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "eventcast.HWKeyMsg", + "HWKeyMsg", + "Eventcast__HWKeyMsg", + "eventcast", + sizeof(Eventcast__HWKeyMsg), + 1, + eventcast__hwkey_msg__field_descriptors, + eventcast__hwkey_msg__field_indices_by_name, + 1, eventcast__hwkey_msg__number_ranges, + (ProtobufCMessageInit) eventcast__hwkey_msg__init, + NULL,NULL,NULL /* reserved[123] */ +}; +const ProtobufCEnumValue eventcast__touch_msg__type__enum_values_by_number[8] = +{ + { "START_REQ", "EVENTCAST__TOUCH_MSG__TYPE__START_REQ", 2 }, + { "START_ANS", "EVENTCAST__TOUCH_MSG__TYPE__START_ANS", 3 }, + { "TERMINATE", "EVENTCAST__TOUCH_MSG__TYPE__TERMINATE", 4 }, + { "MAX_COUNT", "EVENTCAST__TOUCH_MSG__TYPE__MAX_COUNT", 5 }, + { "TOUCH_DATA", "EVENTCAST__TOUCH_MSG__TYPE__TOUCH_DATA", 6 }, + { "RESOLUTION", "EVENTCAST__TOUCH_MSG__TYPE__RESOLUTION", 7 }, + { "DISPLAY_MSG", "EVENTCAST__TOUCH_MSG__TYPE__DISPLAY_MSG", 8 }, + { "HWKEY_MSG", "EVENTCAST__TOUCH_MSG__TYPE__HWKEY_MSG", 9 }, +}; +static const ProtobufCIntRange eventcast__touch_msg__type__value_ranges[] = { +{2, 0},{0, 8} +}; +const ProtobufCEnumValueIndex eventcast__touch_msg__type__enum_values_by_name[8] = +{ + { "DISPLAY_MSG", 6 }, + { "HWKEY_MSG", 7 }, + { "MAX_COUNT", 3 }, + { "RESOLUTION", 5 }, + { "START_ANS", 1 }, + { "START_REQ", 0 }, + { "TERMINATE", 2 }, + { "TOUCH_DATA", 4 }, +}; +const ProtobufCEnumDescriptor eventcast__touch_msg__type__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "eventcast.TouchMsg.Type", + "Type", + "Eventcast__TouchMsg__Type", + "eventcast", + 8, + eventcast__touch_msg__type__enum_values_by_number, + 8, + eventcast__touch_msg__type__enum_values_by_name, + 1, + eventcast__touch_msg__type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCFieldDescriptor eventcast__touch_msg__field_descriptors[9] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__TouchMsg, type), + &eventcast__touch_msg__type__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "startReq", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__TouchMsg, startreq), + &eventcast__start_req__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "startAns", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__TouchMsg, startans), + &eventcast__start_ans__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "terminate", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__TouchMsg, terminate), + &eventcast__event_terminate__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "maxCount", + 5, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__TouchMsg, maxcount), + &eventcast__touch_max_count__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "touchData", + 6, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__TouchMsg, touchdata), + &eventcast__touch_data__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resolution", + 7, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__TouchMsg, resolution), + &eventcast__resolution__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "display", + 8, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__TouchMsg, display), + &eventcast__display_msg__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "hwkey", + 9, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__TouchMsg, hwkey), + &eventcast__hwkey_msg__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned eventcast__touch_msg__field_indices_by_name[] = { + 7, /* field[7] = display */ + 8, /* field[8] = hwkey */ + 4, /* field[4] = maxCount */ + 6, /* field[6] = resolution */ + 2, /* field[2] = startAns */ + 1, /* field[1] = startReq */ + 3, /* field[3] = terminate */ + 5, /* field[5] = touchData */ + 0, /* field[0] = type */ +}; +static const ProtobufCIntRange eventcast__touch_msg__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 9 } +}; +const ProtobufCMessageDescriptor eventcast__touch_msg__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "eventcast.TouchMsg", + "TouchMsg", + "Eventcast__TouchMsg", + "eventcast", + sizeof(Eventcast__TouchMsg), + 9, + eventcast__touch_msg__field_descriptors, + eventcast__touch_msg__field_indices_by_name, + 1, eventcast__touch_msg__number_ranges, + (ProtobufCMessageInit) eventcast__touch_msg__init, + NULL,NULL,NULL /* reserved[123] */ +}; +const ProtobufCEnumValue eventcast__event_cast_msg__type__enum_values_by_number[7] = +{ + { "HANDSHAKE_REQ", "EVENTCAST__EVENT_CAST_MSG__TYPE__HANDSHAKE_REQ", 2 }, + { "HANDSHAKE_ANS", "EVENTCAST__EVENT_CAST_MSG__TYPE__HANDSHAKE_ANS", 3 }, + { "EMUL_STATE", "EVENTCAST__EVENT_CAST_MSG__TYPE__EMUL_STATE", 4 }, + { "APP_STATE", "EVENTCAST__EVENT_CAST_MSG__TYPE__APP_STATE", 5 }, + { "EVENT_MSG", "EVENTCAST__EVENT_CAST_MSG__TYPE__EVENT_MSG", 6 }, + { "SENSOR_MSG", "EVENTCAST__EVENT_CAST_MSG__TYPE__SENSOR_MSG", 7 }, + { "TOUCH_MSG", "EVENTCAST__EVENT_CAST_MSG__TYPE__TOUCH_MSG", 8 }, +}; +static const ProtobufCIntRange eventcast__event_cast_msg__type__value_ranges[] = { +{2, 0},{0, 7} +}; +const ProtobufCEnumValueIndex eventcast__event_cast_msg__type__enum_values_by_name[7] = +{ + { "APP_STATE", 3 }, + { "EMUL_STATE", 2 }, + { "EVENT_MSG", 4 }, + { "HANDSHAKE_ANS", 1 }, + { "HANDSHAKE_REQ", 0 }, + { "SENSOR_MSG", 5 }, + { "TOUCH_MSG", 6 }, +}; +const ProtobufCEnumDescriptor eventcast__event_cast_msg__type__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "eventcast.EventCastMsg.Type", + "Type", + "Eventcast__EventCastMsg__Type", + "eventcast", + 7, + eventcast__event_cast_msg__type__enum_values_by_number, + 7, + eventcast__event_cast_msg__type__enum_values_by_name, + 1, + eventcast__event_cast_msg__type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCFieldDescriptor eventcast__event_cast_msg__field_descriptors[8] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__EventCastMsg, type), + &eventcast__event_cast_msg__type__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "handShakeReq", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__EventCastMsg, handshakereq), + &eventcast__hand_shake_req__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "handShakeAns", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__EventCastMsg, handshakeans), + &eventcast__hand_shake_ans__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "emulState", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__EventCastMsg, emulstate), + &eventcast__emulator_state__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "appState", + 5, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__EventCastMsg, appstate), + &eventcast__app_state__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "eventMsg", + 6, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__EventCastMsg, eventmsg), + &eventcast__event_msg__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sensorMsg", + 7, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__EventCastMsg, sensormsg), + &eventcast__sensor_msg__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "touchMsg", + 8, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Eventcast__EventCastMsg, touchmsg), + &eventcast__touch_msg__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned eventcast__event_cast_msg__field_indices_by_name[] = { + 4, /* field[4] = appState */ + 3, /* field[3] = emulState */ + 5, /* field[5] = eventMsg */ + 2, /* field[2] = handShakeAns */ + 1, /* field[1] = handShakeReq */ + 6, /* field[6] = sensorMsg */ + 7, /* field[7] = touchMsg */ + 0, /* field[0] = type */ +}; +static const ProtobufCIntRange eventcast__event_cast_msg__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 8 } +}; +const ProtobufCMessageDescriptor eventcast__event_cast_msg__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "eventcast.EventCastMsg", + "EventCastMsg", + "Eventcast__EventCastMsg", + "eventcast", + sizeof(Eventcast__EventCastMsg), + 8, + eventcast__event_cast_msg__field_descriptors, + eventcast__event_cast_msg__field_indices_by_name, + 1, eventcast__event_cast_msg__number_ranges, + (ProtobufCMessageInit) eventcast__event_cast_msg__init, + NULL,NULL,NULL /* reserved[123] */ +}; +const ProtobufCEnumValue eventcast__message_result__enum_values_by_number[3] = +{ + { "SUCCESS", "EVENTCAST__MESSAGE_RESULT__SUCCESS", 1 }, + { "FAILURE", "EVENTCAST__MESSAGE_RESULT__FAILURE", 2 }, + { "CANCEL", "EVENTCAST__MESSAGE_RESULT__CANCEL", 3 }, +}; +static const ProtobufCIntRange eventcast__message_result__value_ranges[] = { +{1, 0},{0, 3} +}; +const ProtobufCEnumValueIndex eventcast__message_result__enum_values_by_name[3] = +{ + { "CANCEL", 2 }, + { "FAILURE", 1 }, + { "SUCCESS", 0 }, +}; +const ProtobufCEnumDescriptor eventcast__message_result__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "eventcast.MessageResult", + "MessageResult", + "Eventcast__MessageResult", + "eventcast", + 3, + eventcast__message_result__enum_values_by_number, + 3, + eventcast__message_result__enum_values_by_name, + 1, + eventcast__message_result__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +const ProtobufCEnumValue eventcast__connection_state__enum_values_by_number[3] = +{ + { "CONNECTED", "EVENTCAST__CONNECTION_STATE__CONNECTED", 1 }, + { "DISCONNECTED", "EVENTCAST__CONNECTION_STATE__DISCONNECTED", 2 }, + { "TERMINATED", "EVENTCAST__CONNECTION_STATE__TERMINATED", 3 }, +}; +static const ProtobufCIntRange eventcast__connection_state__value_ranges[] = { +{1, 0},{0, 3} +}; +const ProtobufCEnumValueIndex eventcast__connection_state__enum_values_by_name[3] = +{ + { "CONNECTED", 0 }, + { "DISCONNECTED", 1 }, + { "TERMINATED", 2 }, +}; +const ProtobufCEnumDescriptor eventcast__connection_state__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "eventcast.ConnectionState", + "ConnectionState", + "Eventcast__ConnectionState", + "eventcast", + 3, + eventcast__connection_state__enum_values_by_number, + 3, + eventcast__connection_state__enum_values_by_name, + 1, + eventcast__connection_state__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +const ProtobufCEnumValue eventcast__event_type__enum_values_by_number[2] = +{ + { "SENSOR", "EVENTCAST__EVENT_TYPE__SENSOR", 1 }, + { "TOUCH", "EVENTCAST__EVENT_TYPE__TOUCH", 2 }, +}; +static const ProtobufCIntRange eventcast__event_type__value_ranges[] = { +{1, 0},{0, 2} +}; +const ProtobufCEnumValueIndex eventcast__event_type__enum_values_by_name[2] = +{ + { "SENSOR", 0 }, + { "TOUCH", 1 }, +}; +const ProtobufCEnumDescriptor eventcast__event_type__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "eventcast.EventType", + "EventType", + "Eventcast__EventType", + "eventcast", + 2, + eventcast__event_type__enum_values_by_number, + 2, + eventcast__event_type__enum_values_by_name, + 1, + eventcast__event_type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +const ProtobufCEnumValue eventcast__state__enum_values_by_number[2] = +{ + { "ENABLED", "EVENTCAST__STATE__ENABLED", 1 }, + { "DISABLED", "EVENTCAST__STATE__DISABLED", 2 }, +}; +static const ProtobufCIntRange eventcast__state__value_ranges[] = { +{1, 0},{0, 2} +}; +const ProtobufCEnumValueIndex eventcast__state__enum_values_by_name[2] = +{ + { "DISABLED", 1 }, + { "ENABLED", 0 }, +}; +const ProtobufCEnumDescriptor eventcast__state__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "eventcast.State", + "State", + "Eventcast__State", + "eventcast", + 2, + eventcast__state__enum_values_by_number, + 2, + eventcast__state__enum_values_by_name, + 1, + eventcast__state__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +const ProtobufCEnumValue eventcast__sensor_type__enum_values_by_number[5] = +{ + { "ACCEL", "EVENTCAST__SENSOR_TYPE__ACCEL", 1 }, + { "MAGNETIC", "EVENTCAST__SENSOR_TYPE__MAGNETIC", 2 }, + { "GYROSCOPE", "EVENTCAST__SENSOR_TYPE__GYROSCOPE", 3 }, + { "PROXIMITY", "EVENTCAST__SENSOR_TYPE__PROXIMITY", 4 }, + { "LIGHT", "EVENTCAST__SENSOR_TYPE__LIGHT", 5 }, +}; +static const ProtobufCIntRange eventcast__sensor_type__value_ranges[] = { +{1, 0},{0, 5} +}; +const ProtobufCEnumValueIndex eventcast__sensor_type__enum_values_by_name[5] = +{ + { "ACCEL", 0 }, + { "GYROSCOPE", 2 }, + { "LIGHT", 4 }, + { "MAGNETIC", 1 }, + { "PROXIMITY", 3 }, +}; +const ProtobufCEnumDescriptor eventcast__sensor_type__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "eventcast.SensorType", + "SensorType", + "Eventcast__SensorType", + "eventcast", + 5, + eventcast__sensor_type__enum_values_by_number, + 5, + eventcast__sensor_type__enum_values_by_name, + 1, + eventcast__sensor_type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +const ProtobufCEnumValue eventcast__touch_state__enum_values_by_number[2] = +{ + { "PRESSED", "EVENTCAST__TOUCH_STATE__PRESSED", 1 }, + { "RELEASED", "EVENTCAST__TOUCH_STATE__RELEASED", 2 }, +}; +static const ProtobufCIntRange eventcast__touch_state__value_ranges[] = { +{1, 0},{0, 2} +}; +const ProtobufCEnumValueIndex eventcast__touch_state__enum_values_by_name[2] = +{ + { "PRESSED", 0 }, + { "RELEASED", 1 }, +}; +const ProtobufCEnumDescriptor eventcast__touch_state__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "eventcast.TouchState", + "TouchState", + "Eventcast__TouchState", + "eventcast", + 2, + eventcast__touch_state__enum_values_by_number, + 2, + eventcast__touch_state__enum_values_by_name, + 1, + eventcast__touch_state__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +const ProtobufCEnumValue eventcast__hwkey_type__enum_values_by_number[6] = +{ + { "MENU", "EVENTCAST__HWKEY_TYPE__MENU", 1 }, + { "HOME", "EVENTCAST__HWKEY_TYPE__HOME", 2 }, + { "BACK", "EVENTCAST__HWKEY_TYPE__BACK", 3 }, + { "POWER", "EVENTCAST__HWKEY_TYPE__POWER", 4 }, + { "VOLUME_UP", "EVENTCAST__HWKEY_TYPE__VOLUME_UP", 5 }, + { "VOLUME_DOWN", "EVENTCAST__HWKEY_TYPE__VOLUME_DOWN", 6 }, +}; +static const ProtobufCIntRange eventcast__hwkey_type__value_ranges[] = { +{1, 0},{0, 6} +}; +const ProtobufCEnumValueIndex eventcast__hwkey_type__enum_values_by_name[6] = +{ + { "BACK", 2 }, + { "HOME", 1 }, + { "MENU", 0 }, + { "POWER", 3 }, + { "VOLUME_DOWN", 5 }, + { "VOLUME_UP", 4 }, +}; +const ProtobufCEnumDescriptor eventcast__hwkey_type__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "eventcast.HWKeyType", + "HWKeyType", + "Eventcast__HWKeyType", + "eventcast", + 6, + eventcast__hwkey_type__enum_values_by_number, + 6, + eventcast__hwkey_type__enum_values_by_name, + 1, + eventcast__hwkey_type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; diff --git a/tizen/src/eventcast/genmsg/eventcast.pb-c.h b/tizen/src/eventcast/genmsg/eventcast.pb-c.h new file mode 100644 index 0000000000..92f55044bc --- /dev/null +++ b/tizen/src/eventcast/genmsg/eventcast.pb-c.h @@ -0,0 +1,798 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ + +#ifndef PROTOBUF_C_eventcast_2eproto__INCLUDED +#define PROTOBUF_C_eventcast_2eproto__INCLUDED + +#include + +PROTOBUF_C_BEGIN_DECLS + + +typedef struct _Eventcast__HandShakeReq Eventcast__HandShakeReq; +typedef struct _Eventcast__HandShakeAns Eventcast__HandShakeAns; +typedef struct _Eventcast__EmulatorState Eventcast__EmulatorState; +typedef struct _Eventcast__AppState Eventcast__AppState; +typedef struct _Eventcast__StartReq Eventcast__StartReq; +typedef struct _Eventcast__StartAns Eventcast__StartAns; +typedef struct _Eventcast__SetEventStatus Eventcast__SetEventStatus; +typedef struct _Eventcast__EventMsg Eventcast__EventMsg; +typedef struct _Eventcast__EventTerminate Eventcast__EventTerminate; +typedef struct _Eventcast__SetSensorStatus Eventcast__SetSensorStatus; +typedef struct _Eventcast__SensorData Eventcast__SensorData; +typedef struct _Eventcast__SensorMsg Eventcast__SensorMsg; +typedef struct _Eventcast__Resolution Eventcast__Resolution; +typedef struct _Eventcast__DisplayMsg Eventcast__DisplayMsg; +typedef struct _Eventcast__TouchMaxCount Eventcast__TouchMaxCount; +typedef struct _Eventcast__TouchData Eventcast__TouchData; +typedef struct _Eventcast__HWKeyMsg Eventcast__HWKeyMsg; +typedef struct _Eventcast__TouchMsg Eventcast__TouchMsg; +typedef struct _Eventcast__EventCastMsg Eventcast__EventCastMsg; + + +/* --- enums --- */ + +typedef enum _Eventcast__EventMsg__TYPE { + EVENTCAST__EVENT_MSG__TYPE__START_REQ = 2, + EVENTCAST__EVENT_MSG__TYPE__START_ANS = 3, + EVENTCAST__EVENT_MSG__TYPE__TERMINATE = 4, + EVENTCAST__EVENT_MSG__TYPE__EVENT_STATUS = 5 +} Eventcast__EventMsg__TYPE; +typedef enum _Eventcast__SensorMsg__Type { + EVENTCAST__SENSOR_MSG__TYPE__START_REQ = 2, + EVENTCAST__SENSOR_MSG__TYPE__START_ANS = 3, + EVENTCAST__SENSOR_MSG__TYPE__TERMINATE = 4, + EVENTCAST__SENSOR_MSG__TYPE__SENSOR_STATUS = 5, + EVENTCAST__SENSOR_MSG__TYPE__SENSOR_DATA = 6 +} Eventcast__SensorMsg__Type; +typedef enum _Eventcast__TouchMsg__Type { + EVENTCAST__TOUCH_MSG__TYPE__START_REQ = 2, + EVENTCAST__TOUCH_MSG__TYPE__START_ANS = 3, + EVENTCAST__TOUCH_MSG__TYPE__TERMINATE = 4, + EVENTCAST__TOUCH_MSG__TYPE__MAX_COUNT = 5, + EVENTCAST__TOUCH_MSG__TYPE__TOUCH_DATA = 6, + EVENTCAST__TOUCH_MSG__TYPE__RESOLUTION = 7, + EVENTCAST__TOUCH_MSG__TYPE__DISPLAY_MSG = 8, + EVENTCAST__TOUCH_MSG__TYPE__HWKEY_MSG = 9 +} Eventcast__TouchMsg__Type; +typedef enum _Eventcast__EventCastMsg__Type { + EVENTCAST__EVENT_CAST_MSG__TYPE__HANDSHAKE_REQ = 2, + EVENTCAST__EVENT_CAST_MSG__TYPE__HANDSHAKE_ANS = 3, + EVENTCAST__EVENT_CAST_MSG__TYPE__EMUL_STATE = 4, + EVENTCAST__EVENT_CAST_MSG__TYPE__APP_STATE = 5, + EVENTCAST__EVENT_CAST_MSG__TYPE__EVENT_MSG = 6, + EVENTCAST__EVENT_CAST_MSG__TYPE__SENSOR_MSG = 7, + EVENTCAST__EVENT_CAST_MSG__TYPE__TOUCH_MSG = 8 +} Eventcast__EventCastMsg__Type; +typedef enum _Eventcast__MessageResult { + EVENTCAST__MESSAGE_RESULT__SUCCESS = 1, + EVENTCAST__MESSAGE_RESULT__FAILURE = 2, + EVENTCAST__MESSAGE_RESULT__CANCEL = 3 +} Eventcast__MessageResult; +typedef enum _Eventcast__ConnectionState { + EVENTCAST__CONNECTION_STATE__CONNECTED = 1, + EVENTCAST__CONNECTION_STATE__DISCONNECTED = 2, + EVENTCAST__CONNECTION_STATE__TERMINATED = 3 +} Eventcast__ConnectionState; +typedef enum _Eventcast__EventType { + EVENTCAST__EVENT_TYPE__SENSOR = 1, + EVENTCAST__EVENT_TYPE__TOUCH = 2 +} Eventcast__EventType; +typedef enum _Eventcast__State { + EVENTCAST__STATE__ENABLED = 1, + EVENTCAST__STATE__DISABLED = 2 +} Eventcast__State; +typedef enum _Eventcast__SensorType { + EVENTCAST__SENSOR_TYPE__ACCEL = 1, + EVENTCAST__SENSOR_TYPE__MAGNETIC = 2, + EVENTCAST__SENSOR_TYPE__GYROSCOPE = 3, + EVENTCAST__SENSOR_TYPE__PROXIMITY = 4, + EVENTCAST__SENSOR_TYPE__LIGHT = 5 +} Eventcast__SensorType; +typedef enum _Eventcast__TouchState { + EVENTCAST__TOUCH_STATE__PRESSED = 1, + EVENTCAST__TOUCH_STATE__RELEASED = 2 +} Eventcast__TouchState; +typedef enum _Eventcast__HWKeyType { + EVENTCAST__HWKEY_TYPE__MENU = 1, + EVENTCAST__HWKEY_TYPE__HOME = 2, + EVENTCAST__HWKEY_TYPE__BACK = 3, + EVENTCAST__HWKEY_TYPE__POWER = 4, + EVENTCAST__HWKEY_TYPE__VOLUME_UP = 5, + EVENTCAST__HWKEY_TYPE__VOLUME_DOWN = 6 +} Eventcast__HWKeyType; + +/* --- messages --- */ + +struct _Eventcast__HandShakeReq +{ + ProtobufCMessage base; + int32_t key; +}; +#define EVENTCAST__HAND_SHAKE_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&eventcast__hand_shake_req__descriptor) \ + , 0 } + + +struct _Eventcast__HandShakeAns +{ + ProtobufCMessage base; + Eventcast__MessageResult result; +}; +#define EVENTCAST__HAND_SHAKE_ANS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&eventcast__hand_shake_ans__descriptor) \ + , 0 } + + +struct _Eventcast__EmulatorState +{ + ProtobufCMessage base; + Eventcast__ConnectionState state; +}; +#define EVENTCAST__EMULATOR_STATE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&eventcast__emulator_state__descriptor) \ + , 0 } + + +struct _Eventcast__AppState +{ + ProtobufCMessage base; + Eventcast__ConnectionState state; +}; +#define EVENTCAST__APP_STATE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&eventcast__app_state__descriptor) \ + , 0 } + + +struct _Eventcast__StartReq +{ + ProtobufCMessage base; +}; +#define EVENTCAST__START_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&eventcast__start_req__descriptor) \ + } + + +struct _Eventcast__StartAns +{ + ProtobufCMessage base; + Eventcast__MessageResult result; +}; +#define EVENTCAST__START_ANS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&eventcast__start_ans__descriptor) \ + , 0 } + + +struct _Eventcast__SetEventStatus +{ + ProtobufCMessage base; + Eventcast__EventType type; + Eventcast__State state; +}; +#define EVENTCAST__SET_EVENT_STATUS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&eventcast__set_event_status__descriptor) \ + , 0, 0 } + + +struct _Eventcast__EventMsg +{ + ProtobufCMessage base; + Eventcast__EventMsg__TYPE type; + Eventcast__StartReq *startreq; + Eventcast__StartAns *startans; + Eventcast__EventTerminate *terminate; + Eventcast__SetEventStatus *setstatus; +}; +#define EVENTCAST__EVENT_MSG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&eventcast__event_msg__descriptor) \ + , 0, NULL, NULL, NULL, NULL } + + +struct _Eventcast__EventTerminate +{ + ProtobufCMessage base; +}; +#define EVENTCAST__EVENT_TERMINATE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&eventcast__event_terminate__descriptor) \ + } + + +struct _Eventcast__SetSensorStatus +{ + ProtobufCMessage base; + Eventcast__SensorType type; + Eventcast__State state; +}; +#define EVENTCAST__SET_SENSOR_STATUS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&eventcast__set_sensor_status__descriptor) \ + , 0, 0 } + + +struct _Eventcast__SensorData +{ + ProtobufCMessage base; + Eventcast__SensorType sensor; + char *x; + char *y; + char *z; +}; +extern char eventcast__sensor_data__x__default_value[]; +extern char eventcast__sensor_data__y__default_value[]; +extern char eventcast__sensor_data__z__default_value[]; +#define EVENTCAST__SENSOR_DATA__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&eventcast__sensor_data__descriptor) \ + , 0, eventcast__sensor_data__x__default_value, eventcast__sensor_data__y__default_value, eventcast__sensor_data__z__default_value } + + +struct _Eventcast__SensorMsg +{ + ProtobufCMessage base; + Eventcast__SensorMsg__Type type; + Eventcast__StartReq *startreq; + Eventcast__StartAns *startans; + Eventcast__EventTerminate *terminate; + Eventcast__SetSensorStatus *setstatus; + Eventcast__SensorData *data; +}; +#define EVENTCAST__SENSOR_MSG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&eventcast__sensor_msg__descriptor) \ + , 0, NULL, NULL, NULL, NULL, NULL } + + +struct _Eventcast__Resolution +{ + ProtobufCMessage base; + int32_t width; + int32_t height; +}; +#define EVENTCAST__RESOLUTION__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&eventcast__resolution__descriptor) \ + , 0, 0 } + + +struct _Eventcast__DisplayMsg +{ + ProtobufCMessage base; + protobuf_c_boolean has_framerate; + int32_t framerate; + protobuf_c_boolean has_imagedata; + ProtobufCBinaryData imagedata; +}; +#define EVENTCAST__DISPLAY_MSG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&eventcast__display_msg__descriptor) \ + , 0,0, 0,{0,NULL} } + + +struct _Eventcast__TouchMaxCount +{ + ProtobufCMessage base; + protobuf_c_boolean has_max; + int32_t max; +}; +#define EVENTCAST__TOUCH_MAX_COUNT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&eventcast__touch_max_count__descriptor) \ + , 0,10 } + + +struct _Eventcast__TouchData +{ + ProtobufCMessage base; + protobuf_c_boolean has_index; + int32_t index; + protobuf_c_boolean has_xpoint; + float xpoint; + protobuf_c_boolean has_ypoint; + float ypoint; + protobuf_c_boolean has_state; + Eventcast__TouchState state; +}; +#define EVENTCAST__TOUCH_DATA__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&eventcast__touch_data__descriptor) \ + , 0,0, 0,0, 0,0, 0,0 } + + +struct _Eventcast__HWKeyMsg +{ + ProtobufCMessage base; + Eventcast__HWKeyType type; +}; +#define EVENTCAST__HWKEY_MSG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&eventcast__hwkey_msg__descriptor) \ + , 0 } + + +struct _Eventcast__TouchMsg +{ + ProtobufCMessage base; + Eventcast__TouchMsg__Type type; + Eventcast__StartReq *startreq; + Eventcast__StartAns *startans; + Eventcast__EventTerminate *terminate; + Eventcast__TouchMaxCount *maxcount; + Eventcast__TouchData *touchdata; + Eventcast__Resolution *resolution; + Eventcast__DisplayMsg *display; + Eventcast__HWKeyMsg *hwkey; +}; +#define EVENTCAST__TOUCH_MSG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&eventcast__touch_msg__descriptor) \ + , 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL } + + +struct _Eventcast__EventCastMsg +{ + ProtobufCMessage base; + Eventcast__EventCastMsg__Type type; + Eventcast__HandShakeReq *handshakereq; + Eventcast__HandShakeAns *handshakeans; + Eventcast__EmulatorState *emulstate; + Eventcast__AppState *appstate; + Eventcast__EventMsg *eventmsg; + Eventcast__SensorMsg *sensormsg; + Eventcast__TouchMsg *touchmsg; +}; +#define EVENTCAST__EVENT_CAST_MSG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&eventcast__event_cast_msg__descriptor) \ + , 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL } + + +/* Eventcast__HandShakeReq methods */ +void eventcast__hand_shake_req__init + (Eventcast__HandShakeReq *message); +size_t eventcast__hand_shake_req__get_packed_size + (const Eventcast__HandShakeReq *message); +size_t eventcast__hand_shake_req__pack + (const Eventcast__HandShakeReq *message, + uint8_t *out); +size_t eventcast__hand_shake_req__pack_to_buffer + (const Eventcast__HandShakeReq *message, + ProtobufCBuffer *buffer); +Eventcast__HandShakeReq * + eventcast__hand_shake_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void eventcast__hand_shake_req__free_unpacked + (Eventcast__HandShakeReq *message, + ProtobufCAllocator *allocator); +/* Eventcast__HandShakeAns methods */ +void eventcast__hand_shake_ans__init + (Eventcast__HandShakeAns *message); +size_t eventcast__hand_shake_ans__get_packed_size + (const Eventcast__HandShakeAns *message); +size_t eventcast__hand_shake_ans__pack + (const Eventcast__HandShakeAns *message, + uint8_t *out); +size_t eventcast__hand_shake_ans__pack_to_buffer + (const Eventcast__HandShakeAns *message, + ProtobufCBuffer *buffer); +Eventcast__HandShakeAns * + eventcast__hand_shake_ans__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void eventcast__hand_shake_ans__free_unpacked + (Eventcast__HandShakeAns *message, + ProtobufCAllocator *allocator); +/* Eventcast__EmulatorState methods */ +void eventcast__emulator_state__init + (Eventcast__EmulatorState *message); +size_t eventcast__emulator_state__get_packed_size + (const Eventcast__EmulatorState *message); +size_t eventcast__emulator_state__pack + (const Eventcast__EmulatorState *message, + uint8_t *out); +size_t eventcast__emulator_state__pack_to_buffer + (const Eventcast__EmulatorState *message, + ProtobufCBuffer *buffer); +Eventcast__EmulatorState * + eventcast__emulator_state__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void eventcast__emulator_state__free_unpacked + (Eventcast__EmulatorState *message, + ProtobufCAllocator *allocator); +/* Eventcast__AppState methods */ +void eventcast__app_state__init + (Eventcast__AppState *message); +size_t eventcast__app_state__get_packed_size + (const Eventcast__AppState *message); +size_t eventcast__app_state__pack + (const Eventcast__AppState *message, + uint8_t *out); +size_t eventcast__app_state__pack_to_buffer + (const Eventcast__AppState *message, + ProtobufCBuffer *buffer); +Eventcast__AppState * + eventcast__app_state__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void eventcast__app_state__free_unpacked + (Eventcast__AppState *message, + ProtobufCAllocator *allocator); +/* Eventcast__StartReq methods */ +void eventcast__start_req__init + (Eventcast__StartReq *message); +size_t eventcast__start_req__get_packed_size + (const Eventcast__StartReq *message); +size_t eventcast__start_req__pack + (const Eventcast__StartReq *message, + uint8_t *out); +size_t eventcast__start_req__pack_to_buffer + (const Eventcast__StartReq *message, + ProtobufCBuffer *buffer); +Eventcast__StartReq * + eventcast__start_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void eventcast__start_req__free_unpacked + (Eventcast__StartReq *message, + ProtobufCAllocator *allocator); +/* Eventcast__StartAns methods */ +void eventcast__start_ans__init + (Eventcast__StartAns *message); +size_t eventcast__start_ans__get_packed_size + (const Eventcast__StartAns *message); +size_t eventcast__start_ans__pack + (const Eventcast__StartAns *message, + uint8_t *out); +size_t eventcast__start_ans__pack_to_buffer + (const Eventcast__StartAns *message, + ProtobufCBuffer *buffer); +Eventcast__StartAns * + eventcast__start_ans__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void eventcast__start_ans__free_unpacked + (Eventcast__StartAns *message, + ProtobufCAllocator *allocator); +/* Eventcast__SetEventStatus methods */ +void eventcast__set_event_status__init + (Eventcast__SetEventStatus *message); +size_t eventcast__set_event_status__get_packed_size + (const Eventcast__SetEventStatus *message); +size_t eventcast__set_event_status__pack + (const Eventcast__SetEventStatus *message, + uint8_t *out); +size_t eventcast__set_event_status__pack_to_buffer + (const Eventcast__SetEventStatus *message, + ProtobufCBuffer *buffer); +Eventcast__SetEventStatus * + eventcast__set_event_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void eventcast__set_event_status__free_unpacked + (Eventcast__SetEventStatus *message, + ProtobufCAllocator *allocator); +/* Eventcast__EventMsg methods */ +void eventcast__event_msg__init + (Eventcast__EventMsg *message); +size_t eventcast__event_msg__get_packed_size + (const Eventcast__EventMsg *message); +size_t eventcast__event_msg__pack + (const Eventcast__EventMsg *message, + uint8_t *out); +size_t eventcast__event_msg__pack_to_buffer + (const Eventcast__EventMsg *message, + ProtobufCBuffer *buffer); +Eventcast__EventMsg * + eventcast__event_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void eventcast__event_msg__free_unpacked + (Eventcast__EventMsg *message, + ProtobufCAllocator *allocator); +/* Eventcast__EventTerminate methods */ +void eventcast__event_terminate__init + (Eventcast__EventTerminate *message); +size_t eventcast__event_terminate__get_packed_size + (const Eventcast__EventTerminate *message); +size_t eventcast__event_terminate__pack + (const Eventcast__EventTerminate *message, + uint8_t *out); +size_t eventcast__event_terminate__pack_to_buffer + (const Eventcast__EventTerminate *message, + ProtobufCBuffer *buffer); +Eventcast__EventTerminate * + eventcast__event_terminate__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void eventcast__event_terminate__free_unpacked + (Eventcast__EventTerminate *message, + ProtobufCAllocator *allocator); +/* Eventcast__SetSensorStatus methods */ +void eventcast__set_sensor_status__init + (Eventcast__SetSensorStatus *message); +size_t eventcast__set_sensor_status__get_packed_size + (const Eventcast__SetSensorStatus *message); +size_t eventcast__set_sensor_status__pack + (const Eventcast__SetSensorStatus *message, + uint8_t *out); +size_t eventcast__set_sensor_status__pack_to_buffer + (const Eventcast__SetSensorStatus *message, + ProtobufCBuffer *buffer); +Eventcast__SetSensorStatus * + eventcast__set_sensor_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void eventcast__set_sensor_status__free_unpacked + (Eventcast__SetSensorStatus *message, + ProtobufCAllocator *allocator); +/* Eventcast__SensorData methods */ +void eventcast__sensor_data__init + (Eventcast__SensorData *message); +size_t eventcast__sensor_data__get_packed_size + (const Eventcast__SensorData *message); +size_t eventcast__sensor_data__pack + (const Eventcast__SensorData *message, + uint8_t *out); +size_t eventcast__sensor_data__pack_to_buffer + (const Eventcast__SensorData *message, + ProtobufCBuffer *buffer); +Eventcast__SensorData * + eventcast__sensor_data__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void eventcast__sensor_data__free_unpacked + (Eventcast__SensorData *message, + ProtobufCAllocator *allocator); +/* Eventcast__SensorMsg methods */ +void eventcast__sensor_msg__init + (Eventcast__SensorMsg *message); +size_t eventcast__sensor_msg__get_packed_size + (const Eventcast__SensorMsg *message); +size_t eventcast__sensor_msg__pack + (const Eventcast__SensorMsg *message, + uint8_t *out); +size_t eventcast__sensor_msg__pack_to_buffer + (const Eventcast__SensorMsg *message, + ProtobufCBuffer *buffer); +Eventcast__SensorMsg * + eventcast__sensor_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void eventcast__sensor_msg__free_unpacked + (Eventcast__SensorMsg *message, + ProtobufCAllocator *allocator); +/* Eventcast__Resolution methods */ +void eventcast__resolution__init + (Eventcast__Resolution *message); +size_t eventcast__resolution__get_packed_size + (const Eventcast__Resolution *message); +size_t eventcast__resolution__pack + (const Eventcast__Resolution *message, + uint8_t *out); +size_t eventcast__resolution__pack_to_buffer + (const Eventcast__Resolution *message, + ProtobufCBuffer *buffer); +Eventcast__Resolution * + eventcast__resolution__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void eventcast__resolution__free_unpacked + (Eventcast__Resolution *message, + ProtobufCAllocator *allocator); +/* Eventcast__DisplayMsg methods */ +void eventcast__display_msg__init + (Eventcast__DisplayMsg *message); +size_t eventcast__display_msg__get_packed_size + (const Eventcast__DisplayMsg *message); +size_t eventcast__display_msg__pack + (const Eventcast__DisplayMsg *message, + uint8_t *out); +size_t eventcast__display_msg__pack_to_buffer + (const Eventcast__DisplayMsg *message, + ProtobufCBuffer *buffer); +Eventcast__DisplayMsg * + eventcast__display_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void eventcast__display_msg__free_unpacked + (Eventcast__DisplayMsg *message, + ProtobufCAllocator *allocator); +/* Eventcast__TouchMaxCount methods */ +void eventcast__touch_max_count__init + (Eventcast__TouchMaxCount *message); +size_t eventcast__touch_max_count__get_packed_size + (const Eventcast__TouchMaxCount *message); +size_t eventcast__touch_max_count__pack + (const Eventcast__TouchMaxCount *message, + uint8_t *out); +size_t eventcast__touch_max_count__pack_to_buffer + (const Eventcast__TouchMaxCount *message, + ProtobufCBuffer *buffer); +Eventcast__TouchMaxCount * + eventcast__touch_max_count__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void eventcast__touch_max_count__free_unpacked + (Eventcast__TouchMaxCount *message, + ProtobufCAllocator *allocator); +/* Eventcast__TouchData methods */ +void eventcast__touch_data__init + (Eventcast__TouchData *message); +size_t eventcast__touch_data__get_packed_size + (const Eventcast__TouchData *message); +size_t eventcast__touch_data__pack + (const Eventcast__TouchData *message, + uint8_t *out); +size_t eventcast__touch_data__pack_to_buffer + (const Eventcast__TouchData *message, + ProtobufCBuffer *buffer); +Eventcast__TouchData * + eventcast__touch_data__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void eventcast__touch_data__free_unpacked + (Eventcast__TouchData *message, + ProtobufCAllocator *allocator); +/* Eventcast__HWKeyMsg methods */ +void eventcast__hwkey_msg__init + (Eventcast__HWKeyMsg *message); +size_t eventcast__hwkey_msg__get_packed_size + (const Eventcast__HWKeyMsg *message); +size_t eventcast__hwkey_msg__pack + (const Eventcast__HWKeyMsg *message, + uint8_t *out); +size_t eventcast__hwkey_msg__pack_to_buffer + (const Eventcast__HWKeyMsg *message, + ProtobufCBuffer *buffer); +Eventcast__HWKeyMsg * + eventcast__hwkey_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void eventcast__hwkey_msg__free_unpacked + (Eventcast__HWKeyMsg *message, + ProtobufCAllocator *allocator); +/* Eventcast__TouchMsg methods */ +void eventcast__touch_msg__init + (Eventcast__TouchMsg *message); +size_t eventcast__touch_msg__get_packed_size + (const Eventcast__TouchMsg *message); +size_t eventcast__touch_msg__pack + (const Eventcast__TouchMsg *message, + uint8_t *out); +size_t eventcast__touch_msg__pack_to_buffer + (const Eventcast__TouchMsg *message, + ProtobufCBuffer *buffer); +Eventcast__TouchMsg * + eventcast__touch_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void eventcast__touch_msg__free_unpacked + (Eventcast__TouchMsg *message, + ProtobufCAllocator *allocator); +/* Eventcast__EventCastMsg methods */ +void eventcast__event_cast_msg__init + (Eventcast__EventCastMsg *message); +size_t eventcast__event_cast_msg__get_packed_size + (const Eventcast__EventCastMsg *message); +size_t eventcast__event_cast_msg__pack + (const Eventcast__EventCastMsg *message, + uint8_t *out); +size_t eventcast__event_cast_msg__pack_to_buffer + (const Eventcast__EventCastMsg *message, + ProtobufCBuffer *buffer); +Eventcast__EventCastMsg * + eventcast__event_cast_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void eventcast__event_cast_msg__free_unpacked + (Eventcast__EventCastMsg *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*Eventcast__HandShakeReq_Closure) + (const Eventcast__HandShakeReq *message, + void *closure_data); +typedef void (*Eventcast__HandShakeAns_Closure) + (const Eventcast__HandShakeAns *message, + void *closure_data); +typedef void (*Eventcast__EmulatorState_Closure) + (const Eventcast__EmulatorState *message, + void *closure_data); +typedef void (*Eventcast__AppState_Closure) + (const Eventcast__AppState *message, + void *closure_data); +typedef void (*Eventcast__StartReq_Closure) + (const Eventcast__StartReq *message, + void *closure_data); +typedef void (*Eventcast__StartAns_Closure) + (const Eventcast__StartAns *message, + void *closure_data); +typedef void (*Eventcast__SetEventStatus_Closure) + (const Eventcast__SetEventStatus *message, + void *closure_data); +typedef void (*Eventcast__EventMsg_Closure) + (const Eventcast__EventMsg *message, + void *closure_data); +typedef void (*Eventcast__EventTerminate_Closure) + (const Eventcast__EventTerminate *message, + void *closure_data); +typedef void (*Eventcast__SetSensorStatus_Closure) + (const Eventcast__SetSensorStatus *message, + void *closure_data); +typedef void (*Eventcast__SensorData_Closure) + (const Eventcast__SensorData *message, + void *closure_data); +typedef void (*Eventcast__SensorMsg_Closure) + (const Eventcast__SensorMsg *message, + void *closure_data); +typedef void (*Eventcast__Resolution_Closure) + (const Eventcast__Resolution *message, + void *closure_data); +typedef void (*Eventcast__DisplayMsg_Closure) + (const Eventcast__DisplayMsg *message, + void *closure_data); +typedef void (*Eventcast__TouchMaxCount_Closure) + (const Eventcast__TouchMaxCount *message, + void *closure_data); +typedef void (*Eventcast__TouchData_Closure) + (const Eventcast__TouchData *message, + void *closure_data); +typedef void (*Eventcast__HWKeyMsg_Closure) + (const Eventcast__HWKeyMsg *message, + void *closure_data); +typedef void (*Eventcast__TouchMsg_Closure) + (const Eventcast__TouchMsg *message, + void *closure_data); +typedef void (*Eventcast__EventCastMsg_Closure) + (const Eventcast__EventCastMsg *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCEnumDescriptor eventcast__message_result__descriptor; +extern const ProtobufCEnumDescriptor eventcast__connection_state__descriptor; +extern const ProtobufCEnumDescriptor eventcast__event_type__descriptor; +extern const ProtobufCEnumDescriptor eventcast__state__descriptor; +extern const ProtobufCEnumDescriptor eventcast__sensor_type__descriptor; +extern const ProtobufCEnumDescriptor eventcast__touch_state__descriptor; +extern const ProtobufCEnumDescriptor eventcast__hwkey_type__descriptor; +extern const ProtobufCMessageDescriptor eventcast__hand_shake_req__descriptor; +extern const ProtobufCMessageDescriptor eventcast__hand_shake_ans__descriptor; +extern const ProtobufCMessageDescriptor eventcast__emulator_state__descriptor; +extern const ProtobufCMessageDescriptor eventcast__app_state__descriptor; +extern const ProtobufCMessageDescriptor eventcast__start_req__descriptor; +extern const ProtobufCMessageDescriptor eventcast__start_ans__descriptor; +extern const ProtobufCMessageDescriptor eventcast__set_event_status__descriptor; +extern const ProtobufCMessageDescriptor eventcast__event_msg__descriptor; +extern const ProtobufCEnumDescriptor eventcast__event_msg__type__descriptor; +extern const ProtobufCMessageDescriptor eventcast__event_terminate__descriptor; +extern const ProtobufCMessageDescriptor eventcast__set_sensor_status__descriptor; +extern const ProtobufCMessageDescriptor eventcast__sensor_data__descriptor; +extern const ProtobufCMessageDescriptor eventcast__sensor_msg__descriptor; +extern const ProtobufCEnumDescriptor eventcast__sensor_msg__type__descriptor; +extern const ProtobufCMessageDescriptor eventcast__resolution__descriptor; +extern const ProtobufCMessageDescriptor eventcast__display_msg__descriptor; +extern const ProtobufCMessageDescriptor eventcast__touch_max_count__descriptor; +extern const ProtobufCMessageDescriptor eventcast__touch_data__descriptor; +extern const ProtobufCMessageDescriptor eventcast__hwkey_msg__descriptor; +extern const ProtobufCMessageDescriptor eventcast__touch_msg__descriptor; +extern const ProtobufCEnumDescriptor eventcast__touch_msg__type__descriptor; +extern const ProtobufCMessageDescriptor eventcast__event_cast_msg__descriptor; +extern const ProtobufCEnumDescriptor eventcast__event_cast_msg__type__descriptor; + +PROTOBUF_C_END_DECLS + + +#endif /* PROTOBUF_eventcast_2eproto__INCLUDED */ diff --git a/tizen/src/tethering/msg/tethering.proto b/tizen/src/eventcast/msg/eventcast.proto similarity index 96% rename from tizen/src/tethering/msg/tethering.proto rename to tizen/src/eventcast/msg/eventcast.proto index 01988bc394..559458f486 100644 --- a/tizen/src/tethering/msg/tethering.proto +++ b/tizen/src/eventcast/msg/eventcast.proto @@ -1,8 +1,8 @@ -package tethering; +package eventcast; -option java_package = "device.tethering.genmsg"; +option java_package = "device.eventcast.genmsg"; -// protoc-c --c_out=../genmsg tethering.proto +// protoc-c --c_out=../genmsg eventcast.proto // define value enum MessageResult { @@ -193,7 +193,7 @@ message TouchMsg { optional HWKeyMsg hwkey = 9; } -message TetheringMsg { +message EventCastMsg { enum Type { HANDSHAKE_REQ = 2; HANDSHAKE_ANS = 3; diff --git a/tizen/src/tethering/sensor.c b/tizen/src/eventcast/sensor.c similarity index 66% rename from tizen/src/tethering/sensor.c rename to tizen/src/eventcast/sensor.c index 902637caec..b69c48caf6 100644 --- a/tizen/src/tethering/sensor.c +++ b/tizen/src/eventcast/sensor.c @@ -45,8 +45,8 @@ #include "sensor.h" #include "common.h" -#include "ecs/ecs_tethering.h" -#include "genmsg/tethering.pb-c.h" +#include "ecs/ecs_eventcast.h" +#include "genmsg/eventcast.pb-c.h" #include "util/new_debug_ch.h" @@ -74,14 +74,14 @@ enum sensor_level { static int sensor_device_status; // create a sensor message. -static bool build_sensor_msg(Tethering__SensorMsg *sensor) +static bool build_sensor_msg(Eventcast__SensorMsg *sensor) { bool ret = false; - Tethering__TetheringMsg msg = TETHERING__TETHERING_MSG__INIT; + Eventcast__EventCastMsg msg = EVENTCAST__EVENT_CAST_MSG__INIT; LOG_TRACE("enter: %s\n", __func__); - msg.type = TETHERING__TETHERING_MSG__TYPE__SENSOR_MSG; + msg.type = EVENTCAST__EVENT_CAST_MSG__TYPE__SENSOR_MSG; msg.sensormsg = sensor; ret = send_msg_to_controller(&msg); @@ -91,17 +91,17 @@ static bool build_sensor_msg(Tethering__SensorMsg *sensor) return ret; } -static bool send_sensor_start_ans_msg(Tethering__MessageResult result) +static bool send_sensor_start_ans_msg(Eventcast__MessageResult result) { bool ret = false; - Tethering__SensorMsg event = TETHERING__SENSOR_MSG__INIT; - Tethering__StartAns start_ans = TETHERING__START_ANS__INIT; + Eventcast__SensorMsg event = EVENTCAST__SENSOR_MSG__INIT; + Eventcast__StartAns start_ans = EVENTCAST__START_ANS__INIT; LOG_TRACE("enter: %s\n", __func__); start_ans.result = result; - event.type = TETHERING__SENSOR_MSG__TYPE__START_ANS; + event.type = EVENTCAST__SENSOR_MSG__TYPE__START_ANS; event.startans = &start_ans; LOG_TRACE("send sensor_start_ans message\n"); @@ -112,21 +112,21 @@ static bool send_sensor_start_ans_msg(Tethering__MessageResult result) return ret; } -static bool send_set_sensor_status_msg(Tethering__SensorType sensor_type, - Tethering__State status) +static bool send_set_sensor_status_msg(Eventcast__SensorType sensor_type, + Eventcast__State status) { bool ret = false; - Tethering__SensorMsg sensor = TETHERING__SENSOR_MSG__INIT; - Tethering__SetSensorStatus sensor_status = - TETHERING__SET_SENSOR_STATUS__INIT; + Eventcast__SensorMsg sensor = EVENTCAST__SENSOR_MSG__INIT; + Eventcast__SetSensorStatus sensor_status = + EVENTCAST__SET_SENSOR_STATUS__INIT; LOG_TRACE("enter: %s\n", __func__); sensor_status.type = sensor_type; sensor_status.state = status; - sensor.type = TETHERING__SENSOR_MSG__TYPE__SENSOR_STATUS; + sensor.type = EVENTCAST__SENSOR_MSG__TYPE__SENSOR_STATUS; sensor.setstatus = &sensor_status; LOG_TRACE("send sensor_set_event_status message\n"); @@ -137,7 +137,7 @@ static bool send_set_sensor_status_msg(Tethering__SensorType sensor_type, return ret; } -static void set_sensor_data(Tethering__SensorData *data) +static void set_sensor_data(Eventcast__SensorData *data) { /* * data format for sensor device @@ -147,61 +147,61 @@ static void set_sensor_data(Tethering__SensorData *data) */ switch(data->sensor) { - case TETHERING__SENSOR_TYPE__ACCEL: + case EVENTCAST__SENSOR_TYPE__ACCEL: { char tmp[255] = {0}; sprintf(tmp, "%d\n%d\n%lf\n%lf\n%lf\n", level_accel, 3, (atof(data->x) * ACCEL_ADJUST), (atof(data->y) * ACCEL_ADJUST), (atof(data->z) * ACCEL_ADJUST)); - send_tethering_sensor_data(tmp, strlen(tmp)); + send_eventcast_sensor_data(tmp, strlen(tmp)); LOG_TRACE("sensor_accel x: %s, y: %s, z: %s\n", data->x, data->y, data->z); } break; - case TETHERING__SENSOR_TYPE__MAGNETIC: + case EVENTCAST__SENSOR_TYPE__MAGNETIC: { char tmp[255] = {0}; sprintf(tmp, "%d\n%d\n%s\n%s\n%s\n", level_magnetic, 3, data->x, data->y, data->z); - send_tethering_sensor_data(tmp, strlen(tmp)); + send_eventcast_sensor_data(tmp, strlen(tmp)); LOG_TRACE("sensor_mag x: %s, y: %s, z: %s\n", data->x, data->y, data->z); } break; - case TETHERING__SENSOR_TYPE__GYROSCOPE: + case EVENTCAST__SENSOR_TYPE__GYROSCOPE: { char tmp[255] = {0}; sprintf(tmp, "%d\n%d\n%lf\n%lf\n%lf\n", level_gyro, 3, (atof(data->x) / GYRO_ADJUST), (atof(data->y) / GYRO_ADJUST), (atof(data->z) / GYRO_ADJUST)); - send_tethering_sensor_data(tmp, strlen(tmp)); + send_eventcast_sensor_data(tmp, strlen(tmp)); LOG_TRACE("sensor_gyro x: %s, y: %s, z: %s\n", data->x, data->y, data->z); } break; - case TETHERING__SENSOR_TYPE__PROXIMITY: + case EVENTCAST__SENSOR_TYPE__PROXIMITY: { char tmp[255] = {0}; double x = (double)(atoi(data->x)); sprintf(tmp, "%d\n%d\n%.1f\n", level_proxi, 1, x); - send_tethering_sensor_data(tmp, strlen(tmp)); + send_eventcast_sensor_data(tmp, strlen(tmp)); LOG_TRACE("sensor_proxi x: %.1f, %s\n", x, tmp); } break; - case TETHERING__SENSOR_TYPE__LIGHT: + case EVENTCAST__SENSOR_TYPE__LIGHT: { char tmp[255] = {0}; sprintf(tmp, "%d\n%d\n%s%s\n", level_light, 2, data->x, data->y); - send_tethering_sensor_data(tmp, strlen(tmp)); + send_eventcast_sensor_data(tmp, strlen(tmp)); LOG_TRACE("sensor_light x: %s\n", data->x); } @@ -212,36 +212,36 @@ static void set_sensor_data(Tethering__SensorData *data) } } -bool msgproc_tethering_sensor_msg(void *message) +bool msgproc_eventcast_sensor_msg(void *message) { bool ret = true; - Tethering__SensorMsg *msg = (Tethering__SensorMsg *)message; + Eventcast__SensorMsg *msg = (Eventcast__SensorMsg *)message; switch(msg->type) { - case TETHERING__SENSOR_MSG__TYPE__START_REQ: + case EVENTCAST__SENSOR_MSG__TYPE__START_REQ: LOG_TRACE("SENSOR_MSG_TYPE_START_REQ\n"); // set sensor type. - send_set_sensor_status_msg(TETHERING__SENSOR_TYPE__ACCEL, - TETHERING__STATE__ENABLED); - send_set_sensor_status_msg(TETHERING__SENSOR_TYPE__MAGNETIC, - TETHERING__STATE__ENABLED); - send_set_sensor_status_msg(TETHERING__SENSOR_TYPE__GYROSCOPE, - TETHERING__STATE__ENABLED); - send_set_sensor_status_msg(TETHERING__SENSOR_TYPE__PROXIMITY, - TETHERING__STATE__ENABLED); - send_set_sensor_status_msg(TETHERING__SENSOR_TYPE__LIGHT, - TETHERING__STATE__ENABLED); + send_set_sensor_status_msg(EVENTCAST__SENSOR_TYPE__ACCEL, + EVENTCAST__STATE__ENABLED); + send_set_sensor_status_msg(EVENTCAST__SENSOR_TYPE__MAGNETIC, + EVENTCAST__STATE__ENABLED); + send_set_sensor_status_msg(EVENTCAST__SENSOR_TYPE__GYROSCOPE, + EVENTCAST__STATE__ENABLED); + send_set_sensor_status_msg(EVENTCAST__SENSOR_TYPE__PROXIMITY, + EVENTCAST__STATE__ENABLED); + send_set_sensor_status_msg(EVENTCAST__SENSOR_TYPE__LIGHT, + EVENTCAST__STATE__ENABLED); LOG_TRACE("SENSOR_MSG_TYPE_START_ANS\n"); - send_sensor_start_ans_msg(TETHERING__MESSAGE_RESULT__SUCCESS); + send_sensor_start_ans_msg(EVENTCAST__MESSAGE_RESULT__SUCCESS); break; - case TETHERING__SENSOR_MSG__TYPE__TERMINATE: + case EVENTCAST__SENSOR_MSG__TYPE__TERMINATE: LOG_TRACE("SENSOR_MSG_TYPE_TERMINATE\n"); break; - case TETHERING__SENSOR_MSG__TYPE__SENSOR_DATA: + case EVENTCAST__SENSOR_MSG__TYPE__SENSOR_DATA: LOG_TRACE("SENSOR_MSG_TYPE_SENSOR_DATA\n"); set_sensor_data(msg->data); break; @@ -254,13 +254,13 @@ bool msgproc_tethering_sensor_msg(void *message) return ret; } -int get_tethering_sensor_status(void) +int get_eventcast_sensor_status(void) { return sensor_device_status; } -void set_tethering_sensor_status(int status) +void set_eventcast_sensor_status(int status) { sensor_device_status = status; - send_tethering_sensor_status_ecp(); + send_eventcast_sensor_status_ecp(); } diff --git a/tizen/src/tethering/sensor.h b/tizen/src/eventcast/sensor.h similarity index 88% rename from tizen/src/tethering/sensor.h rename to tizen/src/eventcast/sensor.h index 42ece22b9c..c20b6958f5 100644 --- a/tizen/src/tethering/sensor.h +++ b/tizen/src/eventcast/sensor.h @@ -28,8 +28,8 @@ * */ -bool msgproc_tethering_sensor_msg(void *msg); +bool msgproc_eventcast_sensor_msg(void *msg); -int get_tethering_sensor_status(void); +int get_eventcast_sensor_status(void); -void set_tethering_sensor_status(int status); +void set_eventcast_sensor_status(int status); diff --git a/tizen/src/tethering/touch.c b/tizen/src/eventcast/touch.c similarity index 71% rename from tizen/src/tethering/touch.c rename to tizen/src/eventcast/touch.c index 30a0b3a09d..08887d6671 100644 --- a/tizen/src/tethering/touch.c +++ b/tizen/src/eventcast/touch.c @@ -33,8 +33,8 @@ #include "common.h" #include "touch.h" #include "encode_fb.h" -#include "genmsg/tethering.pb-c.h" -#include "ecs/ecs_tethering.h" +#include "genmsg/eventcast.pb-c.h" +#include "ecs/ecs_eventcast.h" #include "util/new_debug_ch.h" DECLARE_DEBUG_CHANNEL(app_tethering); @@ -45,17 +45,17 @@ static bool send_display_image_data(void); #define HARD_KEY_MENU 169 #define HARD_KEY_BACK 158 -static bool build_touch_msg(Tethering__TouchMsg *touch) +static bool build_touch_msg(Eventcast__TouchMsg *touch) { bool ret = false; - Tethering__TetheringMsg msg = TETHERING__TETHERING_MSG__INIT; + Eventcast__EventCastMsg msg = EVENTCAST__EVENT_CAST_MSG__INIT; LOG_TRACE("enter: %s\n", __func__); - msg.type = TETHERING__TETHERING_MSG__TYPE__TOUCH_MSG; + msg.type = EVENTCAST__EVENT_CAST_MSG__TYPE__TOUCH_MSG; msg.touchmsg = touch; - LOG_TRACE("touch message size: %d\n", tethering__tethering_msg__get_packed_size(&msg)); + LOG_TRACE("touch message size: %d\n", eventcast__event_cast_msg__get_packed_size(&msg)); ret = send_msg_to_controller(&msg); LOG_TRACE("leave: %s, ret: %d\n", __func__, ret); @@ -63,18 +63,18 @@ static bool build_touch_msg(Tethering__TouchMsg *touch) return ret; } -static bool send_touch_start_ans_msg(Tethering__MessageResult result) +static bool send_touch_start_ans_msg(Eventcast__MessageResult result) { bool ret = false; - Tethering__TouchMsg mt = TETHERING__TOUCH_MSG__INIT; - Tethering__StartAns start_ans = TETHERING__START_ANS__INIT; + Eventcast__TouchMsg mt = EVENTCAST__TOUCH_MSG__INIT; + Eventcast__StartAns start_ans = EVENTCAST__START_ANS__INIT; LOG_TRACE("enter: %s\n", __func__); start_ans.result = result; - mt.type = TETHERING__TOUCH_MSG__TYPE__START_ANS; + mt.type = EVENTCAST__TOUCH_MSG__TYPE__START_ANS; mt.startans = &start_ans; ret = build_touch_msg(&mt); @@ -88,15 +88,15 @@ static bool send_set_touch_max_count(void) { bool ret = false; - Tethering__TouchMsg mt = TETHERING__TOUCH_MSG__INIT; - Tethering__TouchMaxCount touch_cnt = - TETHERING__TOUCH_MAX_COUNT__INIT; + Eventcast__TouchMsg mt = EVENTCAST__TOUCH_MSG__INIT; + Eventcast__TouchMaxCount touch_cnt = + EVENTCAST__TOUCH_MAX_COUNT__INIT; LOG_TRACE("enter: %s\n", __func__); touch_cnt.max = get_emul_max_touch_point(); - mt.type = TETHERING__TOUCH_MSG__TYPE__MAX_COUNT; + mt.type = EVENTCAST__TOUCH_MSG__TYPE__MAX_COUNT; mt.maxcount = &touch_cnt; LOG_TRACE("send touch max count: %d\n", touch_cnt.max); @@ -107,20 +107,20 @@ static bool send_set_touch_max_count(void) return ret; } -static void set_touch_data(Tethering__TouchData *data) +static void set_touch_data(Eventcast__TouchData *data) { float x = 0.0, y = 0.0; int32_t index = 0, state = 0; switch(data->state) { - case TETHERING__TOUCH_STATE__PRESSED: + case EVENTCAST__TOUCH_STATE__PRESSED: LOG_TRACE("touch pressed\n"); index = data->index; x = data->xpoint; y = data->ypoint; state = PRESSED; break; - case TETHERING__TOUCH_STATE__RELEASED: + case EVENTCAST__TOUCH_STATE__RELEASED: LOG_TRACE("touch released\n"); index = data->index; x = data->xpoint; @@ -133,22 +133,22 @@ static void set_touch_data(Tethering__TouchData *data) } LOG_TRACE("set touch_data. index: %d, x: %lf, y: %lf\n", index, x, y); - send_tethering_touch_data(x, y, index, state); + send_eventcast_touch_data(x, y, index, state); } static bool send_set_touch_resolution(void) { bool ret = false; - Tethering__TouchMsg mt = TETHERING__TOUCH_MSG__INIT; - Tethering__Resolution resolution = TETHERING__RESOLUTION__INIT; + Eventcast__TouchMsg mt = EVENTCAST__TOUCH_MSG__INIT; + Eventcast__Resolution resolution = EVENTCAST__RESOLUTION__INIT; LOG_TRACE("enter: %s\n", __func__); resolution.width = get_emul_resolution_width(); resolution.height = get_emul_resolution_height(); - mt.type = TETHERING__TOUCH_MSG__TYPE__RESOLUTION; + mt.type = EVENTCAST__TOUCH_MSG__TYPE__RESOLUTION; mt.resolution = &resolution; LOG_TRACE("send touch resolution: %dx%d\n", @@ -160,32 +160,32 @@ static bool send_set_touch_resolution(void) return ret; } -static void set_hwkey_data(Tethering__HWKeyMsg *msg) +static void set_hwkey_data(Eventcast__HWKeyMsg *msg) { int32_t keycode = 0; switch (msg->type) { - case TETHERING__HWKEY_TYPE__MENU: + case EVENTCAST__HWKEY_TYPE__MENU: keycode = HARD_KEY_MENU; break; - case TETHERING__HWKEY_TYPE__HOME: + case EVENTCAST__HWKEY_TYPE__HOME: keycode = HARD_KEY_HOME; break; - case TETHERING__HWKEY_TYPE__BACK: + case EVENTCAST__HWKEY_TYPE__BACK: keycode = HARD_KEY_BACK; break; - case TETHERING__HWKEY_TYPE__POWER: + case EVENTCAST__HWKEY_TYPE__POWER: keycode = HARD_KEY_POWER; break; - case TETHERING__HWKEY_TYPE__VOLUME_UP: + case EVENTCAST__HWKEY_TYPE__VOLUME_UP: keycode = HARD_KEY_VOL_UP; break; - case TETHERING__HWKEY_TYPE__VOLUME_DOWN: + case EVENTCAST__HWKEY_TYPE__VOLUME_DOWN: keycode = HARD_KEY_VOL_DOWN; break; @@ -194,31 +194,31 @@ static void set_hwkey_data(Tethering__HWKeyMsg *msg) } LOG_TRACE("convert hwkey msg to keycode: %d\n", keycode); - send_tethering_hwkey_data(keycode); + send_eventcast_hwkey_data(keycode); } -bool msgproc_tethering_touch_msg(void *message) +bool msgproc_eventcast_touch_msg(void *message) { bool ret = true; - Tethering__TouchMsg *msg = (Tethering__TouchMsg *)message; + Eventcast__TouchMsg *msg = (Eventcast__TouchMsg *)message; switch(msg->type) { - case TETHERING__TOUCH_MSG__TYPE__START_REQ: + case EVENTCAST__TOUCH_MSG__TYPE__START_REQ: LOG_TRACE("TOUCH_MSG_TYPE_START\n"); send_set_touch_max_count(); send_set_touch_resolution(); - ret = send_touch_start_ans_msg(TETHERING__MESSAGE_RESULT__SUCCESS); + ret = send_touch_start_ans_msg(EVENTCAST__MESSAGE_RESULT__SUCCESS); break; - case TETHERING__TOUCH_MSG__TYPE__TERMINATE: + case EVENTCAST__TOUCH_MSG__TYPE__TERMINATE: LOG_TRACE("TOUCH_MSG_TYPE_TERMINATE\n"); break; - case TETHERING__TOUCH_MSG__TYPE__TOUCH_DATA: + case EVENTCAST__TOUCH_MSG__TYPE__TOUCH_DATA: LOG_TRACE("TOUCH_MSG_TYPE_TOUCH_DATA\n"); set_touch_data(msg->touchdata); break; - case TETHERING__TOUCH_MSG__TYPE__DISPLAY_MSG: + case EVENTCAST__TOUCH_MSG__TYPE__DISPLAY_MSG: LOG_TRACE("TOUCH_MSG_TYPE_DISPLAY_MSG\n"); if (is_display_dirty()) { @@ -229,7 +229,7 @@ bool msgproc_tethering_touch_msg(void *message) } break; - case TETHERING__TOUCH_MSG__TYPE__HWKEY_MSG: + case EVENTCAST__TOUCH_MSG__TYPE__HWKEY_MSG: LOG_TRACE("TOUCH_MSG_TYPE_HWKEY_MSG\n"); set_hwkey_data(msg->hwkey); break; @@ -243,15 +243,15 @@ bool msgproc_tethering_touch_msg(void *message) return ret; } -int get_tethering_touch_status(void) +int get_eventcast_touch_status(void) { return touch_device_status; } -void set_tethering_touch_status(int status) +void set_eventcast_touch_status(int status) { touch_device_status = status; - send_tethering_touch_status_ecp(); + send_eventcast_touch_status_ecp(); } static void dump_display_image_data(struct encode_mem *image) @@ -272,8 +272,8 @@ static bool send_display_image_data(void) bool ret = false; struct encode_mem *image = NULL; - Tethering__TouchMsg touch = TETHERING__TOUCH_MSG__INIT; - Tethering__DisplayMsg display = TETHERING__DISPLAY_MSG__INIT; + Eventcast__TouchMsg touch = EVENTCAST__TOUCH_MSG__INIT; + Eventcast__DisplayMsg display = EVENTCAST__DISPLAY_MSG__INIT; LOG_TRACE("enter: %s\n", __func__); @@ -290,7 +290,7 @@ static bool send_display_image_data(void) display.imagedata.len = image->length; display.imagedata.data = image->buffer; - touch.type = TETHERING__TOUCH_MSG__TYPE__DISPLAY_MSG; + touch.type = EVENTCAST__TOUCH_MSG__TYPE__DISPLAY_MSG; touch.display = &display; ret = build_touch_msg(&touch); @@ -300,5 +300,6 @@ static bool send_display_image_data(void) g_free(image); LOG_TRACE("leave: %s, ret: %d\n", __func__, ret); + return ret; } diff --git a/tizen/src/tethering/touch.h b/tizen/src/eventcast/touch.h similarity index 89% rename from tizen/src/tethering/touch.h rename to tizen/src/eventcast/touch.h index cb29c9b804..0d754e1cf6 100644 --- a/tizen/src/tethering/touch.h +++ b/tizen/src/eventcast/touch.h @@ -33,8 +33,8 @@ enum { ENCODE_PNG, }; -bool msgproc_tethering_touch_msg(void *message); +bool msgproc_eventcast_touch_msg(void *message); -int get_tethering_touch_status(void); +int get_eventcast_touch_status(void); -void set_tethering_touch_status(int status); +void set_eventcast_touch_status(int status); diff --git a/tizen/src/tethering/Makefile.objs b/tizen/src/tethering/Makefile.objs deleted file mode 100644 index 9aa4799ed4..0000000000 --- a/tizen/src/tethering/Makefile.objs +++ /dev/null @@ -1,7 +0,0 @@ -obj-y += genmsg/tethering.pb-c.o # protobuf-c.o -obj-y += common.o -obj-y += sensor.o -obj-y += touch.o -obj-y += encode_fb.o - -encode_fb.o-cflags := $(LIBPNG_CFLAGS) diff --git a/tizen/src/tethering/genmsg/tethering.pb-c.c b/tizen/src/tethering/genmsg/tethering.pb-c.c deleted file mode 100644 index 1b4a7e0c36..0000000000 --- a/tizen/src/tethering/genmsg/tethering.pb-c.c +++ /dev/null @@ -1,2314 +0,0 @@ -/* Generated by the protocol buffer compiler. DO NOT EDIT! */ - -/* Do not generate deprecated warnings for self */ -#ifndef PROTOBUF_C_NO_DEPRECATED -#define PROTOBUF_C_NO_DEPRECATED -#endif - -#include "tethering.pb-c.h" -void tethering__hand_shake_req__init - (Tethering__HandShakeReq *message) -{ - static Tethering__HandShakeReq init_value = TETHERING__HAND_SHAKE_REQ__INIT; - *message = init_value; -} -size_t tethering__hand_shake_req__get_packed_size - (const Tethering__HandShakeReq *message) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__hand_shake_req__descriptor); - return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); -} -size_t tethering__hand_shake_req__pack - (const Tethering__HandShakeReq *message, - uint8_t *out) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__hand_shake_req__descriptor); - return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); -} -size_t tethering__hand_shake_req__pack_to_buffer - (const Tethering__HandShakeReq *message, - ProtobufCBuffer *buffer) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__hand_shake_req__descriptor); - return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); -} -Tethering__HandShakeReq * - tethering__hand_shake_req__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data) -{ - return (Tethering__HandShakeReq *) - protobuf_c_message_unpack (&tethering__hand_shake_req__descriptor, - allocator, len, data); -} -void tethering__hand_shake_req__free_unpacked - (Tethering__HandShakeReq *message, - ProtobufCAllocator *allocator) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__hand_shake_req__descriptor); - protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); -} -void tethering__hand_shake_ans__init - (Tethering__HandShakeAns *message) -{ - static Tethering__HandShakeAns init_value = TETHERING__HAND_SHAKE_ANS__INIT; - *message = init_value; -} -size_t tethering__hand_shake_ans__get_packed_size - (const Tethering__HandShakeAns *message) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__hand_shake_ans__descriptor); - return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); -} -size_t tethering__hand_shake_ans__pack - (const Tethering__HandShakeAns *message, - uint8_t *out) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__hand_shake_ans__descriptor); - return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); -} -size_t tethering__hand_shake_ans__pack_to_buffer - (const Tethering__HandShakeAns *message, - ProtobufCBuffer *buffer) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__hand_shake_ans__descriptor); - return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); -} -Tethering__HandShakeAns * - tethering__hand_shake_ans__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data) -{ - return (Tethering__HandShakeAns *) - protobuf_c_message_unpack (&tethering__hand_shake_ans__descriptor, - allocator, len, data); -} -void tethering__hand_shake_ans__free_unpacked - (Tethering__HandShakeAns *message, - ProtobufCAllocator *allocator) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__hand_shake_ans__descriptor); - protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); -} -void tethering__emulator_state__init - (Tethering__EmulatorState *message) -{ - static Tethering__EmulatorState init_value = TETHERING__EMULATOR_STATE__INIT; - *message = init_value; -} -size_t tethering__emulator_state__get_packed_size - (const Tethering__EmulatorState *message) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__emulator_state__descriptor); - return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); -} -size_t tethering__emulator_state__pack - (const Tethering__EmulatorState *message, - uint8_t *out) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__emulator_state__descriptor); - return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); -} -size_t tethering__emulator_state__pack_to_buffer - (const Tethering__EmulatorState *message, - ProtobufCBuffer *buffer) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__emulator_state__descriptor); - return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); -} -Tethering__EmulatorState * - tethering__emulator_state__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data) -{ - return (Tethering__EmulatorState *) - protobuf_c_message_unpack (&tethering__emulator_state__descriptor, - allocator, len, data); -} -void tethering__emulator_state__free_unpacked - (Tethering__EmulatorState *message, - ProtobufCAllocator *allocator) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__emulator_state__descriptor); - protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); -} -void tethering__app_state__init - (Tethering__AppState *message) -{ - static Tethering__AppState init_value = TETHERING__APP_STATE__INIT; - *message = init_value; -} -size_t tethering__app_state__get_packed_size - (const Tethering__AppState *message) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__app_state__descriptor); - return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); -} -size_t tethering__app_state__pack - (const Tethering__AppState *message, - uint8_t *out) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__app_state__descriptor); - return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); -} -size_t tethering__app_state__pack_to_buffer - (const Tethering__AppState *message, - ProtobufCBuffer *buffer) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__app_state__descriptor); - return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); -} -Tethering__AppState * - tethering__app_state__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data) -{ - return (Tethering__AppState *) - protobuf_c_message_unpack (&tethering__app_state__descriptor, - allocator, len, data); -} -void tethering__app_state__free_unpacked - (Tethering__AppState *message, - ProtobufCAllocator *allocator) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__app_state__descriptor); - protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); -} -void tethering__start_req__init - (Tethering__StartReq *message) -{ - static Tethering__StartReq init_value = TETHERING__START_REQ__INIT; - *message = init_value; -} -size_t tethering__start_req__get_packed_size - (const Tethering__StartReq *message) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__start_req__descriptor); - return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); -} -size_t tethering__start_req__pack - (const Tethering__StartReq *message, - uint8_t *out) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__start_req__descriptor); - return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); -} -size_t tethering__start_req__pack_to_buffer - (const Tethering__StartReq *message, - ProtobufCBuffer *buffer) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__start_req__descriptor); - return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); -} -Tethering__StartReq * - tethering__start_req__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data) -{ - return (Tethering__StartReq *) - protobuf_c_message_unpack (&tethering__start_req__descriptor, - allocator, len, data); -} -void tethering__start_req__free_unpacked - (Tethering__StartReq *message, - ProtobufCAllocator *allocator) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__start_req__descriptor); - protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); -} -void tethering__start_ans__init - (Tethering__StartAns *message) -{ - static Tethering__StartAns init_value = TETHERING__START_ANS__INIT; - *message = init_value; -} -size_t tethering__start_ans__get_packed_size - (const Tethering__StartAns *message) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__start_ans__descriptor); - return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); -} -size_t tethering__start_ans__pack - (const Tethering__StartAns *message, - uint8_t *out) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__start_ans__descriptor); - return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); -} -size_t tethering__start_ans__pack_to_buffer - (const Tethering__StartAns *message, - ProtobufCBuffer *buffer) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__start_ans__descriptor); - return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); -} -Tethering__StartAns * - tethering__start_ans__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data) -{ - return (Tethering__StartAns *) - protobuf_c_message_unpack (&tethering__start_ans__descriptor, - allocator, len, data); -} -void tethering__start_ans__free_unpacked - (Tethering__StartAns *message, - ProtobufCAllocator *allocator) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__start_ans__descriptor); - protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); -} -void tethering__set_event_status__init - (Tethering__SetEventStatus *message) -{ - static Tethering__SetEventStatus init_value = TETHERING__SET_EVENT_STATUS__INIT; - *message = init_value; -} -size_t tethering__set_event_status__get_packed_size - (const Tethering__SetEventStatus *message) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__set_event_status__descriptor); - return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); -} -size_t tethering__set_event_status__pack - (const Tethering__SetEventStatus *message, - uint8_t *out) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__set_event_status__descriptor); - return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); -} -size_t tethering__set_event_status__pack_to_buffer - (const Tethering__SetEventStatus *message, - ProtobufCBuffer *buffer) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__set_event_status__descriptor); - return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); -} -Tethering__SetEventStatus * - tethering__set_event_status__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data) -{ - return (Tethering__SetEventStatus *) - protobuf_c_message_unpack (&tethering__set_event_status__descriptor, - allocator, len, data); -} -void tethering__set_event_status__free_unpacked - (Tethering__SetEventStatus *message, - ProtobufCAllocator *allocator) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__set_event_status__descriptor); - protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); -} -void tethering__event_msg__init - (Tethering__EventMsg *message) -{ - static Tethering__EventMsg init_value = TETHERING__EVENT_MSG__INIT; - *message = init_value; -} -size_t tethering__event_msg__get_packed_size - (const Tethering__EventMsg *message) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__event_msg__descriptor); - return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); -} -size_t tethering__event_msg__pack - (const Tethering__EventMsg *message, - uint8_t *out) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__event_msg__descriptor); - return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); -} -size_t tethering__event_msg__pack_to_buffer - (const Tethering__EventMsg *message, - ProtobufCBuffer *buffer) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__event_msg__descriptor); - return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); -} -Tethering__EventMsg * - tethering__event_msg__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data) -{ - return (Tethering__EventMsg *) - protobuf_c_message_unpack (&tethering__event_msg__descriptor, - allocator, len, data); -} -void tethering__event_msg__free_unpacked - (Tethering__EventMsg *message, - ProtobufCAllocator *allocator) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__event_msg__descriptor); - protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); -} -void tethering__event_terminate__init - (Tethering__EventTerminate *message) -{ - static Tethering__EventTerminate init_value = TETHERING__EVENT_TERMINATE__INIT; - *message = init_value; -} -size_t tethering__event_terminate__get_packed_size - (const Tethering__EventTerminate *message) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__event_terminate__descriptor); - return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); -} -size_t tethering__event_terminate__pack - (const Tethering__EventTerminate *message, - uint8_t *out) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__event_terminate__descriptor); - return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); -} -size_t tethering__event_terminate__pack_to_buffer - (const Tethering__EventTerminate *message, - ProtobufCBuffer *buffer) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__event_terminate__descriptor); - return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); -} -Tethering__EventTerminate * - tethering__event_terminate__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data) -{ - return (Tethering__EventTerminate *) - protobuf_c_message_unpack (&tethering__event_terminate__descriptor, - allocator, len, data); -} -void tethering__event_terminate__free_unpacked - (Tethering__EventTerminate *message, - ProtobufCAllocator *allocator) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__event_terminate__descriptor); - protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); -} -void tethering__set_sensor_status__init - (Tethering__SetSensorStatus *message) -{ - static Tethering__SetSensorStatus init_value = TETHERING__SET_SENSOR_STATUS__INIT; - *message = init_value; -} -size_t tethering__set_sensor_status__get_packed_size - (const Tethering__SetSensorStatus *message) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__set_sensor_status__descriptor); - return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); -} -size_t tethering__set_sensor_status__pack - (const Tethering__SetSensorStatus *message, - uint8_t *out) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__set_sensor_status__descriptor); - return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); -} -size_t tethering__set_sensor_status__pack_to_buffer - (const Tethering__SetSensorStatus *message, - ProtobufCBuffer *buffer) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__set_sensor_status__descriptor); - return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); -} -Tethering__SetSensorStatus * - tethering__set_sensor_status__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data) -{ - return (Tethering__SetSensorStatus *) - protobuf_c_message_unpack (&tethering__set_sensor_status__descriptor, - allocator, len, data); -} -void tethering__set_sensor_status__free_unpacked - (Tethering__SetSensorStatus *message, - ProtobufCAllocator *allocator) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__set_sensor_status__descriptor); - protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); -} -void tethering__sensor_data__init - (Tethering__SensorData *message) -{ - static Tethering__SensorData init_value = TETHERING__SENSOR_DATA__INIT; - *message = init_value; -} -size_t tethering__sensor_data__get_packed_size - (const Tethering__SensorData *message) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__sensor_data__descriptor); - return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); -} -size_t tethering__sensor_data__pack - (const Tethering__SensorData *message, - uint8_t *out) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__sensor_data__descriptor); - return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); -} -size_t tethering__sensor_data__pack_to_buffer - (const Tethering__SensorData *message, - ProtobufCBuffer *buffer) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__sensor_data__descriptor); - return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); -} -Tethering__SensorData * - tethering__sensor_data__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data) -{ - return (Tethering__SensorData *) - protobuf_c_message_unpack (&tethering__sensor_data__descriptor, - allocator, len, data); -} -void tethering__sensor_data__free_unpacked - (Tethering__SensorData *message, - ProtobufCAllocator *allocator) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__sensor_data__descriptor); - protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); -} -void tethering__sensor_msg__init - (Tethering__SensorMsg *message) -{ - static Tethering__SensorMsg init_value = TETHERING__SENSOR_MSG__INIT; - *message = init_value; -} -size_t tethering__sensor_msg__get_packed_size - (const Tethering__SensorMsg *message) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__sensor_msg__descriptor); - return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); -} -size_t tethering__sensor_msg__pack - (const Tethering__SensorMsg *message, - uint8_t *out) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__sensor_msg__descriptor); - return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); -} -size_t tethering__sensor_msg__pack_to_buffer - (const Tethering__SensorMsg *message, - ProtobufCBuffer *buffer) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__sensor_msg__descriptor); - return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); -} -Tethering__SensorMsg * - tethering__sensor_msg__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data) -{ - return (Tethering__SensorMsg *) - protobuf_c_message_unpack (&tethering__sensor_msg__descriptor, - allocator, len, data); -} -void tethering__sensor_msg__free_unpacked - (Tethering__SensorMsg *message, - ProtobufCAllocator *allocator) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__sensor_msg__descriptor); - protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); -} -void tethering__resolution__init - (Tethering__Resolution *message) -{ - static Tethering__Resolution init_value = TETHERING__RESOLUTION__INIT; - *message = init_value; -} -size_t tethering__resolution__get_packed_size - (const Tethering__Resolution *message) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__resolution__descriptor); - return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); -} -size_t tethering__resolution__pack - (const Tethering__Resolution *message, - uint8_t *out) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__resolution__descriptor); - return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); -} -size_t tethering__resolution__pack_to_buffer - (const Tethering__Resolution *message, - ProtobufCBuffer *buffer) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__resolution__descriptor); - return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); -} -Tethering__Resolution * - tethering__resolution__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data) -{ - return (Tethering__Resolution *) - protobuf_c_message_unpack (&tethering__resolution__descriptor, - allocator, len, data); -} -void tethering__resolution__free_unpacked - (Tethering__Resolution *message, - ProtobufCAllocator *allocator) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__resolution__descriptor); - protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); -} -void tethering__display_msg__init - (Tethering__DisplayMsg *message) -{ - static Tethering__DisplayMsg init_value = TETHERING__DISPLAY_MSG__INIT; - *message = init_value; -} -size_t tethering__display_msg__get_packed_size - (const Tethering__DisplayMsg *message) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__display_msg__descriptor); - return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); -} -size_t tethering__display_msg__pack - (const Tethering__DisplayMsg *message, - uint8_t *out) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__display_msg__descriptor); - return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); -} -size_t tethering__display_msg__pack_to_buffer - (const Tethering__DisplayMsg *message, - ProtobufCBuffer *buffer) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__display_msg__descriptor); - return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); -} -Tethering__DisplayMsg * - tethering__display_msg__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data) -{ - return (Tethering__DisplayMsg *) - protobuf_c_message_unpack (&tethering__display_msg__descriptor, - allocator, len, data); -} -void tethering__display_msg__free_unpacked - (Tethering__DisplayMsg *message, - ProtobufCAllocator *allocator) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__display_msg__descriptor); - protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); -} -void tethering__touch_max_count__init - (Tethering__TouchMaxCount *message) -{ - static Tethering__TouchMaxCount init_value = TETHERING__TOUCH_MAX_COUNT__INIT; - *message = init_value; -} -size_t tethering__touch_max_count__get_packed_size - (const Tethering__TouchMaxCount *message) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__touch_max_count__descriptor); - return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); -} -size_t tethering__touch_max_count__pack - (const Tethering__TouchMaxCount *message, - uint8_t *out) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__touch_max_count__descriptor); - return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); -} -size_t tethering__touch_max_count__pack_to_buffer - (const Tethering__TouchMaxCount *message, - ProtobufCBuffer *buffer) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__touch_max_count__descriptor); - return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); -} -Tethering__TouchMaxCount * - tethering__touch_max_count__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data) -{ - return (Tethering__TouchMaxCount *) - protobuf_c_message_unpack (&tethering__touch_max_count__descriptor, - allocator, len, data); -} -void tethering__touch_max_count__free_unpacked - (Tethering__TouchMaxCount *message, - ProtobufCAllocator *allocator) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__touch_max_count__descriptor); - protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); -} -void tethering__touch_data__init - (Tethering__TouchData *message) -{ - static Tethering__TouchData init_value = TETHERING__TOUCH_DATA__INIT; - *message = init_value; -} -size_t tethering__touch_data__get_packed_size - (const Tethering__TouchData *message) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__touch_data__descriptor); - return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); -} -size_t tethering__touch_data__pack - (const Tethering__TouchData *message, - uint8_t *out) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__touch_data__descriptor); - return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); -} -size_t tethering__touch_data__pack_to_buffer - (const Tethering__TouchData *message, - ProtobufCBuffer *buffer) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__touch_data__descriptor); - return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); -} -Tethering__TouchData * - tethering__touch_data__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data) -{ - return (Tethering__TouchData *) - protobuf_c_message_unpack (&tethering__touch_data__descriptor, - allocator, len, data); -} -void tethering__touch_data__free_unpacked - (Tethering__TouchData *message, - ProtobufCAllocator *allocator) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__touch_data__descriptor); - protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); -} -void tethering__hwkey_msg__init - (Tethering__HWKeyMsg *message) -{ - static Tethering__HWKeyMsg init_value = TETHERING__HWKEY_MSG__INIT; - *message = init_value; -} -size_t tethering__hwkey_msg__get_packed_size - (const Tethering__HWKeyMsg *message) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__hwkey_msg__descriptor); - return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); -} -size_t tethering__hwkey_msg__pack - (const Tethering__HWKeyMsg *message, - uint8_t *out) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__hwkey_msg__descriptor); - return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); -} -size_t tethering__hwkey_msg__pack_to_buffer - (const Tethering__HWKeyMsg *message, - ProtobufCBuffer *buffer) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__hwkey_msg__descriptor); - return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); -} -Tethering__HWKeyMsg * - tethering__hwkey_msg__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data) -{ - return (Tethering__HWKeyMsg *) - protobuf_c_message_unpack (&tethering__hwkey_msg__descriptor, - allocator, len, data); -} -void tethering__hwkey_msg__free_unpacked - (Tethering__HWKeyMsg *message, - ProtobufCAllocator *allocator) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__hwkey_msg__descriptor); - protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); -} -void tethering__touch_msg__init - (Tethering__TouchMsg *message) -{ - static Tethering__TouchMsg init_value = TETHERING__TOUCH_MSG__INIT; - *message = init_value; -} -size_t tethering__touch_msg__get_packed_size - (const Tethering__TouchMsg *message) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__touch_msg__descriptor); - return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); -} -size_t tethering__touch_msg__pack - (const Tethering__TouchMsg *message, - uint8_t *out) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__touch_msg__descriptor); - return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); -} -size_t tethering__touch_msg__pack_to_buffer - (const Tethering__TouchMsg *message, - ProtobufCBuffer *buffer) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__touch_msg__descriptor); - return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); -} -Tethering__TouchMsg * - tethering__touch_msg__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data) -{ - return (Tethering__TouchMsg *) - protobuf_c_message_unpack (&tethering__touch_msg__descriptor, - allocator, len, data); -} -void tethering__touch_msg__free_unpacked - (Tethering__TouchMsg *message, - ProtobufCAllocator *allocator) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__touch_msg__descriptor); - protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); -} -void tethering__tethering_msg__init - (Tethering__TetheringMsg *message) -{ - static Tethering__TetheringMsg init_value = TETHERING__TETHERING_MSG__INIT; - *message = init_value; -} -size_t tethering__tethering_msg__get_packed_size - (const Tethering__TetheringMsg *message) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__tethering_msg__descriptor); - return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); -} -size_t tethering__tethering_msg__pack - (const Tethering__TetheringMsg *message, - uint8_t *out) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__tethering_msg__descriptor); - return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); -} -size_t tethering__tethering_msg__pack_to_buffer - (const Tethering__TetheringMsg *message, - ProtobufCBuffer *buffer) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__tethering_msg__descriptor); - return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); -} -Tethering__TetheringMsg * - tethering__tethering_msg__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data) -{ - return (Tethering__TetheringMsg *) - protobuf_c_message_unpack (&tethering__tethering_msg__descriptor, - allocator, len, data); -} -void tethering__tethering_msg__free_unpacked - (Tethering__TetheringMsg *message, - ProtobufCAllocator *allocator) -{ - PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__tethering_msg__descriptor); - protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); -} -static const ProtobufCFieldDescriptor tethering__hand_shake_req__field_descriptors[1] = -{ - { - "key", - 1, - PROTOBUF_C_LABEL_REQUIRED, - PROTOBUF_C_TYPE_INT32, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__HandShakeReq, key), - NULL, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, -}; -static const unsigned tethering__hand_shake_req__field_indices_by_name[] = { - 0, /* field[0] = key */ -}; -static const ProtobufCIntRange tethering__hand_shake_req__number_ranges[1 + 1] = -{ - { 1, 0 }, - { 0, 1 } -}; -const ProtobufCMessageDescriptor tethering__hand_shake_req__descriptor = -{ - PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "tethering.HandShakeReq", - "HandShakeReq", - "Tethering__HandShakeReq", - "tethering", - sizeof(Tethering__HandShakeReq), - 1, - tethering__hand_shake_req__field_descriptors, - tethering__hand_shake_req__field_indices_by_name, - 1, tethering__hand_shake_req__number_ranges, - (ProtobufCMessageInit) tethering__hand_shake_req__init, - NULL,NULL,NULL /* reserved[123] */ -}; -static const ProtobufCFieldDescriptor tethering__hand_shake_ans__field_descriptors[1] = -{ - { - "result", - 1, - PROTOBUF_C_LABEL_REQUIRED, - PROTOBUF_C_TYPE_ENUM, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__HandShakeAns, result), - &tethering__message_result__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, -}; -static const unsigned tethering__hand_shake_ans__field_indices_by_name[] = { - 0, /* field[0] = result */ -}; -static const ProtobufCIntRange tethering__hand_shake_ans__number_ranges[1 + 1] = -{ - { 1, 0 }, - { 0, 1 } -}; -const ProtobufCMessageDescriptor tethering__hand_shake_ans__descriptor = -{ - PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "tethering.HandShakeAns", - "HandShakeAns", - "Tethering__HandShakeAns", - "tethering", - sizeof(Tethering__HandShakeAns), - 1, - tethering__hand_shake_ans__field_descriptors, - tethering__hand_shake_ans__field_indices_by_name, - 1, tethering__hand_shake_ans__number_ranges, - (ProtobufCMessageInit) tethering__hand_shake_ans__init, - NULL,NULL,NULL /* reserved[123] */ -}; -static const ProtobufCFieldDescriptor tethering__emulator_state__field_descriptors[1] = -{ - { - "state", - 1, - PROTOBUF_C_LABEL_REQUIRED, - PROTOBUF_C_TYPE_ENUM, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__EmulatorState, state), - &tethering__connection_state__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, -}; -static const unsigned tethering__emulator_state__field_indices_by_name[] = { - 0, /* field[0] = state */ -}; -static const ProtobufCIntRange tethering__emulator_state__number_ranges[1 + 1] = -{ - { 1, 0 }, - { 0, 1 } -}; -const ProtobufCMessageDescriptor tethering__emulator_state__descriptor = -{ - PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "tethering.EmulatorState", - "EmulatorState", - "Tethering__EmulatorState", - "tethering", - sizeof(Tethering__EmulatorState), - 1, - tethering__emulator_state__field_descriptors, - tethering__emulator_state__field_indices_by_name, - 1, tethering__emulator_state__number_ranges, - (ProtobufCMessageInit) tethering__emulator_state__init, - NULL,NULL,NULL /* reserved[123] */ -}; -static const ProtobufCFieldDescriptor tethering__app_state__field_descriptors[1] = -{ - { - "state", - 1, - PROTOBUF_C_LABEL_REQUIRED, - PROTOBUF_C_TYPE_ENUM, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__AppState, state), - &tethering__connection_state__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, -}; -static const unsigned tethering__app_state__field_indices_by_name[] = { - 0, /* field[0] = state */ -}; -static const ProtobufCIntRange tethering__app_state__number_ranges[1 + 1] = -{ - { 1, 0 }, - { 0, 1 } -}; -const ProtobufCMessageDescriptor tethering__app_state__descriptor = -{ - PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "tethering.AppState", - "AppState", - "Tethering__AppState", - "tethering", - sizeof(Tethering__AppState), - 1, - tethering__app_state__field_descriptors, - tethering__app_state__field_indices_by_name, - 1, tethering__app_state__number_ranges, - (ProtobufCMessageInit) tethering__app_state__init, - NULL,NULL,NULL /* reserved[123] */ -}; -#define tethering__start_req__field_descriptors NULL -#define tethering__start_req__field_indices_by_name NULL -#define tethering__start_req__number_ranges NULL -const ProtobufCMessageDescriptor tethering__start_req__descriptor = -{ - PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "tethering.StartReq", - "StartReq", - "Tethering__StartReq", - "tethering", - sizeof(Tethering__StartReq), - 0, - tethering__start_req__field_descriptors, - tethering__start_req__field_indices_by_name, - 0, tethering__start_req__number_ranges, - (ProtobufCMessageInit) tethering__start_req__init, - NULL,NULL,NULL /* reserved[123] */ -}; -static const ProtobufCFieldDescriptor tethering__start_ans__field_descriptors[1] = -{ - { - "result", - 1, - PROTOBUF_C_LABEL_REQUIRED, - PROTOBUF_C_TYPE_ENUM, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__StartAns, result), - &tethering__message_result__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, -}; -static const unsigned tethering__start_ans__field_indices_by_name[] = { - 0, /* field[0] = result */ -}; -static const ProtobufCIntRange tethering__start_ans__number_ranges[1 + 1] = -{ - { 1, 0 }, - { 0, 1 } -}; -const ProtobufCMessageDescriptor tethering__start_ans__descriptor = -{ - PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "tethering.StartAns", - "StartAns", - "Tethering__StartAns", - "tethering", - sizeof(Tethering__StartAns), - 1, - tethering__start_ans__field_descriptors, - tethering__start_ans__field_indices_by_name, - 1, tethering__start_ans__number_ranges, - (ProtobufCMessageInit) tethering__start_ans__init, - NULL,NULL,NULL /* reserved[123] */ -}; -static const ProtobufCFieldDescriptor tethering__set_event_status__field_descriptors[2] = -{ - { - "type", - 1, - PROTOBUF_C_LABEL_REQUIRED, - PROTOBUF_C_TYPE_ENUM, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__SetEventStatus, type), - &tethering__event_type__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "state", - 2, - PROTOBUF_C_LABEL_REQUIRED, - PROTOBUF_C_TYPE_ENUM, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__SetEventStatus, state), - &tethering__state__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, -}; -static const unsigned tethering__set_event_status__field_indices_by_name[] = { - 1, /* field[1] = state */ - 0, /* field[0] = type */ -}; -static const ProtobufCIntRange tethering__set_event_status__number_ranges[1 + 1] = -{ - { 1, 0 }, - { 0, 2 } -}; -const ProtobufCMessageDescriptor tethering__set_event_status__descriptor = -{ - PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "tethering.SetEventStatus", - "SetEventStatus", - "Tethering__SetEventStatus", - "tethering", - sizeof(Tethering__SetEventStatus), - 2, - tethering__set_event_status__field_descriptors, - tethering__set_event_status__field_indices_by_name, - 1, tethering__set_event_status__number_ranges, - (ProtobufCMessageInit) tethering__set_event_status__init, - NULL,NULL,NULL /* reserved[123] */ -}; -const ProtobufCEnumValue tethering__event_msg__type__enum_values_by_number[4] = -{ - { "START_REQ", "TETHERING__EVENT_MSG__TYPE__START_REQ", 2 }, - { "START_ANS", "TETHERING__EVENT_MSG__TYPE__START_ANS", 3 }, - { "TERMINATE", "TETHERING__EVENT_MSG__TYPE__TERMINATE", 4 }, - { "EVENT_STATUS", "TETHERING__EVENT_MSG__TYPE__EVENT_STATUS", 5 }, -}; -static const ProtobufCIntRange tethering__event_msg__type__value_ranges[] = { -{2, 0},{0, 4} -}; -const ProtobufCEnumValueIndex tethering__event_msg__type__enum_values_by_name[4] = -{ - { "EVENT_STATUS", 3 }, - { "START_ANS", 1 }, - { "START_REQ", 0 }, - { "TERMINATE", 2 }, -}; -const ProtobufCEnumDescriptor tethering__event_msg__type__descriptor = -{ - PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "tethering.EventMsg.TYPE", - "TYPE", - "Tethering__EventMsg__TYPE", - "tethering", - 4, - tethering__event_msg__type__enum_values_by_number, - 4, - tethering__event_msg__type__enum_values_by_name, - 1, - tethering__event_msg__type__value_ranges, - NULL,NULL,NULL,NULL /* reserved[1234] */ -}; -static const ProtobufCFieldDescriptor tethering__event_msg__field_descriptors[5] = -{ - { - "type", - 1, - PROTOBUF_C_LABEL_REQUIRED, - PROTOBUF_C_TYPE_ENUM, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__EventMsg, type), - &tethering__event_msg__type__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "startReq", - 2, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__EventMsg, startreq), - &tethering__start_req__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "startAns", - 3, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__EventMsg, startans), - &tethering__start_ans__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "terminate", - 4, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__EventMsg, terminate), - &tethering__event_terminate__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "setStatus", - 5, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__EventMsg, setstatus), - &tethering__set_event_status__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, -}; -static const unsigned tethering__event_msg__field_indices_by_name[] = { - 4, /* field[4] = setStatus */ - 2, /* field[2] = startAns */ - 1, /* field[1] = startReq */ - 3, /* field[3] = terminate */ - 0, /* field[0] = type */ -}; -static const ProtobufCIntRange tethering__event_msg__number_ranges[1 + 1] = -{ - { 1, 0 }, - { 0, 5 } -}; -const ProtobufCMessageDescriptor tethering__event_msg__descriptor = -{ - PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "tethering.EventMsg", - "EventMsg", - "Tethering__EventMsg", - "tethering", - sizeof(Tethering__EventMsg), - 5, - tethering__event_msg__field_descriptors, - tethering__event_msg__field_indices_by_name, - 1, tethering__event_msg__number_ranges, - (ProtobufCMessageInit) tethering__event_msg__init, - NULL,NULL,NULL /* reserved[123] */ -}; -#define tethering__event_terminate__field_descriptors NULL -#define tethering__event_terminate__field_indices_by_name NULL -#define tethering__event_terminate__number_ranges NULL -const ProtobufCMessageDescriptor tethering__event_terminate__descriptor = -{ - PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "tethering.EventTerminate", - "EventTerminate", - "Tethering__EventTerminate", - "tethering", - sizeof(Tethering__EventTerminate), - 0, - tethering__event_terminate__field_descriptors, - tethering__event_terminate__field_indices_by_name, - 0, tethering__event_terminate__number_ranges, - (ProtobufCMessageInit) tethering__event_terminate__init, - NULL,NULL,NULL /* reserved[123] */ -}; -static const ProtobufCFieldDescriptor tethering__set_sensor_status__field_descriptors[2] = -{ - { - "type", - 1, - PROTOBUF_C_LABEL_REQUIRED, - PROTOBUF_C_TYPE_ENUM, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__SetSensorStatus, type), - &tethering__sensor_type__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "state", - 2, - PROTOBUF_C_LABEL_REQUIRED, - PROTOBUF_C_TYPE_ENUM, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__SetSensorStatus, state), - &tethering__state__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, -}; -static const unsigned tethering__set_sensor_status__field_indices_by_name[] = { - 1, /* field[1] = state */ - 0, /* field[0] = type */ -}; -static const ProtobufCIntRange tethering__set_sensor_status__number_ranges[1 + 1] = -{ - { 1, 0 }, - { 0, 2 } -}; -const ProtobufCMessageDescriptor tethering__set_sensor_status__descriptor = -{ - PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "tethering.SetSensorStatus", - "SetSensorStatus", - "Tethering__SetSensorStatus", - "tethering", - sizeof(Tethering__SetSensorStatus), - 2, - tethering__set_sensor_status__field_descriptors, - tethering__set_sensor_status__field_indices_by_name, - 1, tethering__set_sensor_status__number_ranges, - (ProtobufCMessageInit) tethering__set_sensor_status__init, - NULL,NULL,NULL /* reserved[123] */ -}; -char tethering__sensor_data__x__default_value[] = "0"; -char tethering__sensor_data__y__default_value[] = "0"; -char tethering__sensor_data__z__default_value[] = "0"; -static const ProtobufCFieldDescriptor tethering__sensor_data__field_descriptors[4] = -{ - { - "sensor", - 1, - PROTOBUF_C_LABEL_REQUIRED, - PROTOBUF_C_TYPE_ENUM, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__SensorData, sensor), - &tethering__sensor_type__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "x", - 2, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_STRING, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__SensorData, x), - NULL, - &tethering__sensor_data__x__default_value, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "y", - 3, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_STRING, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__SensorData, y), - NULL, - &tethering__sensor_data__y__default_value, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "z", - 4, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_STRING, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__SensorData, z), - NULL, - &tethering__sensor_data__z__default_value, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, -}; -static const unsigned tethering__sensor_data__field_indices_by_name[] = { - 0, /* field[0] = sensor */ - 1, /* field[1] = x */ - 2, /* field[2] = y */ - 3, /* field[3] = z */ -}; -static const ProtobufCIntRange tethering__sensor_data__number_ranges[1 + 1] = -{ - { 1, 0 }, - { 0, 4 } -}; -const ProtobufCMessageDescriptor tethering__sensor_data__descriptor = -{ - PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "tethering.SensorData", - "SensorData", - "Tethering__SensorData", - "tethering", - sizeof(Tethering__SensorData), - 4, - tethering__sensor_data__field_descriptors, - tethering__sensor_data__field_indices_by_name, - 1, tethering__sensor_data__number_ranges, - (ProtobufCMessageInit) tethering__sensor_data__init, - NULL,NULL,NULL /* reserved[123] */ -}; -const ProtobufCEnumValue tethering__sensor_msg__type__enum_values_by_number[5] = -{ - { "START_REQ", "TETHERING__SENSOR_MSG__TYPE__START_REQ", 2 }, - { "START_ANS", "TETHERING__SENSOR_MSG__TYPE__START_ANS", 3 }, - { "TERMINATE", "TETHERING__SENSOR_MSG__TYPE__TERMINATE", 4 }, - { "SENSOR_STATUS", "TETHERING__SENSOR_MSG__TYPE__SENSOR_STATUS", 5 }, - { "SENSOR_DATA", "TETHERING__SENSOR_MSG__TYPE__SENSOR_DATA", 6 }, -}; -static const ProtobufCIntRange tethering__sensor_msg__type__value_ranges[] = { -{2, 0},{0, 5} -}; -const ProtobufCEnumValueIndex tethering__sensor_msg__type__enum_values_by_name[5] = -{ - { "SENSOR_DATA", 4 }, - { "SENSOR_STATUS", 3 }, - { "START_ANS", 1 }, - { "START_REQ", 0 }, - { "TERMINATE", 2 }, -}; -const ProtobufCEnumDescriptor tethering__sensor_msg__type__descriptor = -{ - PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "tethering.SensorMsg.Type", - "Type", - "Tethering__SensorMsg__Type", - "tethering", - 5, - tethering__sensor_msg__type__enum_values_by_number, - 5, - tethering__sensor_msg__type__enum_values_by_name, - 1, - tethering__sensor_msg__type__value_ranges, - NULL,NULL,NULL,NULL /* reserved[1234] */ -}; -static const ProtobufCFieldDescriptor tethering__sensor_msg__field_descriptors[6] = -{ - { - "type", - 1, - PROTOBUF_C_LABEL_REQUIRED, - PROTOBUF_C_TYPE_ENUM, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__SensorMsg, type), - &tethering__sensor_msg__type__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "startReq", - 2, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__SensorMsg, startreq), - &tethering__start_req__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "startAns", - 3, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__SensorMsg, startans), - &tethering__start_ans__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "terminate", - 4, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__SensorMsg, terminate), - &tethering__event_terminate__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "setStatus", - 5, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__SensorMsg, setstatus), - &tethering__set_sensor_status__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "data", - 6, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__SensorMsg, data), - &tethering__sensor_data__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, -}; -static const unsigned tethering__sensor_msg__field_indices_by_name[] = { - 5, /* field[5] = data */ - 4, /* field[4] = setStatus */ - 2, /* field[2] = startAns */ - 1, /* field[1] = startReq */ - 3, /* field[3] = terminate */ - 0, /* field[0] = type */ -}; -static const ProtobufCIntRange tethering__sensor_msg__number_ranges[1 + 1] = -{ - { 1, 0 }, - { 0, 6 } -}; -const ProtobufCMessageDescriptor tethering__sensor_msg__descriptor = -{ - PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "tethering.SensorMsg", - "SensorMsg", - "Tethering__SensorMsg", - "tethering", - sizeof(Tethering__SensorMsg), - 6, - tethering__sensor_msg__field_descriptors, - tethering__sensor_msg__field_indices_by_name, - 1, tethering__sensor_msg__number_ranges, - (ProtobufCMessageInit) tethering__sensor_msg__init, - NULL,NULL,NULL /* reserved[123] */ -}; -static const ProtobufCFieldDescriptor tethering__resolution__field_descriptors[2] = -{ - { - "width", - 1, - PROTOBUF_C_LABEL_REQUIRED, - PROTOBUF_C_TYPE_INT32, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__Resolution, width), - NULL, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "height", - 2, - PROTOBUF_C_LABEL_REQUIRED, - PROTOBUF_C_TYPE_INT32, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__Resolution, height), - NULL, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, -}; -static const unsigned tethering__resolution__field_indices_by_name[] = { - 1, /* field[1] = height */ - 0, /* field[0] = width */ -}; -static const ProtobufCIntRange tethering__resolution__number_ranges[1 + 1] = -{ - { 1, 0 }, - { 0, 2 } -}; -const ProtobufCMessageDescriptor tethering__resolution__descriptor = -{ - PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "tethering.Resolution", - "Resolution", - "Tethering__Resolution", - "tethering", - sizeof(Tethering__Resolution), - 2, - tethering__resolution__field_descriptors, - tethering__resolution__field_indices_by_name, - 1, tethering__resolution__number_ranges, - (ProtobufCMessageInit) tethering__resolution__init, - NULL,NULL,NULL /* reserved[123] */ -}; -static const ProtobufCFieldDescriptor tethering__display_msg__field_descriptors[2] = -{ - { - "frameRate", - 1, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_INT32, - PROTOBUF_C_OFFSETOF(Tethering__DisplayMsg, has_framerate), - PROTOBUF_C_OFFSETOF(Tethering__DisplayMsg, framerate), - NULL, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "imageData", - 2, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_BYTES, - PROTOBUF_C_OFFSETOF(Tethering__DisplayMsg, has_imagedata), - PROTOBUF_C_OFFSETOF(Tethering__DisplayMsg, imagedata), - NULL, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, -}; -static const unsigned tethering__display_msg__field_indices_by_name[] = { - 0, /* field[0] = frameRate */ - 1, /* field[1] = imageData */ -}; -static const ProtobufCIntRange tethering__display_msg__number_ranges[1 + 1] = -{ - { 1, 0 }, - { 0, 2 } -}; -const ProtobufCMessageDescriptor tethering__display_msg__descriptor = -{ - PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "tethering.DisplayMsg", - "DisplayMsg", - "Tethering__DisplayMsg", - "tethering", - sizeof(Tethering__DisplayMsg), - 2, - tethering__display_msg__field_descriptors, - tethering__display_msg__field_indices_by_name, - 1, tethering__display_msg__number_ranges, - (ProtobufCMessageInit) tethering__display_msg__init, - NULL,NULL,NULL /* reserved[123] */ -}; -static const int32_t tethering__touch_max_count__max__default_value = 10; -static const ProtobufCFieldDescriptor tethering__touch_max_count__field_descriptors[1] = -{ - { - "max", - 1, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_INT32, - PROTOBUF_C_OFFSETOF(Tethering__TouchMaxCount, has_max), - PROTOBUF_C_OFFSETOF(Tethering__TouchMaxCount, max), - NULL, - &tethering__touch_max_count__max__default_value, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, -}; -static const unsigned tethering__touch_max_count__field_indices_by_name[] = { - 0, /* field[0] = max */ -}; -static const ProtobufCIntRange tethering__touch_max_count__number_ranges[1 + 1] = -{ - { 1, 0 }, - { 0, 1 } -}; -const ProtobufCMessageDescriptor tethering__touch_max_count__descriptor = -{ - PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "tethering.TouchMaxCount", - "TouchMaxCount", - "Tethering__TouchMaxCount", - "tethering", - sizeof(Tethering__TouchMaxCount), - 1, - tethering__touch_max_count__field_descriptors, - tethering__touch_max_count__field_indices_by_name, - 1, tethering__touch_max_count__number_ranges, - (ProtobufCMessageInit) tethering__touch_max_count__init, - NULL,NULL,NULL /* reserved[123] */ -}; -static const int32_t tethering__touch_data__index__default_value = 0; -static const float tethering__touch_data__x_point__default_value = 0; -static const float tethering__touch_data__y_point__default_value = 0; -static const ProtobufCFieldDescriptor tethering__touch_data__field_descriptors[4] = -{ - { - "index", - 1, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_INT32, - PROTOBUF_C_OFFSETOF(Tethering__TouchData, has_index), - PROTOBUF_C_OFFSETOF(Tethering__TouchData, index), - NULL, - &tethering__touch_data__index__default_value, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "xPoint", - 2, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_FLOAT, - PROTOBUF_C_OFFSETOF(Tethering__TouchData, has_xpoint), - PROTOBUF_C_OFFSETOF(Tethering__TouchData, xpoint), - NULL, - &tethering__touch_data__x_point__default_value, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "yPoint", - 3, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_FLOAT, - PROTOBUF_C_OFFSETOF(Tethering__TouchData, has_ypoint), - PROTOBUF_C_OFFSETOF(Tethering__TouchData, ypoint), - NULL, - &tethering__touch_data__y_point__default_value, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "state", - 4, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_ENUM, - PROTOBUF_C_OFFSETOF(Tethering__TouchData, has_state), - PROTOBUF_C_OFFSETOF(Tethering__TouchData, state), - &tethering__touch_state__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, -}; -static const unsigned tethering__touch_data__field_indices_by_name[] = { - 0, /* field[0] = index */ - 3, /* field[3] = state */ - 1, /* field[1] = xPoint */ - 2, /* field[2] = yPoint */ -}; -static const ProtobufCIntRange tethering__touch_data__number_ranges[1 + 1] = -{ - { 1, 0 }, - { 0, 4 } -}; -const ProtobufCMessageDescriptor tethering__touch_data__descriptor = -{ - PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "tethering.TouchData", - "TouchData", - "Tethering__TouchData", - "tethering", - sizeof(Tethering__TouchData), - 4, - tethering__touch_data__field_descriptors, - tethering__touch_data__field_indices_by_name, - 1, tethering__touch_data__number_ranges, - (ProtobufCMessageInit) tethering__touch_data__init, - NULL,NULL,NULL /* reserved[123] */ -}; -static const ProtobufCFieldDescriptor tethering__hwkey_msg__field_descriptors[1] = -{ - { - "type", - 1, - PROTOBUF_C_LABEL_REQUIRED, - PROTOBUF_C_TYPE_ENUM, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__HWKeyMsg, type), - &tethering__hwkey_type__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, -}; -static const unsigned tethering__hwkey_msg__field_indices_by_name[] = { - 0, /* field[0] = type */ -}; -static const ProtobufCIntRange tethering__hwkey_msg__number_ranges[1 + 1] = -{ - { 1, 0 }, - { 0, 1 } -}; -const ProtobufCMessageDescriptor tethering__hwkey_msg__descriptor = -{ - PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "tethering.HWKeyMsg", - "HWKeyMsg", - "Tethering__HWKeyMsg", - "tethering", - sizeof(Tethering__HWKeyMsg), - 1, - tethering__hwkey_msg__field_descriptors, - tethering__hwkey_msg__field_indices_by_name, - 1, tethering__hwkey_msg__number_ranges, - (ProtobufCMessageInit) tethering__hwkey_msg__init, - NULL,NULL,NULL /* reserved[123] */ -}; -const ProtobufCEnumValue tethering__touch_msg__type__enum_values_by_number[8] = -{ - { "START_REQ", "TETHERING__TOUCH_MSG__TYPE__START_REQ", 2 }, - { "START_ANS", "TETHERING__TOUCH_MSG__TYPE__START_ANS", 3 }, - { "TERMINATE", "TETHERING__TOUCH_MSG__TYPE__TERMINATE", 4 }, - { "MAX_COUNT", "TETHERING__TOUCH_MSG__TYPE__MAX_COUNT", 5 }, - { "TOUCH_DATA", "TETHERING__TOUCH_MSG__TYPE__TOUCH_DATA", 6 }, - { "RESOLUTION", "TETHERING__TOUCH_MSG__TYPE__RESOLUTION", 7 }, - { "DISPLAY_MSG", "TETHERING__TOUCH_MSG__TYPE__DISPLAY_MSG", 8 }, - { "HWKEY_MSG", "TETHERING__TOUCH_MSG__TYPE__HWKEY_MSG", 9 }, -}; -static const ProtobufCIntRange tethering__touch_msg__type__value_ranges[] = { -{2, 0},{0, 8} -}; -const ProtobufCEnumValueIndex tethering__touch_msg__type__enum_values_by_name[8] = -{ - { "DISPLAY_MSG", 6 }, - { "HWKEY_MSG", 7 }, - { "MAX_COUNT", 3 }, - { "RESOLUTION", 5 }, - { "START_ANS", 1 }, - { "START_REQ", 0 }, - { "TERMINATE", 2 }, - { "TOUCH_DATA", 4 }, -}; -const ProtobufCEnumDescriptor tethering__touch_msg__type__descriptor = -{ - PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "tethering.TouchMsg.Type", - "Type", - "Tethering__TouchMsg__Type", - "tethering", - 8, - tethering__touch_msg__type__enum_values_by_number, - 8, - tethering__touch_msg__type__enum_values_by_name, - 1, - tethering__touch_msg__type__value_ranges, - NULL,NULL,NULL,NULL /* reserved[1234] */ -}; -static const ProtobufCFieldDescriptor tethering__touch_msg__field_descriptors[9] = -{ - { - "type", - 1, - PROTOBUF_C_LABEL_REQUIRED, - PROTOBUF_C_TYPE_ENUM, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__TouchMsg, type), - &tethering__touch_msg__type__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "startReq", - 2, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__TouchMsg, startreq), - &tethering__start_req__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "startAns", - 3, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__TouchMsg, startans), - &tethering__start_ans__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "terminate", - 4, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__TouchMsg, terminate), - &tethering__event_terminate__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "maxCount", - 5, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__TouchMsg, maxcount), - &tethering__touch_max_count__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "touchData", - 6, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__TouchMsg, touchdata), - &tethering__touch_data__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "resolution", - 7, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__TouchMsg, resolution), - &tethering__resolution__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "display", - 8, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__TouchMsg, display), - &tethering__display_msg__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "hwkey", - 9, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__TouchMsg, hwkey), - &tethering__hwkey_msg__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, -}; -static const unsigned tethering__touch_msg__field_indices_by_name[] = { - 7, /* field[7] = display */ - 8, /* field[8] = hwkey */ - 4, /* field[4] = maxCount */ - 6, /* field[6] = resolution */ - 2, /* field[2] = startAns */ - 1, /* field[1] = startReq */ - 3, /* field[3] = terminate */ - 5, /* field[5] = touchData */ - 0, /* field[0] = type */ -}; -static const ProtobufCIntRange tethering__touch_msg__number_ranges[1 + 1] = -{ - { 1, 0 }, - { 0, 9 } -}; -const ProtobufCMessageDescriptor tethering__touch_msg__descriptor = -{ - PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "tethering.TouchMsg", - "TouchMsg", - "Tethering__TouchMsg", - "tethering", - sizeof(Tethering__TouchMsg), - 9, - tethering__touch_msg__field_descriptors, - tethering__touch_msg__field_indices_by_name, - 1, tethering__touch_msg__number_ranges, - (ProtobufCMessageInit) tethering__touch_msg__init, - NULL,NULL,NULL /* reserved[123] */ -}; -const ProtobufCEnumValue tethering__tethering_msg__type__enum_values_by_number[7] = -{ - { "HANDSHAKE_REQ", "TETHERING__TETHERING_MSG__TYPE__HANDSHAKE_REQ", 2 }, - { "HANDSHAKE_ANS", "TETHERING__TETHERING_MSG__TYPE__HANDSHAKE_ANS", 3 }, - { "EMUL_STATE", "TETHERING__TETHERING_MSG__TYPE__EMUL_STATE", 4 }, - { "APP_STATE", "TETHERING__TETHERING_MSG__TYPE__APP_STATE", 5 }, - { "EVENT_MSG", "TETHERING__TETHERING_MSG__TYPE__EVENT_MSG", 6 }, - { "SENSOR_MSG", "TETHERING__TETHERING_MSG__TYPE__SENSOR_MSG", 7 }, - { "TOUCH_MSG", "TETHERING__TETHERING_MSG__TYPE__TOUCH_MSG", 8 }, -}; -static const ProtobufCIntRange tethering__tethering_msg__type__value_ranges[] = { -{2, 0},{0, 7} -}; -const ProtobufCEnumValueIndex tethering__tethering_msg__type__enum_values_by_name[7] = -{ - { "APP_STATE", 3 }, - { "EMUL_STATE", 2 }, - { "EVENT_MSG", 4 }, - { "HANDSHAKE_ANS", 1 }, - { "HANDSHAKE_REQ", 0 }, - { "SENSOR_MSG", 5 }, - { "TOUCH_MSG", 6 }, -}; -const ProtobufCEnumDescriptor tethering__tethering_msg__type__descriptor = -{ - PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "tethering.TetheringMsg.Type", - "Type", - "Tethering__TetheringMsg__Type", - "tethering", - 7, - tethering__tethering_msg__type__enum_values_by_number, - 7, - tethering__tethering_msg__type__enum_values_by_name, - 1, - tethering__tethering_msg__type__value_ranges, - NULL,NULL,NULL,NULL /* reserved[1234] */ -}; -static const ProtobufCFieldDescriptor tethering__tethering_msg__field_descriptors[8] = -{ - { - "type", - 1, - PROTOBUF_C_LABEL_REQUIRED, - PROTOBUF_C_TYPE_ENUM, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__TetheringMsg, type), - &tethering__tethering_msg__type__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "handShakeReq", - 2, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__TetheringMsg, handshakereq), - &tethering__hand_shake_req__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "handShakeAns", - 3, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__TetheringMsg, handshakeans), - &tethering__hand_shake_ans__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "emulState", - 4, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__TetheringMsg, emulstate), - &tethering__emulator_state__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "appState", - 5, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__TetheringMsg, appstate), - &tethering__app_state__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "eventMsg", - 6, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__TetheringMsg, eventmsg), - &tethering__event_msg__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "sensorMsg", - 7, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__TetheringMsg, sensormsg), - &tethering__sensor_msg__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, - { - "touchMsg", - 8, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_MESSAGE, - 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Tethering__TetheringMsg, touchmsg), - &tethering__touch_msg__descriptor, - NULL, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, -}; -static const unsigned tethering__tethering_msg__field_indices_by_name[] = { - 4, /* field[4] = appState */ - 3, /* field[3] = emulState */ - 5, /* field[5] = eventMsg */ - 2, /* field[2] = handShakeAns */ - 1, /* field[1] = handShakeReq */ - 6, /* field[6] = sensorMsg */ - 7, /* field[7] = touchMsg */ - 0, /* field[0] = type */ -}; -static const ProtobufCIntRange tethering__tethering_msg__number_ranges[1 + 1] = -{ - { 1, 0 }, - { 0, 8 } -}; -const ProtobufCMessageDescriptor tethering__tethering_msg__descriptor = -{ - PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "tethering.TetheringMsg", - "TetheringMsg", - "Tethering__TetheringMsg", - "tethering", - sizeof(Tethering__TetheringMsg), - 8, - tethering__tethering_msg__field_descriptors, - tethering__tethering_msg__field_indices_by_name, - 1, tethering__tethering_msg__number_ranges, - (ProtobufCMessageInit) tethering__tethering_msg__init, - NULL,NULL,NULL /* reserved[123] */ -}; -const ProtobufCEnumValue tethering__message_result__enum_values_by_number[3] = -{ - { "SUCCESS", "TETHERING__MESSAGE_RESULT__SUCCESS", 1 }, - { "FAILURE", "TETHERING__MESSAGE_RESULT__FAILURE", 2 }, - { "CANCEL", "TETHERING__MESSAGE_RESULT__CANCEL", 3 }, -}; -static const ProtobufCIntRange tethering__message_result__value_ranges[] = { -{1, 0},{0, 3} -}; -const ProtobufCEnumValueIndex tethering__message_result__enum_values_by_name[3] = -{ - { "CANCEL", 2 }, - { "FAILURE", 1 }, - { "SUCCESS", 0 }, -}; -const ProtobufCEnumDescriptor tethering__message_result__descriptor = -{ - PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "tethering.MessageResult", - "MessageResult", - "Tethering__MessageResult", - "tethering", - 3, - tethering__message_result__enum_values_by_number, - 3, - tethering__message_result__enum_values_by_name, - 1, - tethering__message_result__value_ranges, - NULL,NULL,NULL,NULL /* reserved[1234] */ -}; -const ProtobufCEnumValue tethering__connection_state__enum_values_by_number[3] = -{ - { "CONNECTED", "TETHERING__CONNECTION_STATE__CONNECTED", 1 }, - { "DISCONNECTED", "TETHERING__CONNECTION_STATE__DISCONNECTED", 2 }, - { "TERMINATED", "TETHERING__CONNECTION_STATE__TERMINATED", 3 }, -}; -static const ProtobufCIntRange tethering__connection_state__value_ranges[] = { -{1, 0},{0, 3} -}; -const ProtobufCEnumValueIndex tethering__connection_state__enum_values_by_name[3] = -{ - { "CONNECTED", 0 }, - { "DISCONNECTED", 1 }, - { "TERMINATED", 2 }, -}; -const ProtobufCEnumDescriptor tethering__connection_state__descriptor = -{ - PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "tethering.ConnectionState", - "ConnectionState", - "Tethering__ConnectionState", - "tethering", - 3, - tethering__connection_state__enum_values_by_number, - 3, - tethering__connection_state__enum_values_by_name, - 1, - tethering__connection_state__value_ranges, - NULL,NULL,NULL,NULL /* reserved[1234] */ -}; -const ProtobufCEnumValue tethering__event_type__enum_values_by_number[2] = -{ - { "SENSOR", "TETHERING__EVENT_TYPE__SENSOR", 1 }, - { "TOUCH", "TETHERING__EVENT_TYPE__TOUCH", 2 }, -}; -static const ProtobufCIntRange tethering__event_type__value_ranges[] = { -{1, 0},{0, 2} -}; -const ProtobufCEnumValueIndex tethering__event_type__enum_values_by_name[2] = -{ - { "SENSOR", 0 }, - { "TOUCH", 1 }, -}; -const ProtobufCEnumDescriptor tethering__event_type__descriptor = -{ - PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "tethering.EventType", - "EventType", - "Tethering__EventType", - "tethering", - 2, - tethering__event_type__enum_values_by_number, - 2, - tethering__event_type__enum_values_by_name, - 1, - tethering__event_type__value_ranges, - NULL,NULL,NULL,NULL /* reserved[1234] */ -}; -const ProtobufCEnumValue tethering__state__enum_values_by_number[2] = -{ - { "ENABLED", "TETHERING__STATE__ENABLED", 1 }, - { "DISABLED", "TETHERING__STATE__DISABLED", 2 }, -}; -static const ProtobufCIntRange tethering__state__value_ranges[] = { -{1, 0},{0, 2} -}; -const ProtobufCEnumValueIndex tethering__state__enum_values_by_name[2] = -{ - { "DISABLED", 1 }, - { "ENABLED", 0 }, -}; -const ProtobufCEnumDescriptor tethering__state__descriptor = -{ - PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "tethering.State", - "State", - "Tethering__State", - "tethering", - 2, - tethering__state__enum_values_by_number, - 2, - tethering__state__enum_values_by_name, - 1, - tethering__state__value_ranges, - NULL,NULL,NULL,NULL /* reserved[1234] */ -}; -const ProtobufCEnumValue tethering__sensor_type__enum_values_by_number[5] = -{ - { "ACCEL", "TETHERING__SENSOR_TYPE__ACCEL", 1 }, - { "MAGNETIC", "TETHERING__SENSOR_TYPE__MAGNETIC", 2 }, - { "GYROSCOPE", "TETHERING__SENSOR_TYPE__GYROSCOPE", 3 }, - { "PROXIMITY", "TETHERING__SENSOR_TYPE__PROXIMITY", 4 }, - { "LIGHT", "TETHERING__SENSOR_TYPE__LIGHT", 5 }, -}; -static const ProtobufCIntRange tethering__sensor_type__value_ranges[] = { -{1, 0},{0, 5} -}; -const ProtobufCEnumValueIndex tethering__sensor_type__enum_values_by_name[5] = -{ - { "ACCEL", 0 }, - { "GYROSCOPE", 2 }, - { "LIGHT", 4 }, - { "MAGNETIC", 1 }, - { "PROXIMITY", 3 }, -}; -const ProtobufCEnumDescriptor tethering__sensor_type__descriptor = -{ - PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "tethering.SensorType", - "SensorType", - "Tethering__SensorType", - "tethering", - 5, - tethering__sensor_type__enum_values_by_number, - 5, - tethering__sensor_type__enum_values_by_name, - 1, - tethering__sensor_type__value_ranges, - NULL,NULL,NULL,NULL /* reserved[1234] */ -}; -const ProtobufCEnumValue tethering__touch_state__enum_values_by_number[2] = -{ - { "PRESSED", "TETHERING__TOUCH_STATE__PRESSED", 1 }, - { "RELEASED", "TETHERING__TOUCH_STATE__RELEASED", 2 }, -}; -static const ProtobufCIntRange tethering__touch_state__value_ranges[] = { -{1, 0},{0, 2} -}; -const ProtobufCEnumValueIndex tethering__touch_state__enum_values_by_name[2] = -{ - { "PRESSED", 0 }, - { "RELEASED", 1 }, -}; -const ProtobufCEnumDescriptor tethering__touch_state__descriptor = -{ - PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "tethering.TouchState", - "TouchState", - "Tethering__TouchState", - "tethering", - 2, - tethering__touch_state__enum_values_by_number, - 2, - tethering__touch_state__enum_values_by_name, - 1, - tethering__touch_state__value_ranges, - NULL,NULL,NULL,NULL /* reserved[1234] */ -}; -const ProtobufCEnumValue tethering__hwkey_type__enum_values_by_number[6] = -{ - { "MENU", "TETHERING__HWKEY_TYPE__MENU", 1 }, - { "HOME", "TETHERING__HWKEY_TYPE__HOME", 2 }, - { "BACK", "TETHERING__HWKEY_TYPE__BACK", 3 }, - { "POWER", "TETHERING__HWKEY_TYPE__POWER", 4 }, - { "VOLUME_UP", "TETHERING__HWKEY_TYPE__VOLUME_UP", 5 }, - { "VOLUME_DOWN", "TETHERING__HWKEY_TYPE__VOLUME_DOWN", 6 }, -}; -static const ProtobufCIntRange tethering__hwkey_type__value_ranges[] = { -{1, 0},{0, 6} -}; -const ProtobufCEnumValueIndex tethering__hwkey_type__enum_values_by_name[6] = -{ - { "BACK", 2 }, - { "HOME", 1 }, - { "MENU", 0 }, - { "POWER", 3 }, - { "VOLUME_DOWN", 5 }, - { "VOLUME_UP", 4 }, -}; -const ProtobufCEnumDescriptor tethering__hwkey_type__descriptor = -{ - PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "tethering.HWKeyType", - "HWKeyType", - "Tethering__HWKeyType", - "tethering", - 6, - tethering__hwkey_type__enum_values_by_number, - 6, - tethering__hwkey_type__enum_values_by_name, - 1, - tethering__hwkey_type__value_ranges, - NULL,NULL,NULL,NULL /* reserved[1234] */ -}; diff --git a/tizen/src/tethering/genmsg/tethering.pb-c.h b/tizen/src/tethering/genmsg/tethering.pb-c.h deleted file mode 100644 index c2049b36bf..0000000000 --- a/tizen/src/tethering/genmsg/tethering.pb-c.h +++ /dev/null @@ -1,798 +0,0 @@ -/* Generated by the protocol buffer compiler. DO NOT EDIT! */ - -#ifndef PROTOBUF_C_tethering_2eproto__INCLUDED -#define PROTOBUF_C_tethering_2eproto__INCLUDED - -#include "../../../distrib/protobuf/protobuf-c.h" - -PROTOBUF_C_BEGIN_DECLS - - -typedef struct _Tethering__HandShakeReq Tethering__HandShakeReq; -typedef struct _Tethering__HandShakeAns Tethering__HandShakeAns; -typedef struct _Tethering__EmulatorState Tethering__EmulatorState; -typedef struct _Tethering__AppState Tethering__AppState; -typedef struct _Tethering__StartReq Tethering__StartReq; -typedef struct _Tethering__StartAns Tethering__StartAns; -typedef struct _Tethering__SetEventStatus Tethering__SetEventStatus; -typedef struct _Tethering__EventMsg Tethering__EventMsg; -typedef struct _Tethering__EventTerminate Tethering__EventTerminate; -typedef struct _Tethering__SetSensorStatus Tethering__SetSensorStatus; -typedef struct _Tethering__SensorData Tethering__SensorData; -typedef struct _Tethering__SensorMsg Tethering__SensorMsg; -typedef struct _Tethering__Resolution Tethering__Resolution; -typedef struct _Tethering__DisplayMsg Tethering__DisplayMsg; -typedef struct _Tethering__TouchMaxCount Tethering__TouchMaxCount; -typedef struct _Tethering__TouchData Tethering__TouchData; -typedef struct _Tethering__HWKeyMsg Tethering__HWKeyMsg; -typedef struct _Tethering__TouchMsg Tethering__TouchMsg; -typedef struct _Tethering__TetheringMsg Tethering__TetheringMsg; - - -/* --- enums --- */ - -typedef enum _Tethering__EventMsg__TYPE { - TETHERING__EVENT_MSG__TYPE__START_REQ = 2, - TETHERING__EVENT_MSG__TYPE__START_ANS = 3, - TETHERING__EVENT_MSG__TYPE__TERMINATE = 4, - TETHERING__EVENT_MSG__TYPE__EVENT_STATUS = 5 -} Tethering__EventMsg__TYPE; -typedef enum _Tethering__SensorMsg__Type { - TETHERING__SENSOR_MSG__TYPE__START_REQ = 2, - TETHERING__SENSOR_MSG__TYPE__START_ANS = 3, - TETHERING__SENSOR_MSG__TYPE__TERMINATE = 4, - TETHERING__SENSOR_MSG__TYPE__SENSOR_STATUS = 5, - TETHERING__SENSOR_MSG__TYPE__SENSOR_DATA = 6 -} Tethering__SensorMsg__Type; -typedef enum _Tethering__TouchMsg__Type { - TETHERING__TOUCH_MSG__TYPE__START_REQ = 2, - TETHERING__TOUCH_MSG__TYPE__START_ANS = 3, - TETHERING__TOUCH_MSG__TYPE__TERMINATE = 4, - TETHERING__TOUCH_MSG__TYPE__MAX_COUNT = 5, - TETHERING__TOUCH_MSG__TYPE__TOUCH_DATA = 6, - TETHERING__TOUCH_MSG__TYPE__RESOLUTION = 7, - TETHERING__TOUCH_MSG__TYPE__DISPLAY_MSG = 8, - TETHERING__TOUCH_MSG__TYPE__HWKEY_MSG = 9 -} Tethering__TouchMsg__Type; -typedef enum _Tethering__TetheringMsg__Type { - TETHERING__TETHERING_MSG__TYPE__HANDSHAKE_REQ = 2, - TETHERING__TETHERING_MSG__TYPE__HANDSHAKE_ANS = 3, - TETHERING__TETHERING_MSG__TYPE__EMUL_STATE = 4, - TETHERING__TETHERING_MSG__TYPE__APP_STATE = 5, - TETHERING__TETHERING_MSG__TYPE__EVENT_MSG = 6, - TETHERING__TETHERING_MSG__TYPE__SENSOR_MSG = 7, - TETHERING__TETHERING_MSG__TYPE__TOUCH_MSG = 8 -} Tethering__TetheringMsg__Type; -typedef enum _Tethering__MessageResult { - TETHERING__MESSAGE_RESULT__SUCCESS = 1, - TETHERING__MESSAGE_RESULT__FAILURE = 2, - TETHERING__MESSAGE_RESULT__CANCEL = 3 -} Tethering__MessageResult; -typedef enum _Tethering__ConnectionState { - TETHERING__CONNECTION_STATE__CONNECTED = 1, - TETHERING__CONNECTION_STATE__DISCONNECTED = 2, - TETHERING__CONNECTION_STATE__TERMINATED = 3 -} Tethering__ConnectionState; -typedef enum _Tethering__EventType { - TETHERING__EVENT_TYPE__SENSOR = 1, - TETHERING__EVENT_TYPE__TOUCH = 2 -} Tethering__EventType; -typedef enum _Tethering__State { - TETHERING__STATE__ENABLED = 1, - TETHERING__STATE__DISABLED = 2 -} Tethering__State; -typedef enum _Tethering__SensorType { - TETHERING__SENSOR_TYPE__ACCEL = 1, - TETHERING__SENSOR_TYPE__MAGNETIC = 2, - TETHERING__SENSOR_TYPE__GYROSCOPE = 3, - TETHERING__SENSOR_TYPE__PROXIMITY = 4, - TETHERING__SENSOR_TYPE__LIGHT = 5 -} Tethering__SensorType; -typedef enum _Tethering__TouchState { - TETHERING__TOUCH_STATE__PRESSED = 1, - TETHERING__TOUCH_STATE__RELEASED = 2 -} Tethering__TouchState; -typedef enum _Tethering__HWKeyType { - TETHERING__HWKEY_TYPE__MENU = 1, - TETHERING__HWKEY_TYPE__HOME = 2, - TETHERING__HWKEY_TYPE__BACK = 3, - TETHERING__HWKEY_TYPE__POWER = 4, - TETHERING__HWKEY_TYPE__VOLUME_UP = 5, - TETHERING__HWKEY_TYPE__VOLUME_DOWN = 6 -} Tethering__HWKeyType; - -/* --- messages --- */ - -struct _Tethering__HandShakeReq -{ - ProtobufCMessage base; - int32_t key; -}; -#define TETHERING__HAND_SHAKE_REQ__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tethering__hand_shake_req__descriptor) \ - , 0 } - - -struct _Tethering__HandShakeAns -{ - ProtobufCMessage base; - Tethering__MessageResult result; -}; -#define TETHERING__HAND_SHAKE_ANS__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tethering__hand_shake_ans__descriptor) \ - , 0 } - - -struct _Tethering__EmulatorState -{ - ProtobufCMessage base; - Tethering__ConnectionState state; -}; -#define TETHERING__EMULATOR_STATE__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tethering__emulator_state__descriptor) \ - , 0 } - - -struct _Tethering__AppState -{ - ProtobufCMessage base; - Tethering__ConnectionState state; -}; -#define TETHERING__APP_STATE__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tethering__app_state__descriptor) \ - , 0 } - - -struct _Tethering__StartReq -{ - ProtobufCMessage base; -}; -#define TETHERING__START_REQ__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tethering__start_req__descriptor) \ - } - - -struct _Tethering__StartAns -{ - ProtobufCMessage base; - Tethering__MessageResult result; -}; -#define TETHERING__START_ANS__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tethering__start_ans__descriptor) \ - , 0 } - - -struct _Tethering__SetEventStatus -{ - ProtobufCMessage base; - Tethering__EventType type; - Tethering__State state; -}; -#define TETHERING__SET_EVENT_STATUS__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tethering__set_event_status__descriptor) \ - , 0, 0 } - - -struct _Tethering__EventMsg -{ - ProtobufCMessage base; - Tethering__EventMsg__TYPE type; - Tethering__StartReq *startreq; - Tethering__StartAns *startans; - Tethering__EventTerminate *terminate; - Tethering__SetEventStatus *setstatus; -}; -#define TETHERING__EVENT_MSG__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tethering__event_msg__descriptor) \ - , 0, NULL, NULL, NULL, NULL } - - -struct _Tethering__EventTerminate -{ - ProtobufCMessage base; -}; -#define TETHERING__EVENT_TERMINATE__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tethering__event_terminate__descriptor) \ - } - - -struct _Tethering__SetSensorStatus -{ - ProtobufCMessage base; - Tethering__SensorType type; - Tethering__State state; -}; -#define TETHERING__SET_SENSOR_STATUS__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tethering__set_sensor_status__descriptor) \ - , 0, 0 } - - -struct _Tethering__SensorData -{ - ProtobufCMessage base; - Tethering__SensorType sensor; - char *x; - char *y; - char *z; -}; -extern char tethering__sensor_data__x__default_value[]; -extern char tethering__sensor_data__y__default_value[]; -extern char tethering__sensor_data__z__default_value[]; -#define TETHERING__SENSOR_DATA__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tethering__sensor_data__descriptor) \ - , 0, tethering__sensor_data__x__default_value, tethering__sensor_data__y__default_value, tethering__sensor_data__z__default_value } - - -struct _Tethering__SensorMsg -{ - ProtobufCMessage base; - Tethering__SensorMsg__Type type; - Tethering__StartReq *startreq; - Tethering__StartAns *startans; - Tethering__EventTerminate *terminate; - Tethering__SetSensorStatus *setstatus; - Tethering__SensorData *data; -}; -#define TETHERING__SENSOR_MSG__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tethering__sensor_msg__descriptor) \ - , 0, NULL, NULL, NULL, NULL, NULL } - - -struct _Tethering__Resolution -{ - ProtobufCMessage base; - int32_t width; - int32_t height; -}; -#define TETHERING__RESOLUTION__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tethering__resolution__descriptor) \ - , 0, 0 } - - -struct _Tethering__DisplayMsg -{ - ProtobufCMessage base; - protobuf_c_boolean has_framerate; - int32_t framerate; - protobuf_c_boolean has_imagedata; - ProtobufCBinaryData imagedata; -}; -#define TETHERING__DISPLAY_MSG__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tethering__display_msg__descriptor) \ - , 0,0, 0,{0,NULL} } - - -struct _Tethering__TouchMaxCount -{ - ProtobufCMessage base; - protobuf_c_boolean has_max; - int32_t max; -}; -#define TETHERING__TOUCH_MAX_COUNT__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tethering__touch_max_count__descriptor) \ - , 0,10 } - - -struct _Tethering__TouchData -{ - ProtobufCMessage base; - protobuf_c_boolean has_index; - int32_t index; - protobuf_c_boolean has_xpoint; - float xpoint; - protobuf_c_boolean has_ypoint; - float ypoint; - protobuf_c_boolean has_state; - Tethering__TouchState state; -}; -#define TETHERING__TOUCH_DATA__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tethering__touch_data__descriptor) \ - , 0,0, 0,0, 0,0, 0,0 } - - -struct _Tethering__HWKeyMsg -{ - ProtobufCMessage base; - Tethering__HWKeyType type; -}; -#define TETHERING__HWKEY_MSG__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tethering__hwkey_msg__descriptor) \ - , 0 } - - -struct _Tethering__TouchMsg -{ - ProtobufCMessage base; - Tethering__TouchMsg__Type type; - Tethering__StartReq *startreq; - Tethering__StartAns *startans; - Tethering__EventTerminate *terminate; - Tethering__TouchMaxCount *maxcount; - Tethering__TouchData *touchdata; - Tethering__Resolution *resolution; - Tethering__DisplayMsg *display; - Tethering__HWKeyMsg *hwkey; -}; -#define TETHERING__TOUCH_MSG__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tethering__touch_msg__descriptor) \ - , 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL } - - -struct _Tethering__TetheringMsg -{ - ProtobufCMessage base; - Tethering__TetheringMsg__Type type; - Tethering__HandShakeReq *handshakereq; - Tethering__HandShakeAns *handshakeans; - Tethering__EmulatorState *emulstate; - Tethering__AppState *appstate; - Tethering__EventMsg *eventmsg; - Tethering__SensorMsg *sensormsg; - Tethering__TouchMsg *touchmsg; -}; -#define TETHERING__TETHERING_MSG__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tethering__tethering_msg__descriptor) \ - , 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL } - - -/* Tethering__HandShakeReq methods */ -void tethering__hand_shake_req__init - (Tethering__HandShakeReq *message); -size_t tethering__hand_shake_req__get_packed_size - (const Tethering__HandShakeReq *message); -size_t tethering__hand_shake_req__pack - (const Tethering__HandShakeReq *message, - uint8_t *out); -size_t tethering__hand_shake_req__pack_to_buffer - (const Tethering__HandShakeReq *message, - ProtobufCBuffer *buffer); -Tethering__HandShakeReq * - tethering__hand_shake_req__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data); -void tethering__hand_shake_req__free_unpacked - (Tethering__HandShakeReq *message, - ProtobufCAllocator *allocator); -/* Tethering__HandShakeAns methods */ -void tethering__hand_shake_ans__init - (Tethering__HandShakeAns *message); -size_t tethering__hand_shake_ans__get_packed_size - (const Tethering__HandShakeAns *message); -size_t tethering__hand_shake_ans__pack - (const Tethering__HandShakeAns *message, - uint8_t *out); -size_t tethering__hand_shake_ans__pack_to_buffer - (const Tethering__HandShakeAns *message, - ProtobufCBuffer *buffer); -Tethering__HandShakeAns * - tethering__hand_shake_ans__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data); -void tethering__hand_shake_ans__free_unpacked - (Tethering__HandShakeAns *message, - ProtobufCAllocator *allocator); -/* Tethering__EmulatorState methods */ -void tethering__emulator_state__init - (Tethering__EmulatorState *message); -size_t tethering__emulator_state__get_packed_size - (const Tethering__EmulatorState *message); -size_t tethering__emulator_state__pack - (const Tethering__EmulatorState *message, - uint8_t *out); -size_t tethering__emulator_state__pack_to_buffer - (const Tethering__EmulatorState *message, - ProtobufCBuffer *buffer); -Tethering__EmulatorState * - tethering__emulator_state__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data); -void tethering__emulator_state__free_unpacked - (Tethering__EmulatorState *message, - ProtobufCAllocator *allocator); -/* Tethering__AppState methods */ -void tethering__app_state__init - (Tethering__AppState *message); -size_t tethering__app_state__get_packed_size - (const Tethering__AppState *message); -size_t tethering__app_state__pack - (const Tethering__AppState *message, - uint8_t *out); -size_t tethering__app_state__pack_to_buffer - (const Tethering__AppState *message, - ProtobufCBuffer *buffer); -Tethering__AppState * - tethering__app_state__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data); -void tethering__app_state__free_unpacked - (Tethering__AppState *message, - ProtobufCAllocator *allocator); -/* Tethering__StartReq methods */ -void tethering__start_req__init - (Tethering__StartReq *message); -size_t tethering__start_req__get_packed_size - (const Tethering__StartReq *message); -size_t tethering__start_req__pack - (const Tethering__StartReq *message, - uint8_t *out); -size_t tethering__start_req__pack_to_buffer - (const Tethering__StartReq *message, - ProtobufCBuffer *buffer); -Tethering__StartReq * - tethering__start_req__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data); -void tethering__start_req__free_unpacked - (Tethering__StartReq *message, - ProtobufCAllocator *allocator); -/* Tethering__StartAns methods */ -void tethering__start_ans__init - (Tethering__StartAns *message); -size_t tethering__start_ans__get_packed_size - (const Tethering__StartAns *message); -size_t tethering__start_ans__pack - (const Tethering__StartAns *message, - uint8_t *out); -size_t tethering__start_ans__pack_to_buffer - (const Tethering__StartAns *message, - ProtobufCBuffer *buffer); -Tethering__StartAns * - tethering__start_ans__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data); -void tethering__start_ans__free_unpacked - (Tethering__StartAns *message, - ProtobufCAllocator *allocator); -/* Tethering__SetEventStatus methods */ -void tethering__set_event_status__init - (Tethering__SetEventStatus *message); -size_t tethering__set_event_status__get_packed_size - (const Tethering__SetEventStatus *message); -size_t tethering__set_event_status__pack - (const Tethering__SetEventStatus *message, - uint8_t *out); -size_t tethering__set_event_status__pack_to_buffer - (const Tethering__SetEventStatus *message, - ProtobufCBuffer *buffer); -Tethering__SetEventStatus * - tethering__set_event_status__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data); -void tethering__set_event_status__free_unpacked - (Tethering__SetEventStatus *message, - ProtobufCAllocator *allocator); -/* Tethering__EventMsg methods */ -void tethering__event_msg__init - (Tethering__EventMsg *message); -size_t tethering__event_msg__get_packed_size - (const Tethering__EventMsg *message); -size_t tethering__event_msg__pack - (const Tethering__EventMsg *message, - uint8_t *out); -size_t tethering__event_msg__pack_to_buffer - (const Tethering__EventMsg *message, - ProtobufCBuffer *buffer); -Tethering__EventMsg * - tethering__event_msg__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data); -void tethering__event_msg__free_unpacked - (Tethering__EventMsg *message, - ProtobufCAllocator *allocator); -/* Tethering__EventTerminate methods */ -void tethering__event_terminate__init - (Tethering__EventTerminate *message); -size_t tethering__event_terminate__get_packed_size - (const Tethering__EventTerminate *message); -size_t tethering__event_terminate__pack - (const Tethering__EventTerminate *message, - uint8_t *out); -size_t tethering__event_terminate__pack_to_buffer - (const Tethering__EventTerminate *message, - ProtobufCBuffer *buffer); -Tethering__EventTerminate * - tethering__event_terminate__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data); -void tethering__event_terminate__free_unpacked - (Tethering__EventTerminate *message, - ProtobufCAllocator *allocator); -/* Tethering__SetSensorStatus methods */ -void tethering__set_sensor_status__init - (Tethering__SetSensorStatus *message); -size_t tethering__set_sensor_status__get_packed_size - (const Tethering__SetSensorStatus *message); -size_t tethering__set_sensor_status__pack - (const Tethering__SetSensorStatus *message, - uint8_t *out); -size_t tethering__set_sensor_status__pack_to_buffer - (const Tethering__SetSensorStatus *message, - ProtobufCBuffer *buffer); -Tethering__SetSensorStatus * - tethering__set_sensor_status__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data); -void tethering__set_sensor_status__free_unpacked - (Tethering__SetSensorStatus *message, - ProtobufCAllocator *allocator); -/* Tethering__SensorData methods */ -void tethering__sensor_data__init - (Tethering__SensorData *message); -size_t tethering__sensor_data__get_packed_size - (const Tethering__SensorData *message); -size_t tethering__sensor_data__pack - (const Tethering__SensorData *message, - uint8_t *out); -size_t tethering__sensor_data__pack_to_buffer - (const Tethering__SensorData *message, - ProtobufCBuffer *buffer); -Tethering__SensorData * - tethering__sensor_data__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data); -void tethering__sensor_data__free_unpacked - (Tethering__SensorData *message, - ProtobufCAllocator *allocator); -/* Tethering__SensorMsg methods */ -void tethering__sensor_msg__init - (Tethering__SensorMsg *message); -size_t tethering__sensor_msg__get_packed_size - (const Tethering__SensorMsg *message); -size_t tethering__sensor_msg__pack - (const Tethering__SensorMsg *message, - uint8_t *out); -size_t tethering__sensor_msg__pack_to_buffer - (const Tethering__SensorMsg *message, - ProtobufCBuffer *buffer); -Tethering__SensorMsg * - tethering__sensor_msg__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data); -void tethering__sensor_msg__free_unpacked - (Tethering__SensorMsg *message, - ProtobufCAllocator *allocator); -/* Tethering__Resolution methods */ -void tethering__resolution__init - (Tethering__Resolution *message); -size_t tethering__resolution__get_packed_size - (const Tethering__Resolution *message); -size_t tethering__resolution__pack - (const Tethering__Resolution *message, - uint8_t *out); -size_t tethering__resolution__pack_to_buffer - (const Tethering__Resolution *message, - ProtobufCBuffer *buffer); -Tethering__Resolution * - tethering__resolution__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data); -void tethering__resolution__free_unpacked - (Tethering__Resolution *message, - ProtobufCAllocator *allocator); -/* Tethering__DisplayMsg methods */ -void tethering__display_msg__init - (Tethering__DisplayMsg *message); -size_t tethering__display_msg__get_packed_size - (const Tethering__DisplayMsg *message); -size_t tethering__display_msg__pack - (const Tethering__DisplayMsg *message, - uint8_t *out); -size_t tethering__display_msg__pack_to_buffer - (const Tethering__DisplayMsg *message, - ProtobufCBuffer *buffer); -Tethering__DisplayMsg * - tethering__display_msg__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data); -void tethering__display_msg__free_unpacked - (Tethering__DisplayMsg *message, - ProtobufCAllocator *allocator); -/* Tethering__TouchMaxCount methods */ -void tethering__touch_max_count__init - (Tethering__TouchMaxCount *message); -size_t tethering__touch_max_count__get_packed_size - (const Tethering__TouchMaxCount *message); -size_t tethering__touch_max_count__pack - (const Tethering__TouchMaxCount *message, - uint8_t *out); -size_t tethering__touch_max_count__pack_to_buffer - (const Tethering__TouchMaxCount *message, - ProtobufCBuffer *buffer); -Tethering__TouchMaxCount * - tethering__touch_max_count__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data); -void tethering__touch_max_count__free_unpacked - (Tethering__TouchMaxCount *message, - ProtobufCAllocator *allocator); -/* Tethering__TouchData methods */ -void tethering__touch_data__init - (Tethering__TouchData *message); -size_t tethering__touch_data__get_packed_size - (const Tethering__TouchData *message); -size_t tethering__touch_data__pack - (const Tethering__TouchData *message, - uint8_t *out); -size_t tethering__touch_data__pack_to_buffer - (const Tethering__TouchData *message, - ProtobufCBuffer *buffer); -Tethering__TouchData * - tethering__touch_data__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data); -void tethering__touch_data__free_unpacked - (Tethering__TouchData *message, - ProtobufCAllocator *allocator); -/* Tethering__HWKeyMsg methods */ -void tethering__hwkey_msg__init - (Tethering__HWKeyMsg *message); -size_t tethering__hwkey_msg__get_packed_size - (const Tethering__HWKeyMsg *message); -size_t tethering__hwkey_msg__pack - (const Tethering__HWKeyMsg *message, - uint8_t *out); -size_t tethering__hwkey_msg__pack_to_buffer - (const Tethering__HWKeyMsg *message, - ProtobufCBuffer *buffer); -Tethering__HWKeyMsg * - tethering__hwkey_msg__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data); -void tethering__hwkey_msg__free_unpacked - (Tethering__HWKeyMsg *message, - ProtobufCAllocator *allocator); -/* Tethering__TouchMsg methods */ -void tethering__touch_msg__init - (Tethering__TouchMsg *message); -size_t tethering__touch_msg__get_packed_size - (const Tethering__TouchMsg *message); -size_t tethering__touch_msg__pack - (const Tethering__TouchMsg *message, - uint8_t *out); -size_t tethering__touch_msg__pack_to_buffer - (const Tethering__TouchMsg *message, - ProtobufCBuffer *buffer); -Tethering__TouchMsg * - tethering__touch_msg__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data); -void tethering__touch_msg__free_unpacked - (Tethering__TouchMsg *message, - ProtobufCAllocator *allocator); -/* Tethering__TetheringMsg methods */ -void tethering__tethering_msg__init - (Tethering__TetheringMsg *message); -size_t tethering__tethering_msg__get_packed_size - (const Tethering__TetheringMsg *message); -size_t tethering__tethering_msg__pack - (const Tethering__TetheringMsg *message, - uint8_t *out); -size_t tethering__tethering_msg__pack_to_buffer - (const Tethering__TetheringMsg *message, - ProtobufCBuffer *buffer); -Tethering__TetheringMsg * - tethering__tethering_msg__unpack - (ProtobufCAllocator *allocator, - size_t len, - const uint8_t *data); -void tethering__tethering_msg__free_unpacked - (Tethering__TetheringMsg *message, - ProtobufCAllocator *allocator); -/* --- per-message closures --- */ - -typedef void (*Tethering__HandShakeReq_Closure) - (const Tethering__HandShakeReq *message, - void *closure_data); -typedef void (*Tethering__HandShakeAns_Closure) - (const Tethering__HandShakeAns *message, - void *closure_data); -typedef void (*Tethering__EmulatorState_Closure) - (const Tethering__EmulatorState *message, - void *closure_data); -typedef void (*Tethering__AppState_Closure) - (const Tethering__AppState *message, - void *closure_data); -typedef void (*Tethering__StartReq_Closure) - (const Tethering__StartReq *message, - void *closure_data); -typedef void (*Tethering__StartAns_Closure) - (const Tethering__StartAns *message, - void *closure_data); -typedef void (*Tethering__SetEventStatus_Closure) - (const Tethering__SetEventStatus *message, - void *closure_data); -typedef void (*Tethering__EventMsg_Closure) - (const Tethering__EventMsg *message, - void *closure_data); -typedef void (*Tethering__EventTerminate_Closure) - (const Tethering__EventTerminate *message, - void *closure_data); -typedef void (*Tethering__SetSensorStatus_Closure) - (const Tethering__SetSensorStatus *message, - void *closure_data); -typedef void (*Tethering__SensorData_Closure) - (const Tethering__SensorData *message, - void *closure_data); -typedef void (*Tethering__SensorMsg_Closure) - (const Tethering__SensorMsg *message, - void *closure_data); -typedef void (*Tethering__Resolution_Closure) - (const Tethering__Resolution *message, - void *closure_data); -typedef void (*Tethering__DisplayMsg_Closure) - (const Tethering__DisplayMsg *message, - void *closure_data); -typedef void (*Tethering__TouchMaxCount_Closure) - (const Tethering__TouchMaxCount *message, - void *closure_data); -typedef void (*Tethering__TouchData_Closure) - (const Tethering__TouchData *message, - void *closure_data); -typedef void (*Tethering__HWKeyMsg_Closure) - (const Tethering__HWKeyMsg *message, - void *closure_data); -typedef void (*Tethering__TouchMsg_Closure) - (const Tethering__TouchMsg *message, - void *closure_data); -typedef void (*Tethering__TetheringMsg_Closure) - (const Tethering__TetheringMsg *message, - void *closure_data); - -/* --- services --- */ - - -/* --- descriptors --- */ - -extern const ProtobufCEnumDescriptor tethering__message_result__descriptor; -extern const ProtobufCEnumDescriptor tethering__connection_state__descriptor; -extern const ProtobufCEnumDescriptor tethering__event_type__descriptor; -extern const ProtobufCEnumDescriptor tethering__state__descriptor; -extern const ProtobufCEnumDescriptor tethering__sensor_type__descriptor; -extern const ProtobufCEnumDescriptor tethering__touch_state__descriptor; -extern const ProtobufCEnumDescriptor tethering__hwkey_type__descriptor; -extern const ProtobufCMessageDescriptor tethering__hand_shake_req__descriptor; -extern const ProtobufCMessageDescriptor tethering__hand_shake_ans__descriptor; -extern const ProtobufCMessageDescriptor tethering__emulator_state__descriptor; -extern const ProtobufCMessageDescriptor tethering__app_state__descriptor; -extern const ProtobufCMessageDescriptor tethering__start_req__descriptor; -extern const ProtobufCMessageDescriptor tethering__start_ans__descriptor; -extern const ProtobufCMessageDescriptor tethering__set_event_status__descriptor; -extern const ProtobufCMessageDescriptor tethering__event_msg__descriptor; -extern const ProtobufCEnumDescriptor tethering__event_msg__type__descriptor; -extern const ProtobufCMessageDescriptor tethering__event_terminate__descriptor; -extern const ProtobufCMessageDescriptor tethering__set_sensor_status__descriptor; -extern const ProtobufCMessageDescriptor tethering__sensor_data__descriptor; -extern const ProtobufCMessageDescriptor tethering__sensor_msg__descriptor; -extern const ProtobufCEnumDescriptor tethering__sensor_msg__type__descriptor; -extern const ProtobufCMessageDescriptor tethering__resolution__descriptor; -extern const ProtobufCMessageDescriptor tethering__display_msg__descriptor; -extern const ProtobufCMessageDescriptor tethering__touch_max_count__descriptor; -extern const ProtobufCMessageDescriptor tethering__touch_data__descriptor; -extern const ProtobufCMessageDescriptor tethering__hwkey_msg__descriptor; -extern const ProtobufCMessageDescriptor tethering__touch_msg__descriptor; -extern const ProtobufCEnumDescriptor tethering__touch_msg__type__descriptor; -extern const ProtobufCMessageDescriptor tethering__tethering_msg__descriptor; -extern const ProtobufCEnumDescriptor tethering__tethering_msg__type__descriptor; - -PROTOBUF_C_END_DECLS - - -#endif /* PROTOBUF_tethering_2eproto__INCLUDED */ -- 2.34.1