diff --git a/app/src/control_msg.c b/app/src/control_msg.c index d093183a..e8ae4681 100644 --- a/app/src/control_msg.c +++ b/app/src/control_msg.c @@ -92,19 +92,19 @@ size_t sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) { buf[0] = msg->type; switch (msg->type) { - case CONTROL_MSG_TYPE_INJECT_KEYCODE: + case SC_CONTROL_MSG_TYPE_INJECT_KEYCODE: buf[1] = msg->inject_keycode.action; buffer_write32be(&buf[2], msg->inject_keycode.keycode); buffer_write32be(&buf[6], msg->inject_keycode.repeat); buffer_write32be(&buf[10], msg->inject_keycode.metastate); return 14; - case CONTROL_MSG_TYPE_INJECT_TEXT: { + case SC_CONTROL_MSG_TYPE_INJECT_TEXT: { size_t len = write_string(msg->inject_text.text, - CONTROL_MSG_INJECT_TEXT_MAX_LENGTH, &buf[1]); + SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH, &buf[1]); return 1 + len; } - case CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT: + case SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT: buf[1] = msg->inject_touch_event.action; buffer_write64be(&buf[2], msg->inject_touch_event.pointer_id); write_position(&buf[10], &msg->inject_touch_event.position); @@ -113,7 +113,7 @@ sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) { buffer_write16be(&buf[22], pressure); buffer_write32be(&buf[24], msg->inject_touch_event.buttons); return 28; - case CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT: + case SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT: write_position(&buf[1], &msg->inject_scroll_event.position); buffer_write32be(&buf[13], (uint32_t) msg->inject_scroll_event.hscroll); @@ -121,27 +121,26 @@ sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) { (uint32_t) msg->inject_scroll_event.vscroll); buffer_write32be(&buf[21], msg->inject_scroll_event.buttons); return 25; - case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON: + case SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON: buf[1] = msg->inject_keycode.action; return 2; - case CONTROL_MSG_TYPE_GET_CLIPBOARD: + case SC_CONTROL_MSG_TYPE_GET_CLIPBOARD: buf[1] = msg->get_clipboard.copy_key; return 2; - case CONTROL_MSG_TYPE_SET_CLIPBOARD: { + case SC_CONTROL_MSG_TYPE_SET_CLIPBOARD: buffer_write64be(&buf[1], msg->set_clipboard.sequence); buf[9] = !!msg->set_clipboard.paste; size_t len = write_string(msg->set_clipboard.text, - CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH, + SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH, &buf[10]); return 10 + len; - } - case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE: + case SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE: buf[1] = msg->set_screen_power_mode.mode; return 2; - case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL: - case CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL: - case CONTROL_MSG_TYPE_COLLAPSE_PANELS: - case CONTROL_MSG_TYPE_ROTATE_DEVICE: + case SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL: + case SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL: + case SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS: + case SC_CONTROL_MSG_TYPE_ROTATE_DEVICE: // no additional data return 1; default: @@ -154,17 +153,17 @@ void sc_control_msg_log(const struct sc_control_msg *msg) { #define LOG_CMSG(fmt, ...) LOGV("input: " fmt, ## __VA_ARGS__) switch (msg->type) { - case CONTROL_MSG_TYPE_INJECT_KEYCODE: + case SC_CONTROL_MSG_TYPE_INJECT_KEYCODE: LOG_CMSG("key %-4s code=%d repeat=%" PRIu32 " meta=%06lx", KEYEVENT_ACTION_LABEL(msg->inject_keycode.action), (int) msg->inject_keycode.keycode, msg->inject_keycode.repeat, (long) msg->inject_keycode.metastate); break; - case CONTROL_MSG_TYPE_INJECT_TEXT: + case SC_CONTROL_MSG_TYPE_INJECT_TEXT: LOG_CMSG("text \"%s\"", msg->inject_text.text); break; - case CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT: { + case SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT: { int action = msg->inject_touch_event.action & AMOTION_EVENT_ACTION_MASK; uint64_t id = msg->inject_touch_event.pointer_id; @@ -191,7 +190,7 @@ sc_control_msg_log(const struct sc_control_msg *msg) { } break; } - case CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT: + case SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT: LOG_CMSG("scroll position=%" PRIi32 ",%" PRIi32 " hscroll=%" PRIi32 " vscroll=%" PRIi32 " buttons=%06lx", msg->inject_scroll_event.position.point.x, @@ -200,34 +199,34 @@ sc_control_msg_log(const struct sc_control_msg *msg) { msg->inject_scroll_event.vscroll, (long) msg->inject_scroll_event.buttons); break; - case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON: + case SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON: LOG_CMSG("back-or-screen-on %s", KEYEVENT_ACTION_LABEL(msg->inject_keycode.action)); break; - case CONTROL_MSG_TYPE_GET_CLIPBOARD: + case SC_CONTROL_MSG_TYPE_GET_CLIPBOARD: LOG_CMSG("get clipboard copy_key=%s", copy_key_labels[msg->get_clipboard.copy_key]); break; - case CONTROL_MSG_TYPE_SET_CLIPBOARD: + case SC_CONTROL_MSG_TYPE_SET_CLIPBOARD: LOG_CMSG("clipboard %" PRIu64_ " %s \"%s\"", msg->set_clipboard.sequence, msg->set_clipboard.paste ? "paste" : "nopaste", msg->set_clipboard.text); break; - case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE: + case SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE: LOG_CMSG("power mode %s", SCREEN_POWER_MODE_LABEL(msg->set_screen_power_mode.mode)); break; - case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL: + case SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL: LOG_CMSG("expand notification panel"); break; - case CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL: + case SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL: LOG_CMSG("expand settings panel"); break; - case CONTROL_MSG_TYPE_COLLAPSE_PANELS: + case SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS: LOG_CMSG("collapse panels"); break; - case CONTROL_MSG_TYPE_ROTATE_DEVICE: + case SC_CONTROL_MSG_TYPE_ROTATE_DEVICE: LOG_CMSG("rotate device"); break; default: @@ -239,10 +238,10 @@ sc_control_msg_log(const struct sc_control_msg *msg) { void sc_control_msg_destroy(struct sc_control_msg *msg) { switch (msg->type) { - case CONTROL_MSG_TYPE_INJECT_TEXT: + case SC_CONTROL_MSG_TYPE_INJECT_TEXT: free(msg->inject_text.text); break; - case CONTROL_MSG_TYPE_SET_CLIPBOARD: + case SC_CONTROL_MSG_TYPE_SET_CLIPBOARD: free(msg->set_clipboard.text); break; default: diff --git a/app/src/control_msg.h b/app/src/control_msg.h index 2ac96064..fbe203d4 100644 --- a/app/src/control_msg.h +++ b/app/src/control_msg.h @@ -11,40 +11,40 @@ #include "android/keycodes.h" #include "coords.h" -#define CONTROL_MSG_MAX_SIZE (1 << 18) // 256k +#define SC_CONTROL_MSG_MAX_SIZE (1 << 18) // 256k -#define CONTROL_MSG_INJECT_TEXT_MAX_LENGTH 300 +#define SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH 300 // type: 1 byte; sequence: 8 bytes; paste flag: 1 byte; length: 4 bytes -#define CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH (CONTROL_MSG_MAX_SIZE - 14) +#define SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH (SC_CONTROL_MSG_MAX_SIZE - 14) #define POINTER_ID_MOUSE UINT64_C(-1) #define POINTER_ID_VIRTUAL_FINGER UINT64_C(-2) enum sc_control_msg_type { - CONTROL_MSG_TYPE_INJECT_KEYCODE, - CONTROL_MSG_TYPE_INJECT_TEXT, - CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT, - CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT, - CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON, - CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL, - CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL, - CONTROL_MSG_TYPE_COLLAPSE_PANELS, - CONTROL_MSG_TYPE_GET_CLIPBOARD, - CONTROL_MSG_TYPE_SET_CLIPBOARD, - CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE, - CONTROL_MSG_TYPE_ROTATE_DEVICE, + SC_CONTROL_MSG_TYPE_INJECT_KEYCODE, + SC_CONTROL_MSG_TYPE_INJECT_TEXT, + SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT, + SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT, + SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON, + SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL, + SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL, + SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS, + SC_CONTROL_MSG_TYPE_GET_CLIPBOARD, + SC_CONTROL_MSG_TYPE_SET_CLIPBOARD, + SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE, + SC_CONTROL_MSG_TYPE_ROTATE_DEVICE, }; -enum screen_power_mode { +enum sc_screen_power_mode { // see - SCREEN_POWER_MODE_OFF = 0, - SCREEN_POWER_MODE_NORMAL = 2, + SC_SCREEN_POWER_MODE_OFF = 0, + SC_SCREEN_POWER_MODE_NORMAL = 2, }; -enum get_clipboard_copy_key { - GET_CLIPBOARD_COPY_KEY_NONE, - GET_CLIPBOARD_COPY_KEY_COPY, - GET_CLIPBOARD_COPY_KEY_CUT, +enum sc_copy_key { + SC_COPY_KEY_NONE, + SC_COPY_KEY_COPY, + SC_COPY_KEY_CUT, }; struct sc_control_msg { @@ -77,7 +77,7 @@ struct sc_control_msg { // screen may only be turned on on ACTION_DOWN } back_or_screen_on; struct { - enum get_clipboard_copy_key copy_key; + enum sc_copy_key copy_key; } get_clipboard; struct { uint64_t sequence; @@ -85,7 +85,7 @@ struct sc_control_msg { bool paste; } set_clipboard; struct { - enum screen_power_mode mode; + enum sc_screen_power_mode mode; } set_screen_power_mode; }; }; diff --git a/app/src/controller.c b/app/src/controller.c index 9135d967..626a5e30 100644 --- a/app/src/controller.c +++ b/app/src/controller.c @@ -66,7 +66,7 @@ sc_controller_push_msg(struct sc_controller *controller, static bool process_msg(struct sc_controller *controller, const struct sc_control_msg *msg) { - static unsigned char serialized_msg[CONTROL_MSG_MAX_SIZE]; + static unsigned char serialized_msg[SC_CONTROL_MSG_MAX_SIZE]; size_t length = sc_control_msg_serialize(msg, serialized_msg); if (!length) { return false; diff --git a/app/src/input_manager.c b/app/src/input_manager.c index 28c74791..d623c5ae 100644 --- a/app/src/input_manager.c +++ b/app/src/input_manager.c @@ -161,7 +161,7 @@ send_keycode(struct sc_controller *controller, enum android_keycode keycode, enum sc_action action, const char *name) { // send DOWN event struct sc_control_msg msg; - msg.type = CONTROL_MSG_TYPE_INJECT_KEYCODE; + msg.type = SC_CONTROL_MSG_TYPE_INJECT_KEYCODE; msg.inject_keycode.action = action == SC_ACTION_DOWN ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP; @@ -215,7 +215,7 @@ static void press_back_or_turn_screen_on(struct sc_controller *controller, enum sc_action action) { struct sc_control_msg msg; - msg.type = CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON; + msg.type = SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON; msg.back_or_screen_on.action = action == SC_ACTION_DOWN ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP; @@ -228,7 +228,7 @@ press_back_or_turn_screen_on(struct sc_controller *controller, static void expand_notification_panel(struct sc_controller *controller) { struct sc_control_msg msg; - msg.type = CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL; + msg.type = SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL; if (!sc_controller_push_msg(controller, &msg)) { LOGW("Could not request 'expand notification panel'"); @@ -238,7 +238,7 @@ expand_notification_panel(struct sc_controller *controller) { static void expand_settings_panel(struct sc_controller *controller) { struct sc_control_msg msg; - msg.type = CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL; + msg.type = SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL; if (!sc_controller_push_msg(controller, &msg)) { LOGW("Could not request 'expand settings panel'"); @@ -248,7 +248,7 @@ expand_settings_panel(struct sc_controller *controller) { static void collapse_panels(struct sc_controller *controller) { struct sc_control_msg msg; - msg.type = CONTROL_MSG_TYPE_COLLAPSE_PANELS; + msg.type = SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS; if (!sc_controller_push_msg(controller, &msg)) { LOGW("Could not request 'collapse notification panel'"); @@ -257,9 +257,9 @@ collapse_panels(struct sc_controller *controller) { static bool get_device_clipboard(struct sc_controller *controller, - enum get_clipboard_copy_key copy_key) { + enum sc_copy_key copy_key) { struct sc_control_msg msg; - msg.type = CONTROL_MSG_TYPE_GET_CLIPBOARD; + msg.type = SC_CONTROL_MSG_TYPE_GET_CLIPBOARD; msg.get_clipboard.copy_key = copy_key; if (!sc_controller_push_msg(controller, &msg)) { @@ -287,7 +287,7 @@ set_device_clipboard(struct sc_controller *controller, bool paste, } struct sc_control_msg msg; - msg.type = CONTROL_MSG_TYPE_SET_CLIPBOARD; + msg.type = SC_CONTROL_MSG_TYPE_SET_CLIPBOARD; msg.set_clipboard.sequence = sequence; msg.set_clipboard.text = text_dup; msg.set_clipboard.paste = paste; @@ -303,9 +303,9 @@ set_device_clipboard(struct sc_controller *controller, bool paste, static void set_screen_power_mode(struct sc_controller *controller, - enum screen_power_mode mode) { + enum sc_screen_power_mode mode) { struct sc_control_msg msg; - msg.type = CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE; + msg.type = SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE; msg.set_screen_power_mode.mode = mode; if (!sc_controller_push_msg(controller, &msg)) { @@ -350,7 +350,7 @@ clipboard_paste(struct sc_controller *controller) { } struct sc_control_msg msg; - msg.type = CONTROL_MSG_TYPE_INJECT_TEXT; + msg.type = SC_CONTROL_MSG_TYPE_INJECT_TEXT; msg.inject_text.text = text_dup; if (!sc_controller_push_msg(controller, &msg)) { free(text_dup); @@ -361,7 +361,7 @@ clipboard_paste(struct sc_controller *controller) { static void rotate_device(struct sc_controller *controller) { struct sc_control_msg msg; - msg.type = CONTROL_MSG_TYPE_ROTATE_DEVICE; + msg.type = SC_CONTROL_MSG_TYPE_ROTATE_DEVICE; if (!sc_controller_push_msg(controller, &msg)) { LOGW("Could not request device rotation"); @@ -407,7 +407,7 @@ simulate_virtual_finger(struct sc_input_manager *im, bool up = action == AMOTION_EVENT_ACTION_UP; struct sc_control_msg msg; - msg.type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT; + msg.type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT; msg.inject_touch_event.action = action; msg.inject_touch_event.position.screen_size = im->screen->frame_size; msg.inject_touch_event.position.point = point; @@ -487,9 +487,9 @@ sc_input_manager_process_key(struct sc_input_manager *im, return; case SDLK_o: if (controller && !repeat && down) { - enum screen_power_mode mode = shift - ? SCREEN_POWER_MODE_NORMAL - : SCREEN_POWER_MODE_OFF; + enum sc_screen_power_mode mode = shift + ? SC_SCREEN_POWER_MODE_NORMAL + : SC_SCREEN_POWER_MODE_OFF; set_screen_power_mode(controller, mode); } return; @@ -517,14 +517,12 @@ sc_input_manager_process_key(struct sc_input_manager *im, return; case SDLK_c: if (controller && !shift && !repeat && down) { - get_device_clipboard(controller, - GET_CLIPBOARD_COPY_KEY_COPY); + get_device_clipboard(controller, SC_COPY_KEY_COPY); } return; case SDLK_x: if (controller && !shift && !repeat && down) { - get_device_clipboard(controller, - GET_CLIPBOARD_COPY_KEY_CUT); + get_device_clipboard(controller, SC_COPY_KEY_CUT); } return; case SDLK_v: diff --git a/app/src/keyboard_inject.c b/app/src/keyboard_inject.c index 7276d325..fe297310 100644 --- a/app/src/keyboard_inject.c +++ b/app/src/keyboard_inject.c @@ -248,7 +248,7 @@ convert_meta_state(uint16_t mod) { static bool convert_input_key(const struct sc_key_event *event, struct sc_control_msg *msg, enum sc_key_inject_mode key_inject_mode, uint32_t repeat) { - msg->type = CONTROL_MSG_TYPE_INJECT_KEYCODE; + msg->type = SC_CONTROL_MSG_TYPE_INJECT_KEYCODE; if (!convert_keycode(event->keycode, &msg->inject_keycode.keycode, event->mods_state, key_inject_mode)) { @@ -310,7 +310,7 @@ sc_key_processor_process_text(struct sc_key_processor *kp, } struct sc_control_msg msg; - msg.type = CONTROL_MSG_TYPE_INJECT_TEXT; + msg.type = SC_CONTROL_MSG_TYPE_INJECT_TEXT; msg.inject_text.text = strdup(event->text); if (!msg.inject_text.text) { LOGW("Could not strdup input text"); diff --git a/app/src/mouse_inject.c b/app/src/mouse_inject.c index 855aaa9f..2e89de9a 100644 --- a/app/src/mouse_inject.c +++ b/app/src/mouse_inject.c @@ -66,7 +66,7 @@ sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp, struct sc_mouse_inject *mi = DOWNCAST(mp); struct sc_control_msg msg = { - .type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT, + .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT, .inject_touch_event = { .action = AMOTION_EVENT_ACTION_MOVE, .pointer_id = POINTER_ID_MOUSE, @@ -87,7 +87,7 @@ sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp, struct sc_mouse_inject *mi = DOWNCAST(mp); struct sc_control_msg msg = { - .type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT, + .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT, .inject_touch_event = { .action = convert_mouse_action(event->action), .pointer_id = POINTER_ID_MOUSE, @@ -108,7 +108,7 @@ sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp, struct sc_mouse_inject *mi = DOWNCAST(mp); struct sc_control_msg msg = { - .type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT, + .type = SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT, .inject_scroll_event = { .position = event->position, .hscroll = event->hscroll, @@ -128,7 +128,7 @@ sc_mouse_processor_process_touch(struct sc_mouse_processor *mp, struct sc_mouse_inject *mi = DOWNCAST(mp); struct sc_control_msg msg = { - .type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT, + .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT, .inject_touch_event = { .action = convert_touch_action(event->action), .pointer_id = event->pointer_id, diff --git a/app/src/scrcpy.c b/app/src/scrcpy.c index 5f4455ba..1534c772 100644 --- a/app/src/scrcpy.c +++ b/app/src/scrcpy.c @@ -515,8 +515,8 @@ aoa_hid_end: if (options->turn_screen_off) { struct sc_control_msg msg; - msg.type = CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE; - msg.set_screen_power_mode.mode = SCREEN_POWER_MODE_OFF; + msg.type = SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE; + msg.set_screen_power_mode.mode = SC_SCREEN_POWER_MODE_OFF; if (!sc_controller_push_msg(&s->controller, &msg)) { LOGW("Could not request 'set screen power mode'"); diff --git a/app/tests/test_control_msg_serialize.c b/app/tests/test_control_msg_serialize.c index 95a54a98..72e3d87a 100644 --- a/app/tests/test_control_msg_serialize.c +++ b/app/tests/test_control_msg_serialize.c @@ -7,7 +7,7 @@ static void test_serialize_inject_keycode(void) { struct sc_control_msg msg = { - .type = CONTROL_MSG_TYPE_INJECT_KEYCODE, + .type = SC_CONTROL_MSG_TYPE_INJECT_KEYCODE, .inject_keycode = { .action = AKEY_EVENT_ACTION_UP, .keycode = AKEYCODE_ENTER, @@ -16,12 +16,12 @@ static void test_serialize_inject_keycode(void) { }, }; - unsigned char buf[CONTROL_MSG_MAX_SIZE]; + unsigned char buf[SC_CONTROL_MSG_MAX_SIZE]; size_t size = sc_control_msg_serialize(&msg, buf); assert(size == 14); const unsigned char expected[] = { - CONTROL_MSG_TYPE_INJECT_KEYCODE, + SC_CONTROL_MSG_TYPE_INJECT_KEYCODE, 0x01, // AKEY_EVENT_ACTION_UP 0x00, 0x00, 0x00, 0x42, // AKEYCODE_ENTER 0x00, 0x00, 0x00, 0X05, // repeat @@ -32,18 +32,18 @@ static void test_serialize_inject_keycode(void) { static void test_serialize_inject_text(void) { struct sc_control_msg msg = { - .type = CONTROL_MSG_TYPE_INJECT_TEXT, + .type = SC_CONTROL_MSG_TYPE_INJECT_TEXT, .inject_text = { .text = "hello, world!", }, }; - unsigned char buf[CONTROL_MSG_MAX_SIZE]; + unsigned char buf[SC_CONTROL_MSG_MAX_SIZE]; size_t size = sc_control_msg_serialize(&msg, buf); assert(size == 18); const unsigned char expected[] = { - CONTROL_MSG_TYPE_INJECT_TEXT, + SC_CONTROL_MSG_TYPE_INJECT_TEXT, 0x00, 0x00, 0x00, 0x0d, // text length 'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', // text }; @@ -52,30 +52,30 @@ static void test_serialize_inject_text(void) { static void test_serialize_inject_text_long(void) { struct sc_control_msg msg; - msg.type = CONTROL_MSG_TYPE_INJECT_TEXT; - char text[CONTROL_MSG_INJECT_TEXT_MAX_LENGTH + 1]; - memset(text, 'a', CONTROL_MSG_INJECT_TEXT_MAX_LENGTH); - text[CONTROL_MSG_INJECT_TEXT_MAX_LENGTH] = '\0'; + msg.type = SC_CONTROL_MSG_TYPE_INJECT_TEXT; + char text[SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH + 1]; + memset(text, 'a', SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH); + text[SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH] = '\0'; msg.inject_text.text = text; - unsigned char buf[CONTROL_MSG_MAX_SIZE]; + unsigned char buf[SC_CONTROL_MSG_MAX_SIZE]; size_t size = sc_control_msg_serialize(&msg, buf); - assert(size == 5 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH); + assert(size == 5 + SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH); - unsigned char expected[5 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH]; - expected[0] = CONTROL_MSG_TYPE_INJECT_TEXT; + unsigned char expected[5 + SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH]; + expected[0] = SC_CONTROL_MSG_TYPE_INJECT_TEXT; expected[1] = 0x00; expected[2] = 0x00; expected[3] = 0x01; expected[4] = 0x2c; // text length (32 bits) - memset(&expected[5], 'a', CONTROL_MSG_INJECT_TEXT_MAX_LENGTH); + memset(&expected[5], 'a', SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH); assert(!memcmp(buf, expected, sizeof(expected))); } static void test_serialize_inject_touch_event(void) { struct sc_control_msg msg = { - .type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT, + .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT, .inject_touch_event = { .action = AMOTION_EVENT_ACTION_DOWN, .pointer_id = UINT64_C(0x1234567887654321), @@ -94,12 +94,12 @@ static void test_serialize_inject_touch_event(void) { }, }; - unsigned char buf[CONTROL_MSG_MAX_SIZE]; + unsigned char buf[SC_CONTROL_MSG_MAX_SIZE]; size_t size = sc_control_msg_serialize(&msg, buf); assert(size == 28); const unsigned char expected[] = { - CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT, + SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT, 0x00, // AKEY_EVENT_ACTION_DOWN 0x12, 0x34, 0x56, 0x78, 0x87, 0x65, 0x43, 0x21, // pointer id 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0xc8, // 100 200 @@ -112,7 +112,7 @@ static void test_serialize_inject_touch_event(void) { static void test_serialize_inject_scroll_event(void) { struct sc_control_msg msg = { - .type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT, + .type = SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT, .inject_scroll_event = { .position = { .point = { @@ -130,12 +130,12 @@ static void test_serialize_inject_scroll_event(void) { }, }; - unsigned char buf[CONTROL_MSG_MAX_SIZE]; + unsigned char buf[SC_CONTROL_MSG_MAX_SIZE]; size_t size = sc_control_msg_serialize(&msg, buf); assert(size == 25); const unsigned char expected[] = { - CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT, + SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x04, 0x02, // 260 1026 0x04, 0x38, 0x07, 0x80, // 1080 1920 0x00, 0x00, 0x00, 0x01, // 1 @@ -147,18 +147,18 @@ static void test_serialize_inject_scroll_event(void) { static void test_serialize_back_or_screen_on(void) { struct sc_control_msg msg = { - .type = CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON, + .type = SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON, .back_or_screen_on = { .action = AKEY_EVENT_ACTION_UP, }, }; - unsigned char buf[CONTROL_MSG_MAX_SIZE]; + unsigned char buf[SC_CONTROL_MSG_MAX_SIZE]; size_t size = sc_control_msg_serialize(&msg, buf); assert(size == 2); const unsigned char expected[] = { - CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON, + SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON, 0x01, // AKEY_EVENT_ACTION_UP }; assert(!memcmp(buf, expected, sizeof(expected))); @@ -166,71 +166,71 @@ static void test_serialize_back_or_screen_on(void) { static void test_serialize_expand_notification_panel(void) { struct sc_control_msg msg = { - .type = CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL, + .type = SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL, }; - unsigned char buf[CONTROL_MSG_MAX_SIZE]; + unsigned char buf[SC_CONTROL_MSG_MAX_SIZE]; size_t size = sc_control_msg_serialize(&msg, buf); assert(size == 1); const unsigned char expected[] = { - CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL, + SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL, }; assert(!memcmp(buf, expected, sizeof(expected))); } static void test_serialize_expand_settings_panel(void) { struct sc_control_msg msg = { - .type = CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL, + .type = SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL, }; - unsigned char buf[CONTROL_MSG_MAX_SIZE]; + unsigned char buf[SC_CONTROL_MSG_MAX_SIZE]; size_t size = sc_control_msg_serialize(&msg, buf); assert(size == 1); const unsigned char expected[] = { - CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL, + SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL, }; assert(!memcmp(buf, expected, sizeof(expected))); } static void test_serialize_collapse_panels(void) { struct sc_control_msg msg = { - .type = CONTROL_MSG_TYPE_COLLAPSE_PANELS, + .type = SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS, }; - unsigned char buf[CONTROL_MSG_MAX_SIZE]; + unsigned char buf[SC_CONTROL_MSG_MAX_SIZE]; size_t size = sc_control_msg_serialize(&msg, buf); assert(size == 1); const unsigned char expected[] = { - CONTROL_MSG_TYPE_COLLAPSE_PANELS, + SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS, }; assert(!memcmp(buf, expected, sizeof(expected))); } static void test_serialize_get_clipboard(void) { struct sc_control_msg msg = { - .type = CONTROL_MSG_TYPE_GET_CLIPBOARD, + .type = SC_CONTROL_MSG_TYPE_GET_CLIPBOARD, .get_clipboard = { - .copy_key = GET_CLIPBOARD_COPY_KEY_COPY, + .copy_key = SC_COPY_KEY_COPY, }, }; - unsigned char buf[CONTROL_MSG_MAX_SIZE]; + unsigned char buf[SC_CONTROL_MSG_MAX_SIZE]; size_t size = sc_control_msg_serialize(&msg, buf); assert(size == 2); const unsigned char expected[] = { - CONTROL_MSG_TYPE_GET_CLIPBOARD, - GET_CLIPBOARD_COPY_KEY_COPY, + SC_CONTROL_MSG_TYPE_GET_CLIPBOARD, + SC_COPY_KEY_COPY, }; assert(!memcmp(buf, expected, sizeof(expected))); } static void test_serialize_set_clipboard(void) { struct sc_control_msg msg = { - .type = CONTROL_MSG_TYPE_SET_CLIPBOARD, + .type = SC_CONTROL_MSG_TYPE_SET_CLIPBOARD, .set_clipboard = { .sequence = UINT64_C(0x0102030405060708), .paste = true, @@ -238,12 +238,12 @@ static void test_serialize_set_clipboard(void) { }, }; - unsigned char buf[CONTROL_MSG_MAX_SIZE]; + unsigned char buf[SC_CONTROL_MSG_MAX_SIZE]; size_t size = sc_control_msg_serialize(&msg, buf); assert(size == 27); const unsigned char expected[] = { - CONTROL_MSG_TYPE_SET_CLIPBOARD, + SC_CONTROL_MSG_TYPE_SET_CLIPBOARD, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // sequence 1, // paste 0x00, 0x00, 0x00, 0x0d, // text length @@ -254,7 +254,7 @@ static void test_serialize_set_clipboard(void) { static void test_serialize_set_clipboard_long(void) { struct sc_control_msg msg = { - .type = CONTROL_MSG_TYPE_SET_CLIPBOARD, + .type = SC_CONTROL_MSG_TYPE_SET_CLIPBOARD, .set_clipboard = { .sequence = UINT64_C(0x0102030405060708), .paste = true, @@ -262,60 +262,60 @@ static void test_serialize_set_clipboard_long(void) { }, }; - char text[CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH + 1]; - memset(text, 'a', CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH); - text[CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH] = '\0'; + char text[SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH + 1]; + memset(text, 'a', SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH); + text[SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH] = '\0'; msg.set_clipboard.text = text; - unsigned char buf[CONTROL_MSG_MAX_SIZE]; + unsigned char buf[SC_CONTROL_MSG_MAX_SIZE]; size_t size = sc_control_msg_serialize(&msg, buf); - assert(size == CONTROL_MSG_MAX_SIZE); + assert(size == SC_CONTROL_MSG_MAX_SIZE); - unsigned char expected[CONTROL_MSG_MAX_SIZE] = { - CONTROL_MSG_TYPE_SET_CLIPBOARD, + unsigned char expected[SC_CONTROL_MSG_MAX_SIZE] = { + SC_CONTROL_MSG_TYPE_SET_CLIPBOARD, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // sequence 1, // paste // text length - CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 24, - (CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 16) & 0xff, - (CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 8) & 0xff, - CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH & 0xff, + SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 24, + (SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 16) & 0xff, + (SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 8) & 0xff, + SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH & 0xff, }; - memset(expected + 14, 'a', CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH); + memset(expected + 14, 'a', SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH); assert(!memcmp(buf, expected, sizeof(expected))); } static void test_serialize_set_screen_power_mode(void) { struct sc_control_msg msg = { - .type = CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE, + .type = SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE, .set_screen_power_mode = { - .mode = SCREEN_POWER_MODE_NORMAL, + .mode = SC_SCREEN_POWER_MODE_NORMAL, }, }; - unsigned char buf[CONTROL_MSG_MAX_SIZE]; + unsigned char buf[SC_CONTROL_MSG_MAX_SIZE]; size_t size = sc_control_msg_serialize(&msg, buf); assert(size == 2); const unsigned char expected[] = { - CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE, - 0x02, // SCREEN_POWER_MODE_NORMAL + SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE, + 0x02, // SC_SCREEN_POWER_MODE_NORMAL }; assert(!memcmp(buf, expected, sizeof(expected))); } static void test_serialize_rotate_device(void) { struct sc_control_msg msg = { - .type = CONTROL_MSG_TYPE_ROTATE_DEVICE, + .type = SC_CONTROL_MSG_TYPE_ROTATE_DEVICE, }; - unsigned char buf[CONTROL_MSG_MAX_SIZE]; + unsigned char buf[SC_CONTROL_MSG_MAX_SIZE]; size_t size = sc_control_msg_serialize(&msg, buf); assert(size == 1); const unsigned char expected[] = { - CONTROL_MSG_TYPE_ROTATE_DEVICE, + SC_CONTROL_MSG_TYPE_ROTATE_DEVICE, }; assert(!memcmp(buf, expected, sizeof(expected))); }