naming tethering might be confusing to users.
Change-Id: I154e59aefd932728cb3b73ece6c14d4223cc03de
Signed-off-by: Kitae Kim <kt920.kim@samsung.com>
obj-y += ecs/
# tethering
-obj-y += tethering/
+obj-y += eventcast/
# maru skin
obj-y += skin/
#include "hw/pci/maru_brightness.h"
#include "debug_ch.h"
-#include "tethering/encode_fb.h"
+#include "eventcast/encode_fb.h"
#include <SDL.h>
#ifndef CONFIG_WIN32
#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);
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
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);
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);
#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
#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];
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);
}
#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];
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");
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));
"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;
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;
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;
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);
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);
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;
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) {
} 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;
*/
/*
- * 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);
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
(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",
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 */
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 */
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 */
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 */
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",
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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",
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 */
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 */
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 */
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 */
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] =
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 */
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 */
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] =
#ifndef PROTOBUF_C_ecs_2eproto__INCLUDED
#define PROTOBUF_C_ecs_2eproto__INCLUDED
-#include "../../../distrib/protobuf/protobuf-c.h"
+#include <google/protobuf-c/protobuf-c.h>
PROTOBUF_C_BEGIN_DECLS
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;
, NULL, 0,{0,NULL} }
-struct _ECS__TetheringReq
+struct _ECS__EventCastReq
{
ProtobufCMessage base;
char *category;
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;
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;
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} }
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) \
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
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,
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
{ "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}
{ "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 },
{ "MONITOR_REQ", 10 },
{ "NFC_NTF", 14 },
{ "NFC_REQ", 13 },
- { "TETHERING_ANS", 16 },
- { "TETHERING_NTF", 17 },
- { "TETHERING_REQ", 15 },
};
const ProtobufCEnumDescriptor ecs__master__type__descriptor =
{
#ifndef PROTOBUF_C_ecs_5fids_2eproto__INCLUDED
#define PROTOBUF_C_ecs_5fids_2eproto__INCLUDED
-#include "../../../distrib/protobuf/protobuf-c.h"
+#include <google/protobuf-c/protobuf-c.h>
PROTOBUF_C_BEGIN_DECLS
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 --- */
optional bytes data = 2;
}
-message TetheringReq {
+message EventCastReq {
required string category = 1;
required int32 length = 2;
required int32 group = 3;
optional bytes data = 5;
}
-message TetheringAns {
+message EventCastAns {
required int32 errcode = 1;
optional string errstr = 2;
required string category = 3;
optional bytes data = 7;
}
-message TetheringNtf {
+message EventCastNtf {
required string category = 1;
required int32 length = 2;
required int32 group = 3;
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;
}
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;
NFC_REQ = 101;
NFC_NTF = 102;
- TETHERING_REQ = 103;
- TETHERING_ANS = 104;
- TETHERING_NTF = 105;
+ EVENTCAST_REQ = 103;
+ EVENTCAST_ANS = 104;
+ EVENTCAST_NTF = 105;
}
#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
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
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) {
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);
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;
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 {
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");
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");
}
// 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);
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");
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");
}
// 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;
}
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) {
}
}
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;
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;
}
ret = ioctlsocket(sockfd, FIONREAD, &to_read_bytes_long);
if (ret < 0) {
perror("invalid ioctl opertion\n");
- disconnect_tethering_app();
+ disconnect_eventcast_app();
return;
}
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;
}
to_read_bytes, 0);
if (read_size == 0) {
LOG_SEVERE("failed to read data\n");
- disconnect_tethering_app();
+ disconnect_eventcast_app();
return;
}
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;
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();
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__);
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;
}
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;
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);
}
qemu_mutex_unlock(&client->mutex);
- tethering_loop(client->fd);
+ eventcast_loop(client->fd);
}
return client;
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);
{
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);
((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;
}
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;
}
--- /dev/null
+/* 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] */
+};
--- /dev/null
+/* Generated by the protocol buffer compiler. DO NOT EDIT! */
+
+#ifndef PROTOBUF_C_eventcast_2eproto__INCLUDED
+#define PROTOBUF_C_eventcast_2eproto__INCLUDED
+
+#include <google/protobuf-c/protobuf-c.h>
+
+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 */
-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 {
optional HWKeyMsg hwkey = 9;
}
-message TetheringMsg {
+message EventCastMsg {
enum Type {
HANDSHAKE_REQ = 2;
HANDSHAKE_ANS = 3;
#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"
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);
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");
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");
return ret;
}
-static void set_sensor_data(Tethering__SensorData *data)
+static void set_sensor_data(Eventcast__SensorData *data)
{
/*
* data format for sensor device
*/
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);
}
}
}
-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;
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();
}
*
*/
-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);
#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);
#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);
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);
{
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);
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;
}
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",
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;
}
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()) {
}
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;
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)
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__);
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);
g_free(image);
LOG_TRACE("leave: %s, ret: %d\n", __func__, ret);
+
return ret;
}
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);
+++ /dev/null
-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)
+++ /dev/null
-/* 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] */
-};
+++ /dev/null
-/* 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 */
projects / sdk / emulator / qemu.git / commitdiff