From 07377cb1d1fa092d89c3a69524ad422902257ba1 Mon Sep 17 00:00:00 2001 From: Kitae Kim Date: Thu, 31 Oct 2013 18:28:30 +0900 Subject: [PATCH] tethering: added tethering feature. app_tethering is for communicating with App on target. This module is a client side to connect App that creates sensor or touch point data and it deliveries received data to each device. ecs_tethering is for communicating with ECP. This module handles messages from ECP. The messages consist of connect, disconnect, connection status and etc.. Change-Id: I2c31f785fe824fd578fafb08e9f9efe423f26ea6 Signed-off-by: Kitae Kim --- tizen/src/Makefile.tizen | 3 + tizen/src/ecs/Makefile.tizen | 2 +- tizen/src/ecs/ecs.c | 8 +- tizen/src/ecs/ecs.h | 4 + tizen/src/ecs/ecs_msg.c | 4 +- tizen/src/ecs/ecs_tethering.c | 229 ++++ tizen/src/ecs/ecs_tethering.h | 33 + tizen/src/ecs/genmsg/ecs.pb-c.c | 470 ++++++- tizen/src/ecs/genmsg/ecs.pb-c.h | 125 +- tizen/src/ecs/genmsg/ecs_ids.pb-c.c | 16 +- tizen/src/ecs/genmsg/ecs_ids.pb-c.h | 5 +- tizen/src/ecs/msg/ecs.proto | 40 +- tizen/src/ecs/msg/ecs_ids.proto | 4 + tizen/src/emulator.c | 2 + tizen/src/tethering/Makefile.tizen | 9 + tizen/src/tethering/app_tethering.c | 987 ++++++++++++++ tizen/src/tethering/app_tethering.h | 39 + tizen/src/tethering/genmsg/tethering.pb-c.c | 1964 +++++++++++++++++++++++++++ tizen/src/tethering/genmsg/tethering.pb-c.h | 677 +++++++++ tizen/src/tethering/msg/tethering.proto | 162 +++ 20 files changed, 4763 insertions(+), 20 deletions(-) create mode 100644 tizen/src/ecs/ecs_tethering.c create mode 100644 tizen/src/ecs/ecs_tethering.h create mode 100644 tizen/src/tethering/Makefile.tizen create mode 100644 tizen/src/tethering/app_tethering.c create mode 100644 tizen/src/tethering/app_tethering.h create mode 100644 tizen/src/tethering/genmsg/tethering.pb-c.c create mode 100644 tizen/src/tethering/genmsg/tethering.pb-c.h create mode 100644 tizen/src/tethering/msg/tethering.proto diff --git a/tizen/src/Makefile.tizen b/tizen/src/Makefile.tizen index ba9ac67..0e75868 100644 --- a/tizen/src/Makefile.tizen +++ b/tizen/src/Makefile.tizen @@ -108,6 +108,9 @@ obj-y += debug_ch.o # ECS include $(SRC_PATH)/tizen/src/ecs/Makefile.tizen +# tethering +include $(SRC_PATH)/tizen/src/tethering/Makefile.tizen + # maru hardware include $(SRC_PATH)/tizen/src/Makefile.tizen.$(TARGET_BASE_ARCH) diff --git a/tizen/src/ecs/Makefile.tizen b/tizen/src/ecs/Makefile.tizen index f43cadf..0d1a74f 100644 --- a/tizen/src/ecs/Makefile.tizen +++ b/tizen/src/ecs/Makefile.tizen @@ -8,4 +8,4 @@ QEMU_CFLAGS += -I$(SRC_PATH)/tizen/src/ecs/genmsg obj-y += ecs.pb-c.o ecs_ids.pb-c.o 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 diff --git a/tizen/src/ecs/ecs.c b/tizen/src/ecs/ecs.c index d4265b7..f44b8f3 100644 --- a/tizen/src/ecs/ecs.c +++ b/tizen/src/ecs/ecs.c @@ -966,6 +966,13 @@ bool handle_protobuf_msg(ECS_Client* cli, char* data, int len) goto fail; msgproc_keepalive_ans(cli, msg); } + else if (master->type == ECS__MASTER__TYPE__TETHERING_REQ) + { + ECS__TetheringReq* msg = master->tethering_req; + if (!msg) + goto fail; + msgproc_tethering_req(cli, msg); + } ecs__master__free_unpacked(master, NULL); return true; @@ -974,4 +981,3 @@ fail: ecs__master__free_unpacked(master, NULL); return false; } - diff --git a/tizen/src/ecs/ecs.h b/tizen/src/ecs/ecs.h index 557951f..05e9c5e 100644 --- a/tizen/src/ecs/ecs.h +++ b/tizen/src/ecs/ecs.h @@ -76,6 +76,9 @@ #define COMMAND_TYPE_MONITOR "monitor" #define COMMAND_TYPE_DEVICE "device" +// +#define COMMAND_TYPE_TETHERING "tethering" + #define ECS_MSG_STARTINFO_REQ "startinfo_req" #define ECS_MSG_STARTINFO_ANS "startinfo_ans" @@ -210,6 +213,7 @@ bool msgproc_device_req(ECS_Client* ccli, ECS__DeviceReq* msg); bool msgproc_nfc_req(ECS_Client* ccli, ECS__NfcReq* msg); void msgproc_checkversion_req(ECS_Client* ccli, ECS__CheckVersionReq* msg); void msgproc_keepalive_ans(ECS_Client* ccli, ECS__KeepAliveAns* msg); +bool msgproc_tethering_req(ECS_Client* ccli, ECS__TetheringReq* msg); /* version check */ //void send_ecs_version_check(ECS_Client* ccli); diff --git a/tizen/src/ecs/ecs_msg.c b/tizen/src/ecs/ecs_msg.c index 9a9e39c..5ef0f6b 100644 --- a/tizen/src/ecs/ecs_msg.c +++ b/tizen/src/ecs/ecs_msg.c @@ -50,7 +50,6 @@ #endif #include "qemu-common.h" -//#include "qemu_socket.h" #include "sdb.h" #include "ecs-json-streamer.h" #include "qmp-commands.h" @@ -310,7 +309,7 @@ bool msgproc_device_req(ECS_Client* ccli, ECS__DeviceReq* msg) if (!strncmp(cmd, MSG_TYPE_SENSOR, 6)) { if (group == MSG_GROUP_STATUS) { - if (action ==MSG_ACTION_ACCEL) { + if (action == MSG_ACTION_ACCEL) { get_sensor_accel(); } else if (action == MSG_ACTION_GYRO) { get_sensor_gyro(); @@ -605,3 +604,4 @@ bool send_nfc_ntf(struct nfc_msg_info* msg) return true; } + diff --git a/tizen/src/ecs/ecs_tethering.c b/tizen/src/ecs/ecs_tethering.c new file mode 100644 index 0000000..f332349 --- /dev/null +++ b/tizen/src/ecs/ecs_tethering.c @@ -0,0 +1,229 @@ +/* + * Emulator Control Server - Device Tethering Handler + * + * Copyright (c) 2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Contact: + * KiTae Kim + * JiHey Kim + * YeongKyoon Lee + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +#include "qemu-common.h" +#include "qemu/sockets.h" + +#include "ecs.h" +#include "ecs_tethering.h" +#include "../tethering/app_tethering.h" + +#include "../debug_ch.h" + +MULTI_DEBUG_CHANNEL(tizen, ecs_tethering); + +#define MSG_BUF_SIZE 255 +#define MSG_LEN_SIZE 4 + +// ecs <-> ecp messages +#define ECS_TETHERING_MSG_CATEGORY "tethering" + +#define ECS_TETHERING_MSG_GROUP_ECP 1 +// #define TETHERING_MSG_GROUP_USB +// #define TETHERING_MSG_GROUP_WIFI + +#define ECS_TETHERING_MSG_ACTION_CONNECT 1 +#define ECS_TETHERING_MSG_ACTION_DISCONNECT 2 +#define ECS_TETHERING_MSG_ACTION_CONNECTION_STATUS 3 +#define ECS_TETHERING_MSG_ACTION_SENSOR_STATUS 4 +#define ECS_TETHERING_MSG_ACTION_TOUCH_STATUS 5 + +// ecs <-> ecp +static bool send_tethering_ntf(const char *data, const int len); +static void send_tethering_status_ntf(type_group group, type_action action); + +void send_tethering_sensor_status_ecp(void) +{ + LOG(">> send tethering_event_status to ecp"); + send_tethering_status_ntf(ECS_TETHERING_MSG_GROUP_ECP, + ECS_TETHERING_MSG_ACTION_SENSOR_STATUS); +} + +void send_tethering_multitouch_status_ecp(void) +{ + send_tethering_status_ntf(ECS_TETHERING_MSG_GROUP_ECP, + ECS_TETHERING_MSG_ACTION_TOUCH_STATUS); +} + +void send_tethering_connection_status_ecp(void) +{ + LOG(">> send tethering_connection_status to ecp"); + send_tethering_status_ntf(ECS_TETHERING_MSG_GROUP_ECP, + ECS_TETHERING_MSG_ACTION_CONNECTION_STATUS); +} + +static void send_tethering_status_ntf(type_group group, type_action action) +{ + type_length length = 1; + int status = 0; + uint8_t *msg = NULL; + gchar data[2]; + + switch (action) { + case ECS_TETHERING_MSG_ACTION_CONNECTION_STATUS: + status = get_tethering_connection_status(); + break; + case ECS_TETHERING_MSG_ACTION_SENSOR_STATUS: + status = get_tethering_sensor_status(); + break; + case ECS_TETHERING_MSG_ACTION_TOUCH_STATUS: + status = get_tethering_multitouch_status(); + break; + default: + break; + } + + msg = g_malloc(MSG_BUF_SIZE); + if (!msg) { + return; + } + + g_snprintf(data, sizeof(data), "%d", status); + + memcpy(msg, ECS_TETHERING_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(">> send tethering_ntf to ecp. action=%d, group=%d, data=%s", + action, group, data); + + send_tethering_ntf((const char *)msg, MSG_BUF_SIZE); + + if (msg) { + g_free(msg); + } +} + +static bool send_tethering_ntf(const char *data, const int len) +{ + type_length length = 0; + type_group group = 0; + type_action action = 0; + + const int catsize = 10; + char cat[catsize + 1]; + memset(cat, 0, catsize + 1); + + read_val_str(data, cat, catsize); + read_val_short(data + catsize, &length); + read_val_char(data + catsize + 2, &group); + read_val_char(data + catsize + 2 + 1, &action); + + const char* ijdata = (data + catsize + 2 + 1 + 1); + + LOG("<< header cat = %s, length = %d, action=%d, group=%d", cat, length,action, group); + + ECS__Master master = ECS__MASTER__INIT; + ECS__TetheringNtf ntf = ECS__TETHERING_NTF__INIT; + + ntf.category = (char*) g_malloc(catsize + 1); + strncpy(ntf.category, cat, 10); + + ntf.length = length; + ntf.group = group; + ntf.action = action; + + if (length > 0) { + ntf.has_data = 1; + + ntf.data.data = g_malloc(length); + ntf.data.len = length; + memcpy(ntf.data.data, ijdata, length); + + LOG("data = %s, length = %hu", ijdata, length); + } + + master.type = ECS__MASTER__TYPE__TETHERING_NTF; + master.tethering_ntf = &ntf; + + send_to_ecp(&master); + + if (ntf.data.data && ntf.data.len > 0) { + g_free(ntf.data.data); + } + + if (ntf.category) { + g_free(ntf.category); + } + + return true; +} + + +// handle tethering_req message +bool msgproc_tethering_req(ECS_Client* ccli, ECS__TetheringReq* msg) +{ + gchar cmd[10] = {0}; + + g_strlcpy(cmd, msg->category, sizeof(cmd)); + type_length length = (type_length) msg->length; + type_group group = (type_group) (msg->group & 0xff); + type_action action = (type_action) (msg->action & 0xff); + + LOG(">> header = cmd = %s, length = %d, action=%d, group=%d", + cmd, length, action, group); + + if (group == ECS_TETHERING_MSG_GROUP_ECP) { + switch(action) { + case ECS_TETHERING_MSG_ACTION_CONNECT: + { + if (msg->data.data && msg->data.len > 0) { + const gchar *data = (const gchar *)msg->data.data; + gint port = 0; + + port = g_ascii_strtoull(data, NULL, 10); + + LOG(">> MSG_ACTION_CONNECT"); + LOG(">> port_num: %d", port); + LOG(">> len = %zd, data\" %s\"", strlen(data), data); + + connect_tethering_app(port); + } + } + break; + case ECS_TETHERING_MSG_ACTION_DISCONNECT: + LOG(">> MSG_ACTION_DISCONNECT"); + // end_tethering_socket(tethering_sock); + disconnect_tethering_app(); + break; + case ECS_TETHERING_MSG_ACTION_CONNECTION_STATUS: + case ECS_TETHERING_MSG_ACTION_SENSOR_STATUS: + case ECS_TETHERING_MSG_ACTION_TOUCH_STATUS: + LOG(">> get_status_action"); + send_tethering_status_ntf(group, action); + break; + default: + break; + } + } + + return true; +} diff --git a/tizen/src/ecs/ecs_tethering.h b/tizen/src/ecs/ecs_tethering.h new file mode 100644 index 0000000..e132b83 --- /dev/null +++ b/tizen/src/ecs/ecs_tethering.h @@ -0,0 +1,33 @@ +/* + * Emulator Control Server - Device Tethering Handler + * + * Copyright (c) 2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Contact: + * KiTae Kim + * JiHey Kim + * DaiYoung Kim + * YeongKyoon Lee + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +void send_tethering_sensor_status_ecp(void); +void send_tethering_multitouch_status_ecp(void); +void send_tethering_connection_status_ecp(void); diff --git a/tizen/src/ecs/genmsg/ecs.pb-c.c b/tizen/src/ecs/genmsg/ecs.pb-c.c index e8a2a15..0871aec 100644 --- a/tizen/src/ecs/genmsg/ecs.pb-c.c +++ b/tizen/src/ecs/genmsg/ecs.pb-c.c @@ -651,6 +651,135 @@ void ecs__nfc_ntf__free_unpacked PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__nfc_ntf__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } +void ecs__tethering_req__init + (ECS__TetheringReq *message) +{ + static ECS__TetheringReq init_value = ECS__TETHERING_REQ__INIT; + *message = init_value; +} +size_t ecs__tethering_req__get_packed_size + (const ECS__TetheringReq *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t ecs__tethering_req__pack + (const ECS__TetheringReq *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t ecs__tethering_req__pack_to_buffer + (const ECS__TetheringReq *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +ECS__TetheringReq * + ecs__tethering_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (ECS__TetheringReq *) + protobuf_c_message_unpack (&ecs__tethering_req__descriptor, + allocator, len, data); +} +void ecs__tethering_req__free_unpacked + (ECS__TetheringReq *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void ecs__tethering_ans__init + (ECS__TetheringAns *message) +{ + static ECS__TetheringAns init_value = ECS__TETHERING_ANS__INIT; + *message = init_value; +} +size_t ecs__tethering_ans__get_packed_size + (const ECS__TetheringAns *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_ans__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t ecs__tethering_ans__pack + (const ECS__TetheringAns *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_ans__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t ecs__tethering_ans__pack_to_buffer + (const ECS__TetheringAns *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_ans__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +ECS__TetheringAns * + ecs__tethering_ans__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (ECS__TetheringAns *) + protobuf_c_message_unpack (&ecs__tethering_ans__descriptor, + allocator, len, data); +} +void ecs__tethering_ans__free_unpacked + (ECS__TetheringAns *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_ans__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void ecs__tethering_ntf__init + (ECS__TetheringNtf *message) +{ + static ECS__TetheringNtf init_value = ECS__TETHERING_NTF__INIT; + *message = init_value; +} +size_t ecs__tethering_ntf__get_packed_size + (const ECS__TetheringNtf *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_ntf__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t ecs__tethering_ntf__pack + (const ECS__TetheringNtf *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_ntf__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t ecs__tethering_ntf__pack_to_buffer + (const ECS__TetheringNtf *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_ntf__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +ECS__TetheringNtf * + ecs__tethering_ntf__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (ECS__TetheringNtf *) + protobuf_c_message_unpack (&ecs__tethering_ntf__descriptor, + allocator, len, data); +} +void ecs__tethering_ntf__free_unpacked + (ECS__TetheringNtf *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__tethering_ntf__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} void ecs__master__init (ECS__Master *message) { @@ -1667,7 +1796,303 @@ const ProtobufCMessageDescriptor ecs__nfc_ntf__descriptor = (ProtobufCMessageInit) ecs__nfc_ntf__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor ecs__master__field_descriptors[16] = +static const ProtobufCFieldDescriptor ecs__tethering_req__field_descriptors[5] = +{ + { + "category", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__TetheringReq, category), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "length", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__TetheringReq, length), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "group", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__TetheringReq, group), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "action", + 4, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__TetheringReq, action), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "data", + 5, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BYTES, + PROTOBUF_C_OFFSETOF(ECS__TetheringReq, has_data), + PROTOBUF_C_OFFSETOF(ECS__TetheringReq, data), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned ecs__tethering_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] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor ecs__tethering_req__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "ECS.TetheringReq", + "TetheringReq", + "ECS__TetheringReq", + "ECS", + sizeof(ECS__TetheringReq), + 5, + ecs__tethering_req__field_descriptors, + ecs__tethering_req__field_indices_by_name, + 1, ecs__tethering_req__number_ranges, + (ProtobufCMessageInit) ecs__tethering_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor ecs__tethering_ans__field_descriptors[7] = +{ + { + "errcode", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__TetheringAns, errcode), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "errstr", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__TetheringAns, errstr), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "category", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__TetheringAns, category), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "length", + 4, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__TetheringAns, length), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "group", + 5, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__TetheringAns, group), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "action", + 6, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__TetheringAns, action), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "data", + 7, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BYTES, + PROTOBUF_C_OFFSETOF(ECS__TetheringAns, has_data), + PROTOBUF_C_OFFSETOF(ECS__TetheringAns, data), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned ecs__tethering_ans__field_indices_by_name[] = { + 5, /* field[5] = action */ + 2, /* field[2] = category */ + 6, /* field[6] = data */ + 0, /* field[0] = errcode */ + 1, /* field[1] = errstr */ + 4, /* field[4] = group */ + 3, /* field[3] = length */ +}; +static const ProtobufCIntRange ecs__tethering_ans__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 7 } +}; +const ProtobufCMessageDescriptor ecs__tethering_ans__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "ECS.TetheringAns", + "TetheringAns", + "ECS__TetheringAns", + "ECS", + sizeof(ECS__TetheringAns), + 7, + ecs__tethering_ans__field_descriptors, + ecs__tethering_ans__field_indices_by_name, + 1, ecs__tethering_ans__number_ranges, + (ProtobufCMessageInit) ecs__tethering_ans__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor ecs__tethering_ntf__field_descriptors[5] = +{ + { + "category", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__TetheringNtf, category), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "length", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__TetheringNtf, length), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "group", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__TetheringNtf, group), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "action", + 4, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__TetheringNtf, action), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "data", + 5, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BYTES, + PROTOBUF_C_OFFSETOF(ECS__TetheringNtf, has_data), + PROTOBUF_C_OFFSETOF(ECS__TetheringNtf, data), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned ecs__tethering_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] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor ecs__tethering_ntf__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "ECS.TetheringNtf", + "TetheringNtf", + "ECS__TetheringNtf", + "ECS", + sizeof(ECS__TetheringNtf), + 5, + ecs__tethering_ntf__field_descriptors, + ecs__tethering_ntf__field_indices_by_name, + 1, ecs__tethering_ntf__number_ranges, + (ProtobufCMessageInit) ecs__tethering_ntf__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor ecs__master__field_descriptors[19] = { { "type", @@ -1861,6 +2286,42 @@ static const ProtobufCFieldDescriptor ecs__master__field_descriptors[16] = 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, + { + "tethering_req", + 103, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__Master, tethering_req), + &ecs__tethering_req__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "tethering_ans", + 104, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__Master, tethering_ans), + &ecs__tethering_ans__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "tethering_ntf", + 105, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__Master, tethering_ntf), + &ecs__tethering_ntf__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, }; static const unsigned ecs__master__field_indices_by_name[] = { 2, /* field[2] = checkversion_ans */ @@ -1878,13 +2339,16 @@ static const unsigned ecs__master__field_indices_by_name[] = { 11, /* field[11] = monitor_req */ 15, /* field[15] = nfc_ntf */ 14, /* field[14] = nfc_req */ + 17, /* field[17] = tethering_ans */ + 18, /* field[18] = tethering_ntf */ + 16, /* field[16] = tethering_req */ 0, /* field[0] = type */ }; static const ProtobufCIntRange ecs__master__number_ranges[2 + 1] = { { 1, 0 }, { 101, 14 }, - { 0, 16 } + { 0, 19 } }; const ProtobufCMessageDescriptor ecs__master__descriptor = { @@ -1894,7 +2358,7 @@ const ProtobufCMessageDescriptor ecs__master__descriptor = "ECS__Master", "ECS", sizeof(ECS__Master), - 16, + 19, ecs__master__field_descriptors, ecs__master__field_indices_by_name, 2, ecs__master__number_ranges, diff --git a/tizen/src/ecs/genmsg/ecs.pb-c.h b/tizen/src/ecs/genmsg/ecs.pb-c.h index f3449dc..c81f5d3 100644 --- a/tizen/src/ecs/genmsg/ecs.pb-c.h +++ b/tizen/src/ecs/genmsg/ecs.pb-c.h @@ -3,7 +3,6 @@ #ifndef PROTOBUF_C_ecs_2eproto__INCLUDED #define PROTOBUF_C_ecs_2eproto__INCLUDED -//#include #include "../../../distrib/protobuf/protobuf-c.h" PROTOBUF_C_BEGIN_DECLS @@ -25,6 +24,9 @@ typedef struct _ECS__MonitorAns ECS__MonitorAns; typedef struct _ECS__MonitorNtf ECS__MonitorNtf; typedef struct _ECS__NfcReq ECS__NfcReq; typedef struct _ECS__NfcNtf ECS__NfcNtf; +typedef struct _ECS__TetheringReq ECS__TetheringReq; +typedef struct _ECS__TetheringAns ECS__TetheringAns; +typedef struct _ECS__TetheringNtf ECS__TetheringNtf; typedef struct _ECS__Master ECS__Master; @@ -223,6 +225,53 @@ struct _ECS__NfcNtf , NULL, 0,{0,NULL} } +struct _ECS__TetheringReq +{ + ProtobufCMessage base; + char *category; + int32_t length; + int32_t group; + int32_t action; + protobuf_c_boolean has_data; + ProtobufCBinaryData data; +}; +#define ECS__TETHERING_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&ecs__tethering_req__descriptor) \ + , NULL, 0, 0, 0, 0,{0,NULL} } + + +struct _ECS__TetheringAns +{ + ProtobufCMessage base; + int32_t errcode; + char *errstr; + char *category; + int32_t length; + int32_t group; + int32_t action; + protobuf_c_boolean has_data; + ProtobufCBinaryData data; +}; +#define ECS__TETHERING_ANS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&ecs__tethering_ans__descriptor) \ + , 0, NULL, NULL, 0, 0, 0, 0,{0,NULL} } + + +struct _ECS__TetheringNtf +{ + ProtobufCMessage base; + char *category; + int32_t length; + int32_t group; + int32_t action; + protobuf_c_boolean has_data; + ProtobufCBinaryData data; +}; +#define ECS__TETHERING_NTF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&ecs__tethering_ntf__descriptor) \ + , NULL, 0, 0, 0, 0,{0,NULL} } + + struct _ECS__Master { ProtobufCMessage base; @@ -242,10 +291,13 @@ struct _ECS__Master ECS__MonitorNtf *monitor_ntf; ECS__NfcReq *nfc_req; ECS__NfcNtf *nfc_ntf; + ECS__TetheringReq *tethering_req; + ECS__TetheringAns *tethering_ans; + ECS__TetheringNtf *tethering_ntf; }; #define ECS__MASTER__INIT \ { PROTOBUF_C_MESSAGE_INIT (&ecs__master__descriptor) \ - , 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL } + , 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL } /* ECS__CheckVersionReq methods */ @@ -533,6 +585,63 @@ ECS__NfcNtf * void ecs__nfc_ntf__free_unpacked (ECS__NfcNtf *message, ProtobufCAllocator *allocator); +/* ECS__TetheringReq methods */ +void ecs__tethering_req__init + (ECS__TetheringReq *message); +size_t ecs__tethering_req__get_packed_size + (const ECS__TetheringReq *message); +size_t ecs__tethering_req__pack + (const ECS__TetheringReq *message, + uint8_t *out); +size_t ecs__tethering_req__pack_to_buffer + (const ECS__TetheringReq *message, + ProtobufCBuffer *buffer); +ECS__TetheringReq * + ecs__tethering_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void ecs__tethering_req__free_unpacked + (ECS__TetheringReq *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, + uint8_t *out); +size_t ecs__tethering_ans__pack_to_buffer + (const ECS__TetheringAns *message, + ProtobufCBuffer *buffer); +ECS__TetheringAns * + ecs__tethering_ans__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void ecs__tethering_ans__free_unpacked + (ECS__TetheringAns *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, + uint8_t *out); +size_t ecs__tethering_ntf__pack_to_buffer + (const ECS__TetheringNtf *message, + ProtobufCBuffer *buffer); +ECS__TetheringNtf * + ecs__tethering_ntf__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void ecs__tethering_ntf__free_unpacked + (ECS__TetheringNtf *message, + ProtobufCAllocator *allocator); /* ECS__Master methods */ void ecs__master__init (ECS__Master *message); @@ -599,6 +708,15 @@ typedef void (*ECS__NfcReq_Closure) typedef void (*ECS__NfcNtf_Closure) (const ECS__NfcNtf *message, void *closure_data); +typedef void (*ECS__TetheringReq_Closure) + (const ECS__TetheringReq *message, + void *closure_data); +typedef void (*ECS__TetheringAns_Closure) + (const ECS__TetheringAns *message, + void *closure_data); +typedef void (*ECS__TetheringNtf_Closure) + (const ECS__TetheringNtf *message, + void *closure_data); typedef void (*ECS__Master_Closure) (const ECS__Master *message, void *closure_data); @@ -623,6 +741,9 @@ extern const ProtobufCMessageDescriptor ecs__monitor_ans__descriptor; extern const ProtobufCMessageDescriptor ecs__monitor_ntf__descriptor; extern const ProtobufCMessageDescriptor ecs__nfc_req__descriptor; extern const ProtobufCMessageDescriptor ecs__nfc_ntf__descriptor; +extern const ProtobufCMessageDescriptor ecs__tethering_req__descriptor; +extern const ProtobufCMessageDescriptor ecs__tethering_ans__descriptor; +extern const ProtobufCMessageDescriptor ecs__tethering_ntf__descriptor; extern const ProtobufCMessageDescriptor ecs__master__descriptor; PROTOBUF_C_END_DECLS diff --git a/tizen/src/ecs/genmsg/ecs_ids.pb-c.c b/tizen/src/ecs/genmsg/ecs_ids.pb-c.c index 6e3747c..5f6451f 100644 --- a/tizen/src/ecs/genmsg/ecs_ids.pb-c.c +++ b/tizen/src/ecs/genmsg/ecs_ids.pb-c.c @@ -6,7 +6,7 @@ #endif #include "ecs_ids.pb-c.h" -const ProtobufCEnumValue ecs__master__type__enum_values_by_number[15] = +const ProtobufCEnumValue ecs__master__type__enum_values_by_number[18] = { { "CHECKVERSION_REQ", "ECS__MASTER__TYPE__CHECKVERSION_REQ", 2 }, { "CHECKVERSION_ANS", "ECS__MASTER__TYPE__CHECKVERSION_ANS", 3 }, @@ -23,11 +23,14 @@ const ProtobufCEnumValue ecs__master__type__enum_values_by_number[15] = { "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 }, }; static const ProtobufCIntRange ecs__master__type__value_ranges[] = { -{2, 0},{101, 13},{0, 15} +{2, 0},{101, 13},{0, 18} }; -const ProtobufCEnumValueIndex ecs__master__type__enum_values_by_name[15] = +const ProtobufCEnumValueIndex ecs__master__type__enum_values_by_name[18] = { { "CHECKVERSION_ANS", 1 }, { "CHECKVERSION_REQ", 0 }, @@ -44,6 +47,9 @@ const ProtobufCEnumValueIndex ecs__master__type__enum_values_by_name[15] = { "MONITOR_REQ", 10 }, { "NFC_NTF", 14 }, { "NFC_REQ", 13 }, + { "TETHERING_ANS", 16 }, + { "TETHERING_NTF", 17 }, + { "TETHERING_REQ", 15 }, }; const ProtobufCEnumDescriptor ecs__master__type__descriptor = { @@ -52,9 +58,9 @@ const ProtobufCEnumDescriptor ecs__master__type__descriptor = "Master_Type", "ECS__MasterType", "ECS", - 15, + 18, ecs__master__type__enum_values_by_number, - 15, + 18, ecs__master__type__enum_values_by_name, 2, ecs__master__type__value_ranges, diff --git a/tizen/src/ecs/genmsg/ecs_ids.pb-c.h b/tizen/src/ecs/genmsg/ecs_ids.pb-c.h index d4ce9d1..5a11824 100644 --- a/tizen/src/ecs/genmsg/ecs_ids.pb-c.h +++ b/tizen/src/ecs/genmsg/ecs_ids.pb-c.h @@ -27,7 +27,10 @@ typedef enum _ECS__MasterType { ECS__MASTER__TYPE__MONITOR_ANS = 13, ECS__MASTER__TYPE__MONITOR_NTF = 14, ECS__MASTER__TYPE__NFC_REQ = 101, - ECS__MASTER__TYPE__NFC_NTF = 102 + 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__MasterType; /* --- messages --- */ diff --git a/tizen/src/ecs/msg/ecs.proto b/tizen/src/ecs/msg/ecs.proto index a00e6ff..0f37f39 100644 --- a/tizen/src/ecs/msg/ecs.proto +++ b/tizen/src/ecs/msg/ecs.proto @@ -27,7 +27,7 @@ message InjectorReq { required string category = 1; required int32 length = 2; required int32 group = 3; - required int32 action = 4; + required int32 action = 4; optional bytes data = 5; } @@ -41,7 +41,7 @@ message InjectorNtf { required string category = 1; required int32 length = 2; required int32 group = 3; - required int32 action = 4; + required int32 action = 4; optional bytes data = 5; } @@ -49,7 +49,7 @@ message DeviceReq { required string category = 1; required int32 length = 2; required int32 group = 3; - required int32 action = 4; + required int32 action = 4; optional bytes data = 5; } @@ -59,7 +59,7 @@ message DeviceAns { required string category = 3; required int32 length = 4; required int32 group = 5; - required int32 action = 6; + required int32 action = 6; optional bytes data = 7; } @@ -67,7 +67,7 @@ message DeviceNtf { required string category = 1; required int32 length = 2; required int32 group = 3; - required int32 action = 4; + required int32 action = 4; optional bytes data = 5; } @@ -99,6 +99,32 @@ message NfcNtf { optional bytes data = 2; } +message TetheringReq { + required string category = 1; + required int32 length = 2; + required int32 group = 3; + required int32 action = 4; + optional bytes data = 5; +} + +message TetheringAns { + required int32 errcode = 1; + optional string errstr = 2; + required string category = 3; + required int32 length = 4; + required int32 group = 5; + required int32 action = 6; + optional bytes data = 7; +} + +message TetheringNtf { + required string category = 1; + required int32 length = 2; + required int32 group = 3; + required int32 action = 4; + optional bytes data = 5; +} + // ======= Main master message ======= message Master { @@ -125,6 +151,10 @@ message Master { // Extensions 101 to 150; 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; } diff --git a/tizen/src/ecs/msg/ecs_ids.proto b/tizen/src/ecs/msg/ecs_ids.proto index 1dfac59..c4b563c 100644 --- a/tizen/src/ecs/msg/ecs_ids.proto +++ b/tizen/src/ecs/msg/ecs_ids.proto @@ -20,4 +20,8 @@ enum Master_Type { // extension from 101 to 150 NFC_REQ = 101; NFC_NTF = 102; + + TETHERING_REQ = 103; + TETHERING_ANS = 104; + TETHERING_NTF = 105; } diff --git a/tizen/src/emulator.c b/tizen/src/emulator.c index 08f0d39..c6606d8 100644 --- a/tizen/src/emulator.c +++ b/tizen/src/emulator.c @@ -53,6 +53,7 @@ #include "skin/maruskin_client.h" #include "debug_ch.h" #include "ecs/ecs.h" +#include "tethering/app_tethering.h" #ifdef CONFIG_SDL #include @@ -115,6 +116,7 @@ void exit_emulator(void) shutdown_skin_server(); shutdown_guest_server(); stop_ecs(); + disconnect_tethering_app(); #if defined(CONFIG_LINUX) || defined(CONFIG_DARWIN) if (shmctl(g_shmid, IPC_RMID, 0) == -1) { diff --git a/tizen/src/tethering/Makefile.tizen b/tizen/src/tethering/Makefile.tizen new file mode 100644 index 0000000..afc81e2 --- /dev/null +++ b/tizen/src/tethering/Makefile.tizen @@ -0,0 +1,9 @@ +# tethering Makefile.tizen + +$(call set-vpath, $(SRC_PATH):$(TARGET_PATH):$(SRC_PATH)/tizen/src/tethering:$(SRC_PATH)/tizen/src/tethering/genmsg:$(SRC_PATH)/tizen/distrib/protobuf) + +QEMU_CFLAGS += -I$(SRC_PATH)/tizen/distrib/protobuf +QEMU_CFLAGS += -I$(SRC_PATH)/tizen/src/tethering/genmsg + +obj-y += tethering.pb-c.o # protobuf-c.o +obj-y += app_tethering.o diff --git a/tizen/src/tethering/app_tethering.c b/tizen/src/tethering/app_tethering.c new file mode 100644 index 0000000..0810de7 --- /dev/null +++ b/tizen/src/tethering/app_tethering.c @@ -0,0 +1,987 @@ +/* + * emulator controller client + * + * Copyright (c) 2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Contact: + * Kitae Kim + * JiHye Kim + * YeongKyoon Lee + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + * + * Contributors: + * - S-Core Co., Ltd + * + */ +#include + +#include "qemu-common.h" +#include "qemu/main-loop.h" +#include "qemu/sockets.h" +#include "ui/console.h" + +#include "emul_state.h" +#include "app_tethering.h" +#include "../ecs/ecs_tethering.h" +#include "genmsg/tethering.pb-c.h" +#include "../hw/maru_virtio_sensor.h" + +#include "../debug_ch.h" +MULTI_DEBUG_CHANNEL(tizen, app_tethering); + +#define TETHERING_MSG_HANDSHAKE_KEY 100 +#define MSG_BUF_SIZE 255 +#define MSG_LEN_SIZE 4 + +#ifndef min +#define min(a,b) ((a)<(b)?(a):(b)) +#endif + +typedef struct tethering_recv_buf { + uint32_t len; + uint32_t stack_size; + char data[MSG_BUF_SIZE]; +} tethering_recv_buf; + +typedef struct _TetheringState { + int sock_fd; + int connection_status; + tethering_recv_buf recv_buf; +} TetheringState; + +enum connection_status { + CONNECTED = 1, + DISCONNECTED, + CONNECTING, +}; + +enum device_status { + ENABLED = 1, + DISABLED, +}; + +#ifndef DEBUG +const char *connection_status_str[3] = {"CONNECTED", "DISCONNECTED", + "CONNECTING"}; +#endif + +static tethering_recv_buf recv_buf; + +static int connection_status = DISCONNECTED; +static int tethering_sock = -1; +// static bool app_state = false; +static int sensor_device_status = DISABLED; +static int mt_device_status = DISABLED; + +static void end_tethering_socket(int sockfd); +static void set_tethering_connection_status(int status); +static void set_tethering_sensor_status(int status); +static void set_tethering_multitouch_status(int status); +#if 0 +static void set_tethering_app_state(bool state); +static bool get_tethering_app_state(void); +#endif + +static void *build_injector_msg(Injector__InjectorMsg* msg, int *payloadsize) +{ + void *buf = NULL; + int msg_packed_size = 0; + + msg_packed_size = injector__injector_msg__get_packed_size(msg); + *payloadsize = msg_packed_size + MSG_LEN_SIZE; + + buf = g_malloc(*payloadsize); + if (!buf) { + ERR("failed to allocate memory\n"); + return NULL; + } + + injector__injector_msg__pack(msg, buf + MSG_LEN_SIZE); + + msg_packed_size = htonl(msg_packed_size); + memcpy(buf, &msg_packed_size, MSG_LEN_SIZE); + + return buf; +} + +static bool send_msg_to_controller(Injector__InjectorMsg *msg) +{ + void *buf = NULL; + int payloadsize = 0, err = 0; + int sockfd = 0; + bool ret = true; + + buf = build_injector_msg(msg, &payloadsize); + if (!buf) { + return false; + } + + sockfd = tethering_sock; + err = qemu_sendto(sockfd, buf, payloadsize, 0, NULL, 0); + if (err < 0) { + ERR("failed to send a message. err: %d\n", err); + ret = false; + } + + if (buf) { + g_free(buf); + } + + return ret; +} + +static bool send_handshake_req_msg(void) +{ + Injector__InjectorMsg msg = INJECTOR__INJECTOR_MSG__INIT; + Injector__HandShakeReq req = INJECTOR__HAND_SHAKE_REQ__INIT; + + TRACE("enter: %s\n", __func__); + + req.key = TETHERING_MSG_HANDSHAKE_KEY; + + msg.type = INJECTOR__INJECTOR_MSG__TYPE__HANDSHAKE_REQ; + msg.handshakereq = &req; + + TRACE("send handshake_req message\n"); + send_msg_to_controller(&msg); + + TRACE("leave: %s\n", __func__); + + return true; +} + +#if 0 +static bool send_emul_state_msg(void) +{ + Injector__InjectorMsg msg = INJECTOR__INJECTOR_MSG__INIT; + Injector__EmulatorState emul_state = INJECTOR__EMULATOR_STATE__INIT; + + TRACE("enter: %s\n", __func__); + + emul_state.state = INJECTOR__CONNECTION_STATE__TERMINATE; + + msg.type = INJECTOR__INJECTOR_MSG__TYPE__EMUL_STATE; + msg.emulstate = &emul_state; + + INFO("send emulator_state message\n"); + send_msg_to_controller(&msg); + + TRACE("leave: %s\n", __func__); + + return true; +} +#endif + +static bool build_event_msg(Injector__EventMsg *event) +{ + bool ret = false; + Injector__InjectorMsg msg = INJECTOR__INJECTOR_MSG__INIT; + + TRACE("enter: %s\n", __func__); + + msg.type = INJECTOR__INJECTOR_MSG__TYPE__EVENT_MSG; + msg.eventmsg = event; + + ret = send_msg_to_controller(&msg); + + TRACE("leave: %s, ret: %d\n", __func__, ret); + + return ret; +} + +static bool send_event_start_ans_msg(Injector__Result result) +{ + bool ret = false; + Injector__EventMsg event = INJECTOR__EVENT_MSG__INIT; + Injector__StartAns start_ans = INJECTOR__START_ANS__INIT; + + TRACE("enter: %s\n", __func__); + + start_ans.result = result; + + event.type = INJECTOR__EVENT_MSG__TYPE__START_ANS; + event.startans = &start_ans; + + TRACE("send event_start_ans message\n"); + ret = build_event_msg(&event); + + TRACE("leave: %s, ret: %d\n", __func__, ret); + + return ret; +} + +static bool send_set_event_status_msg(Injector__Event event_type, + Injector__Status status) +{ + bool ret = false; + Injector__EventMsg event = INJECTOR__EVENT_MSG__INIT; + Injector__SetEventStatus event_status = INJECTOR__SET_EVENT_STATUS__INIT; + + TRACE("enter: %s\n", __func__); + + event_status.event = event_type; + event_status.status = status; + + event.type = INJECTOR__EVENT_MSG__TYPE__EVENT_STATUS; + event.setstatus = &event_status; + + TRACE("send event_set_event_status message\n"); + ret = build_event_msg(&event); + + TRACE("leave: %s, ret: %d\n", __func__, ret); + + return ret; +} + + +// create a sensor message. +static bool build_sensor_msg(Injector__SensorMsg *sensor) +{ + bool ret = false; + Injector__InjectorMsg msg = INJECTOR__INJECTOR_MSG__INIT; + + TRACE("enter: %s\n", __func__); + + msg.type = INJECTOR__INJECTOR_MSG__TYPE__SENSOR_MSG; + msg.sensormsg = sensor; + + ret = send_msg_to_controller(&msg); + + TRACE("leave: %s, ret: %d\n", __func__, ret); + + return ret; +} + +static bool send_sensor_start_ans_msg(Injector__Result result) +{ + bool ret = false; + Injector__SensorMsg event = INJECTOR__SENSOR_MSG__INIT; + Injector__StartAns start_ans = INJECTOR__START_ANS__INIT; + + TRACE("enter: %s\n", __func__); + + start_ans.result = result; + + event.type = INJECTOR__SENSOR_MSG__TYPE__START_ANS; + event.startans = &start_ans; + + TRACE("send sensor_start_ans message\n"); + ret = build_sensor_msg(&event); + + TRACE("leave: %s, ret: %d\n", __func__, ret); + + return ret; +} + +static bool send_set_sensor_status_msg(Injector__SensorType sensor_type, + Injector__Status status) +{ + bool ret = false; + + Injector__SensorMsg sensor = INJECTOR__SENSOR_MSG__INIT; + Injector__SetSensorStatus sensor_status = + INJECTOR__SET_SENSOR_STATUS__INIT; + + TRACE("enter: %s\n", __func__); + + sensor_status.sensor = sensor_type; + sensor_status.status = status; + + sensor.type = INJECTOR__SENSOR_MSG__TYPE__SENSOR_STATUS; + sensor.setstatus = &sensor_status; + + TRACE("send sensor_set_event_status message\n"); + ret = build_sensor_msg(&sensor); + + TRACE("leave: %s, ret: %d\n", __func__, ret); + + return ret; +} + +static void set_sensor_data(Injector__SensorData *data) +{ + switch(data->sensor) { + case INJECTOR__SENSOR_TYPE__ACCEL: + { + char tmp[255] = {0}; + + sprintf(tmp, "%s, %s, %s", data->x, data->y, data->z); + set_sensor_accel(tmp, strlen(tmp)); + + INFO("sensor_accel x: %s, y: %s, z: %s\n", data->x, data->y, data->z); + } + break; + case INJECTOR__SENSOR_TYPE__MAGNETIC: + { + char tmp[255] = {0}; + + sprintf(tmp, "%s %s %s", data->x, data->y, data->z); + set_sensor_mag(tmp, strlen(tmp)); + + INFO("sensor_mag x: %s, y: %s, z: %s\n", data->x, data->y, data->z); + } + break; + case INJECTOR__SENSOR_TYPE__GYROSCOPE: + { + char tmp[255] = {0}; + + sprintf(tmp, "%s %s %s", data->x, data->y, data->z); + set_sensor_gyro(tmp, strlen(tmp)); + + INFO("sensor_gyro x: %s, y: %s, z: %s\n", data->x, data->y, data->z); + } + break; + case INJECTOR__SENSOR_TYPE__PROXIMITY: + { + char tmp[255] = {0}; + + sprintf(tmp, "%s", data->x); + set_sensor_proxi(tmp, strlen(tmp)); + INFO("sensor_proxi x: %s\n", data->x); + } + break; + case INJECTOR__SENSOR_TYPE__LIGHT: + { + char tmp[255] = {0}; + + sprintf(tmp, "%s", data->x); + set_sensor_light(tmp, strlen(tmp)); + INFO("sensor_light x: %s\n", data->x); + } + break; + default: + TRACE("invalid sensor data\n"); + break; + } + + // set ecs_sensor +} + +static bool build_mulitouch_msg(Injector__MultiTouchMsg *multitouch) +{ + bool ret = false; + Injector__InjectorMsg msg = INJECTOR__INJECTOR_MSG__INIT; + + TRACE("enter: %s\n", __func__); + + msg.type = INJECTOR__INJECTOR_MSG__TYPE__TOUCH_MSG; + msg.touchmsg = multitouch; + + ret = send_msg_to_controller(&msg); + + TRACE("leave: %s, ret: %d\n", __func__, ret); + + return ret; +} + +static bool send_mulitouch_start_ans_msg(Injector__Result result) +{ + bool ret = false; + + Injector__MultiTouchMsg mt = INJECTOR__MULTI_TOUCH_MSG__INIT; + Injector__StartAns start_ans = INJECTOR__START_ANS__INIT; + + TRACE("enter: %s\n", __func__); + + start_ans.result = result; + + mt.type = INJECTOR__MULTI_TOUCH_MSG__TYPE__START_ANS; + mt.startans = &start_ans; + + ret = build_mulitouch_msg(&mt); + + TRACE("leave: %s, ret: %d\n", __func__, ret); + + return ret; +} + +static bool send_multitouch_max_count(void) +{ + bool ret = false; + + Injector__MultiTouchMsg mt = INJECTOR__MULTI_TOUCH_MSG__INIT; + Injector__MultiTouchMaxCount touch_cnt = + INJECTOR__MULTI_TOUCH_MAX_COUNT__INIT; + + TRACE("enter: %s\n", __func__); + + touch_cnt.max = get_emul_max_touch_point(); + + mt.type = INJECTOR__MULTI_TOUCH_MSG__TYPE__MAX_COUNT; + mt.maxcount = &touch_cnt; + + INFO("send multi-touch max count: %d\n", touch_cnt.max); + ret = build_mulitouch_msg(&mt); + + TRACE("leave: %s, ret: %d\n", __func__, ret); + + return ret; +} + + +static void set_multitouch_data(Injector__MultiTouchData *data) +{ + float x = 0.0, y = 0.0; + int32_t index = 0; + + switch(data->status) { + case INJECTOR__TOUCH_STATUS__PRESS: + TRACE("touch pressed\n"); + + index = data->index; + x = data->xpoint; + y = data->ypoint; + break; + case INJECTOR__TOUCH_STATUS__RELEASE: + TRACE("touch released\n"); + + index = data->index; + x = data->xpoint; + y = data->ypoint; + break; + default: + TRACE("invalid multitouch data\n"); + break; + } + + INFO("MT. index: %d, x: %f, y: %f\n", index, x, y); + + // set ecs_multitouch + kbd_mouse_event(x, y, index, data->status); +} + +static void msgproc_tethering_handshake_ans(Injector__HandShakeAns *msg) +{ +// ans = msg->result; +} + +static void msgproc_app_state_msg(Injector__AppState *msg) +{ + if (msg->state == INJECTOR__CONNECTION_STATE__TERMINATE) { + INFO("App is terminated\n"); + +// set_tethering_app_state(false); + set_tethering_sensor_status(DISABLED); + set_tethering_multitouch_status(DISABLED); + + disconnect_tethering_app(); + } else { + // does nothing + } +} + + +static bool msgproc_tethering_event_msg(Injector__EventMsg *msg) +{ + bool ret = true; + + switch(msg->type) { + case INJECTOR__EVENT_MSG__TYPE__START_REQ: + { + int touch_status = 0; + + TRACE("EVENT_MSG_TYPE_START_REQ\n"); + send_set_event_status_msg(INJECTOR__EVENT__SENSOR, + INJECTOR__STATUS__ENABLE); + + // TODO: check sensor device whether it exists or not + set_tethering_sensor_status(ENABLED); + + if (is_emul_input_touch_enable()) { + touch_status = INJECTOR__STATUS__ENABLE; + set_tethering_multitouch_status(ENABLED); + } else { + touch_status = INJECTOR__STATUS__DISABLE; + set_tethering_multitouch_status(DISABLED); + } + + TRACE("send multi-touch event_status msg: %d\n", touch_status); + send_set_event_status_msg(INJECTOR__EVENT__MULTITOUCH, touch_status); + + TRACE("send event_start_ans msg: %d\n", touch_status); + send_event_start_ans_msg(INJECTOR__RESULT__SUCCESS); + } + break; +#if 0 + case INJECTOR__EVENT_MSG__TYPE__START_ANS: + break; + case INJECTOR__EVENT_MSG__TYPE__EVENT_STATUS: + break; +#endif + case INJECTOR__EVENT_MSG__TYPE__TERMINATE: + break; + default: + TRACE("invalid event_msg type\n"); + ret = false; + break; + } + + return ret; +} + +static bool msgproc_tethering_sensor_msg(Injector__SensorMsg *msg) +{ + bool ret = true; + + switch(msg->type) { + case INJECTOR__SENSOR_MSG__TYPE__START_REQ: + TRACE("SENSOR_MSG_TYPE_START_REQ\n"); + + // set sensor type. + send_set_sensor_status_msg(INJECTOR__SENSOR_TYPE__ACCEL, + INJECTOR__STATUS__ENABLE); + send_set_sensor_status_msg(INJECTOR__SENSOR_TYPE__MAGNETIC, + INJECTOR__STATUS__ENABLE); + send_set_sensor_status_msg(INJECTOR__SENSOR_TYPE__GYROSCOPE, + INJECTOR__STATUS__ENABLE); + send_set_sensor_status_msg(INJECTOR__SENSOR_TYPE__PROXIMITY, + INJECTOR__STATUS__ENABLE); + send_set_sensor_status_msg(INJECTOR__SENSOR_TYPE__LIGHT, + INJECTOR__STATUS__ENABLE); + + TRACE("SENSOR_MSG_TYPE_START_ANS\n"); + send_sensor_start_ans_msg(INJECTOR__RESULT__SUCCESS); + + break; +#if 0 + case INJECTOR__SENSOR_MSG__TYPE__START_ANS: + break; + case INJECTOR__SENSOR_MSG__TYPE__SENSOR_STATUS: + break; +#endif + case INJECTOR__SENSOR_MSG__TYPE__TERMINATE: + TRACE("SENSOR_MSG_TYPE_TERMINATE\n"); + break; + + case INJECTOR__SENSOR_MSG__TYPE__SENSOR_DATA: + TRACE("SENSOR_MSG_TYPE_SENSOR_DATA\n"); + set_sensor_data(msg->data); + break; + default: + TRACE("invalid sensor_msg type"); + ret = false; + break; + } + + return ret; +} + +static bool msgproc_tethering_mt_msg(Injector__MultiTouchMsg *msg) +{ + bool ret = true; + + switch(msg->type) { + case INJECTOR__MULTI_TOUCH_MSG__TYPE__START_REQ: + TRACE("MULTITOUCH_MSG_TYPE_START\n"); + ret = send_mulitouch_start_ans_msg(INJECTOR__RESULT__SUCCESS); + break; +#if 0 + case INJECTOR__MULTI_TOUCH_MSG__TYPE__START_ANS: + break; +#endif + case INJECTOR__MULTI_TOUCH_MSG__TYPE__TERMINATE: + TRACE("MULTITOUCH_MSG_TYPE_TERMINATE\n"); + break; + case INJECTOR__MULTI_TOUCH_MSG__TYPE__MAX_COUNT: + ret = send_multitouch_max_count(); + TRACE("MULTITOUCH_MSG_TYPE_TERMINATE\n"); + break; + case INJECTOR__MULTI_TOUCH_MSG__TYPE__TOUCH_DATA: + set_multitouch_data(msg->touchdata); + break; + default: + TRACE("invalid multitouch_msg\n"); + ret = false; + break; + } + + return ret; +} + +static bool handle_injector_msg_from_controller(char *data, int len) +{ + Injector__InjectorMsg *injector = NULL; + bool ret = true; + + injector = injector__injector_msg__unpack(NULL, (size_t)len, + (const uint8_t *)data); + + if (!injector) { + // error message + ERR("no injector massage\n"); + return false; + } + + switch (injector->type) { + case INJECTOR__INJECTOR_MSG__TYPE__HANDSHAKE_ANS: + { + // TODO: set the result of handshake_ans to + Injector__HandShakeAns *msg = injector->handshakeans; + if (!msg) { + ret = false; + } else { + msgproc_tethering_handshake_ans(msg); + INFO("receive handshake answer\n"); + + set_tethering_connection_status(CONNECTED); + } + } + break; + case INJECTOR__INJECTOR_MSG__TYPE__APP_STATE: + { + Injector__AppState *msg = injector->appstate; + + INFO("receive app_state msg\n"); + if (!msg) { + ret = false; + } else { + msgproc_app_state_msg(msg); + } + } + break; + case INJECTOR__INJECTOR_MSG__TYPE__EVENT_MSG: + { + Injector__EventMsg *msg = injector->eventmsg; + + INFO("receive event_msg\n"); + if (!msg) { + ret = false; + } else { + msgproc_tethering_event_msg(msg); + } + } + break; + case INJECTOR__INJECTOR_MSG__TYPE__SENSOR_MSG: + { + Injector__SensorMsg *msg = injector->sensormsg; + + INFO("receive sensor_msg\n"); + if (!msg) { + ret = false; + } else { + msgproc_tethering_sensor_msg(msg); + } + } + break; + case INJECTOR__INJECTOR_MSG__TYPE__TOUCH_MSG: + { + Injector__MultiTouchMsg *msg = injector->touchmsg; + + INFO("receive multitouch_msg\n"); + if (!msg) { + ret = false; + } else { + msgproc_tethering_mt_msg(msg); + } + } + break; + default: + TRACE("invalid type message\n"); + ret = false; + break; + } + +#if 1 + if (data) { + g_free(data); + } +#endif + + injector__injector_msg__free_unpacked(injector, NULL); + return ret; +} + +static void reset_tethering_recv_buf(void *opaque) +{ + memset(opaque, 0x00, sizeof(tethering_recv_buf)); +} + +// tethering client socket +static void tethering_io_handler(void *opaque) +{ + int ret = 0; + int payloadsize = 0, read_size = 0; + int to_read_bytes = 0; + +#ifndef CONFIG_WIN32 + ret = ioctl(tethering_sock, FIONREAD, &to_read_bytes); + if (ret < 0) { + ERR("invalid ioctl opertion\n"); + } +#else + unsigned long to_read_bytes_long = 0; + ret = ioctlsocket(tethering_sock. FIONREAD, &to_read_bytes_long); + if (ret < 0) { + } + to_read_bytes = (int)to_read_bytes_long; +#endif + TRACE("ioctl: ret: %d, FIONREAD: %d\n", ret, to_read_bytes); + + if (to_read_bytes == 0) { + INFO("there is no read data\n"); + disconnect_tethering_app(); + return; + } + + if (recv_buf.len == 0) { + ret = qemu_recv(tethering_sock, &payloadsize, sizeof(payloadsize), 0); + if (ret < sizeof(payloadsize)) { + return; + } + + payloadsize = ntohl(payloadsize); + TRACE("payload size: %d\n", payloadsize); + +#if 0 + if (payloadsize > to_read_bytes) { + TRACE("invalid payload size: %d\n", payloadsize); + return; + } +#endif + + recv_buf.len = payloadsize; + + to_read_bytes -= sizeof(payloadsize); + } + + if (to_read_bytes == 0) { + return; + } + + to_read_bytes = min(to_read_bytes, (recv_buf.len - recv_buf.stack_size)); + + read_size = + qemu_recv(tethering_sock, (char *)(recv_buf.data + recv_buf.stack_size), + to_read_bytes, 0); + if (read_size == 0) { + ERR("failed to read data\n"); + disconnect_tethering_app(); + return; + } else { + recv_buf.stack_size += read_size; + } + + if (recv_buf.len == recv_buf.stack_size) { + char *snd_buf = NULL; + + snd_buf = g_malloc(recv_buf.stack_size); + memcpy(snd_buf, recv_buf.data, recv_buf.stack_size); + + handle_injector_msg_from_controller(snd_buf, + recv_buf.stack_size); + reset_tethering_recv_buf(&recv_buf); + } +} + +static int register_tethering_io_handler(int fd) +{ + int ret = 0, err = 0; + + TRACE("enter: %s\n", __func__); + + /* register callbackfn for read */ + err = qemu_set_fd_handler(fd, tethering_io_handler, NULL, NULL); + if (err) { + ERR("failed to set event handler. fd: %d, err: %d\n", fd, err); + ret = -1; + } + + TRACE("leave: %s\n", __func__); + + return ret; +} + +static int destroy_tethering_io_handler(int fd) +{ + int ret = 0, err = 0; + + TRACE("enter: %s\n", __func__); + + err = qemu_set_fd_handler(fd, NULL, NULL, NULL); + + if (err) { + ERR("failed to set event handler. fd: %d, err: %d\n", fd, err); + ret = -1; + } + + TRACE("leave: %s, ret: %d\n", __func__, ret); + + return ret; +} + +static int start_tethering_socket(int port) +{ + struct sockaddr_in addr; + + int sock = -1, opt = 0; + int ret = 0; + + addr.sin_family = AF_INET; + addr.sin_port = htons(port); // i.e. 1234 + inet_aton("127.0.0.1", &addr.sin_addr); + + sock = qemu_socket(PF_INET, SOCK_STREAM, 0); + if (sock < 0) { + // handle error, print message + set_tethering_connection_status(DISCONNECTED); + return -1; + } + INFO("tethering socket is created: %d\n", sock); + + ret = + qemu_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); + if (ret < 0) { + // handle error, + ERR("setsockopt failure\n"); + end_tethering_socket(sock); + return -1; + } + + // set nonblock mode + qemu_set_nonblock(sock); + + set_tethering_connection_status(CONNECTING); + do { + if (connect(sock, &addr, sizeof(addr)) < 0) { + INFO("tethering socket is connecting.\n"); + ret = -socket_error(); + } else { + INFO("tethering socket is connected.\n"); + ret = 0; +// set_tethering_app_state(true); + break; + } + INFO("ret: %d\n", ret); +// } while (ret == -EINTR); + } while (ret == -EINPROGRESS); + + if (ret < 0) { + end_tethering_socket(sock); + sock = -1; + INFO("tethering_sock: %d\n", sock); + } + + return sock; +} + +static void end_tethering_socket(int sockfd) +{ + if (closesocket(sockfd) < 0) { + perror("closesocket failure"); + return; + } + + INFO("tethering socket is closed: %d\n", sockfd); + set_tethering_connection_status(DISCONNECTED); + set_tethering_sensor_status(DISABLED); + set_tethering_multitouch_status(DISABLED); +} + +#if 0 +static void set_tethering_app_state(bool state) +{ + TRACE("set tethering_app state: %d", state); + app_state = state; +} + +static bool get_tethering_app_state(void) +{ + return app_state; +} +#endif + +// ecs <-> tethering +int get_tethering_connection_status(void) +{ + return connection_status; +} + +static void set_tethering_connection_status(int status) +{ + connection_status = status; + if (status) { + INFO("connection status: %s\n", connection_status_str[status - 1]); + } + + send_tethering_connection_status_ecp(); +} + +int get_tethering_sensor_status(void) +{ + return sensor_device_status; +} + +static void set_tethering_sensor_status(int status) +{ + sensor_device_status = status; + send_tethering_sensor_status_ecp(); +} + +int get_tethering_multitouch_status(void) +{ + return mt_device_status; +} + +static void set_tethering_multitouch_status(int status) +{ + mt_device_status = status; + send_tethering_multitouch_status_ecp(); +} + +int connect_tethering_app(int port) +{ + int sock = 0, ret = 0; + + TRACE("connect ecp to app\n"); + + sock = start_tethering_socket(port); + if (sock < 0) { + ERR("failed to start tethering_socket\n"); + tethering_sock = -1; + return -1; + } + + tethering_sock = sock; + + reset_tethering_recv_buf(&recv_buf); + ret = register_tethering_io_handler(sock); + send_handshake_req_msg(); + + return ret; +} + +int disconnect_tethering_app(void) +{ + int sock = 0; + + INFO("disconnect app from ecp\n"); + + sock = tethering_sock; + if (sock < 0) { + ERR("tethering socket is terminated or not ready\n"); + } else { + destroy_tethering_io_handler(sock); +#if 0 + if (get_tethering_app_state()) { + send_emul_state_msg(); + } +#endif + end_tethering_socket(sock); + } + + return 0; +} diff --git a/tizen/src/tethering/app_tethering.h b/tizen/src/tethering/app_tethering.h new file mode 100644 index 0000000..35850dc --- /dev/null +++ b/tizen/src/tethering/app_tethering.h @@ -0,0 +1,39 @@ +/* + * emulator controller client + * + * Copyright (c) 2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Contact: + * Kitae Kim + * JiHye Kim + * YeongKyoon Lee + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +int connect_tethering_app(int port); + +int disconnect_tethering_app(void); + +int get_tethering_connection_status(void); + +int get_tethering_sensor_status(void); + +int get_tethering_multitouch_status(void); diff --git a/tizen/src/tethering/genmsg/tethering.pb-c.c b/tizen/src/tethering/genmsg/tethering.pb-c.c new file mode 100644 index 0000000..3a93617 --- /dev/null +++ b/tizen/src/tethering/genmsg/tethering.pb-c.c @@ -0,0 +1,1964 @@ +/* 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 injector__hand_shake_req__init + (Injector__HandShakeReq *message) +{ + static Injector__HandShakeReq init_value = INJECTOR__HAND_SHAKE_REQ__INIT; + *message = init_value; +} +size_t injector__hand_shake_req__get_packed_size + (const Injector__HandShakeReq *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__hand_shake_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t injector__hand_shake_req__pack + (const Injector__HandShakeReq *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__hand_shake_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t injector__hand_shake_req__pack_to_buffer + (const Injector__HandShakeReq *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__hand_shake_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Injector__HandShakeReq * + injector__hand_shake_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Injector__HandShakeReq *) + protobuf_c_message_unpack (&injector__hand_shake_req__descriptor, + allocator, len, data); +} +void injector__hand_shake_req__free_unpacked + (Injector__HandShakeReq *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__hand_shake_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void injector__hand_shake_ans__init + (Injector__HandShakeAns *message) +{ + static Injector__HandShakeAns init_value = INJECTOR__HAND_SHAKE_ANS__INIT; + *message = init_value; +} +size_t injector__hand_shake_ans__get_packed_size + (const Injector__HandShakeAns *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__hand_shake_ans__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t injector__hand_shake_ans__pack + (const Injector__HandShakeAns *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__hand_shake_ans__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t injector__hand_shake_ans__pack_to_buffer + (const Injector__HandShakeAns *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__hand_shake_ans__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Injector__HandShakeAns * + injector__hand_shake_ans__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Injector__HandShakeAns *) + protobuf_c_message_unpack (&injector__hand_shake_ans__descriptor, + allocator, len, data); +} +void injector__hand_shake_ans__free_unpacked + (Injector__HandShakeAns *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__hand_shake_ans__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void injector__emulator_state__init + (Injector__EmulatorState *message) +{ + static Injector__EmulatorState init_value = INJECTOR__EMULATOR_STATE__INIT; + *message = init_value; +} +size_t injector__emulator_state__get_packed_size + (const Injector__EmulatorState *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__emulator_state__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t injector__emulator_state__pack + (const Injector__EmulatorState *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__emulator_state__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t injector__emulator_state__pack_to_buffer + (const Injector__EmulatorState *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__emulator_state__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Injector__EmulatorState * + injector__emulator_state__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Injector__EmulatorState *) + protobuf_c_message_unpack (&injector__emulator_state__descriptor, + allocator, len, data); +} +void injector__emulator_state__free_unpacked + (Injector__EmulatorState *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__emulator_state__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void injector__app_state__init + (Injector__AppState *message) +{ + static Injector__AppState init_value = INJECTOR__APP_STATE__INIT; + *message = init_value; +} +size_t injector__app_state__get_packed_size + (const Injector__AppState *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__app_state__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t injector__app_state__pack + (const Injector__AppState *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__app_state__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t injector__app_state__pack_to_buffer + (const Injector__AppState *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__app_state__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Injector__AppState * + injector__app_state__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Injector__AppState *) + protobuf_c_message_unpack (&injector__app_state__descriptor, + allocator, len, data); +} +void injector__app_state__free_unpacked + (Injector__AppState *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__app_state__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void injector__start_req__init + (Injector__StartReq *message) +{ + static Injector__StartReq init_value = INJECTOR__START_REQ__INIT; + *message = init_value; +} +size_t injector__start_req__get_packed_size + (const Injector__StartReq *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__start_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t injector__start_req__pack + (const Injector__StartReq *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__start_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t injector__start_req__pack_to_buffer + (const Injector__StartReq *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__start_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Injector__StartReq * + injector__start_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Injector__StartReq *) + protobuf_c_message_unpack (&injector__start_req__descriptor, + allocator, len, data); +} +void injector__start_req__free_unpacked + (Injector__StartReq *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__start_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void injector__start_ans__init + (Injector__StartAns *message) +{ + static Injector__StartAns init_value = INJECTOR__START_ANS__INIT; + *message = init_value; +} +size_t injector__start_ans__get_packed_size + (const Injector__StartAns *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__start_ans__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t injector__start_ans__pack + (const Injector__StartAns *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__start_ans__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t injector__start_ans__pack_to_buffer + (const Injector__StartAns *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__start_ans__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Injector__StartAns * + injector__start_ans__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Injector__StartAns *) + protobuf_c_message_unpack (&injector__start_ans__descriptor, + allocator, len, data); +} +void injector__start_ans__free_unpacked + (Injector__StartAns *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__start_ans__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void injector__set_event_status__init + (Injector__SetEventStatus *message) +{ + static Injector__SetEventStatus init_value = INJECTOR__SET_EVENT_STATUS__INIT; + *message = init_value; +} +size_t injector__set_event_status__get_packed_size + (const Injector__SetEventStatus *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__set_event_status__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t injector__set_event_status__pack + (const Injector__SetEventStatus *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__set_event_status__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t injector__set_event_status__pack_to_buffer + (const Injector__SetEventStatus *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__set_event_status__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Injector__SetEventStatus * + injector__set_event_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Injector__SetEventStatus *) + protobuf_c_message_unpack (&injector__set_event_status__descriptor, + allocator, len, data); +} +void injector__set_event_status__free_unpacked + (Injector__SetEventStatus *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__set_event_status__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void injector__event_msg__init + (Injector__EventMsg *message) +{ + static Injector__EventMsg init_value = INJECTOR__EVENT_MSG__INIT; + *message = init_value; +} +size_t injector__event_msg__get_packed_size + (const Injector__EventMsg *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__event_msg__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t injector__event_msg__pack + (const Injector__EventMsg *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__event_msg__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t injector__event_msg__pack_to_buffer + (const Injector__EventMsg *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__event_msg__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Injector__EventMsg * + injector__event_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Injector__EventMsg *) + protobuf_c_message_unpack (&injector__event_msg__descriptor, + allocator, len, data); +} +void injector__event_msg__free_unpacked + (Injector__EventMsg *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__event_msg__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void injector__event_terminate__init + (Injector__EventTerminate *message) +{ + static Injector__EventTerminate init_value = INJECTOR__EVENT_TERMINATE__INIT; + *message = init_value; +} +size_t injector__event_terminate__get_packed_size + (const Injector__EventTerminate *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__event_terminate__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t injector__event_terminate__pack + (const Injector__EventTerminate *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__event_terminate__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t injector__event_terminate__pack_to_buffer + (const Injector__EventTerminate *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__event_terminate__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Injector__EventTerminate * + injector__event_terminate__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Injector__EventTerminate *) + protobuf_c_message_unpack (&injector__event_terminate__descriptor, + allocator, len, data); +} +void injector__event_terminate__free_unpacked + (Injector__EventTerminate *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__event_terminate__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void injector__set_sensor_status__init + (Injector__SetSensorStatus *message) +{ + static Injector__SetSensorStatus init_value = INJECTOR__SET_SENSOR_STATUS__INIT; + *message = init_value; +} +size_t injector__set_sensor_status__get_packed_size + (const Injector__SetSensorStatus *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__set_sensor_status__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t injector__set_sensor_status__pack + (const Injector__SetSensorStatus *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__set_sensor_status__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t injector__set_sensor_status__pack_to_buffer + (const Injector__SetSensorStatus *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__set_sensor_status__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Injector__SetSensorStatus * + injector__set_sensor_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Injector__SetSensorStatus *) + protobuf_c_message_unpack (&injector__set_sensor_status__descriptor, + allocator, len, data); +} +void injector__set_sensor_status__free_unpacked + (Injector__SetSensorStatus *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__set_sensor_status__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void injector__sensor_data__init + (Injector__SensorData *message) +{ + static Injector__SensorData init_value = INJECTOR__SENSOR_DATA__INIT; + *message = init_value; +} +size_t injector__sensor_data__get_packed_size + (const Injector__SensorData *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__sensor_data__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t injector__sensor_data__pack + (const Injector__SensorData *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__sensor_data__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t injector__sensor_data__pack_to_buffer + (const Injector__SensorData *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__sensor_data__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Injector__SensorData * + injector__sensor_data__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Injector__SensorData *) + protobuf_c_message_unpack (&injector__sensor_data__descriptor, + allocator, len, data); +} +void injector__sensor_data__free_unpacked + (Injector__SensorData *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__sensor_data__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void injector__sensor_msg__init + (Injector__SensorMsg *message) +{ + static Injector__SensorMsg init_value = INJECTOR__SENSOR_MSG__INIT; + *message = init_value; +} +size_t injector__sensor_msg__get_packed_size + (const Injector__SensorMsg *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__sensor_msg__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t injector__sensor_msg__pack + (const Injector__SensorMsg *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__sensor_msg__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t injector__sensor_msg__pack_to_buffer + (const Injector__SensorMsg *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__sensor_msg__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Injector__SensorMsg * + injector__sensor_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Injector__SensorMsg *) + protobuf_c_message_unpack (&injector__sensor_msg__descriptor, + allocator, len, data); +} +void injector__sensor_msg__free_unpacked + (Injector__SensorMsg *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__sensor_msg__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void injector__multi_touch_max_count__init + (Injector__MultiTouchMaxCount *message) +{ + static Injector__MultiTouchMaxCount init_value = INJECTOR__MULTI_TOUCH_MAX_COUNT__INIT; + *message = init_value; +} +size_t injector__multi_touch_max_count__get_packed_size + (const Injector__MultiTouchMaxCount *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_max_count__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t injector__multi_touch_max_count__pack + (const Injector__MultiTouchMaxCount *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_max_count__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t injector__multi_touch_max_count__pack_to_buffer + (const Injector__MultiTouchMaxCount *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_max_count__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Injector__MultiTouchMaxCount * + injector__multi_touch_max_count__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Injector__MultiTouchMaxCount *) + protobuf_c_message_unpack (&injector__multi_touch_max_count__descriptor, + allocator, len, data); +} +void injector__multi_touch_max_count__free_unpacked + (Injector__MultiTouchMaxCount *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_max_count__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void injector__multi_touch_data__init + (Injector__MultiTouchData *message) +{ + static Injector__MultiTouchData init_value = INJECTOR__MULTI_TOUCH_DATA__INIT; + *message = init_value; +} +size_t injector__multi_touch_data__get_packed_size + (const Injector__MultiTouchData *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_data__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t injector__multi_touch_data__pack + (const Injector__MultiTouchData *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_data__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t injector__multi_touch_data__pack_to_buffer + (const Injector__MultiTouchData *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_data__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Injector__MultiTouchData * + injector__multi_touch_data__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Injector__MultiTouchData *) + protobuf_c_message_unpack (&injector__multi_touch_data__descriptor, + allocator, len, data); +} +void injector__multi_touch_data__free_unpacked + (Injector__MultiTouchData *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_data__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void injector__multi_touch_msg__init + (Injector__MultiTouchMsg *message) +{ + static Injector__MultiTouchMsg init_value = INJECTOR__MULTI_TOUCH_MSG__INIT; + *message = init_value; +} +size_t injector__multi_touch_msg__get_packed_size + (const Injector__MultiTouchMsg *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_msg__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t injector__multi_touch_msg__pack + (const Injector__MultiTouchMsg *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_msg__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t injector__multi_touch_msg__pack_to_buffer + (const Injector__MultiTouchMsg *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_msg__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Injector__MultiTouchMsg * + injector__multi_touch_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Injector__MultiTouchMsg *) + protobuf_c_message_unpack (&injector__multi_touch_msg__descriptor, + allocator, len, data); +} +void injector__multi_touch_msg__free_unpacked + (Injector__MultiTouchMsg *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_msg__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void injector__injector_msg__init + (Injector__InjectorMsg *message) +{ + static Injector__InjectorMsg init_value = INJECTOR__INJECTOR_MSG__INIT; + *message = init_value; +} +size_t injector__injector_msg__get_packed_size + (const Injector__InjectorMsg *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__injector_msg__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t injector__injector_msg__pack + (const Injector__InjectorMsg *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__injector_msg__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t injector__injector_msg__pack_to_buffer + (const Injector__InjectorMsg *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__injector_msg__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Injector__InjectorMsg * + injector__injector_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Injector__InjectorMsg *) + protobuf_c_message_unpack (&injector__injector_msg__descriptor, + allocator, len, data); +} +void injector__injector_msg__free_unpacked + (Injector__InjectorMsg *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &injector__injector_msg__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor injector__hand_shake_req__field_descriptors[1] = +{ + { + "key", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Injector__HandShakeReq, key), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned injector__hand_shake_req__field_indices_by_name[] = { + 0, /* field[0] = key */ +}; +static const ProtobufCIntRange injector__hand_shake_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor injector__hand_shake_req__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "injector.HandShakeReq", + "HandShakeReq", + "Injector__HandShakeReq", + "injector", + sizeof(Injector__HandShakeReq), + 1, + injector__hand_shake_req__field_descriptors, + injector__hand_shake_req__field_indices_by_name, + 1, injector__hand_shake_req__number_ranges, + (ProtobufCMessageInit) injector__hand_shake_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor injector__hand_shake_ans__field_descriptors[1] = +{ + { + "result", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Injector__HandShakeAns, result), + &injector__result__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned injector__hand_shake_ans__field_indices_by_name[] = { + 0, /* field[0] = result */ +}; +static const ProtobufCIntRange injector__hand_shake_ans__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor injector__hand_shake_ans__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "injector.HandShakeAns", + "HandShakeAns", + "Injector__HandShakeAns", + "injector", + sizeof(Injector__HandShakeAns), + 1, + injector__hand_shake_ans__field_descriptors, + injector__hand_shake_ans__field_indices_by_name, + 1, injector__hand_shake_ans__number_ranges, + (ProtobufCMessageInit) injector__hand_shake_ans__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor injector__emulator_state__field_descriptors[1] = +{ + { + "state", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Injector__EmulatorState, state), + &injector__connection_state__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned injector__emulator_state__field_indices_by_name[] = { + 0, /* field[0] = state */ +}; +static const ProtobufCIntRange injector__emulator_state__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor injector__emulator_state__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "injector.EmulatorState", + "EmulatorState", + "Injector__EmulatorState", + "injector", + sizeof(Injector__EmulatorState), + 1, + injector__emulator_state__field_descriptors, + injector__emulator_state__field_indices_by_name, + 1, injector__emulator_state__number_ranges, + (ProtobufCMessageInit) injector__emulator_state__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor injector__app_state__field_descriptors[1] = +{ + { + "state", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Injector__AppState, state), + &injector__connection_state__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned injector__app_state__field_indices_by_name[] = { + 0, /* field[0] = state */ +}; +static const ProtobufCIntRange injector__app_state__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor injector__app_state__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "injector.AppState", + "AppState", + "Injector__AppState", + "injector", + sizeof(Injector__AppState), + 1, + injector__app_state__field_descriptors, + injector__app_state__field_indices_by_name, + 1, injector__app_state__number_ranges, + (ProtobufCMessageInit) injector__app_state__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define injector__start_req__field_descriptors NULL +#define injector__start_req__field_indices_by_name NULL +#define injector__start_req__number_ranges NULL +const ProtobufCMessageDescriptor injector__start_req__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "injector.StartReq", + "StartReq", + "Injector__StartReq", + "injector", + sizeof(Injector__StartReq), + 0, + injector__start_req__field_descriptors, + injector__start_req__field_indices_by_name, + 0, injector__start_req__number_ranges, + (ProtobufCMessageInit) injector__start_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor injector__start_ans__field_descriptors[1] = +{ + { + "result", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Injector__StartAns, result), + &injector__result__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned injector__start_ans__field_indices_by_name[] = { + 0, /* field[0] = result */ +}; +static const ProtobufCIntRange injector__start_ans__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor injector__start_ans__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "injector.StartAns", + "StartAns", + "Injector__StartAns", + "injector", + sizeof(Injector__StartAns), + 1, + injector__start_ans__field_descriptors, + injector__start_ans__field_indices_by_name, + 1, injector__start_ans__number_ranges, + (ProtobufCMessageInit) injector__start_ans__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor injector__set_event_status__field_descriptors[2] = +{ + { + "event", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Injector__SetEventStatus, event), + &injector__event__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "status", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Injector__SetEventStatus, status), + &injector__status__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned injector__set_event_status__field_indices_by_name[] = { + 0, /* field[0] = event */ + 1, /* field[1] = status */ +}; +static const ProtobufCIntRange injector__set_event_status__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor injector__set_event_status__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "injector.SetEventStatus", + "SetEventStatus", + "Injector__SetEventStatus", + "injector", + sizeof(Injector__SetEventStatus), + 2, + injector__set_event_status__field_descriptors, + injector__set_event_status__field_indices_by_name, + 1, injector__set_event_status__number_ranges, + (ProtobufCMessageInit) injector__set_event_status__init, + NULL,NULL,NULL /* reserved[123] */ +}; +const ProtobufCEnumValue injector__event_msg__type__enum_values_by_number[4] = +{ + { "START_REQ", "INJECTOR__EVENT_MSG__TYPE__START_REQ", 2 }, + { "START_ANS", "INJECTOR__EVENT_MSG__TYPE__START_ANS", 3 }, + { "TERMINATE", "INJECTOR__EVENT_MSG__TYPE__TERMINATE", 4 }, + { "EVENT_STATUS", "INJECTOR__EVENT_MSG__TYPE__EVENT_STATUS", 5 }, +}; +static const ProtobufCIntRange injector__event_msg__type__value_ranges[] = { +{2, 0},{0, 4} +}; +const ProtobufCEnumValueIndex injector__event_msg__type__enum_values_by_name[4] = +{ + { "EVENT_STATUS", 3 }, + { "START_ANS", 1 }, + { "START_REQ", 0 }, + { "TERMINATE", 2 }, +}; +const ProtobufCEnumDescriptor injector__event_msg__type__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "injector.EventMsg.TYPE", + "TYPE", + "Injector__EventMsg__TYPE", + "injector", + 4, + injector__event_msg__type__enum_values_by_number, + 4, + injector__event_msg__type__enum_values_by_name, + 1, + injector__event_msg__type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCFieldDescriptor injector__event_msg__field_descriptors[5] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Injector__EventMsg, type), + &injector__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(Injector__EventMsg, startreq), + &injector__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(Injector__EventMsg, startans), + &injector__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(Injector__EventMsg, terminate), + &injector__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(Injector__EventMsg, setstatus), + &injector__set_event_status__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned injector__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 injector__event_msg__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor injector__event_msg__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "injector.EventMsg", + "EventMsg", + "Injector__EventMsg", + "injector", + sizeof(Injector__EventMsg), + 5, + injector__event_msg__field_descriptors, + injector__event_msg__field_indices_by_name, + 1, injector__event_msg__number_ranges, + (ProtobufCMessageInit) injector__event_msg__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define injector__event_terminate__field_descriptors NULL +#define injector__event_terminate__field_indices_by_name NULL +#define injector__event_terminate__number_ranges NULL +const ProtobufCMessageDescriptor injector__event_terminate__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "injector.EventTerminate", + "EventTerminate", + "Injector__EventTerminate", + "injector", + sizeof(Injector__EventTerminate), + 0, + injector__event_terminate__field_descriptors, + injector__event_terminate__field_indices_by_name, + 0, injector__event_terminate__number_ranges, + (ProtobufCMessageInit) injector__event_terminate__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor injector__set_sensor_status__field_descriptors[2] = +{ + { + "sensor", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Injector__SetSensorStatus, sensor), + &injector__sensor_type__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "status", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Injector__SetSensorStatus, status), + &injector__status__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned injector__set_sensor_status__field_indices_by_name[] = { + 0, /* field[0] = sensor */ + 1, /* field[1] = status */ +}; +static const ProtobufCIntRange injector__set_sensor_status__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor injector__set_sensor_status__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "injector.SetSensorStatus", + "SetSensorStatus", + "Injector__SetSensorStatus", + "injector", + sizeof(Injector__SetSensorStatus), + 2, + injector__set_sensor_status__field_descriptors, + injector__set_sensor_status__field_indices_by_name, + 1, injector__set_sensor_status__number_ranges, + (ProtobufCMessageInit) injector__set_sensor_status__init, + NULL,NULL,NULL /* reserved[123] */ +}; +char injector__sensor_data__x__default_value[] = "0"; +char injector__sensor_data__y__default_value[] = "0"; +char injector__sensor_data__z__default_value[] = "0"; +static const ProtobufCFieldDescriptor injector__sensor_data__field_descriptors[4] = +{ + { + "sensor", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Injector__SensorData, sensor), + &injector__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(Injector__SensorData, x), + NULL, + &injector__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(Injector__SensorData, y), + NULL, + &injector__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(Injector__SensorData, z), + NULL, + &injector__sensor_data__z__default_value, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned injector__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 injector__sensor_data__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor injector__sensor_data__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "injector.SensorData", + "SensorData", + "Injector__SensorData", + "injector", + sizeof(Injector__SensorData), + 4, + injector__sensor_data__field_descriptors, + injector__sensor_data__field_indices_by_name, + 1, injector__sensor_data__number_ranges, + (ProtobufCMessageInit) injector__sensor_data__init, + NULL,NULL,NULL /* reserved[123] */ +}; +const ProtobufCEnumValue injector__sensor_msg__type__enum_values_by_number[5] = +{ + { "START_REQ", "INJECTOR__SENSOR_MSG__TYPE__START_REQ", 2 }, + { "START_ANS", "INJECTOR__SENSOR_MSG__TYPE__START_ANS", 3 }, + { "TERMINATE", "INJECTOR__SENSOR_MSG__TYPE__TERMINATE", 4 }, + { "SENSOR_STATUS", "INJECTOR__SENSOR_MSG__TYPE__SENSOR_STATUS", 5 }, + { "SENSOR_DATA", "INJECTOR__SENSOR_MSG__TYPE__SENSOR_DATA", 6 }, +}; +static const ProtobufCIntRange injector__sensor_msg__type__value_ranges[] = { +{2, 0},{0, 5} +}; +const ProtobufCEnumValueIndex injector__sensor_msg__type__enum_values_by_name[5] = +{ + { "SENSOR_DATA", 4 }, + { "SENSOR_STATUS", 3 }, + { "START_ANS", 1 }, + { "START_REQ", 0 }, + { "TERMINATE", 2 }, +}; +const ProtobufCEnumDescriptor injector__sensor_msg__type__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "injector.SensorMsg.Type", + "Type", + "Injector__SensorMsg__Type", + "injector", + 5, + injector__sensor_msg__type__enum_values_by_number, + 5, + injector__sensor_msg__type__enum_values_by_name, + 1, + injector__sensor_msg__type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCFieldDescriptor injector__sensor_msg__field_descriptors[6] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Injector__SensorMsg, type), + &injector__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(Injector__SensorMsg, startreq), + &injector__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(Injector__SensorMsg, startans), + &injector__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(Injector__SensorMsg, terminate), + &injector__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(Injector__SensorMsg, setstatus), + &injector__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(Injector__SensorMsg, data), + &injector__sensor_data__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned injector__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 injector__sensor_msg__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 6 } +}; +const ProtobufCMessageDescriptor injector__sensor_msg__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "injector.SensorMsg", + "SensorMsg", + "Injector__SensorMsg", + "injector", + sizeof(Injector__SensorMsg), + 6, + injector__sensor_msg__field_descriptors, + injector__sensor_msg__field_indices_by_name, + 1, injector__sensor_msg__number_ranges, + (ProtobufCMessageInit) injector__sensor_msg__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const int32_t injector__multi_touch_max_count__max__default_value = 10; +static const ProtobufCFieldDescriptor injector__multi_touch_max_count__field_descriptors[1] = +{ + { + "max", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + PROTOBUF_C_OFFSETOF(Injector__MultiTouchMaxCount, has_max), + PROTOBUF_C_OFFSETOF(Injector__MultiTouchMaxCount, max), + NULL, + &injector__multi_touch_max_count__max__default_value, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned injector__multi_touch_max_count__field_indices_by_name[] = { + 0, /* field[0] = max */ +}; +static const ProtobufCIntRange injector__multi_touch_max_count__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor injector__multi_touch_max_count__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "injector.MultiTouchMaxCount", + "MultiTouchMaxCount", + "Injector__MultiTouchMaxCount", + "injector", + sizeof(Injector__MultiTouchMaxCount), + 1, + injector__multi_touch_max_count__field_descriptors, + injector__multi_touch_max_count__field_indices_by_name, + 1, injector__multi_touch_max_count__number_ranges, + (ProtobufCMessageInit) injector__multi_touch_max_count__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const int32_t injector__multi_touch_data__index__default_value = 0; +static const float injector__multi_touch_data__x_point__default_value = 0; +static const float injector__multi_touch_data__y_point__default_value = 0; +static const ProtobufCFieldDescriptor injector__multi_touch_data__field_descriptors[4] = +{ + { + "index", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + PROTOBUF_C_OFFSETOF(Injector__MultiTouchData, has_index), + PROTOBUF_C_OFFSETOF(Injector__MultiTouchData, index), + NULL, + &injector__multi_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(Injector__MultiTouchData, has_xpoint), + PROTOBUF_C_OFFSETOF(Injector__MultiTouchData, xpoint), + NULL, + &injector__multi_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(Injector__MultiTouchData, has_ypoint), + PROTOBUF_C_OFFSETOF(Injector__MultiTouchData, ypoint), + NULL, + &injector__multi_touch_data__y_point__default_value, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "status", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_ENUM, + PROTOBUF_C_OFFSETOF(Injector__MultiTouchData, has_status), + PROTOBUF_C_OFFSETOF(Injector__MultiTouchData, status), + &injector__touch_status__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned injector__multi_touch_data__field_indices_by_name[] = { + 0, /* field[0] = index */ + 3, /* field[3] = status */ + 1, /* field[1] = xPoint */ + 2, /* field[2] = yPoint */ +}; +static const ProtobufCIntRange injector__multi_touch_data__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor injector__multi_touch_data__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "injector.MultiTouchData", + "MultiTouchData", + "Injector__MultiTouchData", + "injector", + sizeof(Injector__MultiTouchData), + 4, + injector__multi_touch_data__field_descriptors, + injector__multi_touch_data__field_indices_by_name, + 1, injector__multi_touch_data__number_ranges, + (ProtobufCMessageInit) injector__multi_touch_data__init, + NULL,NULL,NULL /* reserved[123] */ +}; +const ProtobufCEnumValue injector__multi_touch_msg__type__enum_values_by_number[5] = +{ + { "START_REQ", "INJECTOR__MULTI_TOUCH_MSG__TYPE__START_REQ", 2 }, + { "START_ANS", "INJECTOR__MULTI_TOUCH_MSG__TYPE__START_ANS", 3 }, + { "TERMINATE", "INJECTOR__MULTI_TOUCH_MSG__TYPE__TERMINATE", 4 }, + { "MAX_COUNT", "INJECTOR__MULTI_TOUCH_MSG__TYPE__MAX_COUNT", 5 }, + { "TOUCH_DATA", "INJECTOR__MULTI_TOUCH_MSG__TYPE__TOUCH_DATA", 6 }, +}; +static const ProtobufCIntRange injector__multi_touch_msg__type__value_ranges[] = { +{2, 0},{0, 5} +}; +const ProtobufCEnumValueIndex injector__multi_touch_msg__type__enum_values_by_name[5] = +{ + { "MAX_COUNT", 3 }, + { "START_ANS", 1 }, + { "START_REQ", 0 }, + { "TERMINATE", 2 }, + { "TOUCH_DATA", 4 }, +}; +const ProtobufCEnumDescriptor injector__multi_touch_msg__type__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "injector.MultiTouchMsg.Type", + "Type", + "Injector__MultiTouchMsg__Type", + "injector", + 5, + injector__multi_touch_msg__type__enum_values_by_number, + 5, + injector__multi_touch_msg__type__enum_values_by_name, + 1, + injector__multi_touch_msg__type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCFieldDescriptor injector__multi_touch_msg__field_descriptors[6] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Injector__MultiTouchMsg, type), + &injector__multi_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(Injector__MultiTouchMsg, startreq), + &injector__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(Injector__MultiTouchMsg, startans), + &injector__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(Injector__MultiTouchMsg, terminate), + &injector__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(Injector__MultiTouchMsg, maxcount), + &injector__multi_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(Injector__MultiTouchMsg, touchdata), + &injector__multi_touch_data__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned injector__multi_touch_msg__field_indices_by_name[] = { + 4, /* field[4] = maxCount */ + 2, /* field[2] = startAns */ + 1, /* field[1] = startReq */ + 3, /* field[3] = terminate */ + 5, /* field[5] = touchData */ + 0, /* field[0] = type */ +}; +static const ProtobufCIntRange injector__multi_touch_msg__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 6 } +}; +const ProtobufCMessageDescriptor injector__multi_touch_msg__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "injector.MultiTouchMsg", + "MultiTouchMsg", + "Injector__MultiTouchMsg", + "injector", + sizeof(Injector__MultiTouchMsg), + 6, + injector__multi_touch_msg__field_descriptors, + injector__multi_touch_msg__field_indices_by_name, + 1, injector__multi_touch_msg__number_ranges, + (ProtobufCMessageInit) injector__multi_touch_msg__init, + NULL,NULL,NULL /* reserved[123] */ +}; +const ProtobufCEnumValue injector__injector_msg__type__enum_values_by_number[7] = +{ + { "HANDSHAKE_REQ", "INJECTOR__INJECTOR_MSG__TYPE__HANDSHAKE_REQ", 2 }, + { "HANDSHAKE_ANS", "INJECTOR__INJECTOR_MSG__TYPE__HANDSHAKE_ANS", 3 }, + { "EMUL_STATE", "INJECTOR__INJECTOR_MSG__TYPE__EMUL_STATE", 4 }, + { "APP_STATE", "INJECTOR__INJECTOR_MSG__TYPE__APP_STATE", 5 }, + { "EVENT_MSG", "INJECTOR__INJECTOR_MSG__TYPE__EVENT_MSG", 6 }, + { "SENSOR_MSG", "INJECTOR__INJECTOR_MSG__TYPE__SENSOR_MSG", 7 }, + { "TOUCH_MSG", "INJECTOR__INJECTOR_MSG__TYPE__TOUCH_MSG", 8 }, +}; +static const ProtobufCIntRange injector__injector_msg__type__value_ranges[] = { +{2, 0},{0, 7} +}; +const ProtobufCEnumValueIndex injector__injector_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 injector__injector_msg__type__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "injector.InjectorMsg.Type", + "Type", + "Injector__InjectorMsg__Type", + "injector", + 7, + injector__injector_msg__type__enum_values_by_number, + 7, + injector__injector_msg__type__enum_values_by_name, + 1, + injector__injector_msg__type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCFieldDescriptor injector__injector_msg__field_descriptors[8] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(Injector__InjectorMsg, type), + &injector__injector_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(Injector__InjectorMsg, handshakereq), + &injector__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(Injector__InjectorMsg, handshakeans), + &injector__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(Injector__InjectorMsg, emulstate), + &injector__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(Injector__InjectorMsg, appstate), + &injector__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(Injector__InjectorMsg, eventmsg), + &injector__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(Injector__InjectorMsg, sensormsg), + &injector__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(Injector__InjectorMsg, touchmsg), + &injector__multi_touch_msg__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned injector__injector_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 injector__injector_msg__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 8 } +}; +const ProtobufCMessageDescriptor injector__injector_msg__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "injector.InjectorMsg", + "InjectorMsg", + "Injector__InjectorMsg", + "injector", + sizeof(Injector__InjectorMsg), + 8, + injector__injector_msg__field_descriptors, + injector__injector_msg__field_indices_by_name, + 1, injector__injector_msg__number_ranges, + (ProtobufCMessageInit) injector__injector_msg__init, + NULL,NULL,NULL /* reserved[123] */ +}; +const ProtobufCEnumValue injector__result__enum_values_by_number[3] = +{ + { "SUCCESS", "INJECTOR__RESULT__SUCCESS", 1 }, + { "FAILURE", "INJECTOR__RESULT__FAILURE", 2 }, + { "CANCEL", "INJECTOR__RESULT__CANCEL", 3 }, +}; +static const ProtobufCIntRange injector__result__value_ranges[] = { +{1, 0},{0, 3} +}; +const ProtobufCEnumValueIndex injector__result__enum_values_by_name[3] = +{ + { "CANCEL", 2 }, + { "FAILURE", 1 }, + { "SUCCESS", 0 }, +}; +const ProtobufCEnumDescriptor injector__result__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "injector.Result", + "Result", + "Injector__Result", + "injector", + 3, + injector__result__enum_values_by_number, + 3, + injector__result__enum_values_by_name, + 1, + injector__result__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +const ProtobufCEnumValue injector__connection_state__enum_values_by_number[3] = +{ + { "CONNECT", "INJECTOR__CONNECTION_STATE__CONNECT", 1 }, + { "DISCONNECT", "INJECTOR__CONNECTION_STATE__DISCONNECT", 2 }, + { "TERMINATE", "INJECTOR__CONNECTION_STATE__TERMINATE", 3 }, +}; +static const ProtobufCIntRange injector__connection_state__value_ranges[] = { +{1, 0},{0, 3} +}; +const ProtobufCEnumValueIndex injector__connection_state__enum_values_by_name[3] = +{ + { "CONNECT", 0 }, + { "DISCONNECT", 1 }, + { "TERMINATE", 2 }, +}; +const ProtobufCEnumDescriptor injector__connection_state__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "injector.ConnectionState", + "ConnectionState", + "Injector__ConnectionState", + "injector", + 3, + injector__connection_state__enum_values_by_number, + 3, + injector__connection_state__enum_values_by_name, + 1, + injector__connection_state__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +const ProtobufCEnumValue injector__event__enum_values_by_number[2] = +{ + { "SENSOR", "INJECTOR__EVENT__SENSOR", 1 }, + { "MULTITOUCH", "INJECTOR__EVENT__MULTITOUCH", 2 }, +}; +static const ProtobufCIntRange injector__event__value_ranges[] = { +{1, 0},{0, 2} +}; +const ProtobufCEnumValueIndex injector__event__enum_values_by_name[2] = +{ + { "MULTITOUCH", 1 }, + { "SENSOR", 0 }, +}; +const ProtobufCEnumDescriptor injector__event__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "injector.Event", + "Event", + "Injector__Event", + "injector", + 2, + injector__event__enum_values_by_number, + 2, + injector__event__enum_values_by_name, + 1, + injector__event__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +const ProtobufCEnumValue injector__status__enum_values_by_number[2] = +{ + { "ENABLE", "INJECTOR__STATUS__ENABLE", 1 }, + { "DISABLE", "INJECTOR__STATUS__DISABLE", 2 }, +}; +static const ProtobufCIntRange injector__status__value_ranges[] = { +{1, 0},{0, 2} +}; +const ProtobufCEnumValueIndex injector__status__enum_values_by_name[2] = +{ + { "DISABLE", 1 }, + { "ENABLE", 0 }, +}; +const ProtobufCEnumDescriptor injector__status__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "injector.Status", + "Status", + "Injector__Status", + "injector", + 2, + injector__status__enum_values_by_number, + 2, + injector__status__enum_values_by_name, + 1, + injector__status__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +const ProtobufCEnumValue injector__sensor_type__enum_values_by_number[5] = +{ + { "ACCEL", "INJECTOR__SENSOR_TYPE__ACCEL", 1 }, + { "MAGNETIC", "INJECTOR__SENSOR_TYPE__MAGNETIC", 2 }, + { "GYROSCOPE", "INJECTOR__SENSOR_TYPE__GYROSCOPE", 3 }, + { "PROXIMITY", "INJECTOR__SENSOR_TYPE__PROXIMITY", 4 }, + { "LIGHT", "INJECTOR__SENSOR_TYPE__LIGHT", 5 }, +}; +static const ProtobufCIntRange injector__sensor_type__value_ranges[] = { +{1, 0},{0, 5} +}; +const ProtobufCEnumValueIndex injector__sensor_type__enum_values_by_name[5] = +{ + { "ACCEL", 0 }, + { "GYROSCOPE", 2 }, + { "LIGHT", 4 }, + { "MAGNETIC", 1 }, + { "PROXIMITY", 3 }, +}; +const ProtobufCEnumDescriptor injector__sensor_type__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "injector.SensorType", + "SensorType", + "Injector__SensorType", + "injector", + 5, + injector__sensor_type__enum_values_by_number, + 5, + injector__sensor_type__enum_values_by_name, + 1, + injector__sensor_type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +const ProtobufCEnumValue injector__touch_status__enum_values_by_number[2] = +{ + { "PRESS", "INJECTOR__TOUCH_STATUS__PRESS", 1 }, + { "RELEASE", "INJECTOR__TOUCH_STATUS__RELEASE", 2 }, +}; +static const ProtobufCIntRange injector__touch_status__value_ranges[] = { +{1, 0},{0, 2} +}; +const ProtobufCEnumValueIndex injector__touch_status__enum_values_by_name[2] = +{ + { "PRESS", 0 }, + { "RELEASE", 1 }, +}; +const ProtobufCEnumDescriptor injector__touch_status__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "injector.TouchStatus", + "TouchStatus", + "Injector__TouchStatus", + "injector", + 2, + injector__touch_status__enum_values_by_number, + 2, + injector__touch_status__enum_values_by_name, + 1, + injector__touch_status__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; diff --git a/tizen/src/tethering/genmsg/tethering.pb-c.h b/tizen/src/tethering/genmsg/tethering.pb-c.h new file mode 100644 index 0000000..43e3efe --- /dev/null +++ b/tizen/src/tethering/genmsg/tethering.pb-c.h @@ -0,0 +1,677 @@ +/* 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 _Injector__HandShakeReq Injector__HandShakeReq; +typedef struct _Injector__HandShakeAns Injector__HandShakeAns; +typedef struct _Injector__EmulatorState Injector__EmulatorState; +typedef struct _Injector__AppState Injector__AppState; +typedef struct _Injector__StartReq Injector__StartReq; +typedef struct _Injector__StartAns Injector__StartAns; +typedef struct _Injector__SetEventStatus Injector__SetEventStatus; +typedef struct _Injector__EventMsg Injector__EventMsg; +typedef struct _Injector__EventTerminate Injector__EventTerminate; +typedef struct _Injector__SetSensorStatus Injector__SetSensorStatus; +typedef struct _Injector__SensorData Injector__SensorData; +typedef struct _Injector__SensorMsg Injector__SensorMsg; +typedef struct _Injector__MultiTouchMaxCount Injector__MultiTouchMaxCount; +typedef struct _Injector__MultiTouchData Injector__MultiTouchData; +typedef struct _Injector__MultiTouchMsg Injector__MultiTouchMsg; +typedef struct _Injector__InjectorMsg Injector__InjectorMsg; + + +/* --- enums --- */ + +typedef enum _Injector__EventMsg__TYPE { + INJECTOR__EVENT_MSG__TYPE__START_REQ = 2, + INJECTOR__EVENT_MSG__TYPE__START_ANS = 3, + INJECTOR__EVENT_MSG__TYPE__TERMINATE = 4, + INJECTOR__EVENT_MSG__TYPE__EVENT_STATUS = 5 +} Injector__EventMsg__TYPE; +typedef enum _Injector__SensorMsg__Type { + INJECTOR__SENSOR_MSG__TYPE__START_REQ = 2, + INJECTOR__SENSOR_MSG__TYPE__START_ANS = 3, + INJECTOR__SENSOR_MSG__TYPE__TERMINATE = 4, + INJECTOR__SENSOR_MSG__TYPE__SENSOR_STATUS = 5, + INJECTOR__SENSOR_MSG__TYPE__SENSOR_DATA = 6 +} Injector__SensorMsg__Type; +typedef enum _Injector__MultiTouchMsg__Type { + INJECTOR__MULTI_TOUCH_MSG__TYPE__START_REQ = 2, + INJECTOR__MULTI_TOUCH_MSG__TYPE__START_ANS = 3, + INJECTOR__MULTI_TOUCH_MSG__TYPE__TERMINATE = 4, + INJECTOR__MULTI_TOUCH_MSG__TYPE__MAX_COUNT = 5, + INJECTOR__MULTI_TOUCH_MSG__TYPE__TOUCH_DATA = 6 +} Injector__MultiTouchMsg__Type; +typedef enum _Injector__InjectorMsg__Type { + INJECTOR__INJECTOR_MSG__TYPE__HANDSHAKE_REQ = 2, + INJECTOR__INJECTOR_MSG__TYPE__HANDSHAKE_ANS = 3, + INJECTOR__INJECTOR_MSG__TYPE__EMUL_STATE = 4, + INJECTOR__INJECTOR_MSG__TYPE__APP_STATE = 5, + INJECTOR__INJECTOR_MSG__TYPE__EVENT_MSG = 6, + INJECTOR__INJECTOR_MSG__TYPE__SENSOR_MSG = 7, + INJECTOR__INJECTOR_MSG__TYPE__TOUCH_MSG = 8 +} Injector__InjectorMsg__Type; +typedef enum _Injector__Result { + INJECTOR__RESULT__SUCCESS = 1, + INJECTOR__RESULT__FAILURE = 2, + INJECTOR__RESULT__CANCEL = 3 +} Injector__Result; +typedef enum _Injector__ConnectionState { + INJECTOR__CONNECTION_STATE__CONNECT = 1, + INJECTOR__CONNECTION_STATE__DISCONNECT = 2, + INJECTOR__CONNECTION_STATE__TERMINATE = 3 +} Injector__ConnectionState; +typedef enum _Injector__Event { + INJECTOR__EVENT__SENSOR = 1, + INJECTOR__EVENT__MULTITOUCH = 2 +} Injector__Event; +typedef enum _Injector__Status { + INJECTOR__STATUS__ENABLE = 1, + INJECTOR__STATUS__DISABLE = 2 +} Injector__Status; +typedef enum _Injector__SensorType { + INJECTOR__SENSOR_TYPE__ACCEL = 1, + INJECTOR__SENSOR_TYPE__MAGNETIC = 2, + INJECTOR__SENSOR_TYPE__GYROSCOPE = 3, + INJECTOR__SENSOR_TYPE__PROXIMITY = 4, + INJECTOR__SENSOR_TYPE__LIGHT = 5 +} Injector__SensorType; +typedef enum _Injector__TouchStatus { + INJECTOR__TOUCH_STATUS__PRESS = 1, + INJECTOR__TOUCH_STATUS__RELEASE = 2 +} Injector__TouchStatus; + +/* --- messages --- */ + +struct _Injector__HandShakeReq +{ + ProtobufCMessage base; + int32_t key; +}; +#define INJECTOR__HAND_SHAKE_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&injector__hand_shake_req__descriptor) \ + , 0 } + + +struct _Injector__HandShakeAns +{ + ProtobufCMessage base; + Injector__Result result; +}; +#define INJECTOR__HAND_SHAKE_ANS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&injector__hand_shake_ans__descriptor) \ + , 0 } + + +struct _Injector__EmulatorState +{ + ProtobufCMessage base; + Injector__ConnectionState state; +}; +#define INJECTOR__EMULATOR_STATE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&injector__emulator_state__descriptor) \ + , 0 } + + +struct _Injector__AppState +{ + ProtobufCMessage base; + Injector__ConnectionState state; +}; +#define INJECTOR__APP_STATE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&injector__app_state__descriptor) \ + , 0 } + + +struct _Injector__StartReq +{ + ProtobufCMessage base; +}; +#define INJECTOR__START_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&injector__start_req__descriptor) \ + } + + +struct _Injector__StartAns +{ + ProtobufCMessage base; + Injector__Result result; +}; +#define INJECTOR__START_ANS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&injector__start_ans__descriptor) \ + , 0 } + + +struct _Injector__SetEventStatus +{ + ProtobufCMessage base; + Injector__Event event; + Injector__Status status; +}; +#define INJECTOR__SET_EVENT_STATUS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&injector__set_event_status__descriptor) \ + , 0, 0 } + + +struct _Injector__EventMsg +{ + ProtobufCMessage base; + Injector__EventMsg__TYPE type; + Injector__StartReq *startreq; + Injector__StartAns *startans; + Injector__EventTerminate *terminate; + Injector__SetEventStatus *setstatus; +}; +#define INJECTOR__EVENT_MSG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&injector__event_msg__descriptor) \ + , 0, NULL, NULL, NULL, NULL } + + +struct _Injector__EventTerminate +{ + ProtobufCMessage base; +}; +#define INJECTOR__EVENT_TERMINATE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&injector__event_terminate__descriptor) \ + } + + +struct _Injector__SetSensorStatus +{ + ProtobufCMessage base; + Injector__SensorType sensor; + Injector__Status status; +}; +#define INJECTOR__SET_SENSOR_STATUS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&injector__set_sensor_status__descriptor) \ + , 0, 0 } + + +struct _Injector__SensorData +{ + ProtobufCMessage base; + Injector__SensorType sensor; + char *x; + char *y; + char *z; +}; +extern char injector__sensor_data__x__default_value[]; +extern char injector__sensor_data__y__default_value[]; +extern char injector__sensor_data__z__default_value[]; +#define INJECTOR__SENSOR_DATA__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&injector__sensor_data__descriptor) \ + , 0, injector__sensor_data__x__default_value, injector__sensor_data__y__default_value, injector__sensor_data__z__default_value } + + +struct _Injector__SensorMsg +{ + ProtobufCMessage base; + Injector__SensorMsg__Type type; + Injector__StartReq *startreq; + Injector__StartAns *startans; + Injector__EventTerminate *terminate; + Injector__SetSensorStatus *setstatus; + Injector__SensorData *data; +}; +#define INJECTOR__SENSOR_MSG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&injector__sensor_msg__descriptor) \ + , 0, NULL, NULL, NULL, NULL, NULL } + + +struct _Injector__MultiTouchMaxCount +{ + ProtobufCMessage base; + protobuf_c_boolean has_max; + int32_t max; +}; +#define INJECTOR__MULTI_TOUCH_MAX_COUNT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&injector__multi_touch_max_count__descriptor) \ + , 0,10 } + + +struct _Injector__MultiTouchData +{ + 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_status; + Injector__TouchStatus status; +}; +#define INJECTOR__MULTI_TOUCH_DATA__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&injector__multi_touch_data__descriptor) \ + , 0,0, 0,0, 0,0, 0,0 } + + +struct _Injector__MultiTouchMsg +{ + ProtobufCMessage base; + Injector__MultiTouchMsg__Type type; + Injector__StartReq *startreq; + Injector__StartAns *startans; + Injector__EventTerminate *terminate; + Injector__MultiTouchMaxCount *maxcount; + Injector__MultiTouchData *touchdata; +}; +#define INJECTOR__MULTI_TOUCH_MSG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&injector__multi_touch_msg__descriptor) \ + , 0, NULL, NULL, NULL, NULL, NULL } + + +struct _Injector__InjectorMsg +{ + ProtobufCMessage base; + Injector__InjectorMsg__Type type; + Injector__HandShakeReq *handshakereq; + Injector__HandShakeAns *handshakeans; + Injector__EmulatorState *emulstate; + Injector__AppState *appstate; + Injector__EventMsg *eventmsg; + Injector__SensorMsg *sensormsg; + Injector__MultiTouchMsg *touchmsg; +}; +#define INJECTOR__INJECTOR_MSG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&injector__injector_msg__descriptor) \ + , 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL } + + +/* Injector__HandShakeReq methods */ +void injector__hand_shake_req__init + (Injector__HandShakeReq *message); +size_t injector__hand_shake_req__get_packed_size + (const Injector__HandShakeReq *message); +size_t injector__hand_shake_req__pack + (const Injector__HandShakeReq *message, + uint8_t *out); +size_t injector__hand_shake_req__pack_to_buffer + (const Injector__HandShakeReq *message, + ProtobufCBuffer *buffer); +Injector__HandShakeReq * + injector__hand_shake_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void injector__hand_shake_req__free_unpacked + (Injector__HandShakeReq *message, + ProtobufCAllocator *allocator); +/* Injector__HandShakeAns methods */ +void injector__hand_shake_ans__init + (Injector__HandShakeAns *message); +size_t injector__hand_shake_ans__get_packed_size + (const Injector__HandShakeAns *message); +size_t injector__hand_shake_ans__pack + (const Injector__HandShakeAns *message, + uint8_t *out); +size_t injector__hand_shake_ans__pack_to_buffer + (const Injector__HandShakeAns *message, + ProtobufCBuffer *buffer); +Injector__HandShakeAns * + injector__hand_shake_ans__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void injector__hand_shake_ans__free_unpacked + (Injector__HandShakeAns *message, + ProtobufCAllocator *allocator); +/* Injector__EmulatorState methods */ +void injector__emulator_state__init + (Injector__EmulatorState *message); +size_t injector__emulator_state__get_packed_size + (const Injector__EmulatorState *message); +size_t injector__emulator_state__pack + (const Injector__EmulatorState *message, + uint8_t *out); +size_t injector__emulator_state__pack_to_buffer + (const Injector__EmulatorState *message, + ProtobufCBuffer *buffer); +Injector__EmulatorState * + injector__emulator_state__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void injector__emulator_state__free_unpacked + (Injector__EmulatorState *message, + ProtobufCAllocator *allocator); +/* Injector__AppState methods */ +void injector__app_state__init + (Injector__AppState *message); +size_t injector__app_state__get_packed_size + (const Injector__AppState *message); +size_t injector__app_state__pack + (const Injector__AppState *message, + uint8_t *out); +size_t injector__app_state__pack_to_buffer + (const Injector__AppState *message, + ProtobufCBuffer *buffer); +Injector__AppState * + injector__app_state__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void injector__app_state__free_unpacked + (Injector__AppState *message, + ProtobufCAllocator *allocator); +/* Injector__StartReq methods */ +void injector__start_req__init + (Injector__StartReq *message); +size_t injector__start_req__get_packed_size + (const Injector__StartReq *message); +size_t injector__start_req__pack + (const Injector__StartReq *message, + uint8_t *out); +size_t injector__start_req__pack_to_buffer + (const Injector__StartReq *message, + ProtobufCBuffer *buffer); +Injector__StartReq * + injector__start_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void injector__start_req__free_unpacked + (Injector__StartReq *message, + ProtobufCAllocator *allocator); +/* Injector__StartAns methods */ +void injector__start_ans__init + (Injector__StartAns *message); +size_t injector__start_ans__get_packed_size + (const Injector__StartAns *message); +size_t injector__start_ans__pack + (const Injector__StartAns *message, + uint8_t *out); +size_t injector__start_ans__pack_to_buffer + (const Injector__StartAns *message, + ProtobufCBuffer *buffer); +Injector__StartAns * + injector__start_ans__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void injector__start_ans__free_unpacked + (Injector__StartAns *message, + ProtobufCAllocator *allocator); +/* Injector__SetEventStatus methods */ +void injector__set_event_status__init + (Injector__SetEventStatus *message); +size_t injector__set_event_status__get_packed_size + (const Injector__SetEventStatus *message); +size_t injector__set_event_status__pack + (const Injector__SetEventStatus *message, + uint8_t *out); +size_t injector__set_event_status__pack_to_buffer + (const Injector__SetEventStatus *message, + ProtobufCBuffer *buffer); +Injector__SetEventStatus * + injector__set_event_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void injector__set_event_status__free_unpacked + (Injector__SetEventStatus *message, + ProtobufCAllocator *allocator); +/* Injector__EventMsg methods */ +void injector__event_msg__init + (Injector__EventMsg *message); +size_t injector__event_msg__get_packed_size + (const Injector__EventMsg *message); +size_t injector__event_msg__pack + (const Injector__EventMsg *message, + uint8_t *out); +size_t injector__event_msg__pack_to_buffer + (const Injector__EventMsg *message, + ProtobufCBuffer *buffer); +Injector__EventMsg * + injector__event_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void injector__event_msg__free_unpacked + (Injector__EventMsg *message, + ProtobufCAllocator *allocator); +/* Injector__EventTerminate methods */ +void injector__event_terminate__init + (Injector__EventTerminate *message); +size_t injector__event_terminate__get_packed_size + (const Injector__EventTerminate *message); +size_t injector__event_terminate__pack + (const Injector__EventTerminate *message, + uint8_t *out); +size_t injector__event_terminate__pack_to_buffer + (const Injector__EventTerminate *message, + ProtobufCBuffer *buffer); +Injector__EventTerminate * + injector__event_terminate__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void injector__event_terminate__free_unpacked + (Injector__EventTerminate *message, + ProtobufCAllocator *allocator); +/* Injector__SetSensorStatus methods */ +void injector__set_sensor_status__init + (Injector__SetSensorStatus *message); +size_t injector__set_sensor_status__get_packed_size + (const Injector__SetSensorStatus *message); +size_t injector__set_sensor_status__pack + (const Injector__SetSensorStatus *message, + uint8_t *out); +size_t injector__set_sensor_status__pack_to_buffer + (const Injector__SetSensorStatus *message, + ProtobufCBuffer *buffer); +Injector__SetSensorStatus * + injector__set_sensor_status__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void injector__set_sensor_status__free_unpacked + (Injector__SetSensorStatus *message, + ProtobufCAllocator *allocator); +/* Injector__SensorData methods */ +void injector__sensor_data__init + (Injector__SensorData *message); +size_t injector__sensor_data__get_packed_size + (const Injector__SensorData *message); +size_t injector__sensor_data__pack + (const Injector__SensorData *message, + uint8_t *out); +size_t injector__sensor_data__pack_to_buffer + (const Injector__SensorData *message, + ProtobufCBuffer *buffer); +Injector__SensorData * + injector__sensor_data__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void injector__sensor_data__free_unpacked + (Injector__SensorData *message, + ProtobufCAllocator *allocator); +/* Injector__SensorMsg methods */ +void injector__sensor_msg__init + (Injector__SensorMsg *message); +size_t injector__sensor_msg__get_packed_size + (const Injector__SensorMsg *message); +size_t injector__sensor_msg__pack + (const Injector__SensorMsg *message, + uint8_t *out); +size_t injector__sensor_msg__pack_to_buffer + (const Injector__SensorMsg *message, + ProtobufCBuffer *buffer); +Injector__SensorMsg * + injector__sensor_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void injector__sensor_msg__free_unpacked + (Injector__SensorMsg *message, + ProtobufCAllocator *allocator); +/* Injector__MultiTouchMaxCount methods */ +void injector__multi_touch_max_count__init + (Injector__MultiTouchMaxCount *message); +size_t injector__multi_touch_max_count__get_packed_size + (const Injector__MultiTouchMaxCount *message); +size_t injector__multi_touch_max_count__pack + (const Injector__MultiTouchMaxCount *message, + uint8_t *out); +size_t injector__multi_touch_max_count__pack_to_buffer + (const Injector__MultiTouchMaxCount *message, + ProtobufCBuffer *buffer); +Injector__MultiTouchMaxCount * + injector__multi_touch_max_count__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void injector__multi_touch_max_count__free_unpacked + (Injector__MultiTouchMaxCount *message, + ProtobufCAllocator *allocator); +/* Injector__MultiTouchData methods */ +void injector__multi_touch_data__init + (Injector__MultiTouchData *message); +size_t injector__multi_touch_data__get_packed_size + (const Injector__MultiTouchData *message); +size_t injector__multi_touch_data__pack + (const Injector__MultiTouchData *message, + uint8_t *out); +size_t injector__multi_touch_data__pack_to_buffer + (const Injector__MultiTouchData *message, + ProtobufCBuffer *buffer); +Injector__MultiTouchData * + injector__multi_touch_data__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void injector__multi_touch_data__free_unpacked + (Injector__MultiTouchData *message, + ProtobufCAllocator *allocator); +/* Injector__MultiTouchMsg methods */ +void injector__multi_touch_msg__init + (Injector__MultiTouchMsg *message); +size_t injector__multi_touch_msg__get_packed_size + (const Injector__MultiTouchMsg *message); +size_t injector__multi_touch_msg__pack + (const Injector__MultiTouchMsg *message, + uint8_t *out); +size_t injector__multi_touch_msg__pack_to_buffer + (const Injector__MultiTouchMsg *message, + ProtobufCBuffer *buffer); +Injector__MultiTouchMsg * + injector__multi_touch_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void injector__multi_touch_msg__free_unpacked + (Injector__MultiTouchMsg *message, + ProtobufCAllocator *allocator); +/* Injector__InjectorMsg methods */ +void injector__injector_msg__init + (Injector__InjectorMsg *message); +size_t injector__injector_msg__get_packed_size + (const Injector__InjectorMsg *message); +size_t injector__injector_msg__pack + (const Injector__InjectorMsg *message, + uint8_t *out); +size_t injector__injector_msg__pack_to_buffer + (const Injector__InjectorMsg *message, + ProtobufCBuffer *buffer); +Injector__InjectorMsg * + injector__injector_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void injector__injector_msg__free_unpacked + (Injector__InjectorMsg *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*Injector__HandShakeReq_Closure) + (const Injector__HandShakeReq *message, + void *closure_data); +typedef void (*Injector__HandShakeAns_Closure) + (const Injector__HandShakeAns *message, + void *closure_data); +typedef void (*Injector__EmulatorState_Closure) + (const Injector__EmulatorState *message, + void *closure_data); +typedef void (*Injector__AppState_Closure) + (const Injector__AppState *message, + void *closure_data); +typedef void (*Injector__StartReq_Closure) + (const Injector__StartReq *message, + void *closure_data); +typedef void (*Injector__StartAns_Closure) + (const Injector__StartAns *message, + void *closure_data); +typedef void (*Injector__SetEventStatus_Closure) + (const Injector__SetEventStatus *message, + void *closure_data); +typedef void (*Injector__EventMsg_Closure) + (const Injector__EventMsg *message, + void *closure_data); +typedef void (*Injector__EventTerminate_Closure) + (const Injector__EventTerminate *message, + void *closure_data); +typedef void (*Injector__SetSensorStatus_Closure) + (const Injector__SetSensorStatus *message, + void *closure_data); +typedef void (*Injector__SensorData_Closure) + (const Injector__SensorData *message, + void *closure_data); +typedef void (*Injector__SensorMsg_Closure) + (const Injector__SensorMsg *message, + void *closure_data); +typedef void (*Injector__MultiTouchMaxCount_Closure) + (const Injector__MultiTouchMaxCount *message, + void *closure_data); +typedef void (*Injector__MultiTouchData_Closure) + (const Injector__MultiTouchData *message, + void *closure_data); +typedef void (*Injector__MultiTouchMsg_Closure) + (const Injector__MultiTouchMsg *message, + void *closure_data); +typedef void (*Injector__InjectorMsg_Closure) + (const Injector__InjectorMsg *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCEnumDescriptor injector__result__descriptor; +extern const ProtobufCEnumDescriptor injector__connection_state__descriptor; +extern const ProtobufCEnumDescriptor injector__event__descriptor; +extern const ProtobufCEnumDescriptor injector__status__descriptor; +extern const ProtobufCEnumDescriptor injector__sensor_type__descriptor; +extern const ProtobufCEnumDescriptor injector__touch_status__descriptor; +extern const ProtobufCMessageDescriptor injector__hand_shake_req__descriptor; +extern const ProtobufCMessageDescriptor injector__hand_shake_ans__descriptor; +extern const ProtobufCMessageDescriptor injector__emulator_state__descriptor; +extern const ProtobufCMessageDescriptor injector__app_state__descriptor; +extern const ProtobufCMessageDescriptor injector__start_req__descriptor; +extern const ProtobufCMessageDescriptor injector__start_ans__descriptor; +extern const ProtobufCMessageDescriptor injector__set_event_status__descriptor; +extern const ProtobufCMessageDescriptor injector__event_msg__descriptor; +extern const ProtobufCEnumDescriptor injector__event_msg__type__descriptor; +extern const ProtobufCMessageDescriptor injector__event_terminate__descriptor; +extern const ProtobufCMessageDescriptor injector__set_sensor_status__descriptor; +extern const ProtobufCMessageDescriptor injector__sensor_data__descriptor; +extern const ProtobufCMessageDescriptor injector__sensor_msg__descriptor; +extern const ProtobufCEnumDescriptor injector__sensor_msg__type__descriptor; +extern const ProtobufCMessageDescriptor injector__multi_touch_max_count__descriptor; +extern const ProtobufCMessageDescriptor injector__multi_touch_data__descriptor; +extern const ProtobufCMessageDescriptor injector__multi_touch_msg__descriptor; +extern const ProtobufCEnumDescriptor injector__multi_touch_msg__type__descriptor; +extern const ProtobufCMessageDescriptor injector__injector_msg__descriptor; +extern const ProtobufCEnumDescriptor injector__injector_msg__type__descriptor; + +PROTOBUF_C_END_DECLS + + +#endif /* PROTOBUF_tethering_2eproto__INCLUDED */ diff --git a/tizen/src/tethering/msg/tethering.proto b/tizen/src/tethering/msg/tethering.proto new file mode 100644 index 0000000..da0570d --- /dev/null +++ b/tizen/src/tethering/msg/tethering.proto @@ -0,0 +1,162 @@ +package injector; + +option java_package = "event.injector.genmsg"; + +enum Result { + SUCCESS = 1; + FAILURE = 2; + CANCEL = 3; +} + +message HandShakeReq { + required int32 key = 1; +} + +message HandShakeAns { + required Result result = 1; +} + +enum ConnectionState { + CONNECT = 1; + DISCONNECT = 2; + TERMINATE = 3; +} +message EmulatorState { + required ConnectionState state = 1; +} + +message AppState { + required ConnectionState state =1; +} + +message StartReq { + +} + +message StartAns { + required Result result = 1; +} + +enum Event { + SENSOR = 1; + MULTITOUCH = 2; +} + +enum Status { + ENABLE = 1; + DISABLE = 2; +} + +message SetEventStatus { + required Event event = 1; + required Status status = 2; +} + +message EventMsg { + enum TYPE { + START_REQ = 2; + START_ANS = 3; + TERMINATE = 4; + EVENT_STATUS = 5; + } + + required TYPE type = 1; + optional StartReq startReq= 2; + optional StartAns startAns= 3; + optional EventTerminate terminate = 4; + optional SetEventStatus setStatus= 5; +} + +message EventTerminate { + +} + +enum SensorType{ + ACCEL = 1; + MAGNETIC = 2; + GYROSCOPE = 3; + PROXIMITY = 4; + LIGHT = 5; +} + +message SetSensorStatus { + required SensorType sensor = 1; + required Status status = 2; +} + +message SensorData { + required SensorType sensor = 1; + optional string x = 2 [default = "0"]; + optional string y = 3 [default = "0"]; + optional string z = 4 [default = "0"]; +} + +message SensorMsg { + enum Type { + START_REQ = 2; + START_ANS = 3; + TERMINATE = 4; + SENSOR_STATUS = 5; + SENSOR_DATA = 6; + } + + required Type type = 1; + optional StartReq startReq= 2; + optional StartAns startAns= 3; + optional EventTerminate terminate= 4; + optional SetSensorStatus setStatus= 5; + optional SensorData data = 6; +} + +message MultiTouchMaxCount { + optional int32 max = 1 [default = 10]; +} + +enum TouchStatus { + PRESS = 1; + RELEASE = 2; +} + +message MultiTouchData { + optional int32 index = 1 [default = 0]; + optional float xPoint = 2 [default = 0.0]; + optional float yPoint = 3 [default = 0.0]; + optional TouchStatus status = 4; +} + +message MultiTouchMsg { + enum Type { + START_REQ = 2; + START_ANS = 3; + TERMINATE = 4; + MAX_COUNT = 5; + TOUCH_DATA = 6; + } + required Type type = 1; + optional StartReq startReq= 2; + optional StartAns startAns= 3; + optional EventTerminate terminate= 4; + optional MultiTouchMaxCount maxCount = 5; + optional MultiTouchData touchData = 6; +} + +message InjectorMsg { + enum Type { + HANDSHAKE_REQ = 2; + HANDSHAKE_ANS = 3; + EMUL_STATE = 4; + APP_STATE = 5; + EVENT_MSG = 6; + SENSOR_MSG = 7; + TOUCH_MSG = 8; + } + required Type type = 1; + optional HandShakeReq handShakeReq = 2; + optional HandShakeAns handShakeAns = 3; + optional EmulatorState emulState = 4; + optional AppState appState = 5; + optional EventMsg eventMsg = 6; + optional SensorMsg sensorMsg = 7; + optional MultiTouchMsg touchMsg = 8; +} + -- 2.7.4