From 1f28eb7c99bc4c2c78f6f2c3c83d606674669472 Mon Sep 17 00:00:00 2001 From: DaiYoung Kim Date: Sun, 28 Jul 2013 16:39:13 +0900 Subject: [PATCH] ecs: modify protocol Signed-off-by: DaiYoung, Kim --- tizen/src/ecs.c | 22 +-- tizen/src/ecs.h | 8 +- tizen/src/ecs_msg.c | 104 +++++------- tizen/src/genmsg/ecs.pb-c.c | 324 +++++++++++++++++++++++++++++++----- tizen/src/genmsg/ecs.pb-c.h | 127 +++++++++++--- tizen/src/msg/ecs.proto | 32 +++- 6 files changed, 463 insertions(+), 154 deletions(-) diff --git a/tizen/src/ecs.c b/tizen/src/ecs.c index cec64603e4..4d94deacfd 100644 --- a/tizen/src/ecs.c +++ b/tizen/src/ecs.c @@ -780,20 +780,6 @@ static bool injector_command_proc(ECS_Client *clii, QObject *obj) { return true; } -static bool control_command_proc(ECS_Client *clii, QObject *obj) { - int64_t control_type = qdict_get_int(qobject_to_qdict(obj), "control_type"); - - QDict* data = qdict_get_qdict(qobject_to_qdict(obj), "data"); - - if (control_type == CONTROL_COMMAND_HOST_KEYBOARD_ONOFF_REQ) { - control_host_keyboard_onoff_req(clii, data); - } else if (control_type == CONTROL_COMMAND_SCREENSHOT_REQ) { - - } - //LOG(">> control : feature = %s, action=%d, data=%s", feature, action, data); - - return true; -} static bool device_command_proc(ECS_Client *clii, QObject *obj) { QDict* header = qdict_get_qdict(qobject_to_qdict(obj), "header"); @@ -902,7 +888,7 @@ static void handle_ecs_command(JSONMessageParser *parser, QList *tokens, } else if (!strcmp(type_name, COMMAND_TYPE_INJECTOR)) { injector_command_proc(clii, obj); } else if (!strcmp(type_name, COMMAND_TYPE_CONTROL)) { - control_command_proc(clii, obj); + //control_command_proc(clii, obj); } else if (!strcmp(type_name, COMMAND_TYPE_MONITOR)) { handle_qmp_command(clii, type_name, get_data_object(obj)); } else if (!strcmp(type_name, COMMAND_TYPE_DEVICE)) { @@ -1431,12 +1417,12 @@ bool handle_protobuf_msg(ECS_Client* cli, char* data, int len) goto fail; msgproc_injector_req(cli, msg); } - else if (master->type == ECS__MASTER__TYPE__CONTROL_REQ) + else if (master->type == ECS__MASTER__TYPE__CONTROL_MSG) { - ECS__ControlReq* msg = master->control_req; + ECS__ControlMsg* msg = master->control_msg; if (!msg) goto fail; - msgproc_control_req(cli, msg); + msgproc_control_msg(cli, msg); } else if (master->type == ECS__MASTER__TYPE__MONITOR_REQ) { diff --git a/tizen/src/ecs.h b/tizen/src/ecs.h index cff0657bc6..b912d59b99 100644 --- a/tizen/src/ecs.h +++ b/tizen/src/ecs.h @@ -148,6 +148,7 @@ bool send_start_ans(int host_keyboard_onff); bool send_injector_ntf(const char* data, const int len); bool send_control_ntf(const char* data, const int len); bool send_monitor_ntf(const char* data, const int len); +bool send_hostkeyboard_ntf(int is_on); bool send_to_all_client(const char* data, const int len); void send_to_client(int fd, const char* data, const int len) ; @@ -162,7 +163,7 @@ void read_val_str(const char* data, char* ret_val, int len); bool msgproc_start_req(ECS_Client* ccli, ECS__StartReq* msg); bool msgproc_injector_req(ECS_Client* ccli, ECS__InjectorReq* msg); -bool msgproc_control_req(ECS_Client *ccli, ECS__ControlReq* msg); +bool msgproc_control_msg(ECS_Client *cli, ECS__ControlMsg* msg); bool msgproc_monitor_req(ECS_Client *ccli, ECS__MonitorReq* msg); bool msgproc_screen_dump_req(ECS_Client *ccli, ECS__ScreenDumpReq* msg); @@ -172,9 +173,8 @@ enum{ CONTROL_COMMAND_SCREENSHOT_REQ = 2 }; -// messages -//void ecs_startinfo_req(ECS_Client *clii); -void control_host_keyboard_onoff_req(ECS_Client *clii, QDict* data); +// control sub messages +void msgproc_control_hostkeyboard_req(ECS_Client *cli, ECS__HostKeyboardReq* req); void set_sensor_data(int length, const char* data); diff --git a/tizen/src/ecs_msg.c b/tizen/src/ecs_msg.c index 98a15b68ca..7f3ccb7bbe 100644 --- a/tizen/src/ecs_msg.c +++ b/tizen/src/ecs_msg.c @@ -140,8 +140,15 @@ bool msgproc_injector_req(ECS_Client* ccli, ECS__InjectorReq* msg) return true; } -bool msgproc_control_req(ECS_Client *ccli, ECS__ControlReq* msg) +bool msgproc_control_msg(ECS_Client *cli, ECS__ControlMsg* msg) { + if (msg->type == ECS__CONTROL_MSG__CONTROL_TYPE__HOSTKEYBOARD_REQ) + { + ECS__HostKeyboardReq* hkr = msg->hostkeyboard_req; + if (!hkr) + return false; + msgproc_control_hostkeyboard_req(cli, hkr); + } return true; } @@ -158,74 +165,16 @@ bool msgproc_screen_dump_req(ECS_Client *ccli, ECS__ScreenDumpReq* msg) return true; } -/* -void ecs_startinfo_req(ECS_Client *clii) -{ - LOG("ecs_startinfo_req"); - - int usbkbd_status = mloop_evcmd_get_hostkbd_status(); - - LOG("usbkbd_status = %d", usbkbd_status); - - - QDict* objData = qdict_new(); - qdict_put(objData, "host_keyboard_onoff", qint_from_int((int64_t )usbkbd_status)); - - QDict* objMsg = qdict_new(); - qobject_incref(QOBJECT(objData)); - - qdict_put(objMsg, "type", qstring_from_str(ECS_MSG_STARTINFO_ANS)); - qdict_put(objMsg, "result", qstring_from_str("success")); - qdict_put(objMsg, "data", objData); - - QString *json; - json = qobject_to_json(QOBJECT(objMsg)); - - assert(json != NULL); - - qstring_append_chr(json, '\n'); - const char* snddata = qstring_get_str(json); - - LOG("<< startinfo json str = %s", snddata); - - send_to_client(clii->client_fd, snddata); - - QDECREF(json); - QDECREF(objData); - QDECREF(objMsg); -} -*/ +// begin control command -void control_host_keyboard_onoff_req(ECS_Client *clii, QDict* data) +void msgproc_control_hostkeyboard_req(ECS_Client *clii, ECS__HostKeyboardReq* req) { - int64_t is_on = qdict_get_int(data, "is_on"); + int64_t is_on = req->ison; onoff_host_kbd(is_on); } -void host_keyboard_onoff_ntf(int is_on) -{ - QDict* objMsg = qdict_new(); - - qdict_put(objMsg, "type", qstring_from_str("host_keyboard_onoff_ntf")); - qdict_put(objMsg, "ison", qbool_from_int((int64_t)is_on)); - - QString *json; - json = qobject_to_json(QOBJECT(objMsg)); - - assert(json != NULL); - - qstring_append_chr(json, '\n'); - const char* snddata = qstring_get_str(json); - - LOG("<< json str = %s", snddata); - - send_to_all_client(snddata, strlen(snddata)); - - QDECREF(json); - - QDECREF(objMsg); -} +// end control command // @@ -302,8 +251,16 @@ bool send_start_ans(int host_keyboard_onff) ECS__Master master = ECS__MASTER__INIT; ECS__StartAns ans = ECS__START_ANS__INIT; + ans.has_host_keyboard_onoff = 1; ans.host_keyboard_onoff = host_keyboard_onff; + ans.has_camera_onoff = 1; + ans.camera_onoff = 1; + + ans.has_earjack_onoff = 1; + ans.earjack_onoff = 1; + + master.type = ECS__MASTER__TYPE__START_ANS; master.start_ans = &ans; return send_to_ecp(&master); @@ -364,3 +321,24 @@ bool send_injector_ntf(const char* data, const int len) return true; } + + +bool send_hostkeyboard_ntf(int is_on) +{ + ECS__Master master = ECS__MASTER__INIT; + ECS__ControlMsg ctl = ECS__CONTROL_MSG__INIT; + + ECS__HostKeyboardNtf ntf = ECS__HOST_KEYBOARD_NTF__INIT; + + ntf.has_ison = 1; + ntf.ison = is_on; + + ctl.type = ECS__CONTROL_MSG__CONTROL_TYPE__HOSTKEYBOARD_NTF; + ctl.hostkeyboard_ntf = &ntf; + + master.type = ECS__MASTER__TYPE__CONTROL_MSG; + master.control_msg = &ctl; + + return send_to_ecp(&master); +} + diff --git a/tizen/src/genmsg/ecs.pb-c.c b/tizen/src/genmsg/ecs.pb-c.c index d556c7e654..536571dd1c 100644 --- a/tizen/src/genmsg/ecs.pb-c.c +++ b/tizen/src/genmsg/ecs.pb-c.c @@ -522,47 +522,133 @@ void ecs__device_ntf__free_unpacked PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__device_ntf__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void ecs__control_req__init - (ECS__ControlReq *message) +void ecs__host_keyboard_req__init + (ECS__HostKeyboardReq *message) { - static ECS__ControlReq init_value = ECS__CONTROL_REQ__INIT; + static ECS__HostKeyboardReq init_value = ECS__HOST_KEYBOARD_REQ__INIT; *message = init_value; } -size_t ecs__control_req__get_packed_size - (const ECS__ControlReq *message) +size_t ecs__host_keyboard_req__get_packed_size + (const ECS__HostKeyboardReq *message) { - PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__control_req__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__host_keyboard_req__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t ecs__control_req__pack - (const ECS__ControlReq *message, +size_t ecs__host_keyboard_req__pack + (const ECS__HostKeyboardReq *message, uint8_t *out) { - PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__control_req__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__host_keyboard_req__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t ecs__control_req__pack_to_buffer - (const ECS__ControlReq *message, +size_t ecs__host_keyboard_req__pack_to_buffer + (const ECS__HostKeyboardReq *message, ProtobufCBuffer *buffer) { - PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__control_req__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__host_keyboard_req__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -ECS__ControlReq * - ecs__control_req__unpack +ECS__HostKeyboardReq * + ecs__host_keyboard_req__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (ECS__ControlReq *) - protobuf_c_message_unpack (&ecs__control_req__descriptor, + return (ECS__HostKeyboardReq *) + protobuf_c_message_unpack (&ecs__host_keyboard_req__descriptor, allocator, len, data); } -void ecs__control_req__free_unpacked - (ECS__ControlReq *message, +void ecs__host_keyboard_req__free_unpacked + (ECS__HostKeyboardReq *message, ProtobufCAllocator *allocator) { - PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__control_req__descriptor); + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__host_keyboard_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void ecs__host_keyboard_ntf__init + (ECS__HostKeyboardNtf *message) +{ + static ECS__HostKeyboardNtf init_value = ECS__HOST_KEYBOARD_NTF__INIT; + *message = init_value; +} +size_t ecs__host_keyboard_ntf__get_packed_size + (const ECS__HostKeyboardNtf *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__host_keyboard_ntf__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t ecs__host_keyboard_ntf__pack + (const ECS__HostKeyboardNtf *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__host_keyboard_ntf__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t ecs__host_keyboard_ntf__pack_to_buffer + (const ECS__HostKeyboardNtf *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__host_keyboard_ntf__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +ECS__HostKeyboardNtf * + ecs__host_keyboard_ntf__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (ECS__HostKeyboardNtf *) + protobuf_c_message_unpack (&ecs__host_keyboard_ntf__descriptor, + allocator, len, data); +} +void ecs__host_keyboard_ntf__free_unpacked + (ECS__HostKeyboardNtf *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__host_keyboard_ntf__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void ecs__control_msg__init + (ECS__ControlMsg *message) +{ + static ECS__ControlMsg init_value = ECS__CONTROL_MSG__INIT; + *message = init_value; +} +size_t ecs__control_msg__get_packed_size + (const ECS__ControlMsg *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__control_msg__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t ecs__control_msg__pack + (const ECS__ControlMsg *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__control_msg__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t ecs__control_msg__pack_to_buffer + (const ECS__ControlMsg *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__control_msg__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +ECS__ControlMsg * + ecs__control_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (ECS__ControlMsg *) + protobuf_c_message_unpack (&ecs__control_msg__descriptor, + allocator, len, data); +} +void ecs__control_msg__free_unpacked + (ECS__ControlMsg *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &ecs__control_msg__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } void ecs__control_ans__init @@ -1751,42 +1837,198 @@ const ProtobufCMessageDescriptor ecs__device_ntf__descriptor = (ProtobufCMessageInit) ecs__device_ntf__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor ecs__control_req__field_descriptors[1] = +static const ProtobufCFieldDescriptor ecs__host_keyboard_req__field_descriptors[1] = { { - "command", + "ison", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + PROTOBUF_C_OFFSETOF(ECS__HostKeyboardReq, has_ison), + PROTOBUF_C_OFFSETOF(ECS__HostKeyboardReq, ison), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned ecs__host_keyboard_req__field_indices_by_name[] = { + 0, /* field[0] = ison */ +}; +static const ProtobufCIntRange ecs__host_keyboard_req__number_ranges[1 + 1] = +{ + { 3, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor ecs__host_keyboard_req__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "ECS.HostKeyboardReq", + "HostKeyboardReq", + "ECS__HostKeyboardReq", + "ECS", + sizeof(ECS__HostKeyboardReq), + 1, + ecs__host_keyboard_req__field_descriptors, + ecs__host_keyboard_req__field_indices_by_name, + 1, ecs__host_keyboard_req__number_ranges, + (ProtobufCMessageInit) ecs__host_keyboard_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor ecs__host_keyboard_ntf__field_descriptors[3] = +{ + { + "errcode", 1, PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__HostKeyboardNtf, errcode), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "errstr", + 2, + PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(ECS__ControlReq, command), + PROTOBUF_C_OFFSETOF(ECS__HostKeyboardNtf, errstr), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ison", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + PROTOBUF_C_OFFSETOF(ECS__HostKeyboardNtf, has_ison), + PROTOBUF_C_OFFSETOF(ECS__HostKeyboardNtf, ison), NULL, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned ecs__control_req__field_indices_by_name[] = { - 0, /* field[0] = command */ +static const unsigned ecs__host_keyboard_ntf__field_indices_by_name[] = { + 0, /* field[0] = errcode */ + 1, /* field[1] = errstr */ + 2, /* field[2] = ison */ }; -static const ProtobufCIntRange ecs__control_req__number_ranges[1 + 1] = +static const ProtobufCIntRange ecs__host_keyboard_ntf__number_ranges[1 + 1] = { { 1, 0 }, - { 0, 1 } + { 0, 3 } }; -const ProtobufCMessageDescriptor ecs__control_req__descriptor = +const ProtobufCMessageDescriptor ecs__host_keyboard_ntf__descriptor = { PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, - "ECS.ControlReq", - "ControlReq", - "ECS__ControlReq", + "ECS.HostKeyboardNtf", + "HostKeyboardNtf", + "ECS__HostKeyboardNtf", "ECS", - sizeof(ECS__ControlReq), + sizeof(ECS__HostKeyboardNtf), + 3, + ecs__host_keyboard_ntf__field_descriptors, + ecs__host_keyboard_ntf__field_indices_by_name, + 1, ecs__host_keyboard_ntf__number_ranges, + (ProtobufCMessageInit) ecs__host_keyboard_ntf__init, + NULL,NULL,NULL /* reserved[123] */ +}; +const ProtobufCEnumValue ecs__control_msg__control_type__enum_values_by_number[2] = +{ + { "HOSTKEYBOARD_REQ", "ECS__CONTROL_MSG__CONTROL_TYPE__HOSTKEYBOARD_REQ", 2 }, + { "HOSTKEYBOARD_NTF", "ECS__CONTROL_MSG__CONTROL_TYPE__HOSTKEYBOARD_NTF", 3 }, +}; +static const ProtobufCIntRange ecs__control_msg__control_type__value_ranges[] = { +{2, 0},{0, 2} +}; +const ProtobufCEnumValueIndex ecs__control_msg__control_type__enum_values_by_name[2] = +{ + { "HOSTKEYBOARD_NTF", 1 }, + { "HOSTKEYBOARD_REQ", 0 }, +}; +const ProtobufCEnumDescriptor ecs__control_msg__control_type__descriptor = +{ + PROTOBUF_C_ENUM_DESCRIPTOR_MAGIC, + "ECS.ControlMsg.ControlType", + "ControlType", + "ECS__ControlMsg__ControlType", + "ECS", + 2, + ecs__control_msg__control_type__enum_values_by_number, + 2, + ecs__control_msg__control_type__enum_values_by_name, 1, - ecs__control_req__field_descriptors, - ecs__control_req__field_indices_by_name, - 1, ecs__control_req__number_ranges, - (ProtobufCMessageInit) ecs__control_req__init, + ecs__control_msg__control_type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCFieldDescriptor ecs__control_msg__field_descriptors[3] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__ControlMsg, type), + &ecs__control_msg__control_type__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "hostkeyboard_req", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__ControlMsg, hostkeyboard_req), + &ecs__host_keyboard_req__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "hostkeyboard_ntf", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(ECS__ControlMsg, hostkeyboard_ntf), + &ecs__host_keyboard_ntf__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned ecs__control_msg__field_indices_by_name[] = { + 2, /* field[2] = hostkeyboard_ntf */ + 1, /* field[1] = hostkeyboard_req */ + 0, /* field[0] = type */ +}; +static const ProtobufCIntRange ecs__control_msg__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor ecs__control_msg__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "ECS.ControlMsg", + "ControlMsg", + "ECS__ControlMsg", + "ECS", + sizeof(ECS__ControlMsg), + 3, + ecs__control_msg__field_descriptors, + ecs__control_msg__field_indices_by_name, + 1, ecs__control_msg__number_ranges, + (ProtobufCMessageInit) ecs__control_msg__init, NULL,NULL,NULL /* reserved[123] */ }; static const ProtobufCFieldDescriptor ecs__control_ans__field_descriptors[2] = @@ -2173,7 +2415,7 @@ const ProtobufCEnumValue ecs__master__type__enum_values_by_number[20] = { "DEVICE_REQ", "ECS__MASTER__TYPE__DEVICE_REQ", 11 }, { "DEVICE_ANS", "ECS__MASTER__TYPE__DEVICE_ANS", 12 }, { "DEVICE_NTF", "ECS__MASTER__TYPE__DEVICE_NTF", 13 }, - { "CONTROL_REQ", "ECS__MASTER__TYPE__CONTROL_REQ", 14 }, + { "CONTROL_MSG", "ECS__MASTER__TYPE__CONTROL_MSG", 14 }, { "CONTROL_ANS", "ECS__MASTER__TYPE__CONTROL_ANS", 15 }, { "CONTROL_NTF", "ECS__MASTER__TYPE__CONTROL_NTF", 16 }, { "MONITOR_REQ", "ECS__MASTER__TYPE__MONITOR_REQ", 17 }, @@ -2190,8 +2432,8 @@ const ProtobufCEnumValueIndex ecs__master__type__enum_values_by_name[20] = { "CHECKVERSION_ANS", 1 }, { "CHECKVERSION_REQ", 0 }, { "CONTROL_ANS", 13 }, + { "CONTROL_MSG", 12 }, { "CONTROL_NTF", 14 }, - { "CONTROL_REQ", 12 }, { "DEVICE_ANS", 10 }, { "DEVICE_NTF", 11 }, { "DEVICE_REQ", 9 }, @@ -2382,13 +2624,13 @@ static const ProtobufCFieldDescriptor ecs__master__field_descriptors[21] = 0,NULL,NULL /* reserved1,reserved2, etc */ }, { - "control_req", + "control_msg", 14, PROTOBUF_C_LABEL_OPTIONAL, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - PROTOBUF_C_OFFSETOF(ECS__Master, control_req), - &ecs__control_req__descriptor, + PROTOBUF_C_OFFSETOF(ECS__Master, control_msg), + &ecs__control_msg__descriptor, NULL, 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -2482,8 +2724,8 @@ static const unsigned ecs__master__field_indices_by_name[] = { 2, /* field[2] = checkversion_ans */ 1, /* field[1] = checkversion_req */ 14, /* field[14] = control_ans */ + 13, /* field[13] = control_msg */ 15, /* field[15] = control_ntf */ - 13, /* field[13] = control_req */ 11, /* field[11] = device_ans */ 12, /* field[12] = device_ntf */ 10, /* field[10] = device_req */ diff --git a/tizen/src/genmsg/ecs.pb-c.h b/tizen/src/genmsg/ecs.pb-c.h index fd91b4f999..25d3c4abce 100644 --- a/tizen/src/genmsg/ecs.pb-c.h +++ b/tizen/src/genmsg/ecs.pb-c.h @@ -20,7 +20,9 @@ typedef struct _ECS__InjectorNtf ECS__InjectorNtf; typedef struct _ECS__DeviceReq ECS__DeviceReq; typedef struct _ECS__DeviceAns ECS__DeviceAns; typedef struct _ECS__DeviceNtf ECS__DeviceNtf; -typedef struct _ECS__ControlReq ECS__ControlReq; +typedef struct _ECS__HostKeyboardReq ECS__HostKeyboardReq; +typedef struct _ECS__HostKeyboardNtf ECS__HostKeyboardNtf; +typedef struct _ECS__ControlMsg ECS__ControlMsg; typedef struct _ECS__ControlAns ECS__ControlAns; typedef struct _ECS__ControlNtf ECS__ControlNtf; typedef struct _ECS__MonitorReq ECS__MonitorReq; @@ -33,6 +35,10 @@ typedef struct _ECS__Master ECS__Master; /* --- enums --- */ +typedef enum _ECS__ControlMsg__ControlType { + ECS__CONTROL_MSG__CONTROL_TYPE__HOSTKEYBOARD_REQ = 2, + ECS__CONTROL_MSG__CONTROL_TYPE__HOSTKEYBOARD_NTF = 3 +} ECS__ControlMsg__ControlType; typedef enum _ECS__Master__Type { ECS__MASTER__TYPE__CHECKVERSION_REQ = 2, ECS__MASTER__TYPE__CHECKVERSION_ANS = 3, @@ -46,7 +52,7 @@ typedef enum _ECS__Master__Type { ECS__MASTER__TYPE__DEVICE_REQ = 11, ECS__MASTER__TYPE__DEVICE_ANS = 12, ECS__MASTER__TYPE__DEVICE_NTF = 13, - ECS__MASTER__TYPE__CONTROL_REQ = 14, + ECS__MASTER__TYPE__CONTROL_MSG = 14, ECS__MASTER__TYPE__CONTROL_ANS = 15, ECS__MASTER__TYPE__CONTROL_NTF = 16, ECS__MASTER__TYPE__MONITOR_REQ = 17, @@ -217,14 +223,40 @@ struct _ECS__DeviceNtf , NULL, 0, 0, 0, 0,{0,NULL} } -struct _ECS__ControlReq +struct _ECS__HostKeyboardReq { ProtobufCMessage base; - char *command; + protobuf_c_boolean has_ison; + int32_t ison; }; -#define ECS__CONTROL_REQ__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&ecs__control_req__descriptor) \ - , NULL } +#define ECS__HOST_KEYBOARD_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&ecs__host_keyboard_req__descriptor) \ + , 0,0 } + + +struct _ECS__HostKeyboardNtf +{ + ProtobufCMessage base; + int32_t errcode; + char *errstr; + protobuf_c_boolean has_ison; + int32_t ison; +}; +#define ECS__HOST_KEYBOARD_NTF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&ecs__host_keyboard_ntf__descriptor) \ + , 0, NULL, 0,0 } + + +struct _ECS__ControlMsg +{ + ProtobufCMessage base; + ECS__ControlMsg__ControlType type; + ECS__HostKeyboardReq *hostkeyboard_req; + ECS__HostKeyboardNtf *hostkeyboard_ntf; +}; +#define ECS__CONTROL_MSG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&ecs__control_msg__descriptor) \ + , 0, NULL, NULL } struct _ECS__ControlAns @@ -324,7 +356,7 @@ struct _ECS__Master ECS__DeviceReq *device_req; ECS__DeviceAns *device_ans; ECS__DeviceNtf *device_ntf; - ECS__ControlReq *control_req; + ECS__ControlMsg *control_msg; ECS__ControlAns *control_ans; ECS__ControlNtf *control_ntf; ECS__MonitorReq *monitor_req; @@ -566,24 +598,62 @@ ECS__DeviceNtf * void ecs__device_ntf__free_unpacked (ECS__DeviceNtf *message, ProtobufCAllocator *allocator); -/* ECS__ControlReq methods */ -void ecs__control_req__init - (ECS__ControlReq *message); -size_t ecs__control_req__get_packed_size - (const ECS__ControlReq *message); -size_t ecs__control_req__pack - (const ECS__ControlReq *message, +/* ECS__HostKeyboardReq methods */ +void ecs__host_keyboard_req__init + (ECS__HostKeyboardReq *message); +size_t ecs__host_keyboard_req__get_packed_size + (const ECS__HostKeyboardReq *message); +size_t ecs__host_keyboard_req__pack + (const ECS__HostKeyboardReq *message, uint8_t *out); -size_t ecs__control_req__pack_to_buffer - (const ECS__ControlReq *message, +size_t ecs__host_keyboard_req__pack_to_buffer + (const ECS__HostKeyboardReq *message, ProtobufCBuffer *buffer); -ECS__ControlReq * - ecs__control_req__unpack +ECS__HostKeyboardReq * + ecs__host_keyboard_req__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void ecs__control_req__free_unpacked - (ECS__ControlReq *message, +void ecs__host_keyboard_req__free_unpacked + (ECS__HostKeyboardReq *message, + ProtobufCAllocator *allocator); +/* ECS__HostKeyboardNtf methods */ +void ecs__host_keyboard_ntf__init + (ECS__HostKeyboardNtf *message); +size_t ecs__host_keyboard_ntf__get_packed_size + (const ECS__HostKeyboardNtf *message); +size_t ecs__host_keyboard_ntf__pack + (const ECS__HostKeyboardNtf *message, + uint8_t *out); +size_t ecs__host_keyboard_ntf__pack_to_buffer + (const ECS__HostKeyboardNtf *message, + ProtobufCBuffer *buffer); +ECS__HostKeyboardNtf * + ecs__host_keyboard_ntf__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void ecs__host_keyboard_ntf__free_unpacked + (ECS__HostKeyboardNtf *message, + ProtobufCAllocator *allocator); +/* ECS__ControlMsg methods */ +void ecs__control_msg__init + (ECS__ControlMsg *message); +size_t ecs__control_msg__get_packed_size + (const ECS__ControlMsg *message); +size_t ecs__control_msg__pack + (const ECS__ControlMsg *message, + uint8_t *out); +size_t ecs__control_msg__pack_to_buffer + (const ECS__ControlMsg *message, + ProtobufCBuffer *buffer); +ECS__ControlMsg * + ecs__control_msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void ecs__control_msg__free_unpacked + (ECS__ControlMsg *message, ProtobufCAllocator *allocator); /* ECS__ControlAns methods */ void ecs__control_ans__init @@ -775,8 +845,14 @@ typedef void (*ECS__DeviceAns_Closure) typedef void (*ECS__DeviceNtf_Closure) (const ECS__DeviceNtf *message, void *closure_data); -typedef void (*ECS__ControlReq_Closure) - (const ECS__ControlReq *message, +typedef void (*ECS__HostKeyboardReq_Closure) + (const ECS__HostKeyboardReq *message, + void *closure_data); +typedef void (*ECS__HostKeyboardNtf_Closure) + (const ECS__HostKeyboardNtf *message, + void *closure_data); +typedef void (*ECS__ControlMsg_Closure) + (const ECS__ControlMsg *message, void *closure_data); typedef void (*ECS__ControlAns_Closure) (const ECS__ControlAns *message, @@ -820,7 +896,10 @@ extern const ProtobufCMessageDescriptor ecs__injector_ntf__descriptor; extern const ProtobufCMessageDescriptor ecs__device_req__descriptor; extern const ProtobufCMessageDescriptor ecs__device_ans__descriptor; extern const ProtobufCMessageDescriptor ecs__device_ntf__descriptor; -extern const ProtobufCMessageDescriptor ecs__control_req__descriptor; +extern const ProtobufCMessageDescriptor ecs__host_keyboard_req__descriptor; +extern const ProtobufCMessageDescriptor ecs__host_keyboard_ntf__descriptor; +extern const ProtobufCMessageDescriptor ecs__control_msg__descriptor; +extern const ProtobufCEnumDescriptor ecs__control_msg__control_type__descriptor; extern const ProtobufCMessageDescriptor ecs__control_ans__descriptor; extern const ProtobufCMessageDescriptor ecs__control_ntf__descriptor; extern const ProtobufCMessageDescriptor ecs__monitor_req__descriptor; diff --git a/tizen/src/msg/ecs.proto b/tizen/src/msg/ecs.proto index 7c7daa7f63..c5f4442959 100644 --- a/tizen/src/msg/ecs.proto +++ b/tizen/src/msg/ecs.proto @@ -86,10 +86,34 @@ message DeviceNtf { } -message ControlReq { - required string command = 1; + +// control message + +message HostKeyboardReq { + optional int32 ison = 3; +} + +message HostKeyboardNtf { + + required int32 errcode = 1; + optional string errstr = 2; + optional int32 ison = 3; } +message ControlMsg { + + enum ControlType { + HOSTKEYBOARD_REQ = 2; HOSTKEYBOARD_NTF = 3; + } + + required ControlType type = 1; + + optional HostKeyboardReq hostkeyboard_req = 2; + optional HostKeyboardNtf hostkeyboard_ntf = 3; +} + +// + message ControlAns { required int32 errcode = 1; optional string errmsg = 2; @@ -134,7 +158,7 @@ message Master { START_REQ = 6; START_ANS = 7; INJECTOR_REQ = 8; INJECTOR_ANS = 9; INJECTOR_NTF = 10; DEVICE_REQ = 11; DEVICE_ANS = 12; DEVICE_NTF = 13; - CONTROL_REQ = 14; CONTROL_ANS = 15; CONTROL_NTF = 16; + CONTROL_MSG = 14; CONTROL_ANS = 15; CONTROL_NTF = 16; MONITOR_REQ = 17; MONITOR_ANS = 18; MONITOR_NTF = 19; SCREEN_DUMP_REQ = 20; SCREEN_DUMP_ANS = 21; } @@ -158,7 +182,7 @@ message Master { optional DeviceAns device_ans = 12; optional DeviceNtf device_ntf = 13; - optional ControlReq control_req = 14; + optional ControlMsg control_msg = 14; optional ControlAns control_ans = 15; optional ControlNtf control_ntf = 16; -- 2.34.1