Toggle "raw key events" via shortcut

The "raw key events" mode may need to be toggled while scrcpy is running (e.g. to type text then play a game). Remove the command-line argument and bind Ctrl+k to toggle the mode.
Add "raw key events" mode
2018-08-15 21:07:50 +02:00 · 2018-08-15 20:29:07 +02:00
22 changed files with 367 additions and 478 deletions
@@ -1,236 +0,0 @@
 # Build scrcpy
 Here are the instructions to build _scrcpy_ (client and server).
 You may want to build only the client: the server binary, which will be pushed
 to the Android device, does not depend on your system and architecture. In that
 case, use the [prebuilt server] (so you will not need Java or the Android SDK).
 [prebuilt server]: #prebuilt-server
 ## Requirements
 You need [adb]. It is available in the [Android SDK platform
 tools][platform-tools], or packaged in your distribution (`android-adb-tools`).
 On Windows, download the [platform-tools][platform-tools-windows] and extract
 the following files to a directory accessible from your `PATH`:
 - `adb.exe`
 - `AdbWinApi.dll`
 - `AdbWinUsbApi.dll`
 The client requires [FFmpeg] and [LibSDL2]. Just follow the instructions.
 [adb]: https://developer.android.com/studio/command-line/adb.html
 [platform-tools]: https://developer.android.com/studio/releases/platform-tools.html
 [platform-tools-windows]: https://dl.google.com/android/repository/platform-tools-latest-windows.zip
 [ffmpeg]: https://en.wikipedia.org/wiki/FFmpeg
 [LibSDL2]: https://en.wikipedia.org/wiki/Simple_DirectMedia_Layer
 ## System-specific steps
 ### Linux
 Install the required packages from your package manager.
 #### Debian/Ubuntu
 ```bash
 # runtime dependencies
 sudo apt install ffmpeg libsdl2-2.0.0
 # client build dependencies
 sudo apt install make gcc pkg-config meson \
                 libavcodec-dev libavformat-dev libavutil-dev \
                 libsdl2-dev
 # server build dependencies
 sudo apt install openjdk-8-jdk
 ```
 #### Fedora
 ```bash
 # enable RPM fusion free
 sudo dnf install https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm
 # client build dependencies
 sudo dnf install SDL2-devel ffms2-devel meson gcc make
 # server build dependencies
 sudo dnf install java
 ```
 ### Windows
 #### Cross-compile from Linux
 This is the preferred method (and the way the release is built).
 From _Debian_, install _mingw_:
 ```bash
 sudo apt install mingw-w64 mingw-w64-tools
 ```
 You also need the JDK to build the server:
 ```bash
 sudo apt install openjdk-8-jdk
 ```
 Then generate the releases:
 ```bash
 make -f Makefile.CrossWindows
 ```
 It will generate win32 and win64 releases into `dist/`.
 #### In MSYS2
 From Windows, you need [MSYS2] to build the project. From an MSYS2 terminal,
 install the required packages:
 [MSYS2]: http://www.msys2.org/
 ```bash
 # runtime dependencies
 pacman -S mingw-w64-x86_64-SDL2 \
          mingw-w64-x86_64-ffmpeg
 # client build dependencies
 pacman -S mingw-w64-x86_64-make \
          mingw-w64-x86_64-gcc \
          mingw-w64-x86_64-pkg-config \
          mingw-w64-x86_64-meson
 ```
 For a 32 bits version, replace `x86_64` by `i686`:
 ```bash
 # runtime dependencies
 pacman -S mingw-w64-i686-SDL2 \
          mingw-w64-i686-ffmpeg
 # client build dependencies
 pacman -S mingw-w64-i686-make \
          mingw-w64-i686-gcc \
          mingw-w64-i686-pkg-config \
          mingw-w64-i686-meson
 ```
 Java (>= 7) is not available in MSYS2, so if you plan to build the server,
 install it manually and make it available from the `PATH`:
 ```bash
 export PATH="$JAVA_HOME/bin:$PATH"
 ```
 ### Mac OS
 Install the packages with [Homebrew]:
 [Homebrew]: https://brew.sh/
 ```bash
 # runtime dependencies
 brew install sdl2 ffmpeg
 # client build dependencies
 brew install pkg-config meson
 ```
 Additionally, if you want to build the server, install Java 8 from Caskroom, and
 make it avaliable from the `PATH`:
 ```bash
 brew tap caskroom/versions
 brew cask install java8
 export JAVA_HOME="$(/usr/libexec/java_home --version 1.8)"
 export PATH="$JAVA_HOME/bin:$PATH"
 ```
 ### Docker
 See [pierlon/scrcpy-docker](https://github.com/pierlon/scrcpy-docker).
 ## Common steps
 If you want to build the server, install the [Android SDK] (_Android Studio_),
 and set `ANDROID_HOME` to its directory. For example:
 [Android SDK]: https://developer.android.com/studio/index.html
 ```bash
 export ANDROID_HOME=~/android/sdk
 ```
 If you don't want to build the server, use the [prebuilt server].
 Clone the project:
 ```bash
 git clone https://github.com/Genymobile/scrcpy
 cd scrcpy
 ```
 Then, build:
 ```bash
 meson x --buildtype release --strip -Db_lto=true
 cd x
 ninja
 ```
 ### Run
 To run without installing:
 ```bash
 ./run x [options]
 ```
 ### Install
 After a successful build, you can install _scrcpy_ on the system:
 ```bash
 sudo ninja install    # without sudo on Windows
 ```
 This installs two files:
 - `/usr/local/bin/scrcpy`
 - `/usr/local/share/scrcpy/scrcpy-server.jar`
 Just remove them to "uninstall" the application.
 You can then [run](README.md#run) _scrcpy_.
 ## Prebuilt server
 - [`scrcpy-server-v1.3.jar`][direct-scrcpy-server].  
   _(SHA-256: 0f9a5a217f33f0ed7a1498ceb3c0cccf31c53533893aa952e674c1571d2740c1)_
 [direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.3/scrcpy-server-v1.3.jar
 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
 ```bash
 meson x --buildtype release --strip -Db_lto=true \
    -Dprebuilt_server=/path/to/scrcpy-server.jar
 cd x
 ninja
 sudo ninja install
 ```
@@ -26,11 +26,10 @@ If you still encounter problems, please see [issue 9].
 ### I get a black screen for some applications like Silence
-This is expected, they requested to [protect] the screen.
+This is expected, they requested to protect the screen.
 In [Silence], you can disable it in settings → Privacy → Screen security.
 [protect]: https://developer.android.com/reference/android/view/Display#FLAG_SECURE
 [silence]: https://f-droid.org/en/packages/org.smssecure.smssecure/
 See [issue 36].
@@ -11,33 +11,70 @@ It works on _GNU/Linux_, _Windows_ and _MacOS_.
 The Android part requires at least API 21 (Android 5.0).
 You need [adb]. It is available in the [Android SDK platform
 tools][platform-tools], or packaged in your distribution (`android-adb-tools`).
 On Windows, just [download scrcpy for Windows](#windows), `adb` is included.
 Make sure you [enabled adb debugging][enable-adb] on your device(s).
 The client requires [FFmpeg] and [LibSDL2]. On Windows, they are included in the
 [prebuilt application](#windows).
 [adb]: https://developer.android.com/studio/command-line/adb.html
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 [platform-tools]: https://developer.android.com/studio/releases/platform-tools.html
 [platform-tools-windows]: https://dl.google.com/android/repository/platform-tools-latest-windows.zip
 [ffmpeg]: https://en.wikipedia.org/wiki/FFmpeg
 [LibSDL2]: https://en.wikipedia.org/wiki/Simple_DirectMedia_Layer
 ## Build and install
-## Get the app
+### System-specific steps
 #### Linux
-### Linux
+Install the required packages from your package manager.
-On Linux, you typically need to [build the app manually][BUILD]. Don't worry,
+##### Debian/Ubuntu
 it's not that hard.
-For Arch Linux, two [AUR] packages have been created by users:
+```bash
 # runtime dependencies
 sudo apt install ffmpeg libsdl2-2.0.0
 # client build dependencies
 sudo apt install make gcc pkg-config meson \
                 libavcodec-dev libavformat-dev libavutil-dev \
                 libsdl2-dev
 # server build dependencies
 sudo apt install openjdk-8-jdk
 ```
 ##### Fedora
 ```bash
 # enable RPM fusion free
 sudo dnf install https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm
 # client build dependencies
 sudo dnf install SDL2-devel ffms2-devel meson gcc make
 # server build dependencies
 sudo dnf install java
 ```
 ##### Arch Linux
 Two [AUR] packages have been created by users:
 - [`scrcpy`](https://aur.archlinux.org/packages/scrcpy/)
 - [`scrcpy-prebuiltserver`](https://aur.archlinux.org/packages/scrcpy-prebuiltserver/)
 [AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
 For Gentoo, an [Ebuild] is available: [`scrcpy/`][ebuild-link].
-[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
+#### Windows
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
 ### Windows
 For Windows, for simplicity, prebuilt archives with all the dependencies
 (including `adb`) are available:
@@ -50,10 +87,80 @@ For Windows, for simplicity, prebuilt archives with all the dependencies
 [direct-win32]: https://github.com/Genymobile/scrcpy/releases/download/v1.3/scrcpy-win32-v1.3.zip
 [direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.3/scrcpy-win64-v1.3.zip
-You can also [build the app manually][BUILD].
+Instead, you may want to build it manually.
 In that case, download the [platform-tools][platform-tools-windows] and extract
 the following files to a directory accessible from your `PATH`:
 - `adb.exe`
 - `AdbWinApi.dll`
 - `AdbWinUsbApi.dll`
 ##### Cross-compile from Linux
 This is the preferred method (and the way the release is built).
 From _Debian_, install _mingw_:
 ```bash
 sudo apt install mingw-w64 mingw-w64-tools
 ```
 You also need the JDK to build the server:
 ```bash
 sudo apt install openjdk-8-jdk
 ```
 Then generate the releases:
 ```bash
 make -f Makefile.CrossWindows
 ```
 It will generate win32 and win64 releases into `dist/`.
-### Mac OS
+##### In MSYS2
 From Windows, you need [MSYS2] to build the project. From an MSYS2 terminal,
 install the required packages:
 [MSYS2]: http://www.msys2.org/
 ```bash
 # runtime dependencies
 pacman -S mingw-w64-x86_64-SDL2 \
          mingw-w64-x86_64-ffmpeg
 # client build dependencies
 pacman -S mingw-w64-x86_64-make \
          mingw-w64-x86_64-gcc \
          mingw-w64-x86_64-pkg-config \
          mingw-w64-x86_64-meson
 ```
 For a 32 bits version, replace `x86_64` by `i686`:
 ```bash
 # runtime dependencies
 pacman -S mingw-w64-i686-SDL2 \
          mingw-w64-i686-ffmpeg
 # client build dependencies
 pacman -S mingw-w64-i686-make \
          mingw-w64-i686-gcc \
          mingw-w64-i686-pkg-config \
          mingw-w64-i686-meson
 ```
 Java (>= 7) is not available in MSYS2, so if you plan to build the server,
 install it manually and make it available from the `PATH`:
 ```bash
 export PATH="$JAVA_HOME/bin:$PATH"
 ```
 #### Mac OS
 The application is available in [Homebrew]. Just install it:
@@ -63,18 +170,106 @@ The application is available in [Homebrew]. Just install it:
 brew install scrcpy
 ```
-You need `adb`, accessible from your `PATH`. If you don't have it yet:
+Instead, you may want to build it manually. Install the packages:
 ```bash
-brew cask install android-platform-tools
+# runtime dependencies
 brew install sdl2 ffmpeg
 # client build dependencies
 brew install pkg-config meson
 ```
-You can also [build the app manually][BUILD].
+Additionally, if you want to build the server, install Java 8 from Caskroom, and
 make it avaliable from the `PATH`:
 ```bash
 brew tap caskroom/versions
 brew cask install java8
 export JAVA_HOME="$(/usr/libexec/java_home --version 1.8)"
 export PATH="$JAVA_HOME/bin:$PATH"
 ```
 #### Docker
 See [pierlon/scrcpy-docker](https://github.com/pierlon/scrcpy-docker).
 ### Common steps
 Install the [Android SDK] (_Android Studio_), and set `ANDROID_HOME` to
 its directory. For example:
 [Android SDK]: https://developer.android.com/studio/index.html
 ```bash
 export ANDROID_HOME=~/android/sdk
 ```
 Clone the project:
 ```bash
 git clone https://github.com/Genymobile/scrcpy
 cd scrcpy
 ```
 Then, build:
 ```bash
 meson x --buildtype release --strip -Db_lto=true
 cd x
 ninja
 ```
 You can test it from here:
 ```bash
 ninja run
 ```
 Or you can install it on the system:
 ```bash
 sudo ninja install    # without sudo on Windows
 ```
 This installs two files:
 - `/usr/local/bin/scrcpy`
 - `/usr/local/share/scrcpy/scrcpy-server.jar`
 Just remove them to "uninstall" the application.
 #### Prebuilt server
 Since the server binary, that will be pushed to the Android device, does not
 depend on your system and architecture, you may want to use the prebuilt binary
 instead:
 - [`scrcpy-server-v1.3.jar`][direct-scrcpy-server].  
   _(SHA-256: 0f9a5a217f33f0ed7a1498ceb3c0cccf31c53533893aa952e674c1571d2740c1)_
 [direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.3/scrcpy-server-v1.3.jar
 In that case, the build does not require Java or the Android SDK.
 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
 ```bash
 meson x --buildtype release --strip -Db_lto=true \
    -Dprebuilt_server=/path/to/scrcpy-server.jar
 cd x
 ninja
 sudo ninja install
 ```
 ## Run
-Plug an Android device, and execute:
+_At runtime, `adb` must be accessible from your `PATH`._
 If everything is ok, just plug an Android device, and execute:
 ```bash
 scrcpy
@@ -117,11 +312,14 @@ To show physical touches while scrcpy is running:
 scrcpy -t
 ```
-The app may be started directly in fullscreen:
+To run without installing:
 ```bash
 ./run x [options]
 ```
-scrcpy -f
+
-```
+(where `x` is your build directory).
 ## Shortcuts
@@ -140,12 +338,15 @@ scrcpy -f
 | turn screen on                         | _Right-click²_                |
 | paste computer clipboard to device     | `Ctrl`+`v`                    |
 | enable/disable FPS counter (on stdout) | `Ctrl`+`i`                    |
 | toggle "raw key events" mode ([#87])   | `Ctrl`+`k`                    |
 | install APK from computer              | drag & drop APK file          |
 | push file to `/sdcard/`                | drag & drop non-APK file      |
 _¹Double-click on black borders to remove them._  
 _²Right-click turns the screen on if it was off, presses BACK otherwise._
 [#87]: https://github.com/Genymobile/scrcpy/issues/87
 ## Why _scrcpy_?
@@ -157,13 +358,6 @@ A colleague challenged me to find a name as unpronounceable as [gnirehtet].
 [`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
 ## How to build?
 See [BUILD].
 [BUILD]: BUILD.md
 ## Common issues
 See the [FAQ](FAQ.md).
@@ -85,7 +85,7 @@ conf = configuration_data()
 conf.set('BUILD_DEBUG', get_option('buildtype') == 'debug')
 # the version, updated on release
-conf.set_quoted('SCRCPY_VERSION', '1.4')
+conf.set_quoted('SCRCPY_VERSION', '1.3')
 # the prefix used during configuration (meson --prefix=PREFIX)
 conf.set_quoted('PREFIX', get_option('prefix'))
@@ -18,25 +18,9 @@ static inline const char *get_adb_command() {
    return adb_command;
 }
 static void show_adb_err_msg(enum process_result err) {
    switch (err) {
        case PROCESS_ERROR_GENERIC:
            LOGE("Failed to execute adb");
            break;
        case PROCESS_ERROR_MISSING_BINARY:
            LOGE("'adb' command not found (make it accessible from your PATH "
                  "or define its full path in the ADB environment variable)");
            break;
        case PROCESS_SUCCESS:
            /* do nothing */
            break;
    }
 }
 process_t adb_execute(const char *serial, const char *const adb_cmd[], int len) {
    const char *cmd[len + 4];
    int i;
    process_t process;
    cmd[0] = get_adb_command();
    if (serial) {
        cmd[1] = "-s";
@@ -48,12 +32,7 @@ process_t adb_execute(const char *serial, const char *const adb_cmd[], int len)
    memcpy(&cmd[i], adb_cmd, len * sizeof(const char *));
    cmd[len + i] = NULL;
-    enum process_result r = cmd_execute(cmd[0], cmd, &process);
+    return cmd_execute(cmd[0], cmd);
    if (r != PROCESS_SUCCESS) {
        show_adb_err_msg(r);
        return PROCESS_NONE;
    }
    return process;
 }
 process_t adb_forward(const char *serial, uint16_t local_port, const char *device_socket_name) {
@@ -32,13 +32,7 @@
 #endif
 # define NO_EXIT_CODE -1
-enum process_result {
+process_t cmd_execute(const char *path, const char *const argv[]);
    PROCESS_SUCCESS,
    PROCESS_ERROR_GENERIC,
    PROCESS_ERROR_MISSING_BINARY,
 };
 enum process_result cmd_execute(const char *path, const char *const argv[], process_t *process);
 SDL_bool cmd_terminate(process_t pid);
 SDL_bool cmd_simple_wait(process_t pid, exit_code_t *exit_code);
@@ -70,7 +70,84 @@ static enum android_metastate convert_meta_state(SDL_Keymod mod) {
    return autocomplete_metastate(metastate);
 }
-static SDL_bool convert_keycode(SDL_Keycode from, enum android_keycode *to, Uint16 mod) {
+// only used if raw_key_events is enabled
 static SDL_bool convert_text_keycode(SDL_Keycode from, enum android_keycode *to) {
    switch (from) {
        MAP(SDLK_SPACE,         AKEYCODE_SPACE);
        MAP(SDLK_HASH,          AKEYCODE_POUND);
        MAP(SDLK_QUOTE,         AKEYCODE_APOSTROPHE);
        MAP(SDLK_ASTERISK,      AKEYCODE_STAR);
        MAP(SDLK_COMMA,         AKEYCODE_COMMA);
        MAP(SDLK_MINUS,         AKEYCODE_MINUS);
        MAP(SDLK_PERIOD,        AKEYCODE_PERIOD);
        MAP(SDLK_SLASH,         AKEYCODE_SLASH);
        MAP(SDLK_0,             AKEYCODE_0);
        MAP(SDLK_1,             AKEYCODE_1);
        MAP(SDLK_2,             AKEYCODE_2);
        MAP(SDLK_3,             AKEYCODE_3);
        MAP(SDLK_4,             AKEYCODE_4);
        MAP(SDLK_5,             AKEYCODE_5);
        MAP(SDLK_6,             AKEYCODE_6);
        MAP(SDLK_7,             AKEYCODE_7);
        MAP(SDLK_8,             AKEYCODE_8);
        MAP(SDLK_9,             AKEYCODE_9);
        MAP(SDLK_SEMICOLON,     AKEYCODE_SEMICOLON);
        MAP(SDLK_EQUALS,        AKEYCODE_EQUALS);
        MAP(SDLK_AT,            AKEYCODE_AT);
        MAP(SDLK_LEFTBRACKET,   AKEYCODE_LEFT_BRACKET);
        MAP(SDLK_BACKSLASH,     AKEYCODE_BACKSLASH);
        MAP(SDLK_RIGHTBRACKET,  AKEYCODE_RIGHT_BRACKET);
        MAP(SDLK_BACKQUOTE,     AKEYCODE_GRAVE);
        MAP(SDLK_a,             AKEYCODE_A);
        MAP(SDLK_b,             AKEYCODE_B);
        MAP(SDLK_c,             AKEYCODE_C);
        MAP(SDLK_d,             AKEYCODE_D);
        MAP(SDLK_e,             AKEYCODE_E);
        MAP(SDLK_f,             AKEYCODE_F);
        MAP(SDLK_g,             AKEYCODE_G);
        MAP(SDLK_h,             AKEYCODE_H);
        MAP(SDLK_i,             AKEYCODE_I);
        MAP(SDLK_j,             AKEYCODE_J);
        MAP(SDLK_k,             AKEYCODE_K);
        MAP(SDLK_l,             AKEYCODE_L);
        MAP(SDLK_m,             AKEYCODE_M);
        MAP(SDLK_n,             AKEYCODE_N);
        MAP(SDLK_o,             AKEYCODE_O);
        MAP(SDLK_p,             AKEYCODE_P);
        MAP(SDLK_q,             AKEYCODE_Q);
        MAP(SDLK_r,             AKEYCODE_R);
        MAP(SDLK_s,             AKEYCODE_S);
        MAP(SDLK_t,             AKEYCODE_T);
        MAP(SDLK_u,             AKEYCODE_U);
        MAP(SDLK_v,             AKEYCODE_V);
        MAP(SDLK_w,             AKEYCODE_W);
        MAP(SDLK_x,             AKEYCODE_X);
        MAP(SDLK_y,             AKEYCODE_Y);
        MAP(SDLK_z,             AKEYCODE_Z);
        MAP(SDLK_KP_ENTER,      AKEYCODE_NUMPAD_ENTER);
        MAP(SDLK_KP_1,          AKEYCODE_NUMPAD_1);
        MAP(SDLK_KP_2,          AKEYCODE_NUMPAD_2);
        MAP(SDLK_KP_3,          AKEYCODE_NUMPAD_3);
        MAP(SDLK_KP_4,          AKEYCODE_NUMPAD_4);
        MAP(SDLK_KP_5,          AKEYCODE_NUMPAD_5);
        MAP(SDLK_KP_6,          AKEYCODE_NUMPAD_6);
        MAP(SDLK_KP_7,          AKEYCODE_NUMPAD_7);
        MAP(SDLK_KP_8,          AKEYCODE_NUMPAD_8);
        MAP(SDLK_KP_9,          AKEYCODE_NUMPAD_9);
        MAP(SDLK_KP_0,          AKEYCODE_NUMPAD_0);
        MAP(SDLK_KP_DIVIDE,     AKEYCODE_NUMPAD_DIVIDE);
        MAP(SDLK_KP_MULTIPLY,   AKEYCODE_NUMPAD_MULTIPLY);
        MAP(SDLK_KP_MINUS,      AKEYCODE_NUMPAD_SUBTRACT);
        MAP(SDLK_KP_PLUS,       AKEYCODE_NUMPAD_ADD);
        MAP(SDLK_KP_PERIOD,     AKEYCODE_NUMPAD_DOT);
        MAP(SDLK_KP_EQUALS,     AKEYCODE_NUMPAD_EQUALS);
        MAP(SDLK_KP_LEFTPAREN,  AKEYCODE_NUMPAD_LEFT_PAREN);
        MAP(SDLK_KP_RIGHTPAREN, AKEYCODE_NUMPAD_RIGHT_PAREN);
        FAIL;
    }
 }
 static SDL_bool convert_keycode(SDL_Keycode from, enum android_keycode *to) {
    switch (from) {
        MAP(SDLK_RETURN,       AKEYCODE_ENTER);
        MAP(SDLK_KP_ENTER,     AKEYCODE_NUMPAD_ENTER);
@@ -86,39 +163,6 @@ static SDL_bool convert_keycode(SDL_Keycode from, enum android_keycode *to, Uint
        MAP(SDLK_LEFT,         AKEYCODE_DPAD_LEFT);
        MAP(SDLK_DOWN,         AKEYCODE_DPAD_DOWN);
        MAP(SDLK_UP,           AKEYCODE_DPAD_UP);
    }
    if (mod & (KMOD_LALT | KMOD_RALT | KMOD_LGUI | KMOD_RGUI)) {
        return SDL_FALSE;
    }
    // if ALT and META are not pressed, also handle letters and space
    switch (from) {
        MAP(SDLK_a,            AKEYCODE_A);
        MAP(SDLK_b,            AKEYCODE_B);
        MAP(SDLK_c,            AKEYCODE_C);
        MAP(SDLK_d,            AKEYCODE_D);
        MAP(SDLK_e,            AKEYCODE_E);
        MAP(SDLK_f,            AKEYCODE_F);
        MAP(SDLK_g,            AKEYCODE_G);
        MAP(SDLK_h,            AKEYCODE_H);
        MAP(SDLK_i,            AKEYCODE_I);
        MAP(SDLK_j,            AKEYCODE_J);
        MAP(SDLK_k,            AKEYCODE_K);
        MAP(SDLK_l,            AKEYCODE_L);
        MAP(SDLK_m,            AKEYCODE_M);
        MAP(SDLK_n,            AKEYCODE_N);
        MAP(SDLK_o,            AKEYCODE_O);
        MAP(SDLK_p,            AKEYCODE_P);
        MAP(SDLK_q,            AKEYCODE_Q);
        MAP(SDLK_r,            AKEYCODE_R);
        MAP(SDLK_s,            AKEYCODE_S);
        MAP(SDLK_t,            AKEYCODE_T);
        MAP(SDLK_u,            AKEYCODE_U);
        MAP(SDLK_v,            AKEYCODE_V);
        MAP(SDLK_w,            AKEYCODE_W);
        MAP(SDLK_x,            AKEYCODE_X);
        MAP(SDLK_y,            AKEYCODE_Y);
        MAP(SDLK_z,            AKEYCODE_Z);
        MAP(SDLK_SPACE,        AKEYCODE_SPACE);
        FAIL;
    }
 }
@@ -152,19 +196,22 @@ static enum android_motionevent_buttons convert_mouse_buttons(Uint32 state) {
 }
 SDL_bool input_key_from_sdl_to_android(const SDL_KeyboardEvent *from,
-                                       struct control_event *to) {
+                                       struct control_event *to,
                                       SDL_bool raw_key_events) {
    to->type = CONTROL_EVENT_TYPE_KEYCODE;
    if (!convert_keycode_action(from->type, &to->keycode_event.action)) {
        return SDL_FALSE;
    }
-    Uint16 mod = from->keysym.mod;
+    if (!convert_keycode(from->keysym.sym, &to->keycode_event.keycode)) {
-    if (!convert_keycode(from->keysym.sym, &to->keycode_event.keycode, mod)) {
+        if (!raw_key_events ||
-        return SDL_FALSE;
+                !convert_text_keycode(from->keysym.sym, &to->keycode_event.keycode)) {
            return SDL_FALSE;
        }
    }
-    to->keycode_event.metastate = convert_meta_state(mod);
+    to->keycode_event.metastate = convert_meta_state(from->keysym.mod);
    return SDL_TRUE;
 }
@@ -16,7 +16,9 @@ struct complete_mouse_wheel_event {
 };
 SDL_bool input_key_from_sdl_to_android(const SDL_KeyboardEvent *from,
-                                       struct control_event *to);
+                                       struct control_event *to,
                                       SDL_bool raw_key_events);
 SDL_bool mouse_button_from_sdl_to_android(const SDL_MouseButtonEvent *from,
                                          struct size screen_size,
                                          struct control_event *to);
@@ -1,5 +1,5 @@
 #ifndef FILE_HANDLER_H
-#define FILE_HANDLER_H
+#define FILE_HADNELR_H
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_stdinc.h>
@@ -1,6 +1,5 @@
 #include "input_manager.h"
 #include <SDL2/SDL_assert.h>
 #include "convert.h"
 #include "lock_util.h"
 #include "log.h"
@@ -130,10 +129,8 @@ static void clipboard_paste(struct controller *controller) {
 void input_manager_process_text_input(struct input_manager *input_manager,
                                      const SDL_TextInputEvent *event) {
-    char c = event->text[0];
+    if (input_manager->raw_key_events) {
-    if (isalpha(c) || c == ' ') {
+        // we will forward the raw key events instead
        SDL_assert(event->text[1] == '\0');
        // letters and space are handled as raw key event
        return;
    }
    struct control_event control_event;
@@ -223,13 +220,21 @@ void input_manager_process_key(struct input_manager *input_manager,
                    switch_fps_counter_state(input_manager->frames);
                }
                return;
            case SDLK_k:
                if (!repeat && event->type == SDL_KEYDOWN) {
                    input_manager->raw_key_events ^= SDL_TRUE; // toggle
                    LOGI("Raw key events mode %s",
                         input_manager->raw_key_events ? "enabled" : "disabled");
                }
                return;
        }
        return;
    }
    struct control_event control_event;
-    if (input_key_from_sdl_to_android(event, &control_event)) {
+    SDL_bool raw_key_events = input_manager->raw_key_events;
    if (input_key_from_sdl_to_android(event, &control_event, raw_key_events)) {
        if (!controller_push_event(input_manager->controller, &control_event)) {
            LOGW("Cannot send control event");
        }
@@ -11,6 +11,7 @@ struct input_manager {
    struct controller *controller;
    struct frames *frames;
    struct screen *screen;
    SDL_bool raw_key_events;
 };
 void input_manager_process_text_input(struct input_manager *input_manager,
@@ -11,7 +11,6 @@
 struct args {
    const char *serial;
    const char *crop;
    SDL_bool fullscreen;
    SDL_bool help;
    SDL_bool version;
    SDL_bool show_touches;
@@ -37,9 +36,6 @@ static void usage(const char *arg0) {
        "        (typically, portrait for a phone, landscape for a tablet).\n"
        "        Any --max-size value is computed on the cropped size.\n"
        "\n"
        "    -f, --fullscreen\n"
        "        Start in fullscreen.\n"
        "\n"
        "    -h, --help\n"
        "        Print this help.\n"
        "\n"
@@ -204,7 +200,6 @@ static SDL_bool parse_args(struct args *args, int argc, char *argv[]) {
    static const struct option long_options[] = {
        {"bit-rate",     required_argument, NULL, 'b'},
        {"crop",         required_argument, NULL, 'c'},
        {"fullscreen",   no_argument,       NULL, 'f'},
        {"help",         no_argument,       NULL, 'h'},
        {"max-size",     required_argument, NULL, 'm'},
        {"port",         required_argument, NULL, 'p'},
@@ -214,7 +209,7 @@ static SDL_bool parse_args(struct args *args, int argc, char *argv[]) {
        {NULL,           0,                 NULL, 0  },
    };
    int c;
-    while ((c = getopt_long(argc, argv, "b:c:fhm:p:s:tv", long_options, NULL)) != -1) {
+    while ((c = getopt_long(argc, argv, "b:c:hm:p:s:tv", long_options, NULL)) != -1) {
        switch (c) {
            case 'b':
                if (!parse_bit_rate(optarg, &args->bit_rate)) {
@@ -224,9 +219,6 @@ static SDL_bool parse_args(struct args *args, int argc, char *argv[]) {
            case 'c':
                args->crop = optarg;
                break;
            case 'f':
                args->fullscreen = SDL_TRUE;
                break;
            case 'h':
                args->help = SDL_TRUE;
                break;
@@ -313,17 +305,10 @@ int main(int argc, char *argv[]) {
        .max_size = args.max_size,
        .bit_rate = args.bit_rate,
        .show_touches = args.show_touches,
        .fullscreen = args.fullscreen,
    };
    int res = scrcpy(&options) ? 0 : 1;
    avformat_network_deinit(); // ignore failure
 #if defined (__WINDOWS__) && ! defined (WINDOWS_NOCONSOLE)
    if (res != 0) {
        fprintf(stderr, "Press any key to continue...\n");
        getchar();
    }
 #endif
    return res;
 }
@@ -35,6 +35,7 @@ static struct input_manager input_manager = {
    .controller = &controller,
    .frames = &frames,
    .screen = &screen,
    .raw_key_events = SDL_FALSE,
 };
 #if defined(__APPLE__) || defined(__WINDOWS__)
@@ -223,10 +224,6 @@ SDL_bool scrcpy(const struct scrcpy_options *options) {
        show_touches_waited = SDL_TRUE;
    }
    if (options->fullscreen) {
        screen_switch_fullscreen(&screen);
    }
    ret = event_loop();
    LOGD("quit...");
@@ -10,7 +10,6 @@ struct scrcpy_options {
    Uint16 max_size;
    Uint32 bit_rate;
    SDL_bool show_touches;
    SDL_bool fullscreen;
 };
 SDL_bool scrcpy(const struct scrcpy_options *options);
@@ -1,7 +1,5 @@
 #include "command.h"
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/types.h>
@@ -9,65 +7,18 @@
 #include <unistd.h>
 #include "log.h"
-enum process_result cmd_execute(const char *path, const char *const argv[], pid_t *pid) {
+pid_t cmd_execute(const char *path, const char *const argv[]) {
-    int fd[2];
+    pid_t pid = fork();
-
+    if (pid == -1) {
    if (pipe(fd) == -1) {
        perror("pipe");
        return PROCESS_ERROR_GENERIC;
    }
    enum process_result ret = PROCESS_SUCCESS;
    *pid = fork();
    if (*pid == -1) {
        perror("fork");
-        ret = PROCESS_ERROR_GENERIC;
+        return -1;
        goto end;
    }
-
+    if (pid == 0) {
-    if (*pid > 0) {
+        execvp(path, (char *const *)argv);
-        // parent close write side
+        perror("exec");
        close(fd[1]);
        fd[1] = -1;
        // wait for EOF or receive errno from child
        if (read(fd[0], &ret, sizeof(ret)) == -1) {
            perror("read");
            ret = PROCESS_ERROR_GENERIC;
            goto end;
        }
    } else if (*pid == 0) {
        // child close read side
        close(fd[0]);
        if (fcntl(fd[1], F_SETFD, FD_CLOEXEC) == 0) {
            execvp(path, (char *const *)argv);
            if (errno == ENOENT) {
                ret = PROCESS_ERROR_MISSING_BINARY;
            } else {
                ret = PROCESS_ERROR_GENERIC;
            }
            perror("exec");
        } else {
            perror("fcntl");
            ret = PROCESS_ERROR_GENERIC;
        }
        // send ret to the parent
        if (write(fd[1], &ret, sizeof(ret)) == -1) {
            perror("write");
        }
        // close write side before exiting
        close(fd[1]);
        _exit(1);
    }
-
+    return pid;
 end:
    if (fd[0] != -1) {
        close(fd[0]);
    }
    if (fd[1] != -1) {
        close(fd[1]);
    }
    return ret;
 }
 SDL_bool cmd_terminate(pid_t pid) {
@@ -4,7 +4,7 @@
 #include "log.h"
 #include "str_util.h"
-enum process_result cmd_execute(const char *path, const char *const argv[], HANDLE *handle) {
+HANDLE cmd_execute(const char *path, const char *const argv[]) {
    STARTUPINFO si;
    PROCESS_INFORMATION pi;
    memset(&si, 0, sizeof(si));
@@ -18,8 +18,7 @@ enum process_result cmd_execute(const char *path, const char *const argv[], HAND
    size_t ret = xstrjoin(cmd, argv, ' ', sizeof(cmd));
    if (ret >= sizeof(cmd)) {
        LOGE("Command too long (%" PRIsizet " chars)", sizeof(cmd) - 1);
-        *handle = NULL;
+        return NULL;
        return PROCESS_ERROR_GENERIC;
    }
 #ifdef WINDOWS_NOCONSOLE
@@ -28,15 +27,10 @@ enum process_result cmd_execute(const char *path, const char *const argv[], HAND
    int flags = 0;
 #endif
    if (!CreateProcess(NULL, cmd, NULL, NULL, FALSE, flags, NULL, NULL, &si, &pi)) {
-        *handle = NULL;
+        return NULL;
        if (GetLastError() == ERROR_FILE_NOT_FOUND) {
            return PROCESS_ERROR_MISSING_BINARY;
        }
        return PROCESS_ERROR_GENERIC;
    }
-    *handle = pi.hProcess;
+    return pi.hProcess;
    return PROCESS_SUCCESS;
 }
 SDL_bool cmd_terminate(HANDLE handle) {
@@ -35,6 +35,6 @@ prepare-sdl2:
 		SDL2-2.0.8
 prepare-adb:
-	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r28.0.1-windows.zip \
+	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r28.0.0-windows.zip \
-		db78f726d5dc653706dcd15a462ab1b946c643f598df76906c4c1858411c54df \
+		e2c1ec7c8e9b71cf1c8befd3bff91d06b26dd334c3f32b3817e9d46ba260b0e8 \
 		platform-tools
@@ -6,8 +6,8 @@ android {
        applicationId "com.genymobile.scrcpy"
        minSdkVersion 21
        targetSdkVersion 27
-        versionCode 5
+        versionCode 4
-        versionName "1.4"
+        versionName "1.3"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
@@ -5,9 +5,9 @@ import android.net.LocalSocket;
 import android.net.LocalSocketAddress;
 import java.io.Closeable;
 import java.io.FileDescriptor;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.nio.charset.StandardCharsets;
 public final class DesktopConnection implements Closeable {
@@ -18,14 +18,14 @@ public final class DesktopConnection implements Closeable {
    private final LocalSocket socket;
    private final InputStream inputStream;
-    private final FileDescriptor fd;
+    private final OutputStream outputStream;
    private final ControlEventReader reader = new ControlEventReader();
    private DesktopConnection(LocalSocket socket) throws IOException {
        this.socket = socket;
        inputStream = socket.getInputStream();
-        fd = socket.getFileDescriptor();
+        outputStream = socket.getOutputStream();
    }
    private static LocalSocket connect(String abstractName) throws IOException {
@@ -78,11 +78,11 @@ public final class DesktopConnection implements Closeable {
        buffer[DEVICE_NAME_FIELD_LENGTH + 1] = (byte) width;
        buffer[DEVICE_NAME_FIELD_LENGTH + 2] = (byte) (height >> 8);
        buffer[DEVICE_NAME_FIELD_LENGTH + 3] = (byte) height;
-        IO.writeFully(fd, buffer, 0, buffer.length);
+        outputStream.write(buffer, 0, buffer.length);
    }
-    public FileDescriptor getFd() {
+    public OutputStream getOutputStream() {
-        return fd;
+        return outputStream;
    }
    public ControlEvent receiveControlEvent() throws IOException {
@@ -1,31 +0,0 @@
 package com.genymobile.scrcpy;
 import android.system.ErrnoException;
 import android.system.Os;
 import android.system.OsConstants;
 import java.io.FileDescriptor;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 public class IO {
    private IO() {
        // not instantiable
    }
    public static void writeFully(FileDescriptor fd, ByteBuffer from) throws IOException {
        while (from.hasRemaining()) {
            try {
                Os.write(fd, from);
            } catch (ErrnoException e) {
                if (e.errno != OsConstants.EINTR) {
                    throw new IOException(e);
                }
            }
        }
    }
    public static void writeFully(FileDescriptor fd, byte[] buffer, int offset, int len) throws IOException {
        writeFully(fd, ByteBuffer.wrap(buffer, offset, len));
    }
 }
@@ -9,8 +9,8 @@ import android.media.MediaFormat;
 import android.os.IBinder;
 import android.view.Surface;
 import java.io.FileDescriptor;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.nio.ByteBuffer;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -48,7 +48,7 @@ public class ScreenEncoder implements Device.RotationListener {
        return rotationChanged.getAndSet(false);
    }
-    public void streamScreen(Device device, FileDescriptor fd) throws IOException {
+    public void streamScreen(Device device, OutputStream outputStream) throws IOException {
        MediaFormat format = createFormat(bitRate, frameRate, iFrameInterval);
        device.setRotationListener(this);
        boolean alive;
@@ -64,7 +64,7 @@ public class ScreenEncoder implements Device.RotationListener {
                setDisplaySurface(display, surface, contentRect, videoRect);
                codec.start();
                try {
-                    alive = encode(codec, fd);
+                    alive = encode(codec, outputStream);
                } finally {
                    codec.stop();
                    destroyDisplay(display);
@@ -77,7 +77,9 @@ public class ScreenEncoder implements Device.RotationListener {
        }
    }
-    private boolean encode(MediaCodec codec, FileDescriptor fd) throws IOException {
+    private boolean encode(MediaCodec codec, OutputStream outputStream) throws IOException {
        @SuppressWarnings("checkstyle:MagicNumber")
        byte[] buf = new byte[bitRate / 8]; // may contain up to 1 second of video
        boolean eof = false;
        MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
        while (!consumeRotationChange() && !eof) {
@@ -89,8 +91,15 @@ public class ScreenEncoder implements Device.RotationListener {
                    break;
                }
                if (outputBufferId >= 0) {
-                    ByteBuffer codecBuffer = codec.getOutputBuffer(outputBufferId);
+                    ByteBuffer outputBuffer = codec.getOutputBuffer(outputBufferId);
-                    IO.writeFully(fd, codecBuffer);
+                    while (outputBuffer.hasRemaining()) {
                        int remaining = outputBuffer.remaining();
                        int len = Math.min(buf.length, remaining);
                        // the outputBuffer is probably direct (it has no underlying array), and LocalSocket does not expose channels,
                        // so we must copy the data locally to write them manually to the output stream
                        outputBuffer.get(buf, 0, len);
                        outputStream.write(buf, 0, len);
                    }
                }
            } finally {
                if (outputBufferId >= 0) {
@@ -21,7 +21,7 @@ public final class Server {
            try {
                // synchronous
-                screenEncoder.streamScreen(device, connection.getFd());
+                screenEncoder.streamScreen(device, connection.getOutputStream());
            } catch (IOException e) {
                // this is expected on close
                Ln.d("Screen streaming stopped");