From 97df35b366adfd1d6d0e9b2fcdb5560e34682707 Mon Sep 17 00:00:00 2001 From: Kitae Kim Date: Thu, 8 May 2014 15:33:33 +0900 Subject: [PATCH] tethering: modify protobuf messages Change-Id: I7daab3c3d867894bf7fecb6a976529d8d07cf7dc Signed-off-by: Kitae Kim --- tizen/src/tethering/app_tethering.c | 242 ++-- tizen/src/tethering/genmsg/tethering.pb-c.c | 1580 +++++++++++++-------------- tizen/src/tethering/genmsg/tethering.pb-c.h | 900 +++++++-------- tizen/src/tethering/msg/tethering.proto | 102 +- 4 files changed, 1414 insertions(+), 1410 deletions(-) diff --git a/tizen/src/tethering/app_tethering.c b/tizen/src/tethering/app_tethering.c index e637de6..2eae4e2 100644 --- a/tizen/src/tethering/app_tethering.c +++ b/tizen/src/tethering/app_tethering.c @@ -117,12 +117,12 @@ 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) +static void *build_tethering_msg(Tethering__TetheringMsg* msg, int *payloadsize) { void *buf = NULL; int msg_packed_size = 0; - msg_packed_size = injector__injector_msg__get_packed_size(msg); + msg_packed_size = tethering__tethering_msg__get_packed_size(msg); *payloadsize = msg_packed_size + MSG_LEN_SIZE; buf = g_malloc(*payloadsize); @@ -131,7 +131,7 @@ static void *build_injector_msg(Injector__InjectorMsg* msg, int *payloadsize) return NULL; } - injector__injector_msg__pack(msg, buf + MSG_LEN_SIZE); + tethering__tethering_msg__pack(msg, buf + MSG_LEN_SIZE); msg_packed_size = htonl(msg_packed_size); memcpy(buf, &msg_packed_size, MSG_LEN_SIZE); @@ -139,14 +139,14 @@ static void *build_injector_msg(Injector__InjectorMsg* msg, int *payloadsize) return buf; } -static bool send_msg_to_controller(Injector__InjectorMsg *msg) +static bool send_msg_to_controller(Tethering__TetheringMsg *msg) { void *buf = NULL; int payloadsize = 0, err = 0; int sockfd = 0; bool ret = true; - buf = build_injector_msg(msg, &payloadsize); + buf = build_tethering_msg(msg, &payloadsize); if (!buf) { return false; } @@ -167,14 +167,14 @@ static bool send_msg_to_controller(Injector__InjectorMsg *msg) static bool send_handshake_req_msg(void) { - Injector__InjectorMsg msg = INJECTOR__INJECTOR_MSG__INIT; - Injector__HandShakeReq req = INJECTOR__HAND_SHAKE_REQ__INIT; + Tethering__TetheringMsg msg = TETHERING__TETHERING_MSG__INIT; + Tethering__HandShakeReq req = TETHERING__HAND_SHAKE_REQ__INIT; TRACE("enter: %s\n", __func__); req.key = TETHERING_MSG_HANDSHAKE_KEY; - msg.type = INJECTOR__INJECTOR_MSG__TYPE__HANDSHAKE_REQ; + msg.type = TETHERING__TETHERING_MSG__TYPE__HANDSHAKE_REQ; msg.handshakereq = &req; TRACE("send handshake_req message\n"); @@ -188,14 +188,14 @@ static bool send_handshake_req_msg(void) #if 0 static bool send_emul_state_msg(void) { - Injector__InjectorMsg msg = INJECTOR__INJECTOR_MSG__INIT; - Injector__EmulatorState emul_state = INJECTOR__EMULATOR_STATE__INIT; + Tethering__TetheringMsg msg = TETHERING__TETHERING_MSG__INIT; + Tethering__EmulatorState emul_state = TETHERING__EMULATOR_STATE__INIT; TRACE("enter: %s\n", __func__); - emul_state.state = INJECTOR__CONNECTION_STATE__TERMINATE; + emul_state.state = TETHERING__CONNECTION_STATE__TERMINATE; - msg.type = INJECTOR__INJECTOR_MSG__TYPE__EMUL_STATE; + msg.type = TETHERING__TETHERING_MSG__TYPE__EMUL_STATE; msg.emulstate = &emul_state; INFO("send emulator_state message\n"); @@ -207,14 +207,14 @@ static bool send_emul_state_msg(void) } #endif -static bool build_event_msg(Injector__EventMsg *event) +static bool build_event_msg(Tethering__EventMsg *event) { bool ret = false; - Injector__InjectorMsg msg = INJECTOR__INJECTOR_MSG__INIT; + Tethering__TetheringMsg msg = TETHERING__TETHERING_MSG__INIT; TRACE("enter: %s\n", __func__); - msg.type = INJECTOR__INJECTOR_MSG__TYPE__EVENT_MSG; + msg.type = TETHERING__TETHERING_MSG__TYPE__EVENT_MSG; msg.eventmsg = event; ret = send_msg_to_controller(&msg); @@ -224,17 +224,17 @@ static bool build_event_msg(Injector__EventMsg *event) return ret; } -static bool send_event_start_ans_msg(Injector__Result result) +static bool send_event_start_ans_msg(Tethering__MessageResult result) { bool ret = false; - Injector__EventMsg event = INJECTOR__EVENT_MSG__INIT; - Injector__StartAns start_ans = INJECTOR__START_ANS__INIT; + Tethering__EventMsg event = TETHERING__EVENT_MSG__INIT; + Tethering__StartAns start_ans = TETHERING__START_ANS__INIT; TRACE("enter: %s\n", __func__); start_ans.result = result; - event.type = INJECTOR__EVENT_MSG__TYPE__START_ANS; + event.type = TETHERING__EVENT_MSG__TYPE__START_ANS; event.startans = &start_ans; TRACE("send event_start_ans message\n"); @@ -245,19 +245,19 @@ static bool send_event_start_ans_msg(Injector__Result result) return ret; } -static bool send_set_event_status_msg(Injector__Event event_type, - Injector__Status status) +static bool send_set_event_status_msg(Tethering__EventType event_type, + Tethering__State status) { bool ret = false; - Injector__EventMsg event = INJECTOR__EVENT_MSG__INIT; - Injector__SetEventStatus event_status = INJECTOR__SET_EVENT_STATUS__INIT; + Tethering__EventMsg event = TETHERING__EVENT_MSG__INIT; + Tethering__SetEventStatus event_status = TETHERING__SET_EVENT_STATUS__INIT; TRACE("enter: %s\n", __func__); - event_status.event = event_type; - event_status.status = status; + event_status.type = event_type; + event_status.state = status; - event.type = INJECTOR__EVENT_MSG__TYPE__EVENT_STATUS; + event.type = TETHERING__EVENT_MSG__TYPE__EVENT_STATUS; event.setstatus = &event_status; TRACE("send event_set_event_status message\n"); @@ -270,14 +270,14 @@ static bool send_set_event_status_msg(Injector__Event event_type, // create a sensor message. -static bool build_sensor_msg(Injector__SensorMsg *sensor) +static bool build_sensor_msg(Tethering__SensorMsg *sensor) { bool ret = false; - Injector__InjectorMsg msg = INJECTOR__INJECTOR_MSG__INIT; + Tethering__TetheringMsg msg = TETHERING__TETHERING_MSG__INIT; TRACE("enter: %s\n", __func__); - msg.type = INJECTOR__INJECTOR_MSG__TYPE__SENSOR_MSG; + msg.type = TETHERING__TETHERING_MSG__TYPE__SENSOR_MSG; msg.sensormsg = sensor; ret = send_msg_to_controller(&msg); @@ -287,17 +287,17 @@ static bool build_sensor_msg(Injector__SensorMsg *sensor) return ret; } -static bool send_sensor_start_ans_msg(Injector__Result result) +static bool send_sensor_start_ans_msg(Tethering__MessageResult result) { bool ret = false; - Injector__SensorMsg event = INJECTOR__SENSOR_MSG__INIT; - Injector__StartAns start_ans = INJECTOR__START_ANS__INIT; + Tethering__SensorMsg event = TETHERING__SENSOR_MSG__INIT; + Tethering__StartAns start_ans = TETHERING__START_ANS__INIT; TRACE("enter: %s\n", __func__); start_ans.result = result; - event.type = INJECTOR__SENSOR_MSG__TYPE__START_ANS; + event.type = TETHERING__SENSOR_MSG__TYPE__START_ANS; event.startans = &start_ans; TRACE("send sensor_start_ans message\n"); @@ -308,21 +308,21 @@ static bool send_sensor_start_ans_msg(Injector__Result result) return ret; } -static bool send_set_sensor_status_msg(Injector__SensorType sensor_type, - Injector__Status status) +static bool send_set_sensor_status_msg(Tethering__SensorType sensor_type, + Tethering__State status) { bool ret = false; - Injector__SensorMsg sensor = INJECTOR__SENSOR_MSG__INIT; - Injector__SetSensorStatus sensor_status = - INJECTOR__SET_SENSOR_STATUS__INIT; + Tethering__SensorMsg sensor = TETHERING__SENSOR_MSG__INIT; + Tethering__SetSensorStatus sensor_status = + TETHERING__SET_SENSOR_STATUS__INIT; TRACE("enter: %s\n", __func__); - sensor_status.sensor = sensor_type; - sensor_status.status = status; + sensor_status.type = sensor_type; + sensor_status.state = status; - sensor.type = INJECTOR__SENSOR_MSG__TYPE__SENSOR_STATUS; + sensor.type = TETHERING__SENSOR_MSG__TYPE__SENSOR_STATUS; sensor.setstatus = &sensor_status; TRACE("send sensor_set_event_status message\n"); @@ -333,7 +333,7 @@ static bool send_set_sensor_status_msg(Injector__SensorType sensor_type, return ret; } -static void set_sensor_data(Injector__SensorData *data) +static void set_sensor_data(Tethering__SensorData *data) { /* * data format for sensor device @@ -343,7 +343,7 @@ static void set_sensor_data(Injector__SensorData *data) */ switch(data->sensor) { - case INJECTOR__SENSOR_TYPE__ACCEL: + case TETHERING__SENSOR_TYPE__ACCEL: { char tmp[255] = {0}; @@ -355,7 +355,7 @@ static void set_sensor_data(Injector__SensorData *data) data->x, data->y, data->z); } break; - case INJECTOR__SENSOR_TYPE__MAGNETIC: + case TETHERING__SENSOR_TYPE__MAGNETIC: { char tmp[255] = {0}; @@ -367,7 +367,7 @@ static void set_sensor_data(Injector__SensorData *data) data->x, data->y, data->z); } break; - case INJECTOR__SENSOR_TYPE__GYROSCOPE: + case TETHERING__SENSOR_TYPE__GYROSCOPE: { char tmp[255] = {0}; @@ -379,7 +379,7 @@ static void set_sensor_data(Injector__SensorData *data) data->x, data->y, data->z); } break; - case INJECTOR__SENSOR_TYPE__PROXIMITY: + case TETHERING__SENSOR_TYPE__PROXIMITY: { char tmp[255] = {0}; double x = (double)(atoi(data->x)); @@ -390,7 +390,7 @@ static void set_sensor_data(Injector__SensorData *data) TRACE("sensor_proxi x: %.1f, %s\n", x, tmp); } break; - case INJECTOR__SENSOR_TYPE__LIGHT: + case TETHERING__SENSOR_TYPE__LIGHT: { char tmp[255] = {0}; @@ -408,14 +408,14 @@ static void set_sensor_data(Injector__SensorData *data) // set ecs_sensor } -static bool build_mulitouch_msg(Injector__MultiTouchMsg *multitouch) +static bool build_mulitouch_msg(Tethering__MultiTouchMsg *multitouch) { bool ret = false; - Injector__InjectorMsg msg = INJECTOR__INJECTOR_MSG__INIT; + Tethering__TetheringMsg msg = TETHERING__TETHERING_MSG__INIT; TRACE("enter: %s\n", __func__); - msg.type = INJECTOR__INJECTOR_MSG__TYPE__TOUCH_MSG; + msg.type = TETHERING__TETHERING_MSG__TYPE__TOUCH_MSG; msg.touchmsg = multitouch; ret = send_msg_to_controller(&msg); @@ -425,18 +425,18 @@ static bool build_mulitouch_msg(Injector__MultiTouchMsg *multitouch) return ret; } -static bool send_mulitouch_start_ans_msg(Injector__Result result) +static bool send_mulitouch_start_ans_msg(Tethering__MessageResult result) { bool ret = false; - Injector__MultiTouchMsg mt = INJECTOR__MULTI_TOUCH_MSG__INIT; - Injector__StartAns start_ans = INJECTOR__START_ANS__INIT; + Tethering__MultiTouchMsg mt = TETHERING__MULTI_TOUCH_MSG__INIT; + Tethering__StartAns start_ans = TETHERING__START_ANS__INIT; TRACE("enter: %s\n", __func__); start_ans.result = result; - mt.type = INJECTOR__MULTI_TOUCH_MSG__TYPE__START_ANS; + mt.type = TETHERING__MULTI_TOUCH_MSG__TYPE__START_ANS; mt.startans = &start_ans; ret = build_mulitouch_msg(&mt); @@ -450,15 +450,15 @@ static bool send_set_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; + Tethering__MultiTouchMsg mt = TETHERING__MULTI_TOUCH_MSG__INIT; + Tethering__MultiTouchMaxCount touch_cnt = + TETHERING__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.type = TETHERING__MULTI_TOUCH_MSG__TYPE__MAX_COUNT; mt.maxcount = &touch_cnt; INFO("send multi-touch max count: %d\n", touch_cnt.max); @@ -469,25 +469,25 @@ static bool send_set_multitouch_max_count(void) return ret; } -static void set_multitouch_data(Injector__MultiTouchData *data) +static void set_multitouch_data(Tethering__MultiTouchData *data) { float x = 0.0, y = 0.0; - int32_t index = 0, status = 0; + int32_t index = 0, state = 0; - switch(data->status) { - case INJECTOR__TOUCH_STATUS__PRESS: + switch(data->state) { + case TETHERING__TOUCH_STATE__PRESSED: TRACE("touch pressed\n"); index = data->index; x = data->xpoint; y = data->ypoint; - status = PRESSED; + state = PRESSED; break; - case INJECTOR__TOUCH_STATUS__RELEASE: + case TETHERING__TOUCH_STATE__RELEASED: TRACE("touch released\n"); index = data->index; x = data->xpoint; y = data->ypoint; - status = RELEASED; + state = RELEASED; break; default: TRACE("invalid multitouch data\n"); @@ -496,22 +496,22 @@ static void set_multitouch_data(Injector__MultiTouchData *data) INFO("set touch_data. index: %d, x: %d, y: %d\n", index, x, y); // set ecs_multitouch - send_tethering_touch_data(x, y, index, status); + send_tethering_touch_data(x, y, index, state); } static bool send_set_multitouch_resolution(void) { bool ret = false; - Injector__MultiTouchMsg mt = INJECTOR__MULTI_TOUCH_MSG__INIT; - Injector__Resolution resolution = INJECTOR__RESOLUTION__INIT; + Tethering__MultiTouchMsg mt = TETHERING__MULTI_TOUCH_MSG__INIT; + Tethering__Resolution resolution = TETHERING__RESOLUTION__INIT; TRACE("enter: %s\n", __func__); resolution.width = get_emul_resolution_width(); resolution.height = get_emul_resolution_height(); - mt.type = INJECTOR__MULTI_TOUCH_MSG__TYPE__RESOLUTION; + mt.type = TETHERING__MULTI_TOUCH_MSG__TYPE__RESOLUTION; mt.resolution = &resolution; INFO("send multi-touch resolution: %dx%d\n", @@ -523,15 +523,15 @@ static bool send_set_multitouch_resolution(void) return ret; } -static void msgproc_tethering_handshake_ans(Injector__HandShakeAns *msg) +static void msgproc_tethering_handshake_ans(Tethering__HandShakeAns *msg) { // FIXME: handle handshake answer // ans = msg->result; } -static void msgproc_app_state_msg(Injector__AppState *msg) +static void msgproc_app_state_msg(Tethering__AppState *msg) { - if (msg->state == INJECTOR__CONNECTION_STATE__TERMINATE) { + if (msg->state == TETHERING__CONNECTION_STATE__TERMINATED) { INFO("App is terminated\n"); // set_tethering_app_state(false); @@ -545,38 +545,38 @@ static void msgproc_app_state_msg(Injector__AppState *msg) } -static bool msgproc_tethering_event_msg(Injector__EventMsg *msg) +static bool msgproc_tethering_event_msg(Tethering__EventMsg *msg) { bool ret = true; switch(msg->type) { - case INJECTOR__EVENT_MSG__TYPE__START_REQ: + case TETHERING__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); + send_set_event_status_msg(TETHERING__EVENT_TYPE__SENSOR, + TETHERING__STATE__ENABLED); // 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; + touch_status = TETHERING__STATE__ENABLED; set_tethering_multitouch_status(ENABLED); } else { - touch_status = INJECTOR__STATUS__DISABLE; + touch_status = TETHERING__STATE__DISABLED; 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); + send_set_event_status_msg(TETHERING__EVENT_TYPE__TOUCH, touch_status); TRACE("send event_start_ans msg: %d\n", touch_status); - send_event_start_ans_msg(INJECTOR__RESULT__SUCCESS); + send_event_start_ans_msg(TETHERING__MESSAGE_RESULT__SUCCESS); } break; - case INJECTOR__EVENT_MSG__TYPE__TERMINATE: + case TETHERING__EVENT_MSG__TYPE__TERMINATE: break; default: TRACE("invalid event_msg type\n"); @@ -587,35 +587,35 @@ static bool msgproc_tethering_event_msg(Injector__EventMsg *msg) return ret; } -static bool msgproc_tethering_sensor_msg(Injector__SensorMsg *msg) +static bool msgproc_tethering_sensor_msg(Tethering__SensorMsg *msg) { bool ret = true; switch(msg->type) { - case INJECTOR__SENSOR_MSG__TYPE__START_REQ: + case TETHERING__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); + send_set_sensor_status_msg(TETHERING__SENSOR_TYPE__ACCEL, + TETHERING__STATE__ENABLED); + send_set_sensor_status_msg(TETHERING__SENSOR_TYPE__MAGNETIC, + TETHERING__STATE__ENABLED); + send_set_sensor_status_msg(TETHERING__SENSOR_TYPE__GYROSCOPE, + TETHERING__STATE__ENABLED); + send_set_sensor_status_msg(TETHERING__SENSOR_TYPE__PROXIMITY, + TETHERING__STATE__ENABLED); + send_set_sensor_status_msg(TETHERING__SENSOR_TYPE__LIGHT, + TETHERING__STATE__ENABLED); TRACE("SENSOR_MSG_TYPE_START_ANS\n"); - send_sensor_start_ans_msg(INJECTOR__RESULT__SUCCESS); + send_sensor_start_ans_msg(TETHERING__MESSAGE_RESULT__SUCCESS); break; - case INJECTOR__SENSOR_MSG__TYPE__TERMINATE: + case TETHERING__SENSOR_MSG__TYPE__TERMINATE: TRACE("SENSOR_MSG_TYPE_TERMINATE\n"); break; - case INJECTOR__SENSOR_MSG__TYPE__SENSOR_DATA: + case TETHERING__SENSOR_MSG__TYPE__SENSOR_DATA: TRACE("SENSOR_MSG_TYPE_SENSOR_DATA\n"); set_sensor_data(msg->data); break; @@ -628,23 +628,23 @@ static bool msgproc_tethering_sensor_msg(Injector__SensorMsg *msg) return ret; } -static bool msgproc_tethering_mt_msg(Injector__MultiTouchMsg *msg) +static bool msgproc_tethering_mt_msg(Tethering__MultiTouchMsg *msg) { bool ret = true; switch(msg->type) { - case INJECTOR__MULTI_TOUCH_MSG__TYPE__START_REQ: - TRACE("MULTITOUCH_MSG_TYPE_START\n"); + case TETHERING__MULTI_TOUCH_MSG__TYPE__START_REQ: + TRACE("TOUCH_MSG_TYPE_START\n"); send_set_multitouch_max_count(); send_set_multitouch_resolution(); - ret = send_mulitouch_start_ans_msg(INJECTOR__RESULT__SUCCESS); + ret = send_mulitouch_start_ans_msg(TETHERING__MESSAGE_RESULT__SUCCESS); break; - case INJECTOR__MULTI_TOUCH_MSG__TYPE__TERMINATE: - TRACE("MULTITOUCH_MSG_TYPE_TERMINATE\n"); + case TETHERING__MULTI_TOUCH_MSG__TYPE__TERMINATE: + TRACE("TOUCH_MSG_TYPE_TERMINATE\n"); break; - case INJECTOR__MULTI_TOUCH_MSG__TYPE__TOUCH_DATA: + case TETHERING__MULTI_TOUCH_MSG__TYPE__TOUCH_DATA: set_multitouch_data(msg->touchdata); break; default: @@ -656,25 +656,25 @@ static bool msgproc_tethering_mt_msg(Injector__MultiTouchMsg *msg) return ret; } -static bool handle_injector_msg_from_controller(char *data, int len) +static bool handle_tethering_msg_from_controller(char *data, int len) { - Injector__InjectorMsg *injector = NULL; + Tethering__TetheringMsg *tethering = NULL; bool ret = true; - injector = injector__injector_msg__unpack(NULL, (size_t)len, + tethering = tethering__tethering_msg__unpack(NULL, (size_t)len, (const uint8_t *)data); - if (!injector) { + if (!tethering) { // error message - ERR("no injector massage\n"); + ERR("no tethering massage\n"); return false; } - switch (injector->type) { - case INJECTOR__INJECTOR_MSG__TYPE__HANDSHAKE_ANS: + switch (tethering->type) { + case TETHERING__TETHERING_MSG__TYPE__HANDSHAKE_ANS: { // TODO: set the result of handshake_ans to - Injector__HandShakeAns *msg = injector->handshakeans; + Tethering__HandShakeAns *msg = tethering->handshakeans; if (!msg) { ret = false; } else { @@ -685,9 +685,9 @@ static bool handle_injector_msg_from_controller(char *data, int len) } } break; - case INJECTOR__INJECTOR_MSG__TYPE__APP_STATE: + case TETHERING__TETHERING_MSG__TYPE__APP_STATE: { - Injector__AppState *msg = injector->appstate; + Tethering__AppState *msg = tethering->appstate; INFO("receive app_state msg\n"); if (!msg) { @@ -697,9 +697,9 @@ static bool handle_injector_msg_from_controller(char *data, int len) } } break; - case INJECTOR__INJECTOR_MSG__TYPE__EVENT_MSG: + case TETHERING__TETHERING_MSG__TYPE__EVENT_MSG: { - Injector__EventMsg *msg = injector->eventmsg; + Tethering__EventMsg *msg = tethering->eventmsg; INFO("receive event_msg\n"); if (!msg) { @@ -709,9 +709,9 @@ static bool handle_injector_msg_from_controller(char *data, int len) } } break; - case INJECTOR__INJECTOR_MSG__TYPE__SENSOR_MSG: + case TETHERING__TETHERING_MSG__TYPE__SENSOR_MSG: { - Injector__SensorMsg *msg = injector->sensormsg; + Tethering__SensorMsg *msg = tethering->sensormsg; INFO("receive sensor_msg\n"); if (!msg) { @@ -721,9 +721,9 @@ static bool handle_injector_msg_from_controller(char *data, int len) } } break; - case INJECTOR__INJECTOR_MSG__TYPE__TOUCH_MSG: + case TETHERING__TETHERING_MSG__TYPE__TOUCH_MSG: { - Injector__MultiTouchMsg *msg = injector->touchmsg; + Tethering__MultiTouchMsg *msg = tethering->touchmsg; INFO("receive multitouch_msg\n"); if (!msg) { @@ -745,7 +745,7 @@ static bool handle_injector_msg_from_controller(char *data, int len) } #endif - injector__injector_msg__free_unpacked(injector, NULL); + tethering__tethering_msg__free_unpacked(tethering, NULL); return ret; } @@ -823,7 +823,7 @@ static void tethering_io_handler(void *opaque) 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, + handle_tethering_msg_from_controller(snd_buf, recv_buf.stack_size); reset_tethering_recv_buf(&recv_buf); } diff --git a/tizen/src/tethering/genmsg/tethering.pb-c.c b/tizen/src/tethering/genmsg/tethering.pb-c.c index 7d52d8b..ad16dc1 100644 --- a/tizen/src/tethering/genmsg/tethering.pb-c.c +++ b/tizen/src/tethering/genmsg/tethering.pb-c.c @@ -6,738 +6,738 @@ #endif #include "tethering.pb-c.h" -void injector__hand_shake_req__init - (Injector__HandShakeReq *message) +void tethering__hand_shake_req__init + (Tethering__HandShakeReq *message) { - static Injector__HandShakeReq init_value = INJECTOR__HAND_SHAKE_REQ__INIT; + static Tethering__HandShakeReq init_value = TETHERING__HAND_SHAKE_REQ__INIT; *message = init_value; } -size_t injector__hand_shake_req__get_packed_size - (const Injector__HandShakeReq *message) +size_t tethering__hand_shake_req__get_packed_size + (const Tethering__HandShakeReq *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__hand_shake_req__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__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, +size_t tethering__hand_shake_req__pack + (const Tethering__HandShakeReq *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__hand_shake_req__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__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, +size_t tethering__hand_shake_req__pack_to_buffer + (const Tethering__HandShakeReq *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__hand_shake_req__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__hand_shake_req__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -Injector__HandShakeReq * - injector__hand_shake_req__unpack +Tethering__HandShakeReq * + tethering__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, + return (Tethering__HandShakeReq *) + protobuf_c_message_unpack (&tethering__hand_shake_req__descriptor, allocator, len, data); } -void injector__hand_shake_req__free_unpacked - (Injector__HandShakeReq *message, +void tethering__hand_shake_req__free_unpacked + (Tethering__HandShakeReq *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__hand_shake_req__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__hand_shake_req__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void injector__hand_shake_ans__init - (Injector__HandShakeAns *message) +void tethering__hand_shake_ans__init + (Tethering__HandShakeAns *message) { - static Injector__HandShakeAns init_value = INJECTOR__HAND_SHAKE_ANS__INIT; + static Tethering__HandShakeAns init_value = TETHERING__HAND_SHAKE_ANS__INIT; *message = init_value; } -size_t injector__hand_shake_ans__get_packed_size - (const Injector__HandShakeAns *message) +size_t tethering__hand_shake_ans__get_packed_size + (const Tethering__HandShakeAns *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__hand_shake_ans__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__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, +size_t tethering__hand_shake_ans__pack + (const Tethering__HandShakeAns *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__hand_shake_ans__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__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, +size_t tethering__hand_shake_ans__pack_to_buffer + (const Tethering__HandShakeAns *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__hand_shake_ans__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__hand_shake_ans__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -Injector__HandShakeAns * - injector__hand_shake_ans__unpack +Tethering__HandShakeAns * + tethering__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, + return (Tethering__HandShakeAns *) + protobuf_c_message_unpack (&tethering__hand_shake_ans__descriptor, allocator, len, data); } -void injector__hand_shake_ans__free_unpacked - (Injector__HandShakeAns *message, +void tethering__hand_shake_ans__free_unpacked + (Tethering__HandShakeAns *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__hand_shake_ans__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__hand_shake_ans__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void injector__emulator_state__init - (Injector__EmulatorState *message) +void tethering__emulator_state__init + (Tethering__EmulatorState *message) { - static Injector__EmulatorState init_value = INJECTOR__EMULATOR_STATE__INIT; + static Tethering__EmulatorState init_value = TETHERING__EMULATOR_STATE__INIT; *message = init_value; } -size_t injector__emulator_state__get_packed_size - (const Injector__EmulatorState *message) +size_t tethering__emulator_state__get_packed_size + (const Tethering__EmulatorState *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__emulator_state__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__emulator_state__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t injector__emulator_state__pack - (const Injector__EmulatorState *message, +size_t tethering__emulator_state__pack + (const Tethering__EmulatorState *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__emulator_state__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__emulator_state__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t injector__emulator_state__pack_to_buffer - (const Injector__EmulatorState *message, +size_t tethering__emulator_state__pack_to_buffer + (const Tethering__EmulatorState *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__emulator_state__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__emulator_state__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -Injector__EmulatorState * - injector__emulator_state__unpack +Tethering__EmulatorState * + tethering__emulator_state__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (Injector__EmulatorState *) - protobuf_c_message_unpack (&injector__emulator_state__descriptor, + return (Tethering__EmulatorState *) + protobuf_c_message_unpack (&tethering__emulator_state__descriptor, allocator, len, data); } -void injector__emulator_state__free_unpacked - (Injector__EmulatorState *message, +void tethering__emulator_state__free_unpacked + (Tethering__EmulatorState *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__emulator_state__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__emulator_state__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void injector__app_state__init - (Injector__AppState *message) +void tethering__app_state__init + (Tethering__AppState *message) { - static Injector__AppState init_value = INJECTOR__APP_STATE__INIT; + static Tethering__AppState init_value = TETHERING__APP_STATE__INIT; *message = init_value; } -size_t injector__app_state__get_packed_size - (const Injector__AppState *message) +size_t tethering__app_state__get_packed_size + (const Tethering__AppState *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__app_state__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__app_state__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t injector__app_state__pack - (const Injector__AppState *message, +size_t tethering__app_state__pack + (const Tethering__AppState *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__app_state__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__app_state__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t injector__app_state__pack_to_buffer - (const Injector__AppState *message, +size_t tethering__app_state__pack_to_buffer + (const Tethering__AppState *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__app_state__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__app_state__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -Injector__AppState * - injector__app_state__unpack +Tethering__AppState * + tethering__app_state__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (Injector__AppState *) - protobuf_c_message_unpack (&injector__app_state__descriptor, + return (Tethering__AppState *) + protobuf_c_message_unpack (&tethering__app_state__descriptor, allocator, len, data); } -void injector__app_state__free_unpacked - (Injector__AppState *message, +void tethering__app_state__free_unpacked + (Tethering__AppState *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__app_state__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__app_state__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void injector__start_req__init - (Injector__StartReq *message) +void tethering__start_req__init + (Tethering__StartReq *message) { - static Injector__StartReq init_value = INJECTOR__START_REQ__INIT; + static Tethering__StartReq init_value = TETHERING__START_REQ__INIT; *message = init_value; } -size_t injector__start_req__get_packed_size - (const Injector__StartReq *message) +size_t tethering__start_req__get_packed_size + (const Tethering__StartReq *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__start_req__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__start_req__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t injector__start_req__pack - (const Injector__StartReq *message, +size_t tethering__start_req__pack + (const Tethering__StartReq *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__start_req__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__start_req__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t injector__start_req__pack_to_buffer - (const Injector__StartReq *message, +size_t tethering__start_req__pack_to_buffer + (const Tethering__StartReq *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__start_req__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__start_req__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -Injector__StartReq * - injector__start_req__unpack +Tethering__StartReq * + tethering__start_req__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (Injector__StartReq *) - protobuf_c_message_unpack (&injector__start_req__descriptor, + return (Tethering__StartReq *) + protobuf_c_message_unpack (&tethering__start_req__descriptor, allocator, len, data); } -void injector__start_req__free_unpacked - (Injector__StartReq *message, +void tethering__start_req__free_unpacked + (Tethering__StartReq *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__start_req__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__start_req__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void injector__start_ans__init - (Injector__StartAns *message) +void tethering__start_ans__init + (Tethering__StartAns *message) { - static Injector__StartAns init_value = INJECTOR__START_ANS__INIT; + static Tethering__StartAns init_value = TETHERING__START_ANS__INIT; *message = init_value; } -size_t injector__start_ans__get_packed_size - (const Injector__StartAns *message) +size_t tethering__start_ans__get_packed_size + (const Tethering__StartAns *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__start_ans__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__start_ans__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t injector__start_ans__pack - (const Injector__StartAns *message, +size_t tethering__start_ans__pack + (const Tethering__StartAns *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__start_ans__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__start_ans__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t injector__start_ans__pack_to_buffer - (const Injector__StartAns *message, +size_t tethering__start_ans__pack_to_buffer + (const Tethering__StartAns *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__start_ans__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__start_ans__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -Injector__StartAns * - injector__start_ans__unpack +Tethering__StartAns * + tethering__start_ans__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (Injector__StartAns *) - protobuf_c_message_unpack (&injector__start_ans__descriptor, + return (Tethering__StartAns *) + protobuf_c_message_unpack (&tethering__start_ans__descriptor, allocator, len, data); } -void injector__start_ans__free_unpacked - (Injector__StartAns *message, +void tethering__start_ans__free_unpacked + (Tethering__StartAns *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__start_ans__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__start_ans__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void injector__set_event_status__init - (Injector__SetEventStatus *message) +void tethering__set_event_status__init + (Tethering__SetEventStatus *message) { - static Injector__SetEventStatus init_value = INJECTOR__SET_EVENT_STATUS__INIT; + static Tethering__SetEventStatus init_value = TETHERING__SET_EVENT_STATUS__INIT; *message = init_value; } -size_t injector__set_event_status__get_packed_size - (const Injector__SetEventStatus *message) +size_t tethering__set_event_status__get_packed_size + (const Tethering__SetEventStatus *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__set_event_status__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__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, +size_t tethering__set_event_status__pack + (const Tethering__SetEventStatus *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__set_event_status__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__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, +size_t tethering__set_event_status__pack_to_buffer + (const Tethering__SetEventStatus *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__set_event_status__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__set_event_status__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -Injector__SetEventStatus * - injector__set_event_status__unpack +Tethering__SetEventStatus * + tethering__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, + return (Tethering__SetEventStatus *) + protobuf_c_message_unpack (&tethering__set_event_status__descriptor, allocator, len, data); } -void injector__set_event_status__free_unpacked - (Injector__SetEventStatus *message, +void tethering__set_event_status__free_unpacked + (Tethering__SetEventStatus *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__set_event_status__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__set_event_status__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void injector__event_msg__init - (Injector__EventMsg *message) +void tethering__event_msg__init + (Tethering__EventMsg *message) { - static Injector__EventMsg init_value = INJECTOR__EVENT_MSG__INIT; + static Tethering__EventMsg init_value = TETHERING__EVENT_MSG__INIT; *message = init_value; } -size_t injector__event_msg__get_packed_size - (const Injector__EventMsg *message) +size_t tethering__event_msg__get_packed_size + (const Tethering__EventMsg *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__event_msg__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__event_msg__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t injector__event_msg__pack - (const Injector__EventMsg *message, +size_t tethering__event_msg__pack + (const Tethering__EventMsg *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__event_msg__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__event_msg__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t injector__event_msg__pack_to_buffer - (const Injector__EventMsg *message, +size_t tethering__event_msg__pack_to_buffer + (const Tethering__EventMsg *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__event_msg__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__event_msg__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -Injector__EventMsg * - injector__event_msg__unpack +Tethering__EventMsg * + tethering__event_msg__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (Injector__EventMsg *) - protobuf_c_message_unpack (&injector__event_msg__descriptor, + return (Tethering__EventMsg *) + protobuf_c_message_unpack (&tethering__event_msg__descriptor, allocator, len, data); } -void injector__event_msg__free_unpacked - (Injector__EventMsg *message, +void tethering__event_msg__free_unpacked + (Tethering__EventMsg *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__event_msg__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__event_msg__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void injector__event_terminate__init - (Injector__EventTerminate *message) +void tethering__event_terminate__init + (Tethering__EventTerminate *message) { - static Injector__EventTerminate init_value = INJECTOR__EVENT_TERMINATE__INIT; + static Tethering__EventTerminate init_value = TETHERING__EVENT_TERMINATE__INIT; *message = init_value; } -size_t injector__event_terminate__get_packed_size - (const Injector__EventTerminate *message) +size_t tethering__event_terminate__get_packed_size + (const Tethering__EventTerminate *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__event_terminate__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__event_terminate__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t injector__event_terminate__pack - (const Injector__EventTerminate *message, +size_t tethering__event_terminate__pack + (const Tethering__EventTerminate *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__event_terminate__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__event_terminate__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t injector__event_terminate__pack_to_buffer - (const Injector__EventTerminate *message, +size_t tethering__event_terminate__pack_to_buffer + (const Tethering__EventTerminate *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__event_terminate__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__event_terminate__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -Injector__EventTerminate * - injector__event_terminate__unpack +Tethering__EventTerminate * + tethering__event_terminate__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (Injector__EventTerminate *) - protobuf_c_message_unpack (&injector__event_terminate__descriptor, + return (Tethering__EventTerminate *) + protobuf_c_message_unpack (&tethering__event_terminate__descriptor, allocator, len, data); } -void injector__event_terminate__free_unpacked - (Injector__EventTerminate *message, +void tethering__event_terminate__free_unpacked + (Tethering__EventTerminate *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__event_terminate__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__event_terminate__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void injector__set_sensor_status__init - (Injector__SetSensorStatus *message) +void tethering__set_sensor_status__init + (Tethering__SetSensorStatus *message) { - static Injector__SetSensorStatus init_value = INJECTOR__SET_SENSOR_STATUS__INIT; + static Tethering__SetSensorStatus init_value = TETHERING__SET_SENSOR_STATUS__INIT; *message = init_value; } -size_t injector__set_sensor_status__get_packed_size - (const Injector__SetSensorStatus *message) +size_t tethering__set_sensor_status__get_packed_size + (const Tethering__SetSensorStatus *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__set_sensor_status__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__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, +size_t tethering__set_sensor_status__pack + (const Tethering__SetSensorStatus *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__set_sensor_status__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__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, +size_t tethering__set_sensor_status__pack_to_buffer + (const Tethering__SetSensorStatus *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__set_sensor_status__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__set_sensor_status__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -Injector__SetSensorStatus * - injector__set_sensor_status__unpack +Tethering__SetSensorStatus * + tethering__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, + return (Tethering__SetSensorStatus *) + protobuf_c_message_unpack (&tethering__set_sensor_status__descriptor, allocator, len, data); } -void injector__set_sensor_status__free_unpacked - (Injector__SetSensorStatus *message, +void tethering__set_sensor_status__free_unpacked + (Tethering__SetSensorStatus *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__set_sensor_status__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__set_sensor_status__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void injector__sensor_data__init - (Injector__SensorData *message) +void tethering__sensor_data__init + (Tethering__SensorData *message) { - static Injector__SensorData init_value = INJECTOR__SENSOR_DATA__INIT; + static Tethering__SensorData init_value = TETHERING__SENSOR_DATA__INIT; *message = init_value; } -size_t injector__sensor_data__get_packed_size - (const Injector__SensorData *message) +size_t tethering__sensor_data__get_packed_size + (const Tethering__SensorData *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__sensor_data__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__sensor_data__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t injector__sensor_data__pack - (const Injector__SensorData *message, +size_t tethering__sensor_data__pack + (const Tethering__SensorData *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__sensor_data__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__sensor_data__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t injector__sensor_data__pack_to_buffer - (const Injector__SensorData *message, +size_t tethering__sensor_data__pack_to_buffer + (const Tethering__SensorData *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__sensor_data__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__sensor_data__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -Injector__SensorData * - injector__sensor_data__unpack +Tethering__SensorData * + tethering__sensor_data__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (Injector__SensorData *) - protobuf_c_message_unpack (&injector__sensor_data__descriptor, + return (Tethering__SensorData *) + protobuf_c_message_unpack (&tethering__sensor_data__descriptor, allocator, len, data); } -void injector__sensor_data__free_unpacked - (Injector__SensorData *message, +void tethering__sensor_data__free_unpacked + (Tethering__SensorData *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__sensor_data__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__sensor_data__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void injector__sensor_msg__init - (Injector__SensorMsg *message) +void tethering__sensor_msg__init + (Tethering__SensorMsg *message) { - static Injector__SensorMsg init_value = INJECTOR__SENSOR_MSG__INIT; + static Tethering__SensorMsg init_value = TETHERING__SENSOR_MSG__INIT; *message = init_value; } -size_t injector__sensor_msg__get_packed_size - (const Injector__SensorMsg *message) +size_t tethering__sensor_msg__get_packed_size + (const Tethering__SensorMsg *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__sensor_msg__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__sensor_msg__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t injector__sensor_msg__pack - (const Injector__SensorMsg *message, +size_t tethering__sensor_msg__pack + (const Tethering__SensorMsg *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__sensor_msg__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__sensor_msg__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t injector__sensor_msg__pack_to_buffer - (const Injector__SensorMsg *message, +size_t tethering__sensor_msg__pack_to_buffer + (const Tethering__SensorMsg *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__sensor_msg__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__sensor_msg__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -Injector__SensorMsg * - injector__sensor_msg__unpack +Tethering__SensorMsg * + tethering__sensor_msg__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (Injector__SensorMsg *) - protobuf_c_message_unpack (&injector__sensor_msg__descriptor, + return (Tethering__SensorMsg *) + protobuf_c_message_unpack (&tethering__sensor_msg__descriptor, allocator, len, data); } -void injector__sensor_msg__free_unpacked - (Injector__SensorMsg *message, +void tethering__sensor_msg__free_unpacked + (Tethering__SensorMsg *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__sensor_msg__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__sensor_msg__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void injector__resolution__init - (Injector__Resolution *message) +void tethering__resolution__init + (Tethering__Resolution *message) { - static Injector__Resolution init_value = INJECTOR__RESOLUTION__INIT; + static Tethering__Resolution init_value = TETHERING__RESOLUTION__INIT; *message = init_value; } -size_t injector__resolution__get_packed_size - (const Injector__Resolution *message) +size_t tethering__resolution__get_packed_size + (const Tethering__Resolution *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__resolution__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__resolution__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t injector__resolution__pack - (const Injector__Resolution *message, +size_t tethering__resolution__pack + (const Tethering__Resolution *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__resolution__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__resolution__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t injector__resolution__pack_to_buffer - (const Injector__Resolution *message, +size_t tethering__resolution__pack_to_buffer + (const Tethering__Resolution *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__resolution__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__resolution__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -Injector__Resolution * - injector__resolution__unpack +Tethering__Resolution * + tethering__resolution__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (Injector__Resolution *) - protobuf_c_message_unpack (&injector__resolution__descriptor, + return (Tethering__Resolution *) + protobuf_c_message_unpack (&tethering__resolution__descriptor, allocator, len, data); } -void injector__resolution__free_unpacked - (Injector__Resolution *message, +void tethering__resolution__free_unpacked + (Tethering__Resolution *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__resolution__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__resolution__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void injector__multi_touch_max_count__init - (Injector__MultiTouchMaxCount *message) +void tethering__multi_touch_max_count__init + (Tethering__MultiTouchMaxCount *message) { - static Injector__MultiTouchMaxCount init_value = INJECTOR__MULTI_TOUCH_MAX_COUNT__INIT; + static Tethering__MultiTouchMaxCount init_value = TETHERING__MULTI_TOUCH_MAX_COUNT__INIT; *message = init_value; } -size_t injector__multi_touch_max_count__get_packed_size - (const Injector__MultiTouchMaxCount *message) +size_t tethering__multi_touch_max_count__get_packed_size + (const Tethering__MultiTouchMaxCount *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_max_count__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__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, +size_t tethering__multi_touch_max_count__pack + (const Tethering__MultiTouchMaxCount *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_max_count__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__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, +size_t tethering__multi_touch_max_count__pack_to_buffer + (const Tethering__MultiTouchMaxCount *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_max_count__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__multi_touch_max_count__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -Injector__MultiTouchMaxCount * - injector__multi_touch_max_count__unpack +Tethering__MultiTouchMaxCount * + tethering__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, + return (Tethering__MultiTouchMaxCount *) + protobuf_c_message_unpack (&tethering__multi_touch_max_count__descriptor, allocator, len, data); } -void injector__multi_touch_max_count__free_unpacked - (Injector__MultiTouchMaxCount *message, +void tethering__multi_touch_max_count__free_unpacked + (Tethering__MultiTouchMaxCount *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_max_count__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__multi_touch_max_count__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void injector__multi_touch_data__init - (Injector__MultiTouchData *message) +void tethering__multi_touch_data__init + (Tethering__MultiTouchData *message) { - static Injector__MultiTouchData init_value = INJECTOR__MULTI_TOUCH_DATA__INIT; + static Tethering__MultiTouchData init_value = TETHERING__MULTI_TOUCH_DATA__INIT; *message = init_value; } -size_t injector__multi_touch_data__get_packed_size - (const Injector__MultiTouchData *message) +size_t tethering__multi_touch_data__get_packed_size + (const Tethering__MultiTouchData *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_data__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__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, +size_t tethering__multi_touch_data__pack + (const Tethering__MultiTouchData *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_data__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__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, +size_t tethering__multi_touch_data__pack_to_buffer + (const Tethering__MultiTouchData *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_data__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__multi_touch_data__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -Injector__MultiTouchData * - injector__multi_touch_data__unpack +Tethering__MultiTouchData * + tethering__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, + return (Tethering__MultiTouchData *) + protobuf_c_message_unpack (&tethering__multi_touch_data__descriptor, allocator, len, data); } -void injector__multi_touch_data__free_unpacked - (Injector__MultiTouchData *message, +void tethering__multi_touch_data__free_unpacked + (Tethering__MultiTouchData *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_data__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__multi_touch_data__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void injector__multi_touch_msg__init - (Injector__MultiTouchMsg *message) +void tethering__multi_touch_msg__init + (Tethering__MultiTouchMsg *message) { - static Injector__MultiTouchMsg init_value = INJECTOR__MULTI_TOUCH_MSG__INIT; + static Tethering__MultiTouchMsg init_value = TETHERING__MULTI_TOUCH_MSG__INIT; *message = init_value; } -size_t injector__multi_touch_msg__get_packed_size - (const Injector__MultiTouchMsg *message) +size_t tethering__multi_touch_msg__get_packed_size + (const Tethering__MultiTouchMsg *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_msg__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__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, +size_t tethering__multi_touch_msg__pack + (const Tethering__MultiTouchMsg *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_msg__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__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, +size_t tethering__multi_touch_msg__pack_to_buffer + (const Tethering__MultiTouchMsg *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_msg__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__multi_touch_msg__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -Injector__MultiTouchMsg * - injector__multi_touch_msg__unpack +Tethering__MultiTouchMsg * + tethering__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, + return (Tethering__MultiTouchMsg *) + protobuf_c_message_unpack (&tethering__multi_touch_msg__descriptor, allocator, len, data); } -void injector__multi_touch_msg__free_unpacked - (Injector__MultiTouchMsg *message, +void tethering__multi_touch_msg__free_unpacked + (Tethering__MultiTouchMsg *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__multi_touch_msg__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__multi_touch_msg__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void injector__injector_msg__init - (Injector__InjectorMsg *message) +void tethering__tethering_msg__init + (Tethering__TetheringMsg *message) { - static Injector__InjectorMsg init_value = INJECTOR__INJECTOR_MSG__INIT; + static Tethering__TetheringMsg init_value = TETHERING__TETHERING_MSG__INIT; *message = init_value; } -size_t injector__injector_msg__get_packed_size - (const Injector__InjectorMsg *message) +size_t tethering__tethering_msg__get_packed_size + (const Tethering__TetheringMsg *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__injector_msg__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__tethering_msg__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t injector__injector_msg__pack - (const Injector__InjectorMsg *message, +size_t tethering__tethering_msg__pack + (const Tethering__TetheringMsg *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__injector_msg__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__tethering_msg__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t injector__injector_msg__pack_to_buffer - (const Injector__InjectorMsg *message, +size_t tethering__tethering_msg__pack_to_buffer + (const Tethering__TetheringMsg *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__injector_msg__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__tethering_msg__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -Injector__InjectorMsg * - injector__injector_msg__unpack +Tethering__TetheringMsg * + tethering__tethering_msg__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (Injector__InjectorMsg *) - protobuf_c_message_unpack (&injector__injector_msg__descriptor, + return (Tethering__TetheringMsg *) + protobuf_c_message_unpack (&tethering__tethering_msg__descriptor, allocator, len, data); } -void injector__injector_msg__free_unpacked - (Injector__InjectorMsg *message, +void tethering__tethering_msg__free_unpacked + (Tethering__TetheringMsg *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &injector__injector_msg__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &tethering__tethering_msg__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -static const ProtobufCFieldDescriptor injector__hand_shake_req__field_descriptors[1] = +static const ProtobufCFieldDescriptor tethering__hand_shake_req__field_descriptors[1] = { { "key", @@ -745,37 +745,37 @@ static const ProtobufCFieldDescriptor injector__hand_shake_req__field_descriptor PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__HandShakeReq, key), + PROTOBUF_C_OFFSETOF(Tethering__HandShakeReq, key), NULL, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned injector__hand_shake_req__field_indices_by_name[] = { +static const unsigned tethering__hand_shake_req__field_indices_by_name[] = { 0, /* field[0] = key */ }; -static const ProtobufCIntRange injector__hand_shake_req__number_ranges[1 + 1] = +static const ProtobufCIntRange tethering__hand_shake_req__number_ranges[1 + 1] = { { 1, 0 }, { 0, 1 } }; -const ProtobufCMessageDescriptor injector__hand_shake_req__descriptor = +const ProtobufCMessageDescriptor tethering__hand_shake_req__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "injector.HandShakeReq", + "tethering.HandShakeReq", "HandShakeReq", - "Injector__HandShakeReq", - "injector", - sizeof(Injector__HandShakeReq), + "Tethering__HandShakeReq", + "tethering", + sizeof(Tethering__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, + tethering__hand_shake_req__field_descriptors, + tethering__hand_shake_req__field_indices_by_name, + 1, tethering__hand_shake_req__number_ranges, + (ProtobufCMessageInit) tethering__hand_shake_req__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor injector__hand_shake_ans__field_descriptors[1] = +static const ProtobufCFieldDescriptor tethering__hand_shake_ans__field_descriptors[1] = { { "result", @@ -783,37 +783,37 @@ static const ProtobufCFieldDescriptor injector__hand_shake_ans__field_descriptor PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_ENUM, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__HandShakeAns, result), - &injector__result__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__HandShakeAns, result), + &tethering__message_result__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned injector__hand_shake_ans__field_indices_by_name[] = { +static const unsigned tethering__hand_shake_ans__field_indices_by_name[] = { 0, /* field[0] = result */ }; -static const ProtobufCIntRange injector__hand_shake_ans__number_ranges[1 + 1] = +static const ProtobufCIntRange tethering__hand_shake_ans__number_ranges[1 + 1] = { { 1, 0 }, { 0, 1 } }; -const ProtobufCMessageDescriptor injector__hand_shake_ans__descriptor = +const ProtobufCMessageDescriptor tethering__hand_shake_ans__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "injector.HandShakeAns", + "tethering.HandShakeAns", "HandShakeAns", - "Injector__HandShakeAns", - "injector", - sizeof(Injector__HandShakeAns), + "Tethering__HandShakeAns", + "tethering", + sizeof(Tethering__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, + tethering__hand_shake_ans__field_descriptors, + tethering__hand_shake_ans__field_indices_by_name, + 1, tethering__hand_shake_ans__number_ranges, + (ProtobufCMessageInit) tethering__hand_shake_ans__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor injector__emulator_state__field_descriptors[1] = +static const ProtobufCFieldDescriptor tethering__emulator_state__field_descriptors[1] = { { "state", @@ -821,37 +821,37 @@ static const ProtobufCFieldDescriptor injector__emulator_state__field_descriptor PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_ENUM, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__EmulatorState, state), - &injector__connection_state__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__EmulatorState, state), + &tethering__connection_state__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned injector__emulator_state__field_indices_by_name[] = { +static const unsigned tethering__emulator_state__field_indices_by_name[] = { 0, /* field[0] = state */ }; -static const ProtobufCIntRange injector__emulator_state__number_ranges[1 + 1] = +static const ProtobufCIntRange tethering__emulator_state__number_ranges[1 + 1] = { { 1, 0 }, { 0, 1 } }; -const ProtobufCMessageDescriptor injector__emulator_state__descriptor = +const ProtobufCMessageDescriptor tethering__emulator_state__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "injector.EmulatorState", + "tethering.EmulatorState", "EmulatorState", - "Injector__EmulatorState", - "injector", - sizeof(Injector__EmulatorState), + "Tethering__EmulatorState", + "tethering", + sizeof(Tethering__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, + tethering__emulator_state__field_descriptors, + tethering__emulator_state__field_indices_by_name, + 1, tethering__emulator_state__number_ranges, + (ProtobufCMessageInit) tethering__emulator_state__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor injector__app_state__field_descriptors[1] = +static const ProtobufCFieldDescriptor tethering__app_state__field_descriptors[1] = { { "state", @@ -859,55 +859,55 @@ static const ProtobufCFieldDescriptor injector__app_state__field_descriptors[1] PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_ENUM, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__AppState, state), - &injector__connection_state__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__AppState, state), + &tethering__connection_state__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned injector__app_state__field_indices_by_name[] = { +static const unsigned tethering__app_state__field_indices_by_name[] = { 0, /* field[0] = state */ }; -static const ProtobufCIntRange injector__app_state__number_ranges[1 + 1] = +static const ProtobufCIntRange tethering__app_state__number_ranges[1 + 1] = { { 1, 0 }, { 0, 1 } }; -const ProtobufCMessageDescriptor injector__app_state__descriptor = +const ProtobufCMessageDescriptor tethering__app_state__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "injector.AppState", + "tethering.AppState", "AppState", - "Injector__AppState", - "injector", - sizeof(Injector__AppState), + "Tethering__AppState", + "tethering", + sizeof(Tethering__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, + tethering__app_state__field_descriptors, + tethering__app_state__field_indices_by_name, + 1, tethering__app_state__number_ranges, + (ProtobufCMessageInit) tethering__app_state__init, NULL,NULL,NULL /* reserved[123] */ }; -#define 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 = +#define tethering__start_req__field_descriptors NULL +#define tethering__start_req__field_indices_by_name NULL +#define tethering__start_req__number_ranges NULL +const ProtobufCMessageDescriptor tethering__start_req__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "injector.StartReq", + "tethering.StartReq", "StartReq", - "Injector__StartReq", - "injector", - sizeof(Injector__StartReq), + "Tethering__StartReq", + "tethering", + sizeof(Tethering__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, + tethering__start_req__field_descriptors, + tethering__start_req__field_indices_by_name, + 0, tethering__start_req__number_ranges, + (ProtobufCMessageInit) tethering__start_req__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor injector__start_ans__field_descriptors[1] = +static const ProtobufCFieldDescriptor tethering__start_ans__field_descriptors[1] = { { "result", @@ -915,120 +915,120 @@ static const ProtobufCFieldDescriptor injector__start_ans__field_descriptors[1] PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_ENUM, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__StartAns, result), - &injector__result__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__StartAns, result), + &tethering__message_result__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned injector__start_ans__field_indices_by_name[] = { +static const unsigned tethering__start_ans__field_indices_by_name[] = { 0, /* field[0] = result */ }; -static const ProtobufCIntRange injector__start_ans__number_ranges[1 + 1] = +static const ProtobufCIntRange tethering__start_ans__number_ranges[1 + 1] = { { 1, 0 }, { 0, 1 } }; -const ProtobufCMessageDescriptor injector__start_ans__descriptor = +const ProtobufCMessageDescriptor tethering__start_ans__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "injector.StartAns", + "tethering.StartAns", "StartAns", - "Injector__StartAns", - "injector", - sizeof(Injector__StartAns), + "Tethering__StartAns", + "tethering", + sizeof(Tethering__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, + tethering__start_ans__field_descriptors, + tethering__start_ans__field_indices_by_name, + 1, tethering__start_ans__number_ranges, + (ProtobufCMessageInit) tethering__start_ans__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor injector__set_event_status__field_descriptors[2] = +static const ProtobufCFieldDescriptor tethering__set_event_status__field_descriptors[2] = { { - "event", + "type", 1, PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_ENUM, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__SetEventStatus, event), - &injector__event__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__SetEventStatus, type), + &tethering__event_type__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "status", + "state", 2, PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_ENUM, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__SetEventStatus, status), - &injector__status__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__SetEventStatus, state), + &tethering__state__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 unsigned tethering__set_event_status__field_indices_by_name[] = { + 1, /* field[1] = state */ + 0, /* field[0] = type */ }; -static const ProtobufCIntRange injector__set_event_status__number_ranges[1 + 1] = +static const ProtobufCIntRange tethering__set_event_status__number_ranges[1 + 1] = { { 1, 0 }, { 0, 2 } }; -const ProtobufCMessageDescriptor injector__set_event_status__descriptor = +const ProtobufCMessageDescriptor tethering__set_event_status__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "injector.SetEventStatus", + "tethering.SetEventStatus", "SetEventStatus", - "Injector__SetEventStatus", - "injector", - sizeof(Injector__SetEventStatus), + "Tethering__SetEventStatus", + "tethering", + sizeof(Tethering__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, + tethering__set_event_status__field_descriptors, + tethering__set_event_status__field_indices_by_name, + 1, tethering__set_event_status__number_ranges, + (ProtobufCMessageInit) tethering__set_event_status__init, NULL,NULL,NULL /* reserved[123] */ }; -const ProtobufCEnumValue injector__event_msg__type__enum_values_by_number[4] = +const ProtobufCEnumValue tethering__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 }, + { "START_REQ", "TETHERING__EVENT_MSG__TYPE__START_REQ", 2 }, + { "START_ANS", "TETHERING__EVENT_MSG__TYPE__START_ANS", 3 }, + { "TERMINATE", "TETHERING__EVENT_MSG__TYPE__TERMINATE", 4 }, + { "EVENT_STATUS", "TETHERING__EVENT_MSG__TYPE__EVENT_STATUS", 5 }, }; -static const ProtobufCIntRange injector__event_msg__type__value_ranges[] = { +static const ProtobufCIntRange tethering__event_msg__type__value_ranges[] = { {2, 0},{0, 4} }; -const ProtobufCEnumValueIndex injector__event_msg__type__enum_values_by_name[4] = +const ProtobufCEnumValueIndex tethering__event_msg__type__enum_values_by_name[4] = { { "EVENT_STATUS", 3 }, { "START_ANS", 1 }, { "START_REQ", 0 }, { "TERMINATE", 2 }, }; -const ProtobufCEnumDescriptor injector__event_msg__type__descriptor = +const ProtobufCEnumDescriptor tethering__event_msg__type__descriptor = { PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "injector.EventMsg.TYPE", + "tethering.EventMsg.TYPE", "TYPE", - "Injector__EventMsg__TYPE", - "injector", + "Tethering__EventMsg__TYPE", + "tethering", 4, - injector__event_msg__type__enum_values_by_number, + tethering__event_msg__type__enum_values_by_number, 4, - injector__event_msg__type__enum_values_by_name, + tethering__event_msg__type__enum_values_by_name, 1, - injector__event_msg__type__value_ranges, + tethering__event_msg__type__value_ranges, NULL,NULL,NULL,NULL /* reserved[1234] */ }; -static const ProtobufCFieldDescriptor injector__event_msg__field_descriptors[5] = +static const ProtobufCFieldDescriptor tethering__event_msg__field_descriptors[5] = { { "type", @@ -1036,8 +1036,8 @@ static const ProtobufCFieldDescriptor injector__event_msg__field_descriptors[5] PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_ENUM, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__EventMsg, type), - &injector__event_msg__type__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__EventMsg, type), + &tethering__event_msg__type__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1048,8 +1048,8 @@ static const ProtobufCFieldDescriptor injector__event_msg__field_descriptors[5] PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__EventMsg, startreq), - &injector__start_req__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__EventMsg, startreq), + &tethering__start_req__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1060,8 +1060,8 @@ static const ProtobufCFieldDescriptor injector__event_msg__field_descriptors[5] PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__EventMsg, startans), - &injector__start_ans__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__EventMsg, startans), + &tethering__start_ans__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1072,8 +1072,8 @@ static const ProtobufCFieldDescriptor injector__event_msg__field_descriptors[5] PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__EventMsg, terminate), - &injector__event_terminate__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__EventMsg, terminate), + &tethering__event_terminate__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1084,113 +1084,113 @@ static const ProtobufCFieldDescriptor injector__event_msg__field_descriptors[5] PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__EventMsg, setstatus), - &injector__set_event_status__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__EventMsg, setstatus), + &tethering__set_event_status__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned injector__event_msg__field_indices_by_name[] = { +static const unsigned tethering__event_msg__field_indices_by_name[] = { 4, /* field[4] = setStatus */ 2, /* field[2] = startAns */ 1, /* field[1] = startReq */ 3, /* field[3] = terminate */ 0, /* field[0] = type */ }; -static const ProtobufCIntRange injector__event_msg__number_ranges[1 + 1] = +static const ProtobufCIntRange tethering__event_msg__number_ranges[1 + 1] = { { 1, 0 }, { 0, 5 } }; -const ProtobufCMessageDescriptor injector__event_msg__descriptor = +const ProtobufCMessageDescriptor tethering__event_msg__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "injector.EventMsg", + "tethering.EventMsg", "EventMsg", - "Injector__EventMsg", - "injector", - sizeof(Injector__EventMsg), + "Tethering__EventMsg", + "tethering", + sizeof(Tethering__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, + tethering__event_msg__field_descriptors, + tethering__event_msg__field_indices_by_name, + 1, tethering__event_msg__number_ranges, + (ProtobufCMessageInit) tethering__event_msg__init, NULL,NULL,NULL /* reserved[123] */ }; -#define 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 = +#define tethering__event_terminate__field_descriptors NULL +#define tethering__event_terminate__field_indices_by_name NULL +#define tethering__event_terminate__number_ranges NULL +const ProtobufCMessageDescriptor tethering__event_terminate__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "injector.EventTerminate", + "tethering.EventTerminate", "EventTerminate", - "Injector__EventTerminate", - "injector", - sizeof(Injector__EventTerminate), + "Tethering__EventTerminate", + "tethering", + sizeof(Tethering__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, + tethering__event_terminate__field_descriptors, + tethering__event_terminate__field_indices_by_name, + 0, tethering__event_terminate__number_ranges, + (ProtobufCMessageInit) tethering__event_terminate__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor injector__set_sensor_status__field_descriptors[2] = +static const ProtobufCFieldDescriptor tethering__set_sensor_status__field_descriptors[2] = { { - "sensor", + "type", 1, PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_ENUM, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__SetSensorStatus, sensor), - &injector__sensor_type__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__SetSensorStatus, type), + &tethering__sensor_type__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "status", + "state", 2, PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_ENUM, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__SetSensorStatus, status), - &injector__status__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__SetSensorStatus, state), + &tethering__state__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 unsigned tethering__set_sensor_status__field_indices_by_name[] = { + 1, /* field[1] = state */ + 0, /* field[0] = type */ }; -static const ProtobufCIntRange injector__set_sensor_status__number_ranges[1 + 1] = +static const ProtobufCIntRange tethering__set_sensor_status__number_ranges[1 + 1] = { { 1, 0 }, { 0, 2 } }; -const ProtobufCMessageDescriptor injector__set_sensor_status__descriptor = +const ProtobufCMessageDescriptor tethering__set_sensor_status__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "injector.SetSensorStatus", + "tethering.SetSensorStatus", "SetSensorStatus", - "Injector__SetSensorStatus", - "injector", - sizeof(Injector__SetSensorStatus), + "Tethering__SetSensorStatus", + "tethering", + sizeof(Tethering__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, + tethering__set_sensor_status__field_descriptors, + tethering__set_sensor_status__field_indices_by_name, + 1, tethering__set_sensor_status__number_ranges, + (ProtobufCMessageInit) tethering__set_sensor_status__init, NULL,NULL,NULL /* reserved[123] */ }; -char 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] = +char tethering__sensor_data__x__default_value[] = "0"; +char tethering__sensor_data__y__default_value[] = "0"; +char tethering__sensor_data__z__default_value[] = "0"; +static const ProtobufCFieldDescriptor tethering__sensor_data__field_descriptors[4] = { { "sensor", @@ -1198,8 +1198,8 @@ static const ProtobufCFieldDescriptor injector__sensor_data__field_descriptors[4 PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_ENUM, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__SensorData, sensor), - &injector__sensor_type__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__SensorData, sensor), + &tethering__sensor_type__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1210,9 +1210,9 @@ static const ProtobufCFieldDescriptor injector__sensor_data__field_descriptors[4 PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__SensorData, x), + PROTOBUF_C_OFFSETOF(Tethering__SensorData, x), NULL, - &injector__sensor_data__x__default_value, + &tethering__sensor_data__x__default_value, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, @@ -1222,9 +1222,9 @@ static const ProtobufCFieldDescriptor injector__sensor_data__field_descriptors[4 PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__SensorData, y), + PROTOBUF_C_OFFSETOF(Tethering__SensorData, y), NULL, - &injector__sensor_data__y__default_value, + &tethering__sensor_data__y__default_value, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, @@ -1234,51 +1234,51 @@ static const ProtobufCFieldDescriptor injector__sensor_data__field_descriptors[4 PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__SensorData, z), + PROTOBUF_C_OFFSETOF(Tethering__SensorData, z), NULL, - &injector__sensor_data__z__default_value, + &tethering__sensor_data__z__default_value, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned injector__sensor_data__field_indices_by_name[] = { +static const unsigned tethering__sensor_data__field_indices_by_name[] = { 0, /* field[0] = sensor */ 1, /* field[1] = x */ 2, /* field[2] = y */ 3, /* field[3] = z */ }; -static const ProtobufCIntRange injector__sensor_data__number_ranges[1 + 1] = +static const ProtobufCIntRange tethering__sensor_data__number_ranges[1 + 1] = { { 1, 0 }, { 0, 4 } }; -const ProtobufCMessageDescriptor injector__sensor_data__descriptor = +const ProtobufCMessageDescriptor tethering__sensor_data__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "injector.SensorData", + "tethering.SensorData", "SensorData", - "Injector__SensorData", - "injector", - sizeof(Injector__SensorData), + "Tethering__SensorData", + "tethering", + sizeof(Tethering__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, + tethering__sensor_data__field_descriptors, + tethering__sensor_data__field_indices_by_name, + 1, tethering__sensor_data__number_ranges, + (ProtobufCMessageInit) tethering__sensor_data__init, NULL,NULL,NULL /* reserved[123] */ }; -const ProtobufCEnumValue injector__sensor_msg__type__enum_values_by_number[5] = +const ProtobufCEnumValue tethering__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 }, + { "START_REQ", "TETHERING__SENSOR_MSG__TYPE__START_REQ", 2 }, + { "START_ANS", "TETHERING__SENSOR_MSG__TYPE__START_ANS", 3 }, + { "TERMINATE", "TETHERING__SENSOR_MSG__TYPE__TERMINATE", 4 }, + { "SENSOR_STATUS", "TETHERING__SENSOR_MSG__TYPE__SENSOR_STATUS", 5 }, + { "SENSOR_DATA", "TETHERING__SENSOR_MSG__TYPE__SENSOR_DATA", 6 }, }; -static const ProtobufCIntRange injector__sensor_msg__type__value_ranges[] = { +static const ProtobufCIntRange tethering__sensor_msg__type__value_ranges[] = { {2, 0},{0, 5} }; -const ProtobufCEnumValueIndex injector__sensor_msg__type__enum_values_by_name[5] = +const ProtobufCEnumValueIndex tethering__sensor_msg__type__enum_values_by_name[5] = { { "SENSOR_DATA", 4 }, { "SENSOR_STATUS", 3 }, @@ -1286,22 +1286,22 @@ const ProtobufCEnumValueIndex injector__sensor_msg__type__enum_values_by_name[5] { "START_REQ", 0 }, { "TERMINATE", 2 }, }; -const ProtobufCEnumDescriptor injector__sensor_msg__type__descriptor = +const ProtobufCEnumDescriptor tethering__sensor_msg__type__descriptor = { PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "injector.SensorMsg.Type", + "tethering.SensorMsg.Type", "Type", - "Injector__SensorMsg__Type", - "injector", + "Tethering__SensorMsg__Type", + "tethering", 5, - injector__sensor_msg__type__enum_values_by_number, + tethering__sensor_msg__type__enum_values_by_number, 5, - injector__sensor_msg__type__enum_values_by_name, + tethering__sensor_msg__type__enum_values_by_name, 1, - injector__sensor_msg__type__value_ranges, + tethering__sensor_msg__type__value_ranges, NULL,NULL,NULL,NULL /* reserved[1234] */ }; -static const ProtobufCFieldDescriptor injector__sensor_msg__field_descriptors[6] = +static const ProtobufCFieldDescriptor tethering__sensor_msg__field_descriptors[6] = { { "type", @@ -1309,8 +1309,8 @@ static const ProtobufCFieldDescriptor injector__sensor_msg__field_descriptors[6] PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_ENUM, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__SensorMsg, type), - &injector__sensor_msg__type__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__SensorMsg, type), + &tethering__sensor_msg__type__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1321,8 +1321,8 @@ static const ProtobufCFieldDescriptor injector__sensor_msg__field_descriptors[6] PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__SensorMsg, startreq), - &injector__start_req__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__SensorMsg, startreq), + &tethering__start_req__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1333,8 +1333,8 @@ static const ProtobufCFieldDescriptor injector__sensor_msg__field_descriptors[6] PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__SensorMsg, startans), - &injector__start_ans__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__SensorMsg, startans), + &tethering__start_ans__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1345,8 +1345,8 @@ static const ProtobufCFieldDescriptor injector__sensor_msg__field_descriptors[6] PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__SensorMsg, terminate), - &injector__event_terminate__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__SensorMsg, terminate), + &tethering__event_terminate__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1357,8 +1357,8 @@ static const ProtobufCFieldDescriptor injector__sensor_msg__field_descriptors[6] PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__SensorMsg, setstatus), - &injector__set_sensor_status__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__SensorMsg, setstatus), + &tethering__set_sensor_status__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1369,14 +1369,14 @@ static const ProtobufCFieldDescriptor injector__sensor_msg__field_descriptors[6] PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__SensorMsg, data), - &injector__sensor_data__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__SensorMsg, data), + &tethering__sensor_data__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned injector__sensor_msg__field_indices_by_name[] = { +static const unsigned tethering__sensor_msg__field_indices_by_name[] = { 5, /* field[5] = data */ 4, /* field[4] = setStatus */ 2, /* field[2] = startAns */ @@ -1384,27 +1384,27 @@ static const unsigned injector__sensor_msg__field_indices_by_name[] = { 3, /* field[3] = terminate */ 0, /* field[0] = type */ }; -static const ProtobufCIntRange injector__sensor_msg__number_ranges[1 + 1] = +static const ProtobufCIntRange tethering__sensor_msg__number_ranges[1 + 1] = { { 1, 0 }, { 0, 6 } }; -const ProtobufCMessageDescriptor injector__sensor_msg__descriptor = +const ProtobufCMessageDescriptor tethering__sensor_msg__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "injector.SensorMsg", + "tethering.SensorMsg", "SensorMsg", - "Injector__SensorMsg", - "injector", - sizeof(Injector__SensorMsg), + "Tethering__SensorMsg", + "tethering", + sizeof(Tethering__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, + tethering__sensor_msg__field_descriptors, + tethering__sensor_msg__field_indices_by_name, + 1, tethering__sensor_msg__number_ranges, + (ProtobufCMessageInit) tethering__sensor_msg__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor injector__resolution__field_descriptors[2] = +static const ProtobufCFieldDescriptor tethering__resolution__field_descriptors[2] = { { "width", @@ -1412,7 +1412,7 @@ static const ProtobufCFieldDescriptor injector__resolution__field_descriptors[2] PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__Resolution, width), + PROTOBUF_C_OFFSETOF(Tethering__Resolution, width), NULL, NULL, 0, /* packed */ @@ -1424,90 +1424,90 @@ static const ProtobufCFieldDescriptor injector__resolution__field_descriptors[2] PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__Resolution, height), + PROTOBUF_C_OFFSETOF(Tethering__Resolution, height), NULL, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned injector__resolution__field_indices_by_name[] = { +static const unsigned tethering__resolution__field_indices_by_name[] = { 1, /* field[1] = height */ 0, /* field[0] = width */ }; -static const ProtobufCIntRange injector__resolution__number_ranges[1 + 1] = +static const ProtobufCIntRange tethering__resolution__number_ranges[1 + 1] = { { 1, 0 }, { 0, 2 } }; -const ProtobufCMessageDescriptor injector__resolution__descriptor = +const ProtobufCMessageDescriptor tethering__resolution__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "injector.Resolution", + "tethering.Resolution", "Resolution", - "Injector__Resolution", - "injector", - sizeof(Injector__Resolution), + "Tethering__Resolution", + "tethering", + sizeof(Tethering__Resolution), 2, - injector__resolution__field_descriptors, - injector__resolution__field_indices_by_name, - 1, injector__resolution__number_ranges, - (ProtobufCMessageInit) injector__resolution__init, + tethering__resolution__field_descriptors, + tethering__resolution__field_indices_by_name, + 1, tethering__resolution__number_ranges, + (ProtobufCMessageInit) tethering__resolution__init, NULL,NULL,NULL /* reserved[123] */ }; -static const int32_t injector__multi_touch_max_count__max__default_value = 10; -static const ProtobufCFieldDescriptor injector__multi_touch_max_count__field_descriptors[1] = +static const int32_t tethering__multi_touch_max_count__max__default_value = 10; +static const ProtobufCFieldDescriptor tethering__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), + PROTOBUF_C_OFFSETOF(Tethering__MultiTouchMaxCount, has_max), + PROTOBUF_C_OFFSETOF(Tethering__MultiTouchMaxCount, max), NULL, - &injector__multi_touch_max_count__max__default_value, + &tethering__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[] = { +static const unsigned tethering__multi_touch_max_count__field_indices_by_name[] = { 0, /* field[0] = max */ }; -static const ProtobufCIntRange injector__multi_touch_max_count__number_ranges[1 + 1] = +static const ProtobufCIntRange tethering__multi_touch_max_count__number_ranges[1 + 1] = { { 1, 0 }, { 0, 1 } }; -const ProtobufCMessageDescriptor injector__multi_touch_max_count__descriptor = +const ProtobufCMessageDescriptor tethering__multi_touch_max_count__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "injector.MultiTouchMaxCount", + "tethering.MultiTouchMaxCount", "MultiTouchMaxCount", - "Injector__MultiTouchMaxCount", - "injector", - sizeof(Injector__MultiTouchMaxCount), + "Tethering__MultiTouchMaxCount", + "tethering", + sizeof(Tethering__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, + tethering__multi_touch_max_count__field_descriptors, + tethering__multi_touch_max_count__field_indices_by_name, + 1, tethering__multi_touch_max_count__number_ranges, + (ProtobufCMessageInit) tethering__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] = +static const int32_t tethering__multi_touch_data__index__default_value = 0; +static const float tethering__multi_touch_data__x_point__default_value = 0; +static const float tethering__multi_touch_data__y_point__default_value = 0; +static const ProtobufCFieldDescriptor tethering__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), + PROTOBUF_C_OFFSETOF(Tethering__MultiTouchData, has_index), + PROTOBUF_C_OFFSETOF(Tethering__MultiTouchData, index), NULL, - &injector__multi_touch_data__index__default_value, + &tethering__multi_touch_data__index__default_value, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, @@ -1516,10 +1516,10 @@ static const ProtobufCFieldDescriptor injector__multi_touch_data__field_descript 2, PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_FLOAT, - PROTOBUF_C_OFFSETOF(Injector__MultiTouchData, has_xpoint), - PROTOBUF_C_OFFSETOF(Injector__MultiTouchData, xpoint), + PROTOBUF_C_OFFSETOF(Tethering__MultiTouchData, has_xpoint), + PROTOBUF_C_OFFSETOF(Tethering__MultiTouchData, xpoint), NULL, - &injector__multi_touch_data__x_point__default_value, + &tethering__multi_touch_data__x_point__default_value, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, @@ -1528,65 +1528,65 @@ static const ProtobufCFieldDescriptor injector__multi_touch_data__field_descript 3, PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_FLOAT, - PROTOBUF_C_OFFSETOF(Injector__MultiTouchData, has_ypoint), - PROTOBUF_C_OFFSETOF(Injector__MultiTouchData, ypoint), + PROTOBUF_C_OFFSETOF(Tethering__MultiTouchData, has_ypoint), + PROTOBUF_C_OFFSETOF(Tethering__MultiTouchData, ypoint), NULL, - &injector__multi_touch_data__y_point__default_value, + &tethering__multi_touch_data__y_point__default_value, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "status", + "state", 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, + PROTOBUF_C_OFFSETOF(Tethering__MultiTouchData, has_state), + PROTOBUF_C_OFFSETOF(Tethering__MultiTouchData, state), + &tethering__touch_state__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned injector__multi_touch_data__field_indices_by_name[] = { +static const unsigned tethering__multi_touch_data__field_indices_by_name[] = { 0, /* field[0] = index */ - 3, /* field[3] = status */ + 3, /* field[3] = state */ 1, /* field[1] = xPoint */ 2, /* field[2] = yPoint */ }; -static const ProtobufCIntRange injector__multi_touch_data__number_ranges[1 + 1] = +static const ProtobufCIntRange tethering__multi_touch_data__number_ranges[1 + 1] = { { 1, 0 }, { 0, 4 } }; -const ProtobufCMessageDescriptor injector__multi_touch_data__descriptor = +const ProtobufCMessageDescriptor tethering__multi_touch_data__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "injector.MultiTouchData", + "tethering.MultiTouchData", "MultiTouchData", - "Injector__MultiTouchData", - "injector", - sizeof(Injector__MultiTouchData), + "Tethering__MultiTouchData", + "tethering", + sizeof(Tethering__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, + tethering__multi_touch_data__field_descriptors, + tethering__multi_touch_data__field_indices_by_name, + 1, tethering__multi_touch_data__number_ranges, + (ProtobufCMessageInit) tethering__multi_touch_data__init, NULL,NULL,NULL /* reserved[123] */ }; -const ProtobufCEnumValue injector__multi_touch_msg__type__enum_values_by_number[6] = +const ProtobufCEnumValue tethering__multi_touch_msg__type__enum_values_by_number[6] = { - { "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 }, - { "RESOLUTION", "INJECTOR__MULTI_TOUCH_MSG__TYPE__RESOLUTION", 7 }, + { "START_REQ", "TETHERING__MULTI_TOUCH_MSG__TYPE__START_REQ", 2 }, + { "START_ANS", "TETHERING__MULTI_TOUCH_MSG__TYPE__START_ANS", 3 }, + { "TERMINATE", "TETHERING__MULTI_TOUCH_MSG__TYPE__TERMINATE", 4 }, + { "MAX_COUNT", "TETHERING__MULTI_TOUCH_MSG__TYPE__MAX_COUNT", 5 }, + { "TOUCH_DATA", "TETHERING__MULTI_TOUCH_MSG__TYPE__TOUCH_DATA", 6 }, + { "RESOLUTION", "TETHERING__MULTI_TOUCH_MSG__TYPE__RESOLUTION", 7 }, }; -static const ProtobufCIntRange injector__multi_touch_msg__type__value_ranges[] = { +static const ProtobufCIntRange tethering__multi_touch_msg__type__value_ranges[] = { {2, 0},{0, 6} }; -const ProtobufCEnumValueIndex injector__multi_touch_msg__type__enum_values_by_name[6] = +const ProtobufCEnumValueIndex tethering__multi_touch_msg__type__enum_values_by_name[6] = { { "MAX_COUNT", 3 }, { "RESOLUTION", 5 }, @@ -1595,22 +1595,22 @@ const ProtobufCEnumValueIndex injector__multi_touch_msg__type__enum_values_by_na { "TERMINATE", 2 }, { "TOUCH_DATA", 4 }, }; -const ProtobufCEnumDescriptor injector__multi_touch_msg__type__descriptor = +const ProtobufCEnumDescriptor tethering__multi_touch_msg__type__descriptor = { PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "injector.MultiTouchMsg.Type", + "tethering.MultiTouchMsg.Type", "Type", - "Injector__MultiTouchMsg__Type", - "injector", + "Tethering__MultiTouchMsg__Type", + "tethering", 6, - injector__multi_touch_msg__type__enum_values_by_number, + tethering__multi_touch_msg__type__enum_values_by_number, 6, - injector__multi_touch_msg__type__enum_values_by_name, + tethering__multi_touch_msg__type__enum_values_by_name, 1, - injector__multi_touch_msg__type__value_ranges, + tethering__multi_touch_msg__type__value_ranges, NULL,NULL,NULL,NULL /* reserved[1234] */ }; -static const ProtobufCFieldDescriptor injector__multi_touch_msg__field_descriptors[7] = +static const ProtobufCFieldDescriptor tethering__multi_touch_msg__field_descriptors[7] = { { "type", @@ -1618,8 +1618,8 @@ static const ProtobufCFieldDescriptor injector__multi_touch_msg__field_descripto PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_ENUM, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__MultiTouchMsg, type), - &injector__multi_touch_msg__type__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__MultiTouchMsg, type), + &tethering__multi_touch_msg__type__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1630,8 +1630,8 @@ static const ProtobufCFieldDescriptor injector__multi_touch_msg__field_descripto PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__MultiTouchMsg, startreq), - &injector__start_req__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__MultiTouchMsg, startreq), + &tethering__start_req__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1642,8 +1642,8 @@ static const ProtobufCFieldDescriptor injector__multi_touch_msg__field_descripto PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__MultiTouchMsg, startans), - &injector__start_ans__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__MultiTouchMsg, startans), + &tethering__start_ans__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1654,8 +1654,8 @@ static const ProtobufCFieldDescriptor injector__multi_touch_msg__field_descripto PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__MultiTouchMsg, terminate), - &injector__event_terminate__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__MultiTouchMsg, terminate), + &tethering__event_terminate__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1666,8 +1666,8 @@ static const ProtobufCFieldDescriptor injector__multi_touch_msg__field_descripto PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__MultiTouchMsg, maxcount), - &injector__multi_touch_max_count__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__MultiTouchMsg, maxcount), + &tethering__multi_touch_max_count__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1678,8 +1678,8 @@ static const ProtobufCFieldDescriptor injector__multi_touch_msg__field_descripto PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__MultiTouchMsg, touchdata), - &injector__multi_touch_data__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__MultiTouchMsg, touchdata), + &tethering__multi_touch_data__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1690,14 +1690,14 @@ static const ProtobufCFieldDescriptor injector__multi_touch_msg__field_descripto PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__MultiTouchMsg, resolution), - &injector__resolution__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__MultiTouchMsg, resolution), + &tethering__resolution__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned injector__multi_touch_msg__field_indices_by_name[] = { +static const unsigned tethering__multi_touch_msg__field_indices_by_name[] = { 4, /* field[4] = maxCount */ 6, /* field[6] = resolution */ 2, /* field[2] = startAns */ @@ -1706,40 +1706,40 @@ static const unsigned injector__multi_touch_msg__field_indices_by_name[] = { 5, /* field[5] = touchData */ 0, /* field[0] = type */ }; -static const ProtobufCIntRange injector__multi_touch_msg__number_ranges[1 + 1] = +static const ProtobufCIntRange tethering__multi_touch_msg__number_ranges[1 + 1] = { { 1, 0 }, { 0, 7 } }; -const ProtobufCMessageDescriptor injector__multi_touch_msg__descriptor = +const ProtobufCMessageDescriptor tethering__multi_touch_msg__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "injector.MultiTouchMsg", + "tethering.MultiTouchMsg", "MultiTouchMsg", - "Injector__MultiTouchMsg", - "injector", - sizeof(Injector__MultiTouchMsg), + "Tethering__MultiTouchMsg", + "tethering", + sizeof(Tethering__MultiTouchMsg), 7, - 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, + tethering__multi_touch_msg__field_descriptors, + tethering__multi_touch_msg__field_indices_by_name, + 1, tethering__multi_touch_msg__number_ranges, + (ProtobufCMessageInit) tethering__multi_touch_msg__init, NULL,NULL,NULL /* reserved[123] */ }; -const ProtobufCEnumValue injector__injector_msg__type__enum_values_by_number[7] = +const ProtobufCEnumValue tethering__tethering_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 }, + { "HANDSHAKE_REQ", "TETHERING__TETHERING_MSG__TYPE__HANDSHAKE_REQ", 2 }, + { "HANDSHAKE_ANS", "TETHERING__TETHERING_MSG__TYPE__HANDSHAKE_ANS", 3 }, + { "EMUL_STATE", "TETHERING__TETHERING_MSG__TYPE__EMUL_STATE", 4 }, + { "APP_STATE", "TETHERING__TETHERING_MSG__TYPE__APP_STATE", 5 }, + { "EVENT_MSG", "TETHERING__TETHERING_MSG__TYPE__EVENT_MSG", 6 }, + { "SENSOR_MSG", "TETHERING__TETHERING_MSG__TYPE__SENSOR_MSG", 7 }, + { "TOUCH_MSG", "TETHERING__TETHERING_MSG__TYPE__TOUCH_MSG", 8 }, }; -static const ProtobufCIntRange injector__injector_msg__type__value_ranges[] = { +static const ProtobufCIntRange tethering__tethering_msg__type__value_ranges[] = { {2, 0},{0, 7} }; -const ProtobufCEnumValueIndex injector__injector_msg__type__enum_values_by_name[7] = +const ProtobufCEnumValueIndex tethering__tethering_msg__type__enum_values_by_name[7] = { { "APP_STATE", 3 }, { "EMUL_STATE", 2 }, @@ -1749,22 +1749,22 @@ const ProtobufCEnumValueIndex injector__injector_msg__type__enum_values_by_name[ { "SENSOR_MSG", 5 }, { "TOUCH_MSG", 6 }, }; -const ProtobufCEnumDescriptor injector__injector_msg__type__descriptor = +const ProtobufCEnumDescriptor tethering__tethering_msg__type__descriptor = { PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "injector.InjectorMsg.Type", + "tethering.TetheringMsg.Type", "Type", - "Injector__InjectorMsg__Type", - "injector", + "Tethering__TetheringMsg__Type", + "tethering", 7, - injector__injector_msg__type__enum_values_by_number, + tethering__tethering_msg__type__enum_values_by_number, 7, - injector__injector_msg__type__enum_values_by_name, + tethering__tethering_msg__type__enum_values_by_name, 1, - injector__injector_msg__type__value_ranges, + tethering__tethering_msg__type__value_ranges, NULL,NULL,NULL,NULL /* reserved[1234] */ }; -static const ProtobufCFieldDescriptor injector__injector_msg__field_descriptors[8] = +static const ProtobufCFieldDescriptor tethering__tethering_msg__field_descriptors[8] = { { "type", @@ -1772,8 +1772,8 @@ static const ProtobufCFieldDescriptor injector__injector_msg__field_descriptors[ PROTOBUF_C_LABEL_REQUIRED, PROTOBUF_C_TYPE_ENUM, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__InjectorMsg, type), - &injector__injector_msg__type__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__TetheringMsg, type), + &tethering__tethering_msg__type__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1784,8 +1784,8 @@ static const ProtobufCFieldDescriptor injector__injector_msg__field_descriptors[ PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__InjectorMsg, handshakereq), - &injector__hand_shake_req__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__TetheringMsg, handshakereq), + &tethering__hand_shake_req__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1796,8 +1796,8 @@ static const ProtobufCFieldDescriptor injector__injector_msg__field_descriptors[ PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__InjectorMsg, handshakeans), - &injector__hand_shake_ans__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__TetheringMsg, handshakeans), + &tethering__hand_shake_ans__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1808,8 +1808,8 @@ static const ProtobufCFieldDescriptor injector__injector_msg__field_descriptors[ PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__InjectorMsg, emulstate), - &injector__emulator_state__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__TetheringMsg, emulstate), + &tethering__emulator_state__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1820,8 +1820,8 @@ static const ProtobufCFieldDescriptor injector__injector_msg__field_descriptors[ PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__InjectorMsg, appstate), - &injector__app_state__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__TetheringMsg, appstate), + &tethering__app_state__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1832,8 +1832,8 @@ static const ProtobufCFieldDescriptor injector__injector_msg__field_descriptors[ PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__InjectorMsg, eventmsg), - &injector__event_msg__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__TetheringMsg, eventmsg), + &tethering__event_msg__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1844,8 +1844,8 @@ static const ProtobufCFieldDescriptor injector__injector_msg__field_descriptors[ PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__InjectorMsg, sensormsg), - &injector__sensor_msg__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__TetheringMsg, sensormsg), + &tethering__sensor_msg__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1856,14 +1856,14 @@ static const ProtobufCFieldDescriptor injector__injector_msg__field_descriptors[ PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(Injector__InjectorMsg, touchmsg), - &injector__multi_touch_msg__descriptor, + PROTOBUF_C_OFFSETOF(Tethering__TetheringMsg, touchmsg), + &tethering__multi_touch_msg__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned injector__injector_msg__field_indices_by_name[] = { +static const unsigned tethering__tethering_msg__field_indices_by_name[] = { 4, /* field[4] = appState */ 3, /* field[3] = emulState */ 5, /* field[5] = eventMsg */ @@ -1873,154 +1873,154 @@ static const unsigned injector__injector_msg__field_indices_by_name[] = { 7, /* field[7] = touchMsg */ 0, /* field[0] = type */ }; -static const ProtobufCIntRange injector__injector_msg__number_ranges[1 + 1] = +static const ProtobufCIntRange tethering__tethering_msg__number_ranges[1 + 1] = { { 1, 0 }, { 0, 8 } }; -const ProtobufCMessageDescriptor injector__injector_msg__descriptor = +const ProtobufCMessageDescriptor tethering__tethering_msg__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "injector.InjectorMsg", - "InjectorMsg", - "Injector__InjectorMsg", - "injector", - sizeof(Injector__InjectorMsg), + "tethering.TetheringMsg", + "TetheringMsg", + "Tethering__TetheringMsg", + "tethering", + sizeof(Tethering__TetheringMsg), 8, - injector__injector_msg__field_descriptors, - injector__injector_msg__field_indices_by_name, - 1, injector__injector_msg__number_ranges, - (ProtobufCMessageInit) injector__injector_msg__init, + tethering__tethering_msg__field_descriptors, + tethering__tethering_msg__field_indices_by_name, + 1, tethering__tethering_msg__number_ranges, + (ProtobufCMessageInit) tethering__tethering_msg__init, NULL,NULL,NULL /* reserved[123] */ }; -const ProtobufCEnumValue injector__result__enum_values_by_number[3] = +const ProtobufCEnumValue tethering__message_result__enum_values_by_number[3] = { - { "SUCCESS", "INJECTOR__RESULT__SUCCESS", 1 }, - { "FAILURE", "INJECTOR__RESULT__FAILURE", 2 }, - { "CANCEL", "INJECTOR__RESULT__CANCEL", 3 }, + { "SUCCESS", "TETHERING__MESSAGE_RESULT__SUCCESS", 1 }, + { "FAILURE", "TETHERING__MESSAGE_RESULT__FAILURE", 2 }, + { "CANCEL", "TETHERING__MESSAGE_RESULT__CANCEL", 3 }, }; -static const ProtobufCIntRange injector__result__value_ranges[] = { +static const ProtobufCIntRange tethering__message_result__value_ranges[] = { {1, 0},{0, 3} }; -const ProtobufCEnumValueIndex injector__result__enum_values_by_name[3] = +const ProtobufCEnumValueIndex tethering__message_result__enum_values_by_name[3] = { { "CANCEL", 2 }, { "FAILURE", 1 }, { "SUCCESS", 0 }, }; -const ProtobufCEnumDescriptor injector__result__descriptor = +const ProtobufCEnumDescriptor tethering__message_result__descriptor = { PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "injector.Result", - "Result", - "Injector__Result", - "injector", + "tethering.MessageResult", + "MessageResult", + "Tethering__MessageResult", + "tethering", 3, - injector__result__enum_values_by_number, + tethering__message_result__enum_values_by_number, 3, - injector__result__enum_values_by_name, + tethering__message_result__enum_values_by_name, 1, - injector__result__value_ranges, + tethering__message_result__value_ranges, NULL,NULL,NULL,NULL /* reserved[1234] */ }; -const ProtobufCEnumValue injector__connection_state__enum_values_by_number[3] = +const ProtobufCEnumValue tethering__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 }, + { "CONNECTED", "TETHERING__CONNECTION_STATE__CONNECTED", 1 }, + { "DISCONNECTED", "TETHERING__CONNECTION_STATE__DISCONNECTED", 2 }, + { "TERMINATED", "TETHERING__CONNECTION_STATE__TERMINATED", 3 }, }; -static const ProtobufCIntRange injector__connection_state__value_ranges[] = { +static const ProtobufCIntRange tethering__connection_state__value_ranges[] = { {1, 0},{0, 3} }; -const ProtobufCEnumValueIndex injector__connection_state__enum_values_by_name[3] = +const ProtobufCEnumValueIndex tethering__connection_state__enum_values_by_name[3] = { - { "CONNECT", 0 }, - { "DISCONNECT", 1 }, - { "TERMINATE", 2 }, + { "CONNECTED", 0 }, + { "DISCONNECTED", 1 }, + { "TERMINATED", 2 }, }; -const ProtobufCEnumDescriptor injector__connection_state__descriptor = +const ProtobufCEnumDescriptor tethering__connection_state__descriptor = { PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "injector.ConnectionState", + "tethering.ConnectionState", "ConnectionState", - "Injector__ConnectionState", - "injector", + "Tethering__ConnectionState", + "tethering", 3, - injector__connection_state__enum_values_by_number, + tethering__connection_state__enum_values_by_number, 3, - injector__connection_state__enum_values_by_name, + tethering__connection_state__enum_values_by_name, 1, - injector__connection_state__value_ranges, + tethering__connection_state__value_ranges, NULL,NULL,NULL,NULL /* reserved[1234] */ }; -const ProtobufCEnumValue injector__event__enum_values_by_number[2] = +const ProtobufCEnumValue tethering__event_type__enum_values_by_number[2] = { - { "SENSOR", "INJECTOR__EVENT__SENSOR", 1 }, - { "MULTITOUCH", "INJECTOR__EVENT__MULTITOUCH", 2 }, + { "SENSOR", "TETHERING__EVENT_TYPE__SENSOR", 1 }, + { "TOUCH", "TETHERING__EVENT_TYPE__TOUCH", 2 }, }; -static const ProtobufCIntRange injector__event__value_ranges[] = { +static const ProtobufCIntRange tethering__event_type__value_ranges[] = { {1, 0},{0, 2} }; -const ProtobufCEnumValueIndex injector__event__enum_values_by_name[2] = +const ProtobufCEnumValueIndex tethering__event_type__enum_values_by_name[2] = { - { "MULTITOUCH", 1 }, { "SENSOR", 0 }, + { "TOUCH", 1 }, }; -const ProtobufCEnumDescriptor injector__event__descriptor = +const ProtobufCEnumDescriptor tethering__event_type__descriptor = { PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "injector.Event", - "Event", - "Injector__Event", - "injector", + "tethering.EventType", + "EventType", + "Tethering__EventType", + "tethering", 2, - injector__event__enum_values_by_number, + tethering__event_type__enum_values_by_number, 2, - injector__event__enum_values_by_name, + tethering__event_type__enum_values_by_name, 1, - injector__event__value_ranges, + tethering__event_type__value_ranges, NULL,NULL,NULL,NULL /* reserved[1234] */ }; -const ProtobufCEnumValue injector__status__enum_values_by_number[2] = +const ProtobufCEnumValue tethering__state__enum_values_by_number[2] = { - { "ENABLE", "INJECTOR__STATUS__ENABLE", 1 }, - { "DISABLE", "INJECTOR__STATUS__DISABLE", 2 }, + { "ENABLED", "TETHERING__STATE__ENABLED", 1 }, + { "DISABLED", "TETHERING__STATE__DISABLED", 2 }, }; -static const ProtobufCIntRange injector__status__value_ranges[] = { +static const ProtobufCIntRange tethering__state__value_ranges[] = { {1, 0},{0, 2} }; -const ProtobufCEnumValueIndex injector__status__enum_values_by_name[2] = +const ProtobufCEnumValueIndex tethering__state__enum_values_by_name[2] = { - { "DISABLE", 1 }, - { "ENABLE", 0 }, + { "DISABLED", 1 }, + { "ENABLED", 0 }, }; -const ProtobufCEnumDescriptor injector__status__descriptor = +const ProtobufCEnumDescriptor tethering__state__descriptor = { PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "injector.Status", - "Status", - "Injector__Status", - "injector", + "tethering.State", + "State", + "Tethering__State", + "tethering", 2, - injector__status__enum_values_by_number, + tethering__state__enum_values_by_number, 2, - injector__status__enum_values_by_name, + tethering__state__enum_values_by_name, 1, - injector__status__value_ranges, + tethering__state__value_ranges, NULL,NULL,NULL,NULL /* reserved[1234] */ }; -const ProtobufCEnumValue injector__sensor_type__enum_values_by_number[5] = +const ProtobufCEnumValue tethering__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 }, + { "ACCEL", "TETHERING__SENSOR_TYPE__ACCEL", 1 }, + { "MAGNETIC", "TETHERING__SENSOR_TYPE__MAGNETIC", 2 }, + { "GYROSCOPE", "TETHERING__SENSOR_TYPE__GYROSCOPE", 3 }, + { "PROXIMITY", "TETHERING__SENSOR_TYPE__PROXIMITY", 4 }, + { "LIGHT", "TETHERING__SENSOR_TYPE__LIGHT", 5 }, }; -static const ProtobufCIntRange injector__sensor_type__value_ranges[] = { +static const ProtobufCIntRange tethering__sensor_type__value_ranges[] = { {1, 0},{0, 5} }; -const ProtobufCEnumValueIndex injector__sensor_type__enum_values_by_name[5] = +const ProtobufCEnumValueIndex tethering__sensor_type__enum_values_by_name[5] = { { "ACCEL", 0 }, { "GYROSCOPE", 2 }, @@ -2028,46 +2028,46 @@ const ProtobufCEnumValueIndex injector__sensor_type__enum_values_by_name[5] = { "MAGNETIC", 1 }, { "PROXIMITY", 3 }, }; -const ProtobufCEnumDescriptor injector__sensor_type__descriptor = +const ProtobufCEnumDescriptor tethering__sensor_type__descriptor = { PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "injector.SensorType", + "tethering.SensorType", "SensorType", - "Injector__SensorType", - "injector", + "Tethering__SensorType", + "tethering", 5, - injector__sensor_type__enum_values_by_number, + tethering__sensor_type__enum_values_by_number, 5, - injector__sensor_type__enum_values_by_name, + tethering__sensor_type__enum_values_by_name, 1, - injector__sensor_type__value_ranges, + tethering__sensor_type__value_ranges, NULL,NULL,NULL,NULL /* reserved[1234] */ }; -const ProtobufCEnumValue injector__touch_status__enum_values_by_number[2] = +const ProtobufCEnumValue tethering__touch_state__enum_values_by_number[2] = { - { "PRESS", "INJECTOR__TOUCH_STATUS__PRESS", 1 }, - { "RELEASE", "INJECTOR__TOUCH_STATUS__RELEASE", 2 }, + { "PRESSED", "TETHERING__TOUCH_STATE__PRESSED", 1 }, + { "RELEASED", "TETHERING__TOUCH_STATE__RELEASED", 2 }, }; -static const ProtobufCIntRange injector__touch_status__value_ranges[] = { +static const ProtobufCIntRange tethering__touch_state__value_ranges[] = { {1, 0},{0, 2} }; -const ProtobufCEnumValueIndex injector__touch_status__enum_values_by_name[2] = +const ProtobufCEnumValueIndex tethering__touch_state__enum_values_by_name[2] = { - { "PRESS", 0 }, - { "RELEASE", 1 }, + { "PRESSED", 0 }, + { "RELEASED", 1 }, }; -const ProtobufCEnumDescriptor injector__touch_status__descriptor = +const ProtobufCEnumDescriptor tethering__touch_state__descriptor = { PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, - "injector.TouchStatus", - "TouchStatus", - "Injector__TouchStatus", - "injector", + "tethering.TouchState", + "TouchState", + "Tethering__TouchState", + "tethering", 2, - injector__touch_status__enum_values_by_number, + tethering__touch_state__enum_values_by_number, 2, - injector__touch_status__enum_values_by_name, + tethering__touch_state__enum_values_by_name, 1, - injector__touch_status__value_ranges, + tethering__touch_state__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 index 64288af..8e551c0 100644 --- a/tizen/src/tethering/genmsg/tethering.pb-c.h +++ b/tizen/src/tethering/genmsg/tethering.pb-c.h @@ -8,247 +8,247 @@ 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__Resolution Injector__Resolution; -typedef struct _Injector__MultiTouchMaxCount Injector__MultiTouchMaxCount; -typedef struct _Injector__MultiTouchData Injector__MultiTouchData; -typedef struct _Injector__MultiTouchMsg Injector__MultiTouchMsg; -typedef struct _Injector__InjectorMsg Injector__InjectorMsg; +typedef struct _Tethering__HandShakeReq Tethering__HandShakeReq; +typedef struct _Tethering__HandShakeAns Tethering__HandShakeAns; +typedef struct _Tethering__EmulatorState Tethering__EmulatorState; +typedef struct _Tethering__AppState Tethering__AppState; +typedef struct _Tethering__StartReq Tethering__StartReq; +typedef struct _Tethering__StartAns Tethering__StartAns; +typedef struct _Tethering__SetEventStatus Tethering__SetEventStatus; +typedef struct _Tethering__EventMsg Tethering__EventMsg; +typedef struct _Tethering__EventTerminate Tethering__EventTerminate; +typedef struct _Tethering__SetSensorStatus Tethering__SetSensorStatus; +typedef struct _Tethering__SensorData Tethering__SensorData; +typedef struct _Tethering__SensorMsg Tethering__SensorMsg; +typedef struct _Tethering__Resolution Tethering__Resolution; +typedef struct _Tethering__MultiTouchMaxCount Tethering__MultiTouchMaxCount; +typedef struct _Tethering__MultiTouchData Tethering__MultiTouchData; +typedef struct _Tethering__MultiTouchMsg Tethering__MultiTouchMsg; +typedef struct _Tethering__TetheringMsg Tethering__TetheringMsg; /* --- 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__MULTI_TOUCH_MSG__TYPE__RESOLUTION = 7 -} 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; +typedef enum _Tethering__EventMsg__TYPE { + TETHERING__EVENT_MSG__TYPE__START_REQ = 2, + TETHERING__EVENT_MSG__TYPE__START_ANS = 3, + TETHERING__EVENT_MSG__TYPE__TERMINATE = 4, + TETHERING__EVENT_MSG__TYPE__EVENT_STATUS = 5 +} Tethering__EventMsg__TYPE; +typedef enum _Tethering__SensorMsg__Type { + TETHERING__SENSOR_MSG__TYPE__START_REQ = 2, + TETHERING__SENSOR_MSG__TYPE__START_ANS = 3, + TETHERING__SENSOR_MSG__TYPE__TERMINATE = 4, + TETHERING__SENSOR_MSG__TYPE__SENSOR_STATUS = 5, + TETHERING__SENSOR_MSG__TYPE__SENSOR_DATA = 6 +} Tethering__SensorMsg__Type; +typedef enum _Tethering__MultiTouchMsg__Type { + TETHERING__MULTI_TOUCH_MSG__TYPE__START_REQ = 2, + TETHERING__MULTI_TOUCH_MSG__TYPE__START_ANS = 3, + TETHERING__MULTI_TOUCH_MSG__TYPE__TERMINATE = 4, + TETHERING__MULTI_TOUCH_MSG__TYPE__MAX_COUNT = 5, + TETHERING__MULTI_TOUCH_MSG__TYPE__TOUCH_DATA = 6, + TETHERING__MULTI_TOUCH_MSG__TYPE__RESOLUTION = 7 +} Tethering__MultiTouchMsg__Type; +typedef enum _Tethering__TetheringMsg__Type { + TETHERING__TETHERING_MSG__TYPE__HANDSHAKE_REQ = 2, + TETHERING__TETHERING_MSG__TYPE__HANDSHAKE_ANS = 3, + TETHERING__TETHERING_MSG__TYPE__EMUL_STATE = 4, + TETHERING__TETHERING_MSG__TYPE__APP_STATE = 5, + TETHERING__TETHERING_MSG__TYPE__EVENT_MSG = 6, + TETHERING__TETHERING_MSG__TYPE__SENSOR_MSG = 7, + TETHERING__TETHERING_MSG__TYPE__TOUCH_MSG = 8 +} Tethering__TetheringMsg__Type; +typedef enum _Tethering__MessageResult { + TETHERING__MESSAGE_RESULT__SUCCESS = 1, + TETHERING__MESSAGE_RESULT__FAILURE = 2, + TETHERING__MESSAGE_RESULT__CANCEL = 3 +} Tethering__MessageResult; +typedef enum _Tethering__ConnectionState { + TETHERING__CONNECTION_STATE__CONNECTED = 1, + TETHERING__CONNECTION_STATE__DISCONNECTED = 2, + TETHERING__CONNECTION_STATE__TERMINATED = 3 +} Tethering__ConnectionState; +typedef enum _Tethering__EventType { + TETHERING__EVENT_TYPE__SENSOR = 1, + TETHERING__EVENT_TYPE__TOUCH = 2 +} Tethering__EventType; +typedef enum _Tethering__State { + TETHERING__STATE__ENABLED = 1, + TETHERING__STATE__DISABLED = 2 +} Tethering__State; +typedef enum _Tethering__SensorType { + TETHERING__SENSOR_TYPE__ACCEL = 1, + TETHERING__SENSOR_TYPE__MAGNETIC = 2, + TETHERING__SENSOR_TYPE__GYROSCOPE = 3, + TETHERING__SENSOR_TYPE__PROXIMITY = 4, + TETHERING__SENSOR_TYPE__LIGHT = 5 +} Tethering__SensorType; +typedef enum _Tethering__TouchState { + TETHERING__TOUCH_STATE__PRESSED = 1, + TETHERING__TOUCH_STATE__RELEASED = 2 +} Tethering__TouchState; /* --- messages --- */ -struct _Injector__HandShakeReq +struct _Tethering__HandShakeReq { ProtobufCMessage base; int32_t key; }; -#define INJECTOR__HAND_SHAKE_REQ__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&injector__hand_shake_req__descriptor) \ +#define TETHERING__HAND_SHAKE_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tethering__hand_shake_req__descriptor) \ , 0 } -struct _Injector__HandShakeAns +struct _Tethering__HandShakeAns { ProtobufCMessage base; - Injector__Result result; + Tethering__MessageResult result; }; -#define INJECTOR__HAND_SHAKE_ANS__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&injector__hand_shake_ans__descriptor) \ +#define TETHERING__HAND_SHAKE_ANS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tethering__hand_shake_ans__descriptor) \ , 0 } -struct _Injector__EmulatorState +struct _Tethering__EmulatorState { ProtobufCMessage base; - Injector__ConnectionState state; + Tethering__ConnectionState state; }; -#define INJECTOR__EMULATOR_STATE__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&injector__emulator_state__descriptor) \ +#define TETHERING__EMULATOR_STATE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tethering__emulator_state__descriptor) \ , 0 } -struct _Injector__AppState +struct _Tethering__AppState { ProtobufCMessage base; - Injector__ConnectionState state; + Tethering__ConnectionState state; }; -#define INJECTOR__APP_STATE__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&injector__app_state__descriptor) \ +#define TETHERING__APP_STATE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tethering__app_state__descriptor) \ , 0 } -struct _Injector__StartReq +struct _Tethering__StartReq { ProtobufCMessage base; }; -#define INJECTOR__START_REQ__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&injector__start_req__descriptor) \ +#define TETHERING__START_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tethering__start_req__descriptor) \ } -struct _Injector__StartAns +struct _Tethering__StartAns { ProtobufCMessage base; - Injector__Result result; + Tethering__MessageResult result; }; -#define INJECTOR__START_ANS__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&injector__start_ans__descriptor) \ +#define TETHERING__START_ANS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tethering__start_ans__descriptor) \ , 0 } -struct _Injector__SetEventStatus +struct _Tethering__SetEventStatus { ProtobufCMessage base; - Injector__Event event; - Injector__Status status; + Tethering__EventType type; + Tethering__State state; }; -#define INJECTOR__SET_EVENT_STATUS__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&injector__set_event_status__descriptor) \ +#define TETHERING__SET_EVENT_STATUS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tethering__set_event_status__descriptor) \ , 0, 0 } -struct _Injector__EventMsg +struct _Tethering__EventMsg { ProtobufCMessage base; - Injector__EventMsg__TYPE type; - Injector__StartReq *startreq; - Injector__StartAns *startans; - Injector__EventTerminate *terminate; - Injector__SetEventStatus *setstatus; + Tethering__EventMsg__TYPE type; + Tethering__StartReq *startreq; + Tethering__StartAns *startans; + Tethering__EventTerminate *terminate; + Tethering__SetEventStatus *setstatus; }; -#define INJECTOR__EVENT_MSG__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&injector__event_msg__descriptor) \ +#define TETHERING__EVENT_MSG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tethering__event_msg__descriptor) \ , 0, NULL, NULL, NULL, NULL } -struct _Injector__EventTerminate +struct _Tethering__EventTerminate { ProtobufCMessage base; }; -#define INJECTOR__EVENT_TERMINATE__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&injector__event_terminate__descriptor) \ +#define TETHERING__EVENT_TERMINATE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tethering__event_terminate__descriptor) \ } -struct _Injector__SetSensorStatus +struct _Tethering__SetSensorStatus { ProtobufCMessage base; - Injector__SensorType sensor; - Injector__Status status; + Tethering__SensorType type; + Tethering__State state; }; -#define INJECTOR__SET_SENSOR_STATUS__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&injector__set_sensor_status__descriptor) \ +#define TETHERING__SET_SENSOR_STATUS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tethering__set_sensor_status__descriptor) \ , 0, 0 } -struct _Injector__SensorData +struct _Tethering__SensorData { ProtobufCMessage base; - Injector__SensorType sensor; + Tethering__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 } +extern char tethering__sensor_data__x__default_value[]; +extern char tethering__sensor_data__y__default_value[]; +extern char tethering__sensor_data__z__default_value[]; +#define TETHERING__SENSOR_DATA__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tethering__sensor_data__descriptor) \ + , 0, tethering__sensor_data__x__default_value, tethering__sensor_data__y__default_value, tethering__sensor_data__z__default_value } -struct _Injector__SensorMsg +struct _Tethering__SensorMsg { ProtobufCMessage base; - Injector__SensorMsg__Type type; - Injector__StartReq *startreq; - Injector__StartAns *startans; - Injector__EventTerminate *terminate; - Injector__SetSensorStatus *setstatus; - Injector__SensorData *data; + Tethering__SensorMsg__Type type; + Tethering__StartReq *startreq; + Tethering__StartAns *startans; + Tethering__EventTerminate *terminate; + Tethering__SetSensorStatus *setstatus; + Tethering__SensorData *data; }; -#define INJECTOR__SENSOR_MSG__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&injector__sensor_msg__descriptor) \ +#define TETHERING__SENSOR_MSG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tethering__sensor_msg__descriptor) \ , 0, NULL, NULL, NULL, NULL, NULL } -struct _Injector__Resolution +struct _Tethering__Resolution { ProtobufCMessage base; int32_t width; int32_t height; }; -#define INJECTOR__RESOLUTION__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&injector__resolution__descriptor) \ +#define TETHERING__RESOLUTION__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tethering__resolution__descriptor) \ , 0, 0 } -struct _Injector__MultiTouchMaxCount +struct _Tethering__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) \ +#define TETHERING__MULTI_TOUCH_MAX_COUNT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tethering__multi_touch_max_count__descriptor) \ , 0,10 } -struct _Injector__MultiTouchData +struct _Tethering__MultiTouchData { ProtobufCMessage base; protobuf_c_boolean has_index; @@ -257,422 +257,422 @@ struct _Injector__MultiTouchData float xpoint; protobuf_c_boolean has_ypoint; float ypoint; - protobuf_c_boolean has_status; - Injector__TouchStatus status; + protobuf_c_boolean has_state; + Tethering__TouchState state; }; -#define INJECTOR__MULTI_TOUCH_DATA__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&injector__multi_touch_data__descriptor) \ +#define TETHERING__MULTI_TOUCH_DATA__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tethering__multi_touch_data__descriptor) \ , 0,0, 0,0, 0,0, 0,0 } -struct _Injector__MultiTouchMsg +struct _Tethering__MultiTouchMsg { ProtobufCMessage base; - Injector__MultiTouchMsg__Type type; - Injector__StartReq *startreq; - Injector__StartAns *startans; - Injector__EventTerminate *terminate; - Injector__MultiTouchMaxCount *maxcount; - Injector__MultiTouchData *touchdata; - Injector__Resolution *resolution; + Tethering__MultiTouchMsg__Type type; + Tethering__StartReq *startreq; + Tethering__StartAns *startans; + Tethering__EventTerminate *terminate; + Tethering__MultiTouchMaxCount *maxcount; + Tethering__MultiTouchData *touchdata; + Tethering__Resolution *resolution; }; -#define INJECTOR__MULTI_TOUCH_MSG__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&injector__multi_touch_msg__descriptor) \ +#define TETHERING__MULTI_TOUCH_MSG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tethering__multi_touch_msg__descriptor) \ , 0, NULL, NULL, NULL, NULL, NULL, NULL } -struct _Injector__InjectorMsg +struct _Tethering__TetheringMsg { 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; + Tethering__TetheringMsg__Type type; + Tethering__HandShakeReq *handshakereq; + Tethering__HandShakeAns *handshakeans; + Tethering__EmulatorState *emulstate; + Tethering__AppState *appstate; + Tethering__EventMsg *eventmsg; + Tethering__SensorMsg *sensormsg; + Tethering__MultiTouchMsg *touchmsg; }; -#define INJECTOR__INJECTOR_MSG__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&injector__injector_msg__descriptor) \ +#define TETHERING__TETHERING_MSG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tethering__tethering_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, +/* Tethering__HandShakeReq methods */ +void tethering__hand_shake_req__init + (Tethering__HandShakeReq *message); +size_t tethering__hand_shake_req__get_packed_size + (const Tethering__HandShakeReq *message); +size_t tethering__hand_shake_req__pack + (const Tethering__HandShakeReq *message, uint8_t *out); -size_t injector__hand_shake_req__pack_to_buffer - (const Injector__HandShakeReq *message, +size_t tethering__hand_shake_req__pack_to_buffer + (const Tethering__HandShakeReq *message, ProtobufCBuffer *buffer); -Injector__HandShakeReq * - injector__hand_shake_req__unpack +Tethering__HandShakeReq * + tethering__hand_shake_req__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void injector__hand_shake_req__free_unpacked - (Injector__HandShakeReq *message, +void tethering__hand_shake_req__free_unpacked + (Tethering__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, +/* Tethering__HandShakeAns methods */ +void tethering__hand_shake_ans__init + (Tethering__HandShakeAns *message); +size_t tethering__hand_shake_ans__get_packed_size + (const Tethering__HandShakeAns *message); +size_t tethering__hand_shake_ans__pack + (const Tethering__HandShakeAns *message, uint8_t *out); -size_t injector__hand_shake_ans__pack_to_buffer - (const Injector__HandShakeAns *message, +size_t tethering__hand_shake_ans__pack_to_buffer + (const Tethering__HandShakeAns *message, ProtobufCBuffer *buffer); -Injector__HandShakeAns * - injector__hand_shake_ans__unpack +Tethering__HandShakeAns * + tethering__hand_shake_ans__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void injector__hand_shake_ans__free_unpacked - (Injector__HandShakeAns *message, +void tethering__hand_shake_ans__free_unpacked + (Tethering__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, +/* Tethering__EmulatorState methods */ +void tethering__emulator_state__init + (Tethering__EmulatorState *message); +size_t tethering__emulator_state__get_packed_size + (const Tethering__EmulatorState *message); +size_t tethering__emulator_state__pack + (const Tethering__EmulatorState *message, uint8_t *out); -size_t injector__emulator_state__pack_to_buffer - (const Injector__EmulatorState *message, +size_t tethering__emulator_state__pack_to_buffer + (const Tethering__EmulatorState *message, ProtobufCBuffer *buffer); -Injector__EmulatorState * - injector__emulator_state__unpack +Tethering__EmulatorState * + tethering__emulator_state__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void injector__emulator_state__free_unpacked - (Injector__EmulatorState *message, +void tethering__emulator_state__free_unpacked + (Tethering__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, +/* Tethering__AppState methods */ +void tethering__app_state__init + (Tethering__AppState *message); +size_t tethering__app_state__get_packed_size + (const Tethering__AppState *message); +size_t tethering__app_state__pack + (const Tethering__AppState *message, uint8_t *out); -size_t injector__app_state__pack_to_buffer - (const Injector__AppState *message, +size_t tethering__app_state__pack_to_buffer + (const Tethering__AppState *message, ProtobufCBuffer *buffer); -Injector__AppState * - injector__app_state__unpack +Tethering__AppState * + tethering__app_state__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void injector__app_state__free_unpacked - (Injector__AppState *message, +void tethering__app_state__free_unpacked + (Tethering__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, +/* Tethering__StartReq methods */ +void tethering__start_req__init + (Tethering__StartReq *message); +size_t tethering__start_req__get_packed_size + (const Tethering__StartReq *message); +size_t tethering__start_req__pack + (const Tethering__StartReq *message, uint8_t *out); -size_t injector__start_req__pack_to_buffer - (const Injector__StartReq *message, +size_t tethering__start_req__pack_to_buffer + (const Tethering__StartReq *message, ProtobufCBuffer *buffer); -Injector__StartReq * - injector__start_req__unpack +Tethering__StartReq * + tethering__start_req__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void injector__start_req__free_unpacked - (Injector__StartReq *message, +void tethering__start_req__free_unpacked + (Tethering__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, +/* Tethering__StartAns methods */ +void tethering__start_ans__init + (Tethering__StartAns *message); +size_t tethering__start_ans__get_packed_size + (const Tethering__StartAns *message); +size_t tethering__start_ans__pack + (const Tethering__StartAns *message, uint8_t *out); -size_t injector__start_ans__pack_to_buffer - (const Injector__StartAns *message, +size_t tethering__start_ans__pack_to_buffer + (const Tethering__StartAns *message, ProtobufCBuffer *buffer); -Injector__StartAns * - injector__start_ans__unpack +Tethering__StartAns * + tethering__start_ans__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void injector__start_ans__free_unpacked - (Injector__StartAns *message, +void tethering__start_ans__free_unpacked + (Tethering__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, +/* Tethering__SetEventStatus methods */ +void tethering__set_event_status__init + (Tethering__SetEventStatus *message); +size_t tethering__set_event_status__get_packed_size + (const Tethering__SetEventStatus *message); +size_t tethering__set_event_status__pack + (const Tethering__SetEventStatus *message, uint8_t *out); -size_t injector__set_event_status__pack_to_buffer - (const Injector__SetEventStatus *message, +size_t tethering__set_event_status__pack_to_buffer + (const Tethering__SetEventStatus *message, ProtobufCBuffer *buffer); -Injector__SetEventStatus * - injector__set_event_status__unpack +Tethering__SetEventStatus * + tethering__set_event_status__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void injector__set_event_status__free_unpacked - (Injector__SetEventStatus *message, +void tethering__set_event_status__free_unpacked + (Tethering__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, +/* Tethering__EventMsg methods */ +void tethering__event_msg__init + (Tethering__EventMsg *message); +size_t tethering__event_msg__get_packed_size + (const Tethering__EventMsg *message); +size_t tethering__event_msg__pack + (const Tethering__EventMsg *message, uint8_t *out); -size_t injector__event_msg__pack_to_buffer - (const Injector__EventMsg *message, +size_t tethering__event_msg__pack_to_buffer + (const Tethering__EventMsg *message, ProtobufCBuffer *buffer); -Injector__EventMsg * - injector__event_msg__unpack +Tethering__EventMsg * + tethering__event_msg__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void injector__event_msg__free_unpacked - (Injector__EventMsg *message, +void tethering__event_msg__free_unpacked + (Tethering__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, +/* Tethering__EventTerminate methods */ +void tethering__event_terminate__init + (Tethering__EventTerminate *message); +size_t tethering__event_terminate__get_packed_size + (const Tethering__EventTerminate *message); +size_t tethering__event_terminate__pack + (const Tethering__EventTerminate *message, uint8_t *out); -size_t injector__event_terminate__pack_to_buffer - (const Injector__EventTerminate *message, +size_t tethering__event_terminate__pack_to_buffer + (const Tethering__EventTerminate *message, ProtobufCBuffer *buffer); -Injector__EventTerminate * - injector__event_terminate__unpack +Tethering__EventTerminate * + tethering__event_terminate__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void injector__event_terminate__free_unpacked - (Injector__EventTerminate *message, +void tethering__event_terminate__free_unpacked + (Tethering__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, +/* Tethering__SetSensorStatus methods */ +void tethering__set_sensor_status__init + (Tethering__SetSensorStatus *message); +size_t tethering__set_sensor_status__get_packed_size + (const Tethering__SetSensorStatus *message); +size_t tethering__set_sensor_status__pack + (const Tethering__SetSensorStatus *message, uint8_t *out); -size_t injector__set_sensor_status__pack_to_buffer - (const Injector__SetSensorStatus *message, +size_t tethering__set_sensor_status__pack_to_buffer + (const Tethering__SetSensorStatus *message, ProtobufCBuffer *buffer); -Injector__SetSensorStatus * - injector__set_sensor_status__unpack +Tethering__SetSensorStatus * + tethering__set_sensor_status__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void injector__set_sensor_status__free_unpacked - (Injector__SetSensorStatus *message, +void tethering__set_sensor_status__free_unpacked + (Tethering__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, +/* Tethering__SensorData methods */ +void tethering__sensor_data__init + (Tethering__SensorData *message); +size_t tethering__sensor_data__get_packed_size + (const Tethering__SensorData *message); +size_t tethering__sensor_data__pack + (const Tethering__SensorData *message, uint8_t *out); -size_t injector__sensor_data__pack_to_buffer - (const Injector__SensorData *message, +size_t tethering__sensor_data__pack_to_buffer + (const Tethering__SensorData *message, ProtobufCBuffer *buffer); -Injector__SensorData * - injector__sensor_data__unpack +Tethering__SensorData * + tethering__sensor_data__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void injector__sensor_data__free_unpacked - (Injector__SensorData *message, +void tethering__sensor_data__free_unpacked + (Tethering__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, +/* Tethering__SensorMsg methods */ +void tethering__sensor_msg__init + (Tethering__SensorMsg *message); +size_t tethering__sensor_msg__get_packed_size + (const Tethering__SensorMsg *message); +size_t tethering__sensor_msg__pack + (const Tethering__SensorMsg *message, uint8_t *out); -size_t injector__sensor_msg__pack_to_buffer - (const Injector__SensorMsg *message, +size_t tethering__sensor_msg__pack_to_buffer + (const Tethering__SensorMsg *message, ProtobufCBuffer *buffer); -Injector__SensorMsg * - injector__sensor_msg__unpack +Tethering__SensorMsg * + tethering__sensor_msg__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void injector__sensor_msg__free_unpacked - (Injector__SensorMsg *message, +void tethering__sensor_msg__free_unpacked + (Tethering__SensorMsg *message, ProtobufCAllocator *allocator); -/* Injector__Resolution methods */ -void injector__resolution__init - (Injector__Resolution *message); -size_t injector__resolution__get_packed_size - (const Injector__Resolution *message); -size_t injector__resolution__pack - (const Injector__Resolution *message, +/* Tethering__Resolution methods */ +void tethering__resolution__init + (Tethering__Resolution *message); +size_t tethering__resolution__get_packed_size + (const Tethering__Resolution *message); +size_t tethering__resolution__pack + (const Tethering__Resolution *message, uint8_t *out); -size_t injector__resolution__pack_to_buffer - (const Injector__Resolution *message, +size_t tethering__resolution__pack_to_buffer + (const Tethering__Resolution *message, ProtobufCBuffer *buffer); -Injector__Resolution * - injector__resolution__unpack +Tethering__Resolution * + tethering__resolution__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void injector__resolution__free_unpacked - (Injector__Resolution *message, +void tethering__resolution__free_unpacked + (Tethering__Resolution *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, +/* Tethering__MultiTouchMaxCount methods */ +void tethering__multi_touch_max_count__init + (Tethering__MultiTouchMaxCount *message); +size_t tethering__multi_touch_max_count__get_packed_size + (const Tethering__MultiTouchMaxCount *message); +size_t tethering__multi_touch_max_count__pack + (const Tethering__MultiTouchMaxCount *message, uint8_t *out); -size_t injector__multi_touch_max_count__pack_to_buffer - (const Injector__MultiTouchMaxCount *message, +size_t tethering__multi_touch_max_count__pack_to_buffer + (const Tethering__MultiTouchMaxCount *message, ProtobufCBuffer *buffer); -Injector__MultiTouchMaxCount * - injector__multi_touch_max_count__unpack +Tethering__MultiTouchMaxCount * + tethering__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, +void tethering__multi_touch_max_count__free_unpacked + (Tethering__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, +/* Tethering__MultiTouchData methods */ +void tethering__multi_touch_data__init + (Tethering__MultiTouchData *message); +size_t tethering__multi_touch_data__get_packed_size + (const Tethering__MultiTouchData *message); +size_t tethering__multi_touch_data__pack + (const Tethering__MultiTouchData *message, uint8_t *out); -size_t injector__multi_touch_data__pack_to_buffer - (const Injector__MultiTouchData *message, +size_t tethering__multi_touch_data__pack_to_buffer + (const Tethering__MultiTouchData *message, ProtobufCBuffer *buffer); -Injector__MultiTouchData * - injector__multi_touch_data__unpack +Tethering__MultiTouchData * + tethering__multi_touch_data__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void injector__multi_touch_data__free_unpacked - (Injector__MultiTouchData *message, +void tethering__multi_touch_data__free_unpacked + (Tethering__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, +/* Tethering__MultiTouchMsg methods */ +void tethering__multi_touch_msg__init + (Tethering__MultiTouchMsg *message); +size_t tethering__multi_touch_msg__get_packed_size + (const Tethering__MultiTouchMsg *message); +size_t tethering__multi_touch_msg__pack + (const Tethering__MultiTouchMsg *message, uint8_t *out); -size_t injector__multi_touch_msg__pack_to_buffer - (const Injector__MultiTouchMsg *message, +size_t tethering__multi_touch_msg__pack_to_buffer + (const Tethering__MultiTouchMsg *message, ProtobufCBuffer *buffer); -Injector__MultiTouchMsg * - injector__multi_touch_msg__unpack +Tethering__MultiTouchMsg * + tethering__multi_touch_msg__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void injector__multi_touch_msg__free_unpacked - (Injector__MultiTouchMsg *message, +void tethering__multi_touch_msg__free_unpacked + (Tethering__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, +/* Tethering__TetheringMsg methods */ +void tethering__tethering_msg__init + (Tethering__TetheringMsg *message); +size_t tethering__tethering_msg__get_packed_size + (const Tethering__TetheringMsg *message); +size_t tethering__tethering_msg__pack + (const Tethering__TetheringMsg *message, uint8_t *out); -size_t injector__injector_msg__pack_to_buffer - (const Injector__InjectorMsg *message, +size_t tethering__tethering_msg__pack_to_buffer + (const Tethering__TetheringMsg *message, ProtobufCBuffer *buffer); -Injector__InjectorMsg * - injector__injector_msg__unpack +Tethering__TetheringMsg * + tethering__tethering_msg__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void injector__injector_msg__free_unpacked - (Injector__InjectorMsg *message, +void tethering__tethering_msg__free_unpacked + (Tethering__TetheringMsg *message, ProtobufCAllocator *allocator); /* --- per-message closures --- */ -typedef void (*Injector__HandShakeReq_Closure) - (const Injector__HandShakeReq *message, +typedef void (*Tethering__HandShakeReq_Closure) + (const Tethering__HandShakeReq *message, void *closure_data); -typedef void (*Injector__HandShakeAns_Closure) - (const Injector__HandShakeAns *message, +typedef void (*Tethering__HandShakeAns_Closure) + (const Tethering__HandShakeAns *message, void *closure_data); -typedef void (*Injector__EmulatorState_Closure) - (const Injector__EmulatorState *message, +typedef void (*Tethering__EmulatorState_Closure) + (const Tethering__EmulatorState *message, void *closure_data); -typedef void (*Injector__AppState_Closure) - (const Injector__AppState *message, +typedef void (*Tethering__AppState_Closure) + (const Tethering__AppState *message, void *closure_data); -typedef void (*Injector__StartReq_Closure) - (const Injector__StartReq *message, +typedef void (*Tethering__StartReq_Closure) + (const Tethering__StartReq *message, void *closure_data); -typedef void (*Injector__StartAns_Closure) - (const Injector__StartAns *message, +typedef void (*Tethering__StartAns_Closure) + (const Tethering__StartAns *message, void *closure_data); -typedef void (*Injector__SetEventStatus_Closure) - (const Injector__SetEventStatus *message, +typedef void (*Tethering__SetEventStatus_Closure) + (const Tethering__SetEventStatus *message, void *closure_data); -typedef void (*Injector__EventMsg_Closure) - (const Injector__EventMsg *message, +typedef void (*Tethering__EventMsg_Closure) + (const Tethering__EventMsg *message, void *closure_data); -typedef void (*Injector__EventTerminate_Closure) - (const Injector__EventTerminate *message, +typedef void (*Tethering__EventTerminate_Closure) + (const Tethering__EventTerminate *message, void *closure_data); -typedef void (*Injector__SetSensorStatus_Closure) - (const Injector__SetSensorStatus *message, +typedef void (*Tethering__SetSensorStatus_Closure) + (const Tethering__SetSensorStatus *message, void *closure_data); -typedef void (*Injector__SensorData_Closure) - (const Injector__SensorData *message, +typedef void (*Tethering__SensorData_Closure) + (const Tethering__SensorData *message, void *closure_data); -typedef void (*Injector__SensorMsg_Closure) - (const Injector__SensorMsg *message, +typedef void (*Tethering__SensorMsg_Closure) + (const Tethering__SensorMsg *message, void *closure_data); -typedef void (*Injector__Resolution_Closure) - (const Injector__Resolution *message, +typedef void (*Tethering__Resolution_Closure) + (const Tethering__Resolution *message, void *closure_data); -typedef void (*Injector__MultiTouchMaxCount_Closure) - (const Injector__MultiTouchMaxCount *message, +typedef void (*Tethering__MultiTouchMaxCount_Closure) + (const Tethering__MultiTouchMaxCount *message, void *closure_data); -typedef void (*Injector__MultiTouchData_Closure) - (const Injector__MultiTouchData *message, +typedef void (*Tethering__MultiTouchData_Closure) + (const Tethering__MultiTouchData *message, void *closure_data); -typedef void (*Injector__MultiTouchMsg_Closure) - (const Injector__MultiTouchMsg *message, +typedef void (*Tethering__MultiTouchMsg_Closure) + (const Tethering__MultiTouchMsg *message, void *closure_data); -typedef void (*Injector__InjectorMsg_Closure) - (const Injector__InjectorMsg *message, +typedef void (*Tethering__TetheringMsg_Closure) + (const Tethering__TetheringMsg *message, void *closure_data); /* --- services --- */ @@ -680,33 +680,33 @@ typedef void (*Injector__InjectorMsg_Closure) /* --- 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__resolution__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; +extern const ProtobufCEnumDescriptor tethering__message_result__descriptor; +extern const ProtobufCEnumDescriptor tethering__connection_state__descriptor; +extern const ProtobufCEnumDescriptor tethering__event_type__descriptor; +extern const ProtobufCEnumDescriptor tethering__state__descriptor; +extern const ProtobufCEnumDescriptor tethering__sensor_type__descriptor; +extern const ProtobufCEnumDescriptor tethering__touch_state__descriptor; +extern const ProtobufCMessageDescriptor tethering__hand_shake_req__descriptor; +extern const ProtobufCMessageDescriptor tethering__hand_shake_ans__descriptor; +extern const ProtobufCMessageDescriptor tethering__emulator_state__descriptor; +extern const ProtobufCMessageDescriptor tethering__app_state__descriptor; +extern const ProtobufCMessageDescriptor tethering__start_req__descriptor; +extern const ProtobufCMessageDescriptor tethering__start_ans__descriptor; +extern const ProtobufCMessageDescriptor tethering__set_event_status__descriptor; +extern const ProtobufCMessageDescriptor tethering__event_msg__descriptor; +extern const ProtobufCEnumDescriptor tethering__event_msg__type__descriptor; +extern const ProtobufCMessageDescriptor tethering__event_terminate__descriptor; +extern const ProtobufCMessageDescriptor tethering__set_sensor_status__descriptor; +extern const ProtobufCMessageDescriptor tethering__sensor_data__descriptor; +extern const ProtobufCMessageDescriptor tethering__sensor_msg__descriptor; +extern const ProtobufCEnumDescriptor tethering__sensor_msg__type__descriptor; +extern const ProtobufCMessageDescriptor tethering__resolution__descriptor; +extern const ProtobufCMessageDescriptor tethering__multi_touch_max_count__descriptor; +extern const ProtobufCMessageDescriptor tethering__multi_touch_data__descriptor; +extern const ProtobufCMessageDescriptor tethering__multi_touch_msg__descriptor; +extern const ProtobufCEnumDescriptor tethering__multi_touch_msg__type__descriptor; +extern const ProtobufCMessageDescriptor tethering__tethering_msg__descriptor; +extern const ProtobufCEnumDescriptor tethering__tethering_msg__type__descriptor; PROTOBUF_C_END_DECLS diff --git a/tizen/src/tethering/msg/tethering.proto b/tizen/src/tethering/msg/tethering.proto index d4d014f..cf08eee 100644 --- a/tizen/src/tethering/msg/tethering.proto +++ b/tizen/src/tethering/msg/tethering.proto @@ -1,32 +1,60 @@ -package injector; +package tethering; -option java_package = "event.injector.genmsg"; +option java_package = "device.tethering.genmsg"; -enum Result { +// define value + +enum MessageResult { SUCCESS = 1; FAILURE = 2; CANCEL = 3; } +enum ConnectionState { + CONNECTED = 1; + DISCONNECTED = 2; + TERMINATED = 3; +} + +enum EventType { + SENSOR = 1; + TOUCH = 2; +} + +enum State { + ENABLED = 1; + DISABLED = 2; +} + +enum SensorType{ + ACCEL = 1; + MAGNETIC = 2; + GYROSCOPE = 3; + PROXIMITY = 4; + LIGHT = 5; +} + +enum TouchState { + PRESSED = 1; + RELEASED = 2; +} + +// define messages + message HandShakeReq { required int32 key = 1; } message HandShakeAns { - required Result result = 1; + required MessageResult result = 1; } -enum ConnectionState { - CONNECT = 1; - DISCONNECT = 2; - TERMINATE = 3; -} message EmulatorState { required ConnectionState state = 1; } message AppState { - required ConnectionState state =1; + required ConnectionState state = 1; } message StartReq { @@ -34,22 +62,12 @@ message StartReq { } message StartAns { - required Result result = 1; -} - -enum Event { - SENSOR = 1; - MULTITOUCH = 2; -} - -enum Status { - ENABLE = 1; - DISABLE = 2; + required MessageResult result = 1; } message SetEventStatus { - required Event event = 1; - required Status status = 2; + required EventType type = 1; + required State state = 2; } message EventMsg { @@ -61,27 +79,19 @@ message EventMsg { } required TYPE type = 1; - optional StartReq startReq= 2; - optional StartAns startAns= 3; + optional StartReq startReq = 2; + optional StartAns startAns = 3; optional EventTerminate terminate = 4; - optional SetEventStatus setStatus= 5; + 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; + required SensorType type = 1; + required State state = 2; } message SensorData { @@ -103,8 +113,8 @@ message SensorMsg { required Type type = 1; optional StartReq startReq= 2; optional StartAns startAns= 3; - optional EventTerminate terminate= 4; - optional SetSensorStatus setStatus= 5; + optional EventTerminate terminate = 4; + optional SetSensorStatus setStatus = 5; optional SensorData data = 6; } @@ -117,16 +127,11 @@ 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; + optional TouchState state = 4; } message MultiTouchMsg { @@ -139,15 +144,15 @@ message MultiTouchMsg { RESOLUTION = 7; } required Type type = 1; - optional StartReq startReq= 2; - optional StartAns startAns= 3; - optional EventTerminate terminate= 4; + optional StartReq startReq = 2; + optional StartAns startAns = 3; + optional EventTerminate terminate = 4; optional MultiTouchMaxCount maxCount = 5; optional MultiTouchData touchData = 6; optional Resolution resolution = 7; } -message InjectorMsg { +message TetheringMsg { enum Type { HANDSHAKE_REQ = 2; HANDSHAKE_ANS = 3; @@ -166,4 +171,3 @@ message InjectorMsg { optional SensorMsg sensorMsg = 7; optional MultiTouchMsg touchMsg = 8; } - -- 2.7.4