Copy on "get clipboard" if possible

Ctrl+c synchronizes the Android device clipboard to the computer clipboard. To make the copy more straightforward, if the device runs at least Android 7, also send a COPY keycode before copying the clipboard. <https://developer.android.com/reference/android/view/KeyEvent.html#KEYCODE_COPY>
Expose method to inject PASTE on Device
2020-05-28 12:02:21 +02:00 · 2020-05-28 12:02:21 +02:00 · 2020-05-28 12:02:21 +02:00 · 2020-05-28 12:02:20 +02:00
23 changed files with 336 additions and 298 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,8 +1,5 @@
 build/
 /dist/
-/build-*/
-/build_*/
-/release-*/
 .idea/
 .gradle/
 /x/
--- a/README.md
+++ b/README.md
@@ -354,7 +354,7 @@ scrcpy --fullscreen
 scrcpy -f  # short version
 ```

-Fullscreen can then be toggled dynamically with `RCtrl`+`f`.
+Fullscreen can then be toggled dynamically with `Ctrl`+`f`.

 #### Rotation

@@ -370,18 +370,18 @@ Possibles values are:
 - `2`: 180 degrees
 - `3`: 90 degrees clockwise

-The rotation can also be changed dynamically with `RCtrl`+`←` _(left)_ and
-`RCtrl`+`→` _(right)_.
+The rotation can also be changed dynamically with `Ctrl`+`←` _(left)_ and
+`Ctrl`+`→` _(right)_.

 Note that _scrcpy_ manages 3 different rotations:
- - `RCtrl`+`r` requests the device to switch between portrait and landscape (the
+ - `Ctrl`+`r` requests the device to switch between portrait and landscape (the
   current running app may refuse, if it does support the requested
   orientation).
 - `--lock-video-orientation` changes the mirroring orientation (the orientation
   of the video sent from the device to the computer). This affects the
   recording.
- - `--rotation` (or `RCtrl`+`←`/`RCtrl`+`→`) rotates only the window content.
-   This affects only the display, not the recording.
+ - `--rotation` (or `Ctrl`+`←`/`Ctrl`+`→`) rotates only the window content. This
+   affects only the display, not the recording.


 ### Other mirroring options
@@ -417,7 +417,7 @@ The secondary display may only be controlled if the device runs at least Android

 #### Stay awake

-To prevent the device to sleep after some delay when the device is plugged in:
+To prevent the device to sleep after some delay:

 ```bash
 scrcpy --stay-awake
@@ -437,9 +437,9 @@ scrcpy --turn-screen-off
 scrcpy -S
 ```

-Or by pressing `RCtrl`+`o` at any time.
+Or by pressing `Ctrl`+`o` at any time.

-To turn it back on, press `RCtrl`+`Shift`+`o` (or `POWER`, `RCtrl`+`p`).
+To turn it back on, press `Ctrl`+`Shift`+`o` (or `POWER`, `Ctrl`+`p`).

 It can be useful to also prevent the device to sleep:

@@ -483,26 +483,24 @@ Note that it only shows _physical_ touches (with the finger on the device).

 #### Rotate device screen

-Press `RCtrl`+`r` to switch between portrait and landscape modes.
+Press `Ctrl`+`r` to switch between portrait and landscape modes.

 Note that it rotates only if the application in foreground supports the
 requested orientation.

 #### Copy-paste

-Any time the Android clipboard changes, it is automatically synchronized to the
-computer clipboard.
+It is possible to synchronize clipboards between the computer and the device, in
+both directions:

-`Ctrl`+`c` (copy), `Ctrl`+`x` (cut) and `LCtrl`+`v` (paste) work as you expect.
-
-In addition, `RCtrl`+`v` allows to inject the computer clipboard content as a
-sequence of text events . This is useful when the component does not accept text
-pasting (for example in _Termux_), but it can break non-ASCII content.
-
-Another shortcut, `RCtrl`+`Shift`+`v`, only copies the computer clipboard to the
-device clipboard. This is useful when `Ctrl`+`v` does not paste on the device
-(for example, again, in _Termux_).
+ - `Ctrl`+`c` copies the device clipboard to the computer clipboard;
+ - `Ctrl`+`Shift`+`v` copies the computer clipboard to the device clipboard (and
+   pastes if the device runs Android >= 7);
+ - `Ctrl`+`v` _pastes_ the computer clipboard as a sequence of text events (but
+   breaks non-ASCII characters).

+Moreover, any time the Android clipboard changes, it is automatically
+synchronized to the computer clipboard.

 #### Text injection preference

@@ -562,35 +560,30 @@ Also see [issue #14].

 ## Shortcuts

-`RCtrl` is the right `Ctrl` key (the left `Ctrl` key is forwarded to the
-device).
-
-On macOS, `Cmd` also works (for shortcuts which are not already captured by the
-system).
-
- | Action                                      |   Shortcut
- | ------------------------------------------- |:-----------------------------
- | Switch fullscreen mode                      | `RCtrl`+`f`
- | Rotate display left                         | `RCtrl`+`←`
- | Rotate display right                        | `RCtrl`+`→`
- | Resize window to 1:1 (pixel-perfect)        | `RCtrl`+`g`
- | Resize window to remove black borders       | `RCtrl`+`w` \| _Double-click¹_
- | Click on `HOME`                             | `RCtrl`+`h` \| _Middle-click_
- | Click on `BACK`                             | `RCtrl`+`b` \| _Right-click²_
- | Click on `APP_SWITCH`                       | `RCtrl`+`s`
- | Click on `MENU`                             | `RCtrl`+`m`
- | Click on `VOLUME_UP`                        | `RCtrl`+`↑` _(up)_
- | Click on `VOLUME_DOWN`                      | `RCtrl`+`↓` _(down)_
- | Click on `POWER`                            | `RCtrl`+`p`
- | Power on                                    | _Right-click²_
- | Turn device screen off (keep mirroring)     | `RCtrl`+`o`
- | Turn device screen on                       | `RCtrl`+`Shift`+`o`
- | Rotate device screen                        | `RCtrl`+`r`
- | Expand notification panel                   | `RCtrl`+`n`
- | Collapse notification panel                 | `RCtrl`+`Shift`+`n`
- | Inject computer clipboard text              | `RCtrl`+`v`
- | Copy computer clipboard to device           | `RCtrl`+`Shift`+`v`
- | Enable/disable FPS counter (on stdout)      | `RCtrl`+`i`
+ | Action                                      |   Shortcut                    |   Shortcut (macOS)
+ | ------------------------------------------- |:----------------------------- |:-----------------------------
+ | Switch fullscreen mode                      | `Ctrl`+`f`                    | `Cmd`+`f`
+ | Rotate display left                         | `Ctrl`+`←` _(left)_           | `Cmd`+`←` _(left)_
+ | Rotate display right                        | `Ctrl`+`→` _(right)_          | `Cmd`+`→` _(right)_
+ | Resize window to 1:1 (pixel-perfect)        | `Ctrl`+`g`                    | `Cmd`+`g`
+ | Resize window to remove black borders       | `Ctrl`+`x` \| _Double-click¹_ | `Cmd`+`x`  \| _Double-click¹_
+ | Click on `HOME`                             | `Ctrl`+`h` \| _Middle-click_  | `Ctrl`+`h` \| _Middle-click_
+ | Click on `BACK`                             | `Ctrl`+`b` \| _Right-click²_  | `Cmd`+`b`  \| _Right-click²_
+ | Click on `APP_SWITCH`                       | `Ctrl`+`s`                    | `Cmd`+`s`
+ | Click on `MENU`                             | `Ctrl`+`m`                    | `Ctrl`+`m`
+ | Click on `VOLUME_UP`                        | `Ctrl`+`↑` _(up)_             | `Cmd`+`↑` _(up)_
+ | Click on `VOLUME_DOWN`                      | `Ctrl`+`↓` _(down)_           | `Cmd`+`↓` _(down)_
+ | Click on `POWER`                            | `Ctrl`+`p`                    | `Cmd`+`p`
+ | Power on                                    | _Right-click²_                | _Right-click²_
+ | Turn device screen off (keep mirroring)     | `Ctrl`+`o`                    | `Cmd`+`o`
+ | Turn device screen on                       | `Ctrl`+`Shift`+`o`            | `Cmd`+`Shift`+`o`
+ | Rotate device screen                        | `Ctrl`+`r`                    | `Cmd`+`r`
+ | Expand notification panel                   | `Ctrl`+`n`                    | `Cmd`+`n`
+ | Collapse notification panel                 | `Ctrl`+`Shift`+`n`            | `Cmd`+`Shift`+`n`
+ | Copy device clipboard to computer           | `Ctrl`+`c`                    | `Cmd`+`c`
+ | Paste computer clipboard to device          | `Ctrl`+`v`                    | `Cmd`+`v`
+ | Copy computer clipboard to device and paste | `Ctrl`+`Shift`+`v`            | `Cmd`+`Shift`+`v`
+ | Enable/disable FPS counter (on stdout)      | `Ctrl`+`i`                    | `Cmd`+`i`

 _¹Double-click on black borders to remove them._  
 _²Right-click turns the screen on if it was off, presses BACK otherwise._
--- a/app/meson.build
+++ b/app/meson.build
@@ -164,12 +164,12 @@ if get_option('buildtype') == 'debug'
            'src/cli.c',
            'src/util/str_util.c',
        ]],
-        ['test_control_msg_serialize', [
+        ['test_control_event_serialize', [
            'tests/test_control_msg_serialize.c',
            'src/control_msg.c',
            'src/util/str_util.c',
        ]],
-        ['test_device_msg_deserialize', [
+        ['test_device_event_deserialize', [
            'tests/test_device_msg_deserialize.c',
            'src/device_msg.c',
        ]],
--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@@ -167,7 +167,7 @@ Default is "info" for release builds, "debug" for debug builds.

 .TP
 .B \-w, \-\-stay-awake
-Keep the device on while scrcpy is running, when the device is plugged in.
+Keep the device on while scrcpy is running.

 .TP
 .B \-\-window\-borderless
@@ -203,54 +203,52 @@ Default is 0 (automatic).\n

 .SH SHORTCUTS

-RCtrl is the right Ctrl key (the left Ctrl key is forwarded to the device).
-
 .TP
-.B RCtrl+f
+.B Ctrl+f
 Switch fullscreen mode

 .TP
-.B RCtrl+Left
+.B Ctrl+Left
 Rotate display left

 .TP
-.B RCtrl+Right
+.B Ctrl+Right
 Rotate display right

 .TP
-.B RCtrl+g
+.B Ctrl+g
 Resize window to 1:1 (pixel\-perfect)

 .TP
-.B RCtrl+w, Double\-click on black borders
+.B Ctrl+x, Double\-click on black borders
 Resize window to remove black borders

 .TP
-.B RCtrl+h, Home, Middle\-click
+.B Ctrl+h, Home, Middle\-click
 Click on HOME

 .TP
-.B RCtrl+b, RCtrl+Backspace, Right\-click (when screen is on)
+.B Ctrl+b, Ctrl+Backspace, Right\-click (when screen is on)
 Click on BACK

 .TP
-.B RCtrl+s
+.B Ctrl+s
 Click on APP_SWITCH

 .TP
-.B RCtrl+m
+.B Ctrl+m
 Click on MENU

 .TP
-.B RCtrl+Up
+.B Ctrl+Up
 Click on VOLUME_UP

 .TP
-.B RCtrl+Down
+.B Ctrl+Down
 Click on VOLUME_DOWN

 .TP
-.B RCtrl+p
+.B Ctrl+p
 Click on POWER (turn screen on/off)

 .TP
@@ -258,35 +256,39 @@ Click on POWER (turn screen on/off)
 Turn screen on

 .TP
-.B RCtrl+o
+.B Ctrl+o
 Turn device screen off (keep mirroring)

 .TP
-.B RCtrl+Shift+o
+.B Ctrl+Shift+o
 Turn device screen on

 .TP
-.B RCtrl+r
+.B Ctrl+r
 Rotate device screen

 .TP
-.B RCtrl+n
+.B Ctrl+n
 Expand notification panel

 .TP
-.B RCtrl+Shift+n
+.B Ctrl+Shift+n
 Collapse notification panel

 .TP
-.B RCtrl+v
-Inject computer clipboard text
+.B Ctrl+c
+Copy device clipboard to computer

 .TP
-.B RCtrl+Shift+v
-Copy computer clipboard to device
+.B Ctrl+v
+Paste computer clipboard to device

 .TP
-.B RCtrl+i
+.B Ctrl+Shift+v
+Copy computer clipboard to device (and paste if the device runs Android >= 7)
+
+.TP
+.B Ctrl+i
 Enable/disable FPS counter (print frames/second in logs)

 .TP
--- a/app/src/cli.c
+++ b/app/src/cli.c
@@ -12,6 +12,11 @@

 void
 scrcpy_print_usage(const char *arg0) {
+#ifdef __APPLE__
+# define CTRL_OR_CMD "Cmd"
+#else
+# define CTRL_OR_CMD "Ctrl"
+#endif
    fprintf(stderr,
        "Usage: %s [options]\n"
        "\n"
@@ -154,8 +159,7 @@ scrcpy_print_usage(const char *arg0) {
 #endif
        "\n"
        "    -w, --stay-awake\n"
-        "        Keep the device on while scrcpy is running, when the device\n"
-        "        is plugged in.\n"
+        "        Keep the device on while scrcpy is running.\n"
        "\n"
        "    --window-borderless\n"
        "        Disable window decorations (display borderless window).\n"
@@ -181,74 +185,75 @@ scrcpy_print_usage(const char *arg0) {
        "\n"
        "Shortcuts:\n"
        "\n"
-        "    RCtrl is the right Ctrl key (the left Ctrl key is forwarded to\n"
-        "    the device.\n"
-        "\n"
-        "    RCtrl+f\n"
+        "    " CTRL_OR_CMD "+f\n"
        "        Switch fullscreen mode\n"
        "\n"
-        "    RCtrl+Left\n"
+        "    " CTRL_OR_CMD "+Left\n"
        "        Rotate display left\n"
        "\n"
-        "    RCtrl+Right\n"
+        "    " CTRL_OR_CMD "+Right\n"
        "        Rotate display right\n"
        "\n"
-        "    RCtrl+g\n"
+        "    " CTRL_OR_CMD "+g\n"
        "        Resize window to 1:1 (pixel-perfect)\n"
        "\n"
-        "    RCtrl+w\n"
+        "    " CTRL_OR_CMD "+x\n"
        "    Double-click on black borders\n"
        "        Resize window to remove black borders\n"
        "\n"
-        "    RCtrl+h\n"
+        "    Ctrl+h\n"
        "    Middle-click\n"
        "        Click on HOME\n"
        "\n"
-        "    RCtrl+b\n"
-        "    RCtrl+Backspace\n"
+        "    " CTRL_OR_CMD "+b\n"
+        "    " CTRL_OR_CMD "+Backspace\n"
        "    Right-click (when screen is on)\n"
        "        Click on BACK\n"
        "\n"
-        "    RCtrl+s\n"
+        "    " CTRL_OR_CMD "+s\n"
        "        Click on APP_SWITCH\n"
        "\n"
-        "    RCtrl+m\n"
+        "    Ctrl+m\n"
        "        Click on MENU\n"
        "\n"
-        "    RCtrl+Up\n"
+        "    " CTRL_OR_CMD "+Up\n"
        "        Click on VOLUME_UP\n"
        "\n"
-        "    RCtrl+Down\n"
+        "    " CTRL_OR_CMD "+Down\n"
        "        Click on VOLUME_DOWN\n"
        "\n"
-        "    RCtrl+p\n"
+        "    " CTRL_OR_CMD "+p\n"
        "        Click on POWER (turn screen on/off)\n"
        "\n"
        "    Right-click (when screen is off)\n"
        "        Power on\n"
        "\n"
-        "    RCtrl+o\n"
+        "    " CTRL_OR_CMD "+o\n"
        "        Turn device screen off (keep mirroring)\n"
        "\n"
-        "    RCtrl+Shift+o\n"
+        "    " CTRL_OR_CMD "+Shift+o\n"
        "        Turn device screen on\n"
        "\n"
-        "    RCtrl+r\n"
+        "    " CTRL_OR_CMD "+r\n"
        "        Rotate device screen\n"
        "\n"
-        "    RCtrl+n\n"
+        "    " CTRL_OR_CMD "+n\n"
        "        Expand notification panel\n"
        "\n"
-        "    RCtrl+Shift+n\n"
+        "    " CTRL_OR_CMD "+Shift+n\n"
        "        Collapse notification panel\n"
        "\n"
-        "    RCtrl+v\n"
-        "        Inject computer clipboard text\n"
+        "    " CTRL_OR_CMD "+c\n"
+        "        Copy device clipboard to computer\n"
        "\n"
-        "    RCtrl+Shift+v\n"
-        "        Copy computer clipboard to device\n"
+        "    " CTRL_OR_CMD "+v\n"
+        "        Paste computer clipboard to device\n"
        "\n"
-        "    RCtrl+i\n"
+        "    " CTRL_OR_CMD "+Shift+v\n"
+        "        Copy computer clipboard to device (and paste if the device\n"
+        "        runs Android >= 7)\n"
+        "\n"
+        "    " CTRL_OR_CMD "+i\n"
        "        Enable/disable FPS counter (print frames/second in logs)\n"
        "\n"
        "    Drag & drop APK file\n"
--- a/app/src/control_msg.c
+++ b/app/src/control_msg.c
@@ -20,9 +20,9 @@ write_position(uint8_t *buf, const struct position *position) {
 static size_t
 write_string(const char *utf8, size_t max_len, unsigned char *buf) {
    size_t len = utf8_truncation_index(utf8, max_len);
-    buffer_write32be(buf, len);
-    memcpy(&buf[4], utf8, len);
-    return 4 + len;
+    buffer_write16be(buf, (uint16_t) len);
+    memcpy(&buf[2], utf8, len);
+    return 2 + len;
 }

 static uint16_t
@@ -66,11 +66,15 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
            buffer_write32be(&buf[17],
                             (uint32_t) msg->inject_scroll_event.vscroll);
            return 21;
+        case CONTROL_MSG_TYPE_GET_CLIPBOARD:
+            buf[1] = msg->get_clipboard.copy;
+            return 2;
        case CONTROL_MSG_TYPE_SET_CLIPBOARD: {
+            buf[1] = !!msg->set_clipboard.paste;
            size_t len = write_string(msg->set_clipboard.text,
                                      CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH,
-                                      &buf[1]);
-            return 1 + len;
+                                      &buf[2]);
+            return 2 + len;
        }
        case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
            buf[1] = msg->set_screen_power_mode.mode;
@@ -78,7 +82,6 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
        case CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
        case CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL:
        case CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL:
-        case CONTROL_MSG_TYPE_GET_CLIPBOARD:
        case CONTROL_MSG_TYPE_ROTATE_DEVICE:
            // no additional data
            return 1;
--- a/app/src/control_msg.h
+++ b/app/src/control_msg.h
@@ -10,11 +10,10 @@
 #include "android/keycodes.h"
 #include "common.h"

-#define CONTROL_MSG_MAX_SIZE (1 << 18) // 256k
-
 #define CONTROL_MSG_INJECT_TEXT_MAX_LENGTH 300
-// type: 1 byte; length: 4 bytes
-#define CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH (CONTROL_MSG_MAX_SIZE - 5)
+#define CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH 4092
+#define CONTROL_MSG_SERIALIZED_MAX_SIZE \
+    (4 + CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH)

 #define POINTER_ID_MOUSE UINT64_C(-1);

@@ -61,8 +60,12 @@ struct control_msg {
            int32_t hscroll;
            int32_t vscroll;
        } inject_scroll_event;
+        struct {
+            bool copy;
+        } get_clipboard;
        struct {
            char *text; // owned, to be freed by SDL_free()
+            bool paste;
        } set_clipboard;
        struct {
            enum screen_power_mode mode;
@@ -70,7 +73,7 @@ struct control_msg {
    };
 };

-// buf size must be at least CONTROL_MSG_MAX_SIZE
+// buf size must be at least CONTROL_MSG_SERIALIZED_MAX_SIZE
 // return the number of bytes written
 size_t
 control_msg_serialize(const struct control_msg *msg, unsigned char *buf);
--- a/app/src/controller.c
+++ b/app/src/controller.c
@@ -60,7 +60,7 @@ controller_push_msg(struct controller *controller,
 static bool
 process_msg(struct controller *controller,
              const struct control_msg *msg) {
-    static unsigned char serialized_msg[CONTROL_MSG_MAX_SIZE];
+    unsigned char serialized_msg[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int length = control_msg_serialize(msg, serialized_msg);
    if (!length) {
        return false;
--- a/app/src/device_msg.c
+++ b/app/src/device_msg.c
@@ -9,7 +9,7 @@
 ssize_t
 device_msg_deserialize(const unsigned char *buf, size_t len,
                       struct device_msg *msg) {
-    if (len < 5) {
+    if (len < 3) {
        // at least type + empty string length
        return 0; // not available
    }
@@ -17,8 +17,8 @@ device_msg_deserialize(const unsigned char *buf, size_t len,
    msg->type = buf[0];
    switch (msg->type) {
        case DEVICE_MSG_TYPE_CLIPBOARD: {
-            size_t clipboard_len = buffer_read32be(&buf[1]);
-            if (clipboard_len > len - 5) {
+            uint16_t clipboard_len = buffer_read16be(&buf[1]);
+            if (clipboard_len > len - 3) {
                return 0; // not available
            }
            char *text = SDL_malloc(clipboard_len + 1);
@@ -27,12 +27,12 @@ device_msg_deserialize(const unsigned char *buf, size_t len,
                return -1;
            }
            if (clipboard_len) {
-                memcpy(text, &buf[5], clipboard_len);
+                memcpy(text, &buf[3], clipboard_len);
            }
            text[clipboard_len] = '\0';

            msg->clipboard.text = text;
-            return 5 + clipboard_len;
+            return 3 + clipboard_len;
        }
        default:
            LOGW("Unknown device message type: %d", (int) msg->type);
--- a/app/src/device_msg.h
+++ b/app/src/device_msg.h
@@ -7,9 +7,8 @@

 #include "config.h"

-#define DEVICE_MSG_MAX_SIZE (1 << 18) // 256k
-// type: 1 byte; length: 4 bytes
-#define DEVICE_MSG_TEXT_MAX_LENGTH (DEVICE_MSG_MAX_SIZE - 5)
+#define DEVICE_MSG_TEXT_MAX_LENGTH 4093
+#define DEVICE_MSG_SERIALIZED_MAX_SIZE (3 + DEVICE_MSG_TEXT_MAX_LENGTH)

 enum device_msg_type {
    DEVICE_MSG_TYPE_CLIPBOARD,
--- a/app/src/event_converter.c
+++ b/app/src/event_converter.c
@@ -92,7 +92,6 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
        MAP(SDLK_LEFT,         AKEYCODE_DPAD_LEFT);
        MAP(SDLK_DOWN,         AKEYCODE_DPAD_DOWN);
        MAP(SDLK_UP,           AKEYCODE_DPAD_UP);
-        MAP(SDLK_LCTRL,        AKEYCODE_CTRL_LEFT);
        MAP(SDLK_LSHIFT,       AKEYCODE_SHIFT_LEFT);
        MAP(SDLK_RSHIFT,       AKEYCODE_SHIFT_RIGHT);
    }
@@ -114,7 +113,7 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
        }
    }

-    if (prefer_text && !(mod & KMOD_LCTRL)) {
+    if (prefer_text) {
        // do not forward alpha and space key events
        return false;
    }
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
@@ -102,7 +102,18 @@ collapse_notification_panel(struct controller *controller) {
 }

 static void
-set_device_clipboard(struct controller *controller) {
+request_device_clipboard(struct controller *controller, bool copy) {
+    struct control_msg msg;
+    msg.type = CONTROL_MSG_TYPE_GET_CLIPBOARD;
+    msg.get_clipboard.copy = copy;
+
+    if (!controller_push_msg(controller, &msg)) {
+        LOGW("Could not request device clipboard");
+    }
+}
+
+static void
+set_device_clipboard(struct controller *controller, bool paste) {
    char *text = SDL_GetClipboardText();
    if (!text) {
        LOGW("Could not get clipboard text: %s", SDL_GetError());
@@ -117,6 +128,7 @@ set_device_clipboard(struct controller *controller) {
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_SET_CLIPBOARD;
    msg.set_clipboard.text = text;
+    msg.set_clipboard.paste = paste;

    if (!controller_push_msg(controller, &msg)) {
        SDL_free(text);
@@ -241,25 +253,6 @@ convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to,
    return true;
 }

-static void
-inject_as_ctrl(struct input_manager *im, const SDL_KeyboardEvent *event) {
-    struct control_msg msg;
-
-    if (!convert_input_key(event, &msg, false)) {
-        return;
-    }
-
-    // Disable RCtrl and Meta
-    msg.inject_keycode.metastate &=
-        ~(AMETA_CTRL_RIGHT_ON | AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON);
-    // Enable LCtrl
-    msg.inject_keycode.metastate |= AMETA_CTRL_LEFT_ON;
-
-    if (!controller_push_msg(im->controller, &msg)) {
-        LOGW("Could not request 'inject keycode'");
-    }
-}
-
 void
 input_manager_process_key(struct input_manager *im,
                          const SDL_KeyboardEvent *event,
@@ -267,69 +260,69 @@ input_manager_process_key(struct input_manager *im,
    // control: indicates the state of the command-line option --no-control
    // ctrl: the Ctrl key

-    bool lctrl = event->keysym.mod & KMOD_LCTRL;
-    bool rctrl = event->keysym.mod & KMOD_RCTRL;
+    bool ctrl = event->keysym.mod & (KMOD_LCTRL | KMOD_RCTRL);
    bool alt = event->keysym.mod & (KMOD_LALT | KMOD_RALT);
    bool meta = event->keysym.mod & (KMOD_LGUI | KMOD_RGUI);
-    bool shift = event->keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT);

-    bool shortcut_key = rctrl;
+    // use Cmd on macOS, Ctrl on other platforms
 #ifdef __APPLE__
-    shortcut_key |= meta;
+    bool cmd = !ctrl && meta;
 #else
    if (meta) {
-        // No shortcut involve Meta, and it is not forwarded to the device
+        // no shortcuts involve Meta on platforms other than macOS, and it must
+        // not be forwarded to the device
        return;
    }
+    bool cmd = ctrl; // && !meta, already guaranteed
 #endif

    if (alt) {
-        // No shortcuts involve Alt, and it is not forwarded to the device
+        // no shortcuts involve Alt, and it must not be forwarded to the device
        return;
    }

    struct controller *controller = im->controller;

-    SDL_Keycode keycode = event->keysym.sym;
-    bool down = event->type == SDL_KEYDOWN;
-
-    // Capture all RCtrl events
-    if (shortcut_key) {
+    // capture all Ctrl events
+    if (ctrl || cmd) {
+        SDL_Keycode keycode = event->keysym.sym;
+        bool down = event->type == SDL_KEYDOWN;
        int action = down ? ACTION_DOWN : ACTION_UP;
        bool repeat = event->repeat;
+        bool shift = event->keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT);
        switch (keycode) {
            case SDLK_h:
                // Ctrl+h on all platform, since Cmd+h is already captured by
                // the system on macOS to hide the window
-                if (control && !shift && !repeat) {
+                if (control && ctrl && !meta && !shift && !repeat) {
                    action_home(controller, action);
                }
                return;
            case SDLK_b: // fall-through
            case SDLK_BACKSPACE:
-                if (control && !shift && !repeat) {
+                if (control && cmd && !shift && !repeat) {
                    action_back(controller, action);
                }
                return;
            case SDLK_s:
-                if (control && !shift && !repeat) {
+                if (control && cmd && !shift && !repeat) {
                    action_app_switch(controller, action);
                }
                return;
            case SDLK_m:
                // Ctrl+m on all platform, since Cmd+m is already captured by
                // the system on macOS to minimize the window
-                if (control && !shift && !repeat) {
+                if (control && ctrl && !meta && !shift && !repeat) {
                    action_menu(controller, action);
                }
                return;
            case SDLK_p:
-                if (control && !shift && !repeat) {
+                if (control && cmd && !shift && !repeat) {
                    action_power(controller, action);
                }
                return;
            case SDLK_o:
-                if (control && !repeat && down) {
+                if (control && cmd && down) {
                    enum screen_power_mode mode = shift
                                                ? SCREEN_POWER_MODE_NORMAL
                                                : SCREEN_POWER_MODE_OFF;
@@ -337,32 +330,38 @@ input_manager_process_key(struct input_manager *im,
                }
                return;
            case SDLK_DOWN:
-                if (control && !shift) {
+                if (control && cmd && !shift) {
                    // forward repeated events
                    action_volume_down(controller, action);
                }
                return;
            case SDLK_UP:
-                if (control && !shift) {
+                if (control && cmd && !shift) {
                    // forward repeated events
                    action_volume_up(controller, action);
                }
                return;
            case SDLK_LEFT:
-                if (!shift && !repeat && down) {
+                if (cmd && !shift && down) {
                    rotate_client_left(im->screen);
                }
                return;
            case SDLK_RIGHT:
-                if (!shift && !repeat && down) {
+                if (cmd && !shift && down) {
                    rotate_client_right(im->screen);
                }
                return;
+            case SDLK_c:
+                if (control && cmd && !shift && !repeat && down) {
+                    // press COPY and get the clipboard content
+                    request_device_clipboard(controller, true);
+                }
+                return;
            case SDLK_v:
-                if (control && !repeat && down) {
+                if (control && cmd && !repeat && down) {
                    if (shift) {
-                        // store the text in the device clipboard
-                        set_device_clipboard(controller);
+                        // store the text in the device clipboard and paste
+                        set_device_clipboard(controller, true);
                    } else {
                        // inject the text as input events
                        clipboard_paste(controller);
@@ -370,29 +369,29 @@ input_manager_process_key(struct input_manager *im,
                }
                return;
            case SDLK_f:
-                if (!shift && !repeat && down) {
+                if (!shift && cmd && !repeat && down) {
                    screen_switch_fullscreen(im->screen);
                }
                return;
-            case SDLK_w:
-                if (!shift && !repeat && down) {
+            case SDLK_x:
+                if (!shift && cmd && !repeat && down) {
                    screen_resize_to_fit(im->screen);
                }
                return;
            case SDLK_g:
-                if (!shift && !repeat && down) {
+                if (!shift && cmd && !repeat && down) {
                    screen_resize_to_pixel_perfect(im->screen);
                }
                return;
            case SDLK_i:
-                if (!shift && !repeat && down) {
+                if (!shift && cmd && !repeat && down) {
                    struct fps_counter *fps_counter =
                        im->video_buffer->fps_counter;
                    switch_fps_counter_state(fps_counter);
                }
                return;
            case SDLK_n:
-                if (control && !repeat && down) {
+                if (control && cmd && !repeat && down) {
                    if (shift) {
                        collapse_notification_panel(controller);
                    } else {
@@ -401,19 +400,10 @@ input_manager_process_key(struct input_manager *im,
                }
                return;
            case SDLK_r:
-                if (control && !shift && !repeat && down) {
+                if (control && cmd && !shift && !repeat && down) {
                    rotate_device(controller);
                }
                return;
-            case SDLK_c:
-            case SDLK_x:
-                if (control && !shift) {
-                    // For convenience, forward shortcut_key+c and
-                    // shortcut_key+x as Ctrl+c and Ctrl+x (typically "copy" and
-                    // "cut", but not always) to the device
-                    inject_as_ctrl(im, event);
-                }
-                return;
        }

        return;
@@ -423,12 +413,6 @@ input_manager_process_key(struct input_manager *im,
        return;
    }

-    if (lctrl && !shift && keycode == SDLK_v && down) {
-        // Synchronize the computer clipboard to the device clipboard before
-        // sending Ctrl+V, to allow seamless copy-paste.
-        set_device_clipboard(controller);
-    }
-
    struct control_msg msg;
    if (convert_input_key(event, &msg, im->prefer_text)) {
        if (!controller_push_msg(controller, &msg)) {
--- a/app/src/main.c
+++ b/app/src/main.c
@@ -42,7 +42,7 @@ convert_log_level_to_sdl(enum sc_log_level level) {
            return SDL_LOG_PRIORITY_ERROR;
        default:
            assert(!"unexpected log level");
-            return SDL_LOG_PRIORITY_INFO;
+            return SC_LOG_LEVEL_INFO;
    }
 }

@@ -71,7 +71,7 @@ main(int argc, char *argv[]) {
    }

    SDL_LogPriority sdl_log = convert_log_level_to_sdl(args.opts.log_level);
-    SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, sdl_log);
+    SDL_LogSetAllPriority(sdl_log);

    if (args.help) {
        scrcpy_print_usage(argv[0]);
--- a/app/src/receiver.c
+++ b/app/src/receiver.c
@@ -60,29 +60,28 @@ static int
 run_receiver(void *data) {
    struct receiver *receiver = data;

-    static unsigned char buf[DEVICE_MSG_MAX_SIZE];
+    unsigned char buf[DEVICE_MSG_SERIALIZED_MAX_SIZE];
    size_t head = 0;

    for (;;) {
-        assert(head < DEVICE_MSG_MAX_SIZE);
-        ssize_t r = net_recv(receiver->control_socket, buf + head,
-                             DEVICE_MSG_MAX_SIZE - head);
+        assert(head < DEVICE_MSG_SERIALIZED_MAX_SIZE);
+        ssize_t r = net_recv(receiver->control_socket, buf,
+                             DEVICE_MSG_SERIALIZED_MAX_SIZE - head);
        if (r <= 0) {
            LOGD("Receiver stopped");
            break;
        }

-        head += r;
-        ssize_t consumed = process_msgs(buf, head);
+        ssize_t consumed = process_msgs(buf, r);
        if (consumed == -1) {
            // an error occurred
            break;
        }

        if (consumed) {
-            head -= consumed;
            // shift the remaining data in the buffer
-            memmove(buf, &buf[consumed], head);
+            memmove(buf, &buf[consumed], r - consumed);
+            head = r - consumed;
        }
    }

--- a/app/tests/test_control_msg_serialize.c
+++ b/app/tests/test_control_msg_serialize.c
@@ -13,7 +13,7 @@ static void test_serialize_inject_keycode(void) {
        },
    };

-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
    assert(size == 10);

@@ -34,13 +34,13 @@ static void test_serialize_inject_text(void) {
        },
    };

-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
-    assert(size == 18);
+    assert(size == 16);

    const unsigned char expected[] = {
        CONTROL_MSG_TYPE_INJECT_TEXT,
-        0x00, 0x00, 0x00, 0x0d, // text length
+        0x00, 0x0d, // text length
        'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', // text
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
@@ -54,17 +54,15 @@ static void test_serialize_inject_text_long(void) {
    text[CONTROL_MSG_INJECT_TEXT_MAX_LENGTH] = '\0';
    msg.inject_text.text = text;

-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
-    assert(size == 5 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
+    assert(size == 3 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);

-    unsigned char expected[5 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH];
+    unsigned char expected[3 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH];
    expected[0] = 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);
+    expected[1] = 0x01;
+    expected[2] = 0x2c; // text length (16 bits)
+    memset(&expected[3], 'a', CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);

    assert(!memcmp(buf, expected, sizeof(expected)));
 }
@@ -90,7 +88,7 @@ static void test_serialize_inject_touch_event(void) {
        },
    };

-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
    assert(size == 28);

@@ -125,7 +123,7 @@ static void test_serialize_inject_scroll_event(void) {
        },
    };

-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
    assert(size == 21);

@@ -144,7 +142,7 @@ static void test_serialize_back_or_screen_on(void) {
        .type = CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON,
    };

-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
    assert(size == 1);

@@ -159,7 +157,7 @@ static void test_serialize_expand_notification_panel(void) {
        .type = CONTROL_MSG_TYPE_EXPAND_NOTIFICATION_PANEL,
    };

-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
    assert(size == 1);

@@ -174,7 +172,7 @@ static void test_serialize_collapse_notification_panel(void) {
        .type = CONTROL_MSG_TYPE_COLLAPSE_NOTIFICATION_PANEL,
    };

-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
    assert(size == 1);

@@ -187,14 +185,18 @@ static void test_serialize_collapse_notification_panel(void) {
 static void test_serialize_get_clipboard(void) {
    struct control_msg msg = {
        .type = CONTROL_MSG_TYPE_GET_CLIPBOARD,
+        .get_clipboard = {
+            .copy = true,
+        },
    };

-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
-    assert(size == 1);
+    assert(size == 2);

    const unsigned char expected[] = {
        CONTROL_MSG_TYPE_GET_CLIPBOARD,
+        1, // copy
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
 }
@@ -203,17 +205,19 @@ static void test_serialize_set_clipboard(void) {
    struct control_msg msg = {
        .type = CONTROL_MSG_TYPE_SET_CLIPBOARD,
        .set_clipboard = {
+            .paste = true,
            .text = "hello, world!",
        },
    };

-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
-    assert(size == 18);
+    assert(size == 17);

    const unsigned char expected[] = {
        CONTROL_MSG_TYPE_SET_CLIPBOARD,
-        0x00, 0x00, 0x00, 0x0d, // text length
+        1, // paste
+        0x00, 0x0d, // text length
        'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', // text
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
@@ -227,7 +231,7 @@ static void test_serialize_set_screen_power_mode(void) {
        },
    };

-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
    assert(size == 2);

@@ -243,7 +247,7 @@ static void test_serialize_rotate_device(void) {
        .type = CONTROL_MSG_TYPE_ROTATE_DEVICE,
    };

-    unsigned char buf[CONTROL_MSG_MAX_SIZE];
+    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
    assert(size == 1);

--- a/app/tests/test_device_msg_deserialize.c
+++ b/app/tests/test_device_msg_deserialize.c
@@ -4,17 +4,16 @@
 #include "device_msg.h"

 #include <stdio.h>
-
 static void test_deserialize_clipboard(void) {
    const unsigned char input[] = {
        DEVICE_MSG_TYPE_CLIPBOARD,
-        0x00, 0x00, 0x00, 0x03, // text length
+        0x00, 0x03, // text length
        0x41, 0x42, 0x43, // "ABC"
    };

    struct device_msg msg;
    ssize_t r = device_msg_deserialize(input, sizeof(input), &msg);
-    assert(r == 8);
+    assert(r == 6);

    assert(msg.type == DEVICE_MSG_TYPE_CLIPBOARD);
    assert(msg.clipboard.text);
@@ -23,30 +22,7 @@ static void test_deserialize_clipboard(void) {
    device_msg_destroy(&msg);
 }

-static void test_deserialize_clipboard_big(void) {
-    unsigned char input[DEVICE_MSG_MAX_SIZE];
-    input[0] = DEVICE_MSG_TYPE_CLIPBOARD;
-    input[1] = (DEVICE_MSG_TEXT_MAX_LENGTH & 0xff000000u) >> 24;
-    input[2] = (DEVICE_MSG_TEXT_MAX_LENGTH & 0x00ff0000u) >> 16;
-    input[3] = (DEVICE_MSG_TEXT_MAX_LENGTH & 0x0000ff00u) >> 8;
-    input[4] =  DEVICE_MSG_TEXT_MAX_LENGTH & 0x000000ffu;
-
-    memset(input + 5, 'a', DEVICE_MSG_TEXT_MAX_LENGTH);
-
-    struct device_msg msg;
-    ssize_t r = device_msg_deserialize(input, sizeof(input), &msg);
-    assert(r == DEVICE_MSG_MAX_SIZE);
-
-    assert(msg.type == DEVICE_MSG_TYPE_CLIPBOARD);
-    assert(msg.clipboard.text);
-    assert(strlen(msg.clipboard.text) == DEVICE_MSG_TEXT_MAX_LENGTH);
-    assert(msg.clipboard.text[0] == 'a');
-
-    device_msg_destroy(&msg);
-}
-
 int main(void) {
    test_deserialize_clipboard();
-    test_deserialize_clipboard_big();
    return 0;
 }
--- a/server/src/main/java/com/genymobile/scrcpy/ControlMessage.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ControlMessage.java
@@ -17,6 +17,9 @@ public final class ControlMessage {
    public static final int TYPE_SET_SCREEN_POWER_MODE = 9;
    public static final int TYPE_ROTATE_DEVICE = 10;

+    public static final int FLAGS_PASTE = 1;
+    public static final int FLAGS_COPY = 2;
+
    private int type;
    private String text;
    private int metaState; // KeyEvent.META_*
@@ -28,6 +31,7 @@ public final class ControlMessage {
    private Position position;
    private int hScroll;
    private int vScroll;
+    private int flags;

    private ControlMessage() {
    }
@@ -68,10 +72,22 @@ public final class ControlMessage {
        return msg;
    }

-    public static ControlMessage createSetClipboard(String text) {
+    public static ControlMessage createSetClipboard(String text, boolean paste) {
        ControlMessage msg = new ControlMessage();
        msg.type = TYPE_SET_CLIPBOARD;
        msg.text = text;
+        if (paste) {
+            msg.flags = FLAGS_PASTE;
+        }
+        return msg;
+    }
+
+    public static ControlMessage createGetClipboard(boolean copy) {
+        ControlMessage msg = new ControlMessage();
+        msg.type = TYPE_GET_CLIPBOARD;
+        if (copy) {
+            msg.flags = FLAGS_COPY;
+        }
        return msg;
    }

@@ -134,4 +150,8 @@ public final class ControlMessage {
    public int getVScroll() {
        return vScroll;
    }
+
+    public int getFlags() {
+        return flags;
+    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/ControlMessageReader.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ControlMessageReader.java
@@ -12,14 +12,17 @@ public class ControlMessageReader {
    static final int INJECT_TOUCH_EVENT_PAYLOAD_LENGTH = 27;
    static final int INJECT_SCROLL_EVENT_PAYLOAD_LENGTH = 20;
    static final int SET_SCREEN_POWER_MODE_PAYLOAD_LENGTH = 1;
+    static final int GET_CLIPBOARD_PAYLOAD_LENGTH = 1;
+    static final int SET_CLIPBOARD_FIXED_PAYLOAD_LENGTH = 1;

-    private static final int MESSAGE_MAX_SIZE = 1 << 18; // 256k
-
-    public static final int CLIPBOARD_TEXT_MAX_LENGTH = MESSAGE_MAX_SIZE - 5; // type: 1 byte; length: 4 bytes
+    public static final int CLIPBOARD_TEXT_MAX_LENGTH = 4092; // 4096 - 1 (type) - 1 (parse flag) - 2 (length)
    public static final int INJECT_TEXT_MAX_LENGTH = 300;

-    private final byte[] rawBuffer = new byte[MESSAGE_MAX_SIZE];
+    private static final int RAW_BUFFER_SIZE = 4096;
+
+    private final byte[] rawBuffer = new byte[RAW_BUFFER_SIZE];
    private final ByteBuffer buffer = ByteBuffer.wrap(rawBuffer);
+    private final byte[] textBuffer = new byte[CLIPBOARD_TEXT_MAX_LENGTH];

    public ControlMessageReader() {
        // invariant: the buffer is always in "get" mode
@@ -65,6 +68,9 @@ public class ControlMessageReader {
            case ControlMessage.TYPE_INJECT_SCROLL_EVENT:
                msg = parseInjectScrollEvent();
                break;
+            case ControlMessage.TYPE_GET_CLIPBOARD:
+                msg = parseGetClipboard();
+                break;
            case ControlMessage.TYPE_SET_CLIPBOARD:
                msg = parseSetClipboard();
                break;
@@ -74,7 +80,6 @@ public class ControlMessageReader {
            case ControlMessage.TYPE_BACK_OR_SCREEN_ON:
            case ControlMessage.TYPE_EXPAND_NOTIFICATION_PANEL:
            case ControlMessage.TYPE_COLLAPSE_NOTIFICATION_PANEL:
-            case ControlMessage.TYPE_GET_CLIPBOARD:
            case ControlMessage.TYPE_ROTATE_DEVICE:
                msg = ControlMessage.createEmpty(type);
                break;
@@ -102,17 +107,15 @@ public class ControlMessageReader {
    }

    private String parseString() {
-        if (buffer.remaining() < 4) {
+        if (buffer.remaining() < 2) {
            return null;
        }
-        int len = buffer.getInt();
+        int len = toUnsigned(buffer.getShort());
        if (buffer.remaining() < len) {
            return null;
        }
-        int position = buffer.position();
-        // Move the buffer position to consume the text
-        buffer.position(position + len);
-        return new String(rawBuffer, position, len, StandardCharsets.UTF_8);
+        buffer.get(textBuffer, 0, len);
+        return new String(textBuffer, 0, len, StandardCharsets.UTF_8);
    }

    private ControlMessage parseInjectText() {
@@ -148,12 +151,24 @@ public class ControlMessageReader {
        return ControlMessage.createInjectScrollEvent(position, hScroll, vScroll);
    }

+    private ControlMessage parseGetClipboard() {
+        if (buffer.remaining() < GET_CLIPBOARD_PAYLOAD_LENGTH) {
+            return null;
+        }
+        boolean copy = buffer.get() != 0;
+        return ControlMessage.createGetClipboard(copy);
+    }
+
    private ControlMessage parseSetClipboard() {
+        if (buffer.remaining() < SET_CLIPBOARD_FIXED_PAYLOAD_LENGTH) {
+            return null;
+        }
+        boolean parse = buffer.get() != 0;
        String text = parseString();
        if (text == null) {
            return null;
        }
-        return ControlMessage.createSetClipboard(text);
+        return ControlMessage.createSetClipboard(text, parse);
    }

    private ControlMessage parseSetScreenPowerMode() {
--- a/server/src/main/java/com/genymobile/scrcpy/Controller.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Controller.java
@@ -1,5 +1,6 @@
 package com.genymobile.scrcpy;

+import android.os.Build;
 import android.os.SystemClock;
 import android.view.InputDevice;
 import android.view.KeyCharacterMap;
@@ -103,13 +104,12 @@ public class Controller {
                device.collapsePanels();
                break;
            case ControlMessage.TYPE_GET_CLIPBOARD:
-                String clipboardText = device.getClipboardText();
-                if (clipboardText != null) {
-                    sender.pushClipboardText(clipboardText);
-                }
+                boolean copy = (msg.getFlags() & ControlMessage.FLAGS_COPY) != 0;
+                getClipboard(copy);
                break;
            case ControlMessage.TYPE_SET_CLIPBOARD:
-                setClipboard(msg.getText());
+                boolean paste = (msg.getFlags() & ControlMessage.FLAGS_PASTE) != 0;
+                setClipboard(msg.getText(), paste);
                break;
            case ControlMessage.TYPE_SET_SCREEN_POWER_MODE:
                if (device.supportsInputEvents()) {
@@ -227,13 +227,30 @@ public class Controller {
        return device.injectKeycode(keycode);
    }

-    private boolean setClipboard(String text) {
+    private void getClipboard(boolean copy) {
+        // On Android >= 7, also press the COPY key if requested
+        if (copy && Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && device.supportsInputEvents()) {
+            // Must wait until the COPY has been executed
+            device.injectCopyKeycode();
+        }
+
+        String clipboardText = device.getClipboardText();
+        if (clipboardText != null) {
+            sender.pushClipboardText(clipboardText);
+        }
+    }
+
+    private boolean setClipboard(String text, boolean paste) {
        boolean ok = device.setClipboardText(text);
        if (ok) {
            Ln.i("Device clipboard set");
-            return true;
        }

-        return false;
+        // On Android >= 7, also press the PASTE key if requested
+        if (paste && Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && device.supportsInputEvents()) {
+            device.injectPasteKeycode();
+        }
+
+        return ok;
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/Device.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Device.java
@@ -167,15 +167,35 @@ public final class Device {
        return injectEvent(event, InputManager.INJECT_INPUT_EVENT_MODE_ASYNC);
    }

-    public boolean injectKeyEvent(int action, int keyCode, int repeat, int metaState) {
+    public boolean injectKeyEvent(int action, int keyCode, int repeat, int metaState, int mode) {
        long now = SystemClock.uptimeMillis();
        KeyEvent event = new KeyEvent(now, now, action, keyCode, repeat, metaState, KeyCharacterMap.VIRTUAL_KEYBOARD, 0, 0,
                InputDevice.SOURCE_KEYBOARD);
-        return injectEvent(event);
+        return injectEvent(event, mode);
+    }
+
+    public boolean injectKeyEvent(int action, int keyCode, int repeat, int metaState) {
+        return injectKeyEvent(action, keyCode, repeat, metaState, InputManager.INJECT_INPUT_EVENT_MODE_ASYNC);
+    }
+
+    public boolean injectKeycode(int keyCode, int mode) {
+        return injectKeyEvent(KeyEvent.ACTION_DOWN, keyCode, 0, 0) && injectKeyEvent(KeyEvent.ACTION_UP, keyCode, 0, 0, mode);
    }

    public boolean injectKeycode(int keyCode) {
-        return injectKeyEvent(KeyEvent.ACTION_DOWN, keyCode, 0, 0) && injectKeyEvent(KeyEvent.ACTION_UP, keyCode, 0, 0);
+        return injectKeycode(keyCode, InputManager.INJECT_INPUT_EVENT_MODE_ASYNC);
+    }
+
+    public boolean injectCopyKeycode() {
+        isSettingClipboard.set(true);
+        // Must wait until the COPY has been executed
+        boolean ret = injectKeycode(KeyEvent.KEYCODE_COPY, InputManager.INJECT_INPUT_EVENT_MODE_WAIT_FOR_FINISH);
+        isSettingClipboard.set(false);
+        return ret;
+    }
+
+    public boolean injectPasteKeycode() {
+        return injectKeycode(KeyEvent.KEYCODE_PASTE);
    }

    public boolean isScreenOn() {
@@ -207,14 +227,6 @@ public final class Device {
    }

    public boolean setClipboardText(String text) {
-        String currentClipboard = getClipboardText();
-        if (currentClipboard == null || currentClipboard.equals("text")) {
-            // The clipboard already contains the requested text.
-            // Since pasting text from the computer involves setting the device clipboard, it could be set twice on a copy-paste. This would cause
-            // the clipboard listeners to be notified twice, and that would flood the Android keyboard clipboard history. To workaround this
-            // problem, do not explicitly set the clipboard text if it already contains the expected content.
-            return false;
-        }
        isSettingClipboard.set(true);
        boolean ok = serviceManager.getClipboardManager().setText(text);
        isSettingClipboard.set(false);
--- a/server/src/main/java/com/genymobile/scrcpy/DeviceMessageWriter.java
+++ b/server/src/main/java/com/genymobile/scrcpy/DeviceMessageWriter.java
@@ -7,10 +7,10 @@ import java.nio.charset.StandardCharsets;

 public class DeviceMessageWriter {

-    private static final int MESSAGE_MAX_SIZE = 1 << 18; // 256k
-    public static final int CLIPBOARD_TEXT_MAX_LENGTH = MESSAGE_MAX_SIZE - 5; // type: 1 byte; length: 4 bytes
+    public static final int CLIPBOARD_TEXT_MAX_LENGTH = 4093;
+    private static final int MAX_EVENT_SIZE = CLIPBOARD_TEXT_MAX_LENGTH + 3;

-    private final byte[] rawBuffer = new byte[MESSAGE_MAX_SIZE];
+    private final byte[] rawBuffer = new byte[MAX_EVENT_SIZE];
    private final ByteBuffer buffer = ByteBuffer.wrap(rawBuffer);

    public void writeTo(DeviceMessage msg, OutputStream output) throws IOException {
@@ -21,7 +21,7 @@ public class DeviceMessageWriter {
                String text = msg.getText();
                byte[] raw = text.getBytes(StandardCharsets.UTF_8);
                int len = StringUtils.getUtf8TruncationIndex(raw, CLIPBOARD_TEXT_MAX_LENGTH);
-                buffer.putInt(len);
+                buffer.putShort((short) len);
                buffer.put(raw, 0, len);
                output.write(rawBuffer, 0, buffer.position());
                break;
--- a/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java
+++ b/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java
@@ -48,7 +48,7 @@ public class ControlMessageReaderTest {
        DataOutputStream dos = new DataOutputStream(bos);
        dos.writeByte(ControlMessage.TYPE_INJECT_TEXT);
        byte[] text = "testé".getBytes(StandardCharsets.UTF_8);
-        dos.writeInt(text.length);
+        dos.writeShort(text.length);
        dos.write(text);
        byte[] packet = bos.toByteArray();

@@ -68,7 +68,7 @@ public class ControlMessageReaderTest {
        dos.writeByte(ControlMessage.TYPE_INJECT_TEXT);
        byte[] text = new byte[ControlMessageReader.INJECT_TEXT_MAX_LENGTH];
        Arrays.fill(text, (byte) 'a');
-        dos.writeInt(text.length);
+        dos.writeShort(text.length);
        dos.write(text);
        byte[] packet = bos.toByteArray();

@@ -200,6 +200,7 @@ public class ControlMessageReaderTest {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(bos);
        dos.writeByte(ControlMessage.TYPE_GET_CLIPBOARD);
+        dos.writeByte(1); // copy

        byte[] packet = bos.toByteArray();

@@ -207,6 +208,7 @@ public class ControlMessageReaderTest {
        ControlMessage event = reader.next();

        Assert.assertEquals(ControlMessage.TYPE_GET_CLIPBOARD, event.getType());
+        Assert.assertEquals(1, (event.getFlags() & ControlMessage.FLAGS_COPY));
    }

    @Test
@@ -216,8 +218,9 @@ public class ControlMessageReaderTest {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(bos);
        dos.writeByte(ControlMessage.TYPE_SET_CLIPBOARD);
+        dos.writeByte(1); // paste
        byte[] text = "testé".getBytes(StandardCharsets.UTF_8);
-        dos.writeInt(text.length);
+        dos.writeShort(text.length);
        dos.write(text);

        byte[] packet = bos.toByteArray();
@@ -227,6 +230,9 @@ public class ControlMessageReaderTest {

        Assert.assertEquals(ControlMessage.TYPE_SET_CLIPBOARD, event.getType());
        Assert.assertEquals("testé", event.getText());
+
+        boolean parse = (event.getFlags() & ControlMessage.FLAGS_PASTE) != 0;
+        Assert.assertTrue(parse);
    }

    @Test
@@ -238,10 +244,11 @@ public class ControlMessageReaderTest {
        dos.writeByte(ControlMessage.TYPE_SET_CLIPBOARD);

        byte[] rawText = new byte[ControlMessageReader.CLIPBOARD_TEXT_MAX_LENGTH];
+        dos.writeByte(1); // paste
        Arrays.fill(rawText, (byte) 'a');
        String text = new String(rawText, 0, rawText.length);

-        dos.writeInt(rawText.length);
+        dos.writeShort(rawText.length);
        dos.write(rawText);

        byte[] packet = bos.toByteArray();
@@ -251,6 +258,9 @@ public class ControlMessageReaderTest {

        Assert.assertEquals(ControlMessage.TYPE_SET_CLIPBOARD, event.getType());
        Assert.assertEquals(text, event.getText());
+
+        boolean parse = (event.getFlags() & ControlMessage.FLAGS_PASTE) != 0;
+        Assert.assertTrue(parse);
    }

    @Test
--- a/server/src/test/java/com/genymobile/scrcpy/DeviceMessageWriterTest.java
+++ b/server/src/test/java/com/genymobile/scrcpy/DeviceMessageWriterTest.java
@@ -19,7 +19,7 @@ public class DeviceMessageWriterTest {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(bos);
        dos.writeByte(DeviceMessage.TYPE_CLIPBOARD);
-        dos.writeInt(data.length);
+        dos.writeShort(data.length);
        dos.write(data);

        byte[] expected = bos.toByteArray();
Author	SHA1	Message	Date
Romain Vimont	7a77f3bab4	Copy on "get clipboard" if possible Ctrl+c synchronizes the Android device clipboard to the computer clipboard. To make the copy more straightforward, if the device runs at least Android 7, also send a COPY keycode before copying the clipboard. <https://developer.android.com/reference/android/view/KeyEvent.html#KEYCODE_COPY>	2020-05-28 12:02:21 +02:00
Romain Vimont	0f6cdc56fa	Expose method to inject PASTE on Device This will allow a consistent implementation for injecting COPY.	2020-05-28 12:02:21 +02:00
Romain Vimont	09bb6a68cf	Add more convenience methods for injection Expose methods to inject key events and key codes with an additional parameter to specify the "mode" (async, wait for finish, wait for result).	2020-05-28 12:02:21 +02:00
Romain Vimont	f9ddf31c32	Forward SHIFT to the device This allows to select text with Shift + arrow keys. Fixes #942 <https://github.com/Genymobile/scrcpy/issues/942>.	2020-05-28 12:02:20 +02:00