Android/scrcpy
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity

Use sc_ prefix for control_msg enums

Browse source 
Refs afa4a1b728
This commit is contained in:
Romain Vimont 2022-01-26 21:31:30 +01:00
parent 2faf9715be
commit 9d2e00697e
8 changed files with 141 additions and 144 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

57
app/src/control_msg.c
View file

@ -92,19 +92,19 @@ size_t
sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) { sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) {
buf[0] = msg->type; buf[0] = msg->type;
switch (msg->type) { switch (msg->type) {
case CONTROL_MSG_TYPE_INJECT_KEYCODE: case SC_CONTROL_MSG_TYPE_INJECT_KEYCODE:
buf[1] = msg->inject_keycode.action; buf[1] = msg->inject_keycode.action;
buffer_write32be(&buf[2], msg->inject_keycode.keycode); buffer_write32be(&buf[2], msg->inject_keycode.keycode);
buffer_write32be(&buf[6], msg->inject_keycode.repeat); buffer_write32be(&buf[6], msg->inject_keycode.repeat);
buffer_write32be(&buf[10], msg->inject_keycode.metastate); buffer_write32be(&buf[10], msg->inject_keycode.metastate);
return 14; return 14;
case CONTROL_MSG_TYPE_INJECT_TEXT: { case SC_CONTROL_MSG_TYPE_INJECT_TEXT: {
size_t len = size_t len =
write_string(msg->inject_text.text, 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; 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; buf[1] = msg->inject_touch_event.action;
buffer_write64be(&buf[2], msg->inject_touch_event.pointer_id); buffer_write64be(&buf[2], msg->inject_touch_event.pointer_id);
write_position(&buf[10], &msg->inject_touch_event.position); 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_write16be(&buf[22], pressure);
buffer_write32be(&buf[24], msg->inject_touch_event.buttons); buffer_write32be(&buf[24], msg->inject_touch_event.buttons);
return 28; 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); write_position(&buf[1], &msg->inject_scroll_event.position);
buffer_write32be(&buf[13], buffer_write32be(&buf[13],
(uint32_t) msg->inject_scroll_event.hscroll); (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); (uint32_t) msg->inject_scroll_event.vscroll);
buffer_write32be(&buf[21], msg->inject_scroll_event.buttons); buffer_write32be(&buf[21], msg->inject_scroll_event.buttons);
return 25; 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; buf[1] = msg->inject_keycode.action;
return 2; return 2;
case CONTROL_MSG_TYPE_GET_CLIPBOARD: case SC_CONTROL_MSG_TYPE_GET_CLIPBOARD:
buf[1] = msg->get_clipboard.copy_key; buf[1] = msg->get_clipboard.copy_key;
return 2; return 2;
case CONTROL_MSG_TYPE_SET_CLIPBOARD: { case SC_CONTROL_MSG_TYPE_SET_CLIPBOARD:
buffer_write64be(&buf[1], msg->set_clipboard.sequence); buffer_write64be(&buf[1], msg->set_clipboard.sequence);
buf[9] = !!msg->set_clipboard.paste; buf[9] = !!msg->set_clipboard.paste;
size_t len = write_string(msg->set_clipboard.text, size_t len = write_string(msg->set_clipboard.text,
CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH, SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH,
&buf[10]); &buf[10]);
return 10 + len; return 10 + len;
} case SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
buf[1] = msg->set_screen_power_mode.mode; buf[1] = msg->set_screen_power_mode.mode;
return 2; return 2;
case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL: case SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
case CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL: case SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
case CONTROL_MSG_TYPE_COLLAPSE_PANELS: case SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS:
case CONTROL_MSG_TYPE_ROTATE_DEVICE: case SC_CONTROL_MSG_TYPE_ROTATE_DEVICE:
// no additional data // no additional data
return 1; return 1;
default: default:
@ -154,17 +153,17 @@ void
sc_control_msg_log(const struct sc_control_msg *msg) { sc_control_msg_log(const struct sc_control_msg *msg) {
#define LOG_CMSG(fmt, ...) LOGV("input: " fmt, ## __VA_ARGS__) #define LOG_CMSG(fmt, ...) LOGV("input: " fmt, ## __VA_ARGS__)
switch (msg->type) { 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", LOG_CMSG("key %-4s code=%d repeat=%" PRIu32 " meta=%06lx",
KEYEVENT_ACTION_LABEL(msg->inject_keycode.action), KEYEVENT_ACTION_LABEL(msg->inject_keycode.action),
(int) msg->inject_keycode.keycode, (int) msg->inject_keycode.keycode,
msg->inject_keycode.repeat, msg->inject_keycode.repeat,
(long) msg->inject_keycode.metastate); (long) msg->inject_keycode.metastate);
break; break;
case CONTROL_MSG_TYPE_INJECT_TEXT: case SC_CONTROL_MSG_TYPE_INJECT_TEXT:
LOG_CMSG("text \"%s\"", msg->inject_text.text); LOG_CMSG("text \"%s\"", msg->inject_text.text);
break; break;
case CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT: { case SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT: {
int action = msg->inject_touch_event.action int action = msg->inject_touch_event.action
& AMOTION_EVENT_ACTION_MASK; & AMOTION_EVENT_ACTION_MASK;
uint64_t id = msg->inject_touch_event.pointer_id; uint64_t id = msg->inject_touch_event.pointer_id;
@ -191,7 +190,7 @@ sc_control_msg_log(const struct sc_control_msg *msg) {
} }
break; break;
} }
case CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT: case SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
LOG_CMSG("scroll position=%" PRIi32 ",%" PRIi32 " hscroll=%" PRIi32 LOG_CMSG("scroll position=%" PRIi32 ",%" PRIi32 " hscroll=%" PRIi32
" vscroll=%" PRIi32 " buttons=%06lx", " vscroll=%" PRIi32 " buttons=%06lx",
msg->inject_scroll_event.position.point.x, 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, msg->inject_scroll_event.vscroll,
(long) msg->inject_scroll_event.buttons); (long) msg->inject_scroll_event.buttons);
break; 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", LOG_CMSG("back-or-screen-on %s",
KEYEVENT_ACTION_LABEL(msg->inject_keycode.action)); KEYEVENT_ACTION_LABEL(msg->inject_keycode.action));
break; break;
case CONTROL_MSG_TYPE_GET_CLIPBOARD: case SC_CONTROL_MSG_TYPE_GET_CLIPBOARD:
LOG_CMSG("get clipboard copy_key=%s", LOG_CMSG("get clipboard copy_key=%s",
copy_key_labels[msg->get_clipboard.copy_key]); copy_key_labels[msg->get_clipboard.copy_key]);
break; break;
case CONTROL_MSG_TYPE_SET_CLIPBOARD: case SC_CONTROL_MSG_TYPE_SET_CLIPBOARD:
LOG_CMSG("clipboard %" PRIu64_ " %s \"%s\"", LOG_CMSG("clipboard %" PRIu64_ " %s \"%s\"",
msg->set_clipboard.sequence, msg->set_clipboard.sequence,
msg->set_clipboard.paste ? "paste" : "nopaste", msg->set_clipboard.paste ? "paste" : "nopaste",
msg->set_clipboard.text); msg->set_clipboard.text);
break; break;
case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE: case SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
LOG_CMSG("power mode %s", LOG_CMSG("power mode %s",
SCREEN_POWER_MODE_LABEL(msg->set_screen_power_mode.mode)); SCREEN_POWER_MODE_LABEL(msg->set_screen_power_mode.mode));
break; break;
case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL: case SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
LOG_CMSG("expand notification panel"); LOG_CMSG("expand notification panel");
break; break;
case CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL: case SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL:
LOG_CMSG("expand settings panel"); LOG_CMSG("expand settings panel");
break; break;
case CONTROL_MSG_TYPE_COLLAPSE_PANELS: case SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS:
LOG_CMSG("collapse panels"); LOG_CMSG("collapse panels");
break; break;
case CONTROL_MSG_TYPE_ROTATE_DEVICE: case SC_CONTROL_MSG_TYPE_ROTATE_DEVICE:
LOG_CMSG("rotate device"); LOG_CMSG("rotate device");
break; break;
default: default:
@ -239,10 +238,10 @@ sc_control_msg_log(const struct sc_control_msg *msg) {
void void
sc_control_msg_destroy(struct sc_control_msg *msg) { sc_control_msg_destroy(struct sc_control_msg *msg) {
switch (msg->type) { switch (msg->type) {
case CONTROL_MSG_TYPE_INJECT_TEXT: case SC_CONTROL_MSG_TYPE_INJECT_TEXT:
free(msg->inject_text.text); free(msg->inject_text.text);
break; break;
case CONTROL_MSG_TYPE_SET_CLIPBOARD: case SC_CONTROL_MSG_TYPE_SET_CLIPBOARD:
free(msg->set_clipboard.text); free(msg->set_clipboard.text);
break; break;
default: default:

48
app/src/control_msg.h
View file

@ -11,40 +11,40 @@
#include "android/keycodes.h" #include "android/keycodes.h"
#include "coords.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 // 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_MOUSE UINT64_C(-1)
#define POINTER_ID_VIRTUAL_FINGER UINT64_C(-2) #define POINTER_ID_VIRTUAL_FINGER UINT64_C(-2)
enum sc_control_msg_type { enum sc_control_msg_type {
CONTROL_MSG_TYPE_INJECT_KEYCODE, SC_CONTROL_MSG_TYPE_INJECT_KEYCODE,
CONTROL_MSG_TYPE_INJECT_TEXT, SC_CONTROL_MSG_TYPE_INJECT_TEXT,
CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT, SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT, SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON, SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL, SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL, SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
CONTROL_MSG_TYPE_COLLAPSE_PANELS, SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS,
CONTROL_MSG_TYPE_GET_CLIPBOARD, SC_CONTROL_MSG_TYPE_GET_CLIPBOARD,
CONTROL_MSG_TYPE_SET_CLIPBOARD, SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE, SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
CONTROL_MSG_TYPE_ROTATE_DEVICE, SC_CONTROL_MSG_TYPE_ROTATE_DEVICE,
}; };
enum screen_power_mode { enum sc_screen_power_mode {
// see <https://android.googlesource.com/platform/frameworks/base.git/+/pie-release-2/core/java/android/view/SurfaceControl.java#305> // see <https://android.googlesource.com/platform/frameworks/base.git/+/pie-release-2/core/java/android/view/SurfaceControl.java#305>
SCREEN_POWER_MODE_OFF = 0, SC_SCREEN_POWER_MODE_OFF = 0,
SCREEN_POWER_MODE_NORMAL = 2, SC_SCREEN_POWER_MODE_NORMAL = 2,
}; };
enum get_clipboard_copy_key { enum sc_copy_key {
GET_CLIPBOARD_COPY_KEY_NONE, SC_COPY_KEY_NONE,
GET_CLIPBOARD_COPY_KEY_COPY, SC_COPY_KEY_COPY,
GET_CLIPBOARD_COPY_KEY_CUT, SC_COPY_KEY_CUT,
}; };
struct sc_control_msg { struct sc_control_msg {
@ -77,7 +77,7 @@ struct sc_control_msg {
// screen may only be turned on on ACTION_DOWN // screen may only be turned on on ACTION_DOWN
} back_or_screen_on; } back_or_screen_on;
struct { struct {
enum get_clipboard_copy_key copy_key; enum sc_copy_key copy_key;
} get_clipboard; } get_clipboard;
struct { struct {
uint64_t sequence; uint64_t sequence;
@ -85,7 +85,7 @@ struct sc_control_msg {
bool paste; bool paste;
} set_clipboard; } set_clipboard;
struct { struct {
enum screen_power_mode mode; enum sc_screen_power_mode mode;
} set_screen_power_mode; } set_screen_power_mode;
}; };
}; };

2
app/src/controller.c
View file

@ -66,7 +66,7 @@ sc_controller_push_msg(struct sc_controller *controller,
static bool static bool
process_msg(struct sc_controller *controller, process_msg(struct sc_controller *controller,
const struct sc_control_msg *msg) { 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); size_t length = sc_control_msg_serialize(msg, serialized_msg);
if (!length) { if (!length) {
return false; return false;

38
app/src/input_manager.c
View file

@ -161,7 +161,7 @@ send_keycode(struct sc_controller *controller, enum android_keycode keycode,
enum sc_action action, const char *name) { enum sc_action action, const char *name) {
// send DOWN event // send DOWN event
struct sc_control_msg msg; 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 msg.inject_keycode.action = action == SC_ACTION_DOWN
? AKEY_EVENT_ACTION_DOWN ? AKEY_EVENT_ACTION_DOWN
: AKEY_EVENT_ACTION_UP; : AKEY_EVENT_ACTION_UP;
@ -215,7 +215,7 @@ static void
press_back_or_turn_screen_on(struct sc_controller *controller, press_back_or_turn_screen_on(struct sc_controller *controller,
enum sc_action action) { enum sc_action action) {
struct sc_control_msg msg; 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 msg.back_or_screen_on.action = action == SC_ACTION_DOWN
? AKEY_EVENT_ACTION_DOWN ? AKEY_EVENT_ACTION_DOWN
: AKEY_EVENT_ACTION_UP; : AKEY_EVENT_ACTION_UP;
@ -228,7 +228,7 @@ press_back_or_turn_screen_on(struct sc_controller *controller,
static void static void
expand_notification_panel(struct sc_controller *controller) { expand_notification_panel(struct sc_controller *controller) {
struct sc_control_msg msg; 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)) { if (!sc_controller_push_msg(controller, &msg)) {
LOGW("Could not request 'expand notification panel'"); LOGW("Could not request 'expand notification panel'");
@ -238,7 +238,7 @@ expand_notification_panel(struct sc_controller *controller) {
static void static void
expand_settings_panel(struct sc_controller *controller) { expand_settings_panel(struct sc_controller *controller) {
struct sc_control_msg msg; 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)) { if (!sc_controller_push_msg(controller, &msg)) {
LOGW("Could not request 'expand settings panel'"); LOGW("Could not request 'expand settings panel'");
@ -248,7 +248,7 @@ expand_settings_panel(struct sc_controller *controller) {
static void static void
collapse_panels(struct sc_controller *controller) { collapse_panels(struct sc_controller *controller) {
struct sc_control_msg msg; 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)) { if (!sc_controller_push_msg(controller, &msg)) {
LOGW("Could not request 'collapse notification panel'"); LOGW("Could not request 'collapse notification panel'");
@ -257,9 +257,9 @@ collapse_panels(struct sc_controller *controller) {
static bool static bool
get_device_clipboard(struct sc_controller *controller, 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; 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; msg.get_clipboard.copy_key = copy_key;
if (!sc_controller_push_msg(controller, &msg)) { 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; 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.sequence = sequence;
msg.set_clipboard.text = text_dup; msg.set_clipboard.text = text_dup;
msg.set_clipboard.paste = paste; msg.set_clipboard.paste = paste;
@ -303,9 +303,9 @@ set_device_clipboard(struct sc_controller *controller, bool paste,
static void static void
set_screen_power_mode(struct sc_controller *controller, set_screen_power_mode(struct sc_controller *controller,
enum screen_power_mode mode) { enum sc_screen_power_mode mode) {
struct sc_control_msg msg; 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; msg.set_screen_power_mode.mode = mode;
if (!sc_controller_push_msg(controller, &msg)) { if (!sc_controller_push_msg(controller, &msg)) {
@ -350,7 +350,7 @@ clipboard_paste(struct sc_controller *controller) {
} }
struct sc_control_msg msg; 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; msg.inject_text.text = text_dup;
if (!sc_controller_push_msg(controller, &msg)) { if (!sc_controller_push_msg(controller, &msg)) {
free(text_dup); free(text_dup);
@ -361,7 +361,7 @@ clipboard_paste(struct sc_controller *controller) {
static void static void
rotate_device(struct sc_controller *controller) { rotate_device(struct sc_controller *controller) {
struct sc_control_msg msg; 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)) { if (!sc_controller_push_msg(controller, &msg)) {
LOGW("Could not request device rotation"); 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; bool up = action == AMOTION_EVENT_ACTION_UP;
struct sc_control_msg msg; 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.action = action;
msg.inject_touch_event.position.screen_size = im->screen->frame_size; msg.inject_touch_event.position.screen_size = im->screen->frame_size;
msg.inject_touch_event.position.point = point; msg.inject_touch_event.position.point = point;
@ -487,9 +487,9 @@ sc_input_manager_process_key(struct sc_input_manager *im,
return; return;
case SDLK_o: case SDLK_o:
if (controller && !repeat && down) { if (controller && !repeat && down) {
enum screen_power_mode mode = shift enum sc_screen_power_mode mode = shift
? SCREEN_POWER_MODE_NORMAL ? SC_SCREEN_POWER_MODE_NORMAL
: SCREEN_POWER_MODE_OFF; : SC_SCREEN_POWER_MODE_OFF;
set_screen_power_mode(controller, mode); set_screen_power_mode(controller, mode);
} }
return; return;
@ -517,14 +517,12 @@ sc_input_manager_process_key(struct sc_input_manager *im,
return; return;
case SDLK_c: case SDLK_c:
if (controller && !shift && !repeat && down) { if (controller && !shift && !repeat && down) {
get_device_clipboard(controller, get_device_clipboard(controller, SC_COPY_KEY_COPY);
GET_CLIPBOARD_COPY_KEY_COPY);
} }
return; return;
case SDLK_x: case SDLK_x:
if (controller && !shift && !repeat && down) { if (controller && !shift && !repeat && down) {
get_device_clipboard(controller, get_device_clipboard(controller, SC_COPY_KEY_CUT);
GET_CLIPBOARD_COPY_KEY_CUT);
} }
return; return;
case SDLK_v: case SDLK_v:

4
app/src/keyboard_inject.c
View file

@ -248,7 +248,7 @@ convert_meta_state(uint16_t mod) {
static bool static bool
convert_input_key(const struct sc_key_event *event, struct sc_control_msg *msg, 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) { 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, if (!convert_keycode(event->keycode, &msg->inject_keycode.keycode,
event->mods_state, key_inject_mode)) { 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; 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); msg.inject_text.text = strdup(event->text);
if (!msg.inject_text.text) { if (!msg.inject_text.text) {
LOGW("Could not strdup input text"); LOGW("Could not strdup input text");

8
app/src/mouse_inject.c
View file

@ -66,7 +66,7 @@ sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
struct sc_mouse_inject *mi = DOWNCAST(mp); struct sc_mouse_inject *mi = DOWNCAST(mp);
struct sc_control_msg msg = { struct sc_control_msg msg = {
.type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT, .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
.inject_touch_event = { .inject_touch_event = {
.action = AMOTION_EVENT_ACTION_MOVE, .action = AMOTION_EVENT_ACTION_MOVE,
.pointer_id = POINTER_ID_MOUSE, .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_mouse_inject *mi = DOWNCAST(mp);
struct sc_control_msg msg = { struct sc_control_msg msg = {
.type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT, .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
.inject_touch_event = { .inject_touch_event = {
.action = convert_mouse_action(event->action), .action = convert_mouse_action(event->action),
.pointer_id = POINTER_ID_MOUSE, .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_mouse_inject *mi = DOWNCAST(mp);
struct sc_control_msg msg = { struct sc_control_msg msg = {
.type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT, .type = SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
.inject_scroll_event = { .inject_scroll_event = {
.position = event->position, .position = event->position,
.hscroll = event->hscroll, .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_mouse_inject *mi = DOWNCAST(mp);
struct sc_control_msg msg = { struct sc_control_msg msg = {
.type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT, .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
.inject_touch_event = { .inject_touch_event = {
.action = convert_touch_action(event->action), .action = convert_touch_action(event->action),
.pointer_id = event->pointer_id, .pointer_id = event->pointer_id,

4
app/src/scrcpy.c
View file

@ -515,8 +515,8 @@ aoa_hid_end:
if (options->turn_screen_off) { if (options->turn_screen_off) {
struct sc_control_msg msg; 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 = SCREEN_POWER_MODE_OFF; msg.set_screen_power_mode.mode = SC_SCREEN_POWER_MODE_OFF;
if (!sc_controller_push_msg(&s->controller, &msg)) { if (!sc_controller_push_msg(&s->controller, &msg)) {
LOGW("Could not request 'set screen power mode'"); LOGW("Could not request 'set screen power mode'");

124
app/tests/test_control_msg_serialize.c
View file

@ -7,7 +7,7 @@
static void test_serialize_inject_keycode(void) { static void test_serialize_inject_keycode(void) {
struct sc_control_msg msg = { struct sc_control_msg msg = {
.type = CONTROL_MSG_TYPE_INJECT_KEYCODE, .type = SC_CONTROL_MSG_TYPE_INJECT_KEYCODE,
.inject_keycode = { .inject_keycode = {
.action = AKEY_EVENT_ACTION_UP, .action = AKEY_EVENT_ACTION_UP,
.keycode = AKEYCODE_ENTER, .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); size_t size = sc_control_msg_serialize(&msg, buf);
assert(size == 14); assert(size == 14);
const unsigned char expected[] = { const unsigned char expected[] = {
CONTROL_MSG_TYPE_INJECT_KEYCODE, SC_CONTROL_MSG_TYPE_INJECT_KEYCODE,
0x01, // AKEY_EVENT_ACTION_UP 0x01, // AKEY_EVENT_ACTION_UP
0x00, 0x00, 0x00, 0x42, // AKEYCODE_ENTER 0x00, 0x00, 0x00, 0x42, // AKEYCODE_ENTER
0x00, 0x00, 0x00, 0X05, // repeat 0x00, 0x00, 0x00, 0X05, // repeat
@ -32,18 +32,18 @@ static void test_serialize_inject_keycode(void) {
static void test_serialize_inject_text(void) { static void test_serialize_inject_text(void) {
struct sc_control_msg msg = { struct sc_control_msg msg = {
.type = CONTROL_MSG_TYPE_INJECT_TEXT, .type = SC_CONTROL_MSG_TYPE_INJECT_TEXT,
.inject_text = { .inject_text = {
.text = "hello, world!", .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); size_t size = sc_control_msg_serialize(&msg, buf);
assert(size == 18); assert(size == 18);
const unsigned char expected[] = { const unsigned char expected[] = {
CONTROL_MSG_TYPE_INJECT_TEXT, SC_CONTROL_MSG_TYPE_INJECT_TEXT,
0x00, 0x00, 0x00, 0x0d, // text length 0x00, 0x00, 0x00, 0x0d, // text length
'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', // text '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) { static void test_serialize_inject_text_long(void) {
struct sc_control_msg msg; struct sc_control_msg msg;
msg.type = CONTROL_MSG_TYPE_INJECT_TEXT; msg.type = SC_CONTROL_MSG_TYPE_INJECT_TEXT;
char text[CONTROL_MSG_INJECT_TEXT_MAX_LENGTH + 1]; char text[SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH + 1];
memset(text, 'a', CONTROL_MSG_INJECT_TEXT_MAX_LENGTH); memset(text, 'a', SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
text[CONTROL_MSG_INJECT_TEXT_MAX_LENGTH] = '\0'; text[SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH] = '\0';
msg.inject_text.text = text; 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); 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]; unsigned char expected[5 + SC_CONTROL_MSG_INJECT_TEXT_MAX_LENGTH];
expected[0] = CONTROL_MSG_TYPE_INJECT_TEXT; expected[0] = SC_CONTROL_MSG_TYPE_INJECT_TEXT;
expected[1] = 0x00; expected[1] = 0x00;
expected[2] = 0x00; expected[2] = 0x00;
expected[3] = 0x01; expected[3] = 0x01;
expected[4] = 0x2c; // text length (32 bits) 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))); assert(!memcmp(buf, expected, sizeof(expected)));
} }
static void test_serialize_inject_touch_event(void) { static void test_serialize_inject_touch_event(void) {
struct sc_control_msg msg = { struct sc_control_msg msg = {
.type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT, .type = SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
.inject_touch_event = { .inject_touch_event = {
.action = AMOTION_EVENT_ACTION_DOWN, .action = AMOTION_EVENT_ACTION_DOWN,
.pointer_id = UINT64_C(0x1234567887654321), .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); size_t size = sc_control_msg_serialize(&msg, buf);
assert(size == 28); assert(size == 28);
const unsigned char expected[] = { const unsigned char expected[] = {
CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT, SC_CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
0x00, // AKEY_EVENT_ACTION_DOWN 0x00, // AKEY_EVENT_ACTION_DOWN
0x12, 0x34, 0x56, 0x78, 0x87, 0x65, 0x43, 0x21, // pointer id 0x12, 0x34, 0x56, 0x78, 0x87, 0x65, 0x43, 0x21, // pointer id
0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0xc8, // 100 200 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) { static void test_serialize_inject_scroll_event(void) {
struct sc_control_msg msg = { struct sc_control_msg msg = {
.type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT, .type = SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
.inject_scroll_event = { .inject_scroll_event = {
.position = { .position = {
.point = { .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); size_t size = sc_control_msg_serialize(&msg, buf);
assert(size == 25); assert(size == 25);
const unsigned char expected[] = { 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 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x04, 0x02, // 260 1026
0x04, 0x38, 0x07, 0x80, // 1080 1920 0x04, 0x38, 0x07, 0x80, // 1080 1920
0x00, 0x00, 0x00, 0x01, // 1 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) { static void test_serialize_back_or_screen_on(void) {
struct sc_control_msg msg = { 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 = { .back_or_screen_on = {
.action = AKEY_EVENT_ACTION_UP, .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); size_t size = sc_control_msg_serialize(&msg, buf);
assert(size == 2); assert(size == 2);
const unsigned char expected[] = { const unsigned char expected[] = {
CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON, SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
0x01, // AKEY_EVENT_ACTION_UP 0x01, // AKEY_EVENT_ACTION_UP
}; };
assert(!memcmp(buf, expected, sizeof(expected))); 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) { static void test_serialize_expand_notification_panel(void) {
struct sc_control_msg msg = { 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); size_t size = sc_control_msg_serialize(&msg, buf);
assert(size == 1); assert(size == 1);
const unsigned char expected[] = { const unsigned char expected[] = {
CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL, SC_CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
}; };
assert(!memcmp(buf, expected, sizeof(expected))); assert(!memcmp(buf, expected, sizeof(expected)));
} }
static void test_serialize_expand_settings_panel(void) { static void test_serialize_expand_settings_panel(void) {
struct sc_control_msg msg = { 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); size_t size = sc_control_msg_serialize(&msg, buf);
assert(size == 1); assert(size == 1);
const unsigned char expected[] = { const unsigned char expected[] = {
CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL, SC_CONTROL_MSG_TYPE_EXPAND_SETTINGS_PANEL,
}; };
assert(!memcmp(buf, expected, sizeof(expected))); assert(!memcmp(buf, expected, sizeof(expected)));
} }
static void test_serialize_collapse_panels(void) { static void test_serialize_collapse_panels(void) {
struct sc_control_msg msg = { 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); size_t size = sc_control_msg_serialize(&msg, buf);
assert(size == 1); assert(size == 1);
const unsigned char expected[] = { const unsigned char expected[] = {
CONTROL_MSG_TYPE_COLLAPSE_PANELS, SC_CONTROL_MSG_TYPE_COLLAPSE_PANELS,
}; };
assert(!memcmp(buf, expected, sizeof(expected))); assert(!memcmp(buf, expected, sizeof(expected)));
} }
static void test_serialize_get_clipboard(void) { static void test_serialize_get_clipboard(void) {
struct sc_control_msg msg = { struct sc_control_msg msg = {
.type = CONTROL_MSG_TYPE_GET_CLIPBOARD, .type = SC_CONTROL_MSG_TYPE_GET_CLIPBOARD,
.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); size_t size = sc_control_msg_serialize(&msg, buf);
assert(size == 2); assert(size == 2);
const unsigned char expected[] = { const unsigned char expected[] = {
CONTROL_MSG_TYPE_GET_CLIPBOARD, SC_CONTROL_MSG_TYPE_GET_CLIPBOARD,
GET_CLIPBOARD_COPY_KEY_COPY, SC_COPY_KEY_COPY,
}; };
assert(!memcmp(buf, expected, sizeof(expected))); assert(!memcmp(buf, expected, sizeof(expected)));
} }
static void test_serialize_set_clipboard(void) { static void test_serialize_set_clipboard(void) {
struct sc_control_msg msg = { struct sc_control_msg msg = {
.type = CONTROL_MSG_TYPE_SET_CLIPBOARD, .type = SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
.set_clipboard = { .set_clipboard = {
.sequence = UINT64_C(0x0102030405060708), .sequence = UINT64_C(0x0102030405060708),
.paste = true, .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); size_t size = sc_control_msg_serialize(&msg, buf);
assert(size == 27); assert(size == 27);
const unsigned char expected[] = { const unsigned char expected[] = {
CONTROL_MSG_TYPE_SET_CLIPBOARD, SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // sequence 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // sequence
1, // paste 1, // paste
0x00, 0x00, 0x00, 0x0d, // text length 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) { static void test_serialize_set_clipboard_long(void) {
struct sc_control_msg msg = { struct sc_control_msg msg = {
.type = CONTROL_MSG_TYPE_SET_CLIPBOARD, .type = SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
.set_clipboard = { .set_clipboard = {
.sequence = UINT64_C(0x0102030405060708), .sequence = UINT64_C(0x0102030405060708),
.paste = true, .paste = true,
@ -262,60 +262,60 @@ static void test_serialize_set_clipboard_long(void) {
}, },
}; };
char text[CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH + 1]; char text[SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH + 1];
memset(text, 'a', CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH); memset(text, 'a', SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH);
text[CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH] = '\0'; text[SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH] = '\0';
msg.set_clipboard.text = text; 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); 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] = { unsigned char expected[SC_CONTROL_MSG_MAX_SIZE] = {
CONTROL_MSG_TYPE_SET_CLIPBOARD, SC_CONTROL_MSG_TYPE_SET_CLIPBOARD,
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // sequence 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // sequence
1, // paste 1, // paste
// text length // text length
CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 24, SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 24,
(CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 16) & 0xff, (SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 16) & 0xff,
(CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 8) & 0xff, (SC_CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH >> 8) & 0xff,
CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH & 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))); assert(!memcmp(buf, expected, sizeof(expected)));
} }
static void test_serialize_set_screen_power_mode(void) { static void test_serialize_set_screen_power_mode(void) {
struct sc_control_msg msg = { 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 = { .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); size_t size = sc_control_msg_serialize(&msg, buf);
assert(size == 2); assert(size == 2);
const unsigned char expected[] = { const unsigned char expected[] = {
CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE, SC_CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE,
0x02, // SCREEN_POWER_MODE_NORMAL 0x02, // SC_SCREEN_POWER_MODE_NORMAL
}; };
assert(!memcmp(buf, expected, sizeof(expected))); assert(!memcmp(buf, expected, sizeof(expected)));
} }
static void test_serialize_rotate_device(void) { static void test_serialize_rotate_device(void) {
struct sc_control_msg msg = { 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); size_t size = sc_control_msg_serialize(&msg, buf);
assert(size == 1); assert(size == 1);
const unsigned char expected[] = { const unsigned char expected[] = {
CONTROL_MSG_TYPE_ROTATE_DEVICE, SC_CONTROL_MSG_TYPE_ROTATE_DEVICE,
}; };
assert(!memcmp(buf, expected, sizeof(expected))); assert(!memcmp(buf, expected, sizeof(expected)));
} }