Do not warn on terminating the server

If the server is already dead, terminating it fails. This is expected.
Do not block on accept() if server died
2020-03-29 11:24:11 +02:00 · 2020-03-29 11:24:11 +02:00 · 2020-03-28 23:56:37 +01:00 · 2020-03-28 23:56:37 +01:00 · 2020-03-28 23:56:37 +01:00
57 changed files with 424 additions and 1465 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@ -1,25 +0,0 @@
---
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
---
-
- - [ ] I have read the [FAQ](https://github.com/Genymobile/scrcpy/blob/master/FAQ.md).
- - [ ] I have searched in existing [issues](https://github.com/Genymobile/scrcpy/issues).
-
-**Environment**
- - OS: [e.g. Debian, Windows, macOS...]
- - scrcpy version: [e.g. 1.12.1]
- - installation method: [e.g. manual build, apt, snap, brew, Windows release...]
- - device model:
- - Android version: [e.g. 10]
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-On errors, please provide the output of the console (and `adb logcat` if relevant).
-Format them between code blocks (delimited by ```).
-Please do not post screenshots of your terminal, just post the content as text instead.
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@ -1,22 +0,0 @@
---
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: ''
-assignees: ''
-
---
-
- - [ ] I have checked that a similar [feature request](https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3A%22feature+request%22) does not already exist.
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.
--- a/.gitignore
+++ b/.gitignore
@ -2,4 +2,3 @@ build/
 /dist/
 .idea/
 .gradle/
-/x/
--- a/BUILD.md
+++ b/BUILD.md
@ -8,22 +8,6 @@ case, use the [prebuilt server] (so you will not need Java or the Android SDK).

 [prebuilt server]: #prebuilt-server

-## Branches
-
-### `master`
-
-The `master` branch concerns the latest release, and is the home page of the
-project on Github.
-
-
-### `dev`
-
-`dev` is the current development branch. Every commit present in `dev` will be
-in the next release.
-
-If you want to contribute code, please base your commits on the latest `dev`
-branch.
-

 ## Requirements

@ -249,10 +233,10 @@ You can then [run](README.md#run) _scrcpy_.

 ## Prebuilt server

- - [`scrcpy-server-v1.13`][direct-scrcpy-server]  
-   _(SHA-256: 5fee64ca1ccdc2f38550f31f5353c66de3de30c2e929a964e30fa2d005d5f885)_
+ - [`scrcpy-server-v1.12.1`][direct-scrcpy-server]  
+   _(SHA-256: 63e569c8a1d0c1df31d48c4214871c479a601782945fed50c1e61167d78266ea)_

-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.13/scrcpy-server-v1.13
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.12.1/scrcpy-server-v1.12.1

 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
@ -263,6 +247,3 @@ meson x --buildtype release --strip -Db_lto=true \
 ninja -Cx
 sudo ninja -Cx install
 ```
-
-The server only works with a matching client version (this server works with the
-`master` branch).
--- a/FAQ.md
+++ b/FAQ.md
@ -3,102 +3,19 @@
 Here are the common reported problems and their status.


-## `adb` issues
+### On Windows, my device is not detected

-`scrcpy` execute `adb` commands to initialize the connection with the device. If
-`adb` fails, then scrcpy will not work.
+The most common is your device not being detected by `adb`, or is unauthorized.
+Check everything is ok by calling:

-In that case, it will print this error:
+    adb devices

->     ERROR: "adb push" returned with value 1
-
-This is typically not a bug in _scrcpy_, but a problem in your environment.
-
-To find out the cause, execute:
-
-```bash
-adb devices
-```
-
-### `adb` not found
-
-You need `adb` accessible from your `PATH`.
-
-On Windows, the current directory is in your `PATH`, and `adb.exe` is included
-in the release, so it should work out-of-the-box.
-
-
-### Device unauthorized
-
-Check [stackoverflow][device-unauthorized].
-
-[device-unauthorized]: https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized
-
-
-### Device not detected
-
-If your device is not detected, you may need some [drivers] (on Windows).
+Windows may need some [drivers] to detect your device.

 [drivers]: https://developer.android.com/studio/run/oem-usb.html


-### Several devices connected
-
-If several devices are connected, you will encounter this error:
-
->     adb: error: failed to get feature set: more than one device/emulator
-
-the identifier of the device you want to mirror must be provided:
-
-```bash
-scrcpy -s 01234567890abcdef
-```
-
-Note that if your device is connected over TCP/IP, you'll get this message:
-
->     adb: error: more than one device/emulator
->     ERROR: "adb reverse" returned with value 1
->     WARN: 'adb reverse' failed, fallback to 'adb forward'
-
-This is expected (due to a bug on old Android versions, see [#5]), but in that
-case, scrcpy fallbacks to a different method, which should work.
-
-[#5]: https://github.com/Genymobile/scrcpy/issues/5
-
-
-### Conflicts between adb versions
-
->     adb server version (41) doesn't match this client (39); killing...
-
-This error occurs when you use several `adb` versions simultaneously. You must
-find the program using a different `adb` version, and use the same `adb` version
-everywhere.
-
-You could overwrite the `adb` binary in the other program, or ask _scrcpy_ to
-use a specific `adb` binary, by setting the `ADB` environment variable:
-
-```bash
-set ADB=/path/to/your/adb
-scrcpy
-```
-
-
-### Device disconnected
-
-If _scrcpy_ stops itself with the warning "Device disconnected", then the
-`adb` connection has been closed.
-
-Try with another USB cable or plug it into another USB port. See [#281] and
-[#283].
-
-[#281]: https://github.com/Genymobile/scrcpy/issues/281
-[#283]: https://github.com/Genymobile/scrcpy/issues/283
-
-
-
-## Control issues
-
-### Mouse and keyboard do not work
+### I can only mirror, I cannot interact with the device

 On some devices, you may need to enable an option to allow [simulating input].
 In developer options, enable:
@ -112,43 +29,22 @@ In developer options, enable:
 ### Mouse clicks at wrong location

 On MacOS, with HiDPI support and multiple screens, input location are wrongly
-scaled. See [#15].
+scaled. See [issue 15].

-[#15]: https://github.com/Genymobile/scrcpy/issues/15
+[issue 15]: https://github.com/Genymobile/scrcpy/issues/15

-Open _scrcpy_ directly on the monitor you use it.
+A workaround is to build with HiDPI support disabled:

-
-### Special characters do not work
-
-Injecting text input is [limited to ASCII characters][text-input]. A trick
-allows to also inject some [accented characters][accented-characters], but
-that's all. See [#37].
-
-[text-input]: https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3Aunicode
-[accented-characters]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-accented-characters
-[#37]: https://github.com/Genymobile/scrcpy/issues/37
-
-
-## Client issues
-
-### The quality is low
-
-If the definition of your client window is smaller than that of your device
-screen, then you might get poor quality, especially visible on text (see [#40]).
-
-[#40]: https://github.com/Genymobile/scrcpy/issues/40
-
-To improve downscaling quality, trilinear filtering is enabled automatically
-if the renderer is OpenGL and if it supports mipmapping.
-
-On Windows, you might want to force OpenGL:
-
-```
-scrcpy --render-driver=opengl
+```bash
+meson x --buildtype release -Dhidpi_support=false
 ```

-You may also need to configure the [scaling behavior]:
+However, the video will be displayed at lower resolution.
+
+
+### The quality is low on HiDPI display
+
+On Windows, you may need to configure the [scaling behavior].

 > `scrcpy.exe` > Properties > Compatibility > Change high DPI settings >
 > Override high DPI scaling behavior > Scaling performed by: _Application_.
@ -156,7 +52,6 @@ You may also need to configure the [scaling behavior]:
 [scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723


-
 ### KWin compositor crashes

 On Plasma Desktop, compositor is disabled while _scrcpy_ is running.
@ -166,29 +61,19 @@ As a workaround, [disable "Block compositing"][kwin].
 [kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613


-## Crashes
-
-### Exception
+### I get an error "Could not open video stream"

 There may be many reasons. One common cause is that the hardware encoder of your
 device is not able to encode at the given definition:

-> ```
-> ERROR: Exception on thread Thread[main,5,main]
-> android.media.MediaCodec$CodecException: Error 0xfffffc0e
-> ...
-> Exit due to uncaughtException in main thread:
-> ERROR: Could not open video stream
-> INFO: Initial texture: 1080x2336
-> ```
-
-or
-
-> ```
-> ERROR: Exception on thread Thread[main,5,main]
-> java.lang.IllegalStateException
->         at android.media.MediaCodec.native_dequeueOutputBuffer(Native Method)
-> ```
+```
+ERROR: Exception on thread Thread[main,5,main]
+android.media.MediaCodec$CodecException: Error 0xfffffc0e
+...
+Exit due to uncaughtException in main thread:
+ERROR: Could not open video stream
+INFO: Initial texture: 1080x2336
+```

 Just try with a lower definition:

--- a/Makefile.CrossWindows
+++ b/Makefile.CrossWindows
@ -100,30 +100,30 @@ dist-win32: build-server build-win32 build-win32-noconsole
 	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp "$(WIN32_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp "$(WIN32_NOCONSOLE_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/scrcpy-noconsole.exe"
-	cp prebuilt-deps/ffmpeg-4.2.2-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.2-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.2-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.2-win32-shared/bin/swresample-3.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.2-win32-shared/bin/swscale-5.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.1-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.1-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.1-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.1-win32-shared/bin/swresample-3.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.1-win32-shared/bin/swscale-5.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/SDL2-2.0.12/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/SDL2-2.0.10/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"

 dist-win64: build-server build-win64 build-win64-noconsole
 	mkdir -p "$(DIST)/$(WIN64_TARGET_DIR)"
 	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp "$(WIN64_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp "$(WIN64_NOCONSOLE_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN64_TARGET_DIR)/scrcpy-noconsole.exe"
-	cp prebuilt-deps/ffmpeg-4.2.2-win64-shared/bin/avutil-56.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.2-win64-shared/bin/avcodec-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.2-win64-shared/bin/avformat-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.2-win64-shared/bin/swresample-3.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/ffmpeg-4.2.2-win64-shared/bin/swscale-5.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.1-win64-shared/bin/avutil-56.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.1-win64-shared/bin/avcodec-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.1-win64-shared/bin/avformat-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.1-win64-shared/bin/swresample-3.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/ffmpeg-4.2.1-win64-shared/bin/swscale-5.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/SDL2-2.0.12/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/SDL2-2.0.10/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"

 zip-win32: dist-win32
 	cd "$(DIST)/$(WIN32_TARGET_DIR)"; \
--- a/README.md
+++ b/README.md
@ -1,4 +1,4 @@
-# scrcpy (v1.13)
+# scrcpy (v1.12.1)

 This application provides display and control of Android devices connected on
 USB (or [over TCP/IP][article-tcpip]). It does not require any _root_ access.
@ -37,7 +37,7 @@ control it using keyboard and mouse.

 ### Linux

-On Debian (_testing_ and _sid_ for now) and Ubuntu (20.04):
+In Debian (_testing_ and _sid_ for now):

 ```
 apt install scrcpy
@ -66,13 +66,16 @@ hard).

 ### Windows

-For Windows, for simplicity, a prebuilt archive with all the dependencies
-(including `adb`) is available:
+For Windows, for simplicity, prebuilt archives with all the dependencies
+(including `adb`) are available:

- - [`scrcpy-win64-v1.13.zip`][direct-win64]  
-   _(SHA-256: 806aafc00d4db01513193addaa24f47858893ba5efe75770bfef6ae1ea987d27)_
+ - [`scrcpy-win32-v1.12.1.zip`][direct-win32]  
+   _(SHA-256: 0f4b3b063536b50a2df05dc42c760f9cc0093a9a26dbdf02d8232c74dab43480)_
+ - [`scrcpy-win64-v1.12.1.zip`][direct-win64]  
+   _(SHA-256: 57d34b6d16cfd9fe169bc37c4df58ebd256d05c1ea3febc63d9cb0a027ab47c9)_

-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.13/scrcpy-win64-v1.13.zip
+[direct-win32]: https://github.com/Genymobile/scrcpy/releases/download/v1.12.1/scrcpy-win32-v1.12.1.zip
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.12.1/scrcpy-win64-v1.12.1.zip

 It is also available in [Chocolatey]:

@ -80,18 +83,14 @@ It is also available in [Chocolatey]:

 ```bash
 choco install scrcpy
-choco install adb    # if you don't have it yet
 ```

-And in [Scoop]:
+You need `adb`, accessible from your `PATH`. If you don't have it yet:

 ```bash
-scoop install scrcpy
-scoop install adb    # if you don't have it yet
+choco install adb
 ```

-[Scoop]: https://scoop.sh
-
 You can also [build the app manually][BUILD].


@ -210,6 +209,7 @@ To disable mirroring while recording:
 scrcpy --no-display --record file.mp4
 scrcpy -Nr file.mkv
 # interrupt recording with Ctrl+C
+# Ctrl+C does not terminate properly on Windows, so disconnect the device
 ```

 "Skipped frames" are recorded, even if they are not displayed in real time (for
@ -269,7 +269,7 @@ You could use [AutoAdb]:
 autoadb scrcpy -s '{}'
 ```

-[AutoAdb]: https://github.com/rom1v/autoadb
+[AutoAdb]: https://github.com/rom1v/usbaudio

 #### SSH tunnel

@ -340,33 +340,6 @@ scrcpy -f  # short version

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

-#### Rotation
-
-The window may be rotated:
-
-```bash
-scrcpy --rotation 1
-```
-
-Possibles values are:
- - `0`: no rotation
- - `1`: 90 degrees counterclockwise
- - `2`: 180 degrees
- - `3`: 90 degrees clockwise
-
-The rotation can also be changed dynamically with `Ctrl`+`←` _(left)_ and
-`Ctrl`+`→` _(right)_.
-
-Note that _scrcpy_ manages 3 different rotations:
- - `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 `Ctrl`+`←`/`Ctrl`+`→`) rotates only the window content. This
-   affects only the display, not the recording.
-

 ### Other mirroring options

@ -395,18 +368,6 @@ The list of display ids can be retrieved by:
 adb shell dumpsys display   # search "mDisplayId=" in the output
 ```

-#### Stay awake
-
-To prevent the device to sleep after some delay:
-
-```bash
-scrcpy --stay-awake
-scrcpy -w
-```
-
-The initial state is restored when scrcpy is closed.
-
-
 #### Turn screen off

 It is possible to turn the device screen off while mirroring on start with a
@ -421,14 +382,6 @@ Or by pressing `Ctrl`+`o` at any time.

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

-It can be useful to also prevent the device to sleep:
-
-```bash
-scrcpy --turn-screen-off --stay-awake
-scrcpy -Sw
-```
-
-
 #### Render expired frames

 By default, to minimize latency, _scrcpy_ always renders the last decoded frame
@ -448,8 +401,7 @@ device).

 Android provides this feature in _Developers options_.

-_Scrcpy_ provides an option to enable this feature on start and restore the
-initial value on exit:
+_Scrcpy_ provides an option to enable this feature on start and disable on exit:

 ```bash
 scrcpy --show-touches
@ -539,8 +491,6 @@ Also see [issue #14].
 | 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_
--- a/app/meson.build
+++ b/app/meson.build
@ -11,7 +11,6 @@ src = [
    'src/file_handler.c',
    'src/fps_counter.c',
    'src/input_manager.c',
-    'src/opengl.c',
    'src/receiver.c',
    'src/recorder.c',
    'src/scrcpy.c',
--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@ -52,7 +52,7 @@ Print this help.

 .TP
 .BI "\-\-lock\-video\-orientation " value
-Lock video orientation to \fIvalue\fR. Possible values are -1 (unlocked), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees otation counterclockwise.
+Lock video orientation to \fIvalue\fR. Values are integers in the range [-1..3]. Natural device orientation is 0 and each increment adds 90 degrees counterclockwise.

 Default is -1 (unlocked).

@ -74,10 +74,6 @@ Disable device control (mirror the device in read\-only).
 .B \-N, \-\-no\-display
 Do not display device (only when screen recording is enabled).

-.TP
-.B \-\-no\-mipmaps
-If the renderer is OpenGL 3.0+ or OpenGL ES 2.0+, then mipmaps are automatically generated to improve downscaling quality. This option disables the generation of mipmaps.
-
 .TP
 .BI "\-p, \-\-port " port[:port]
 Set the TCP port (range) used by the client to listen.
@ -110,22 +106,10 @@ option if set, or by the file extension (.mp4 or .mkv).
 .BI "\-\-record\-format " format
 Force recording format (either mp4 or mkv).

-.TP
-.BI "\-\-render\-driver " name
-Request SDL to use the given render driver (this is just a hint).
-
-Supported names are currently "direct3d", "opengl", "opengles2", "opengles", "metal" and "software".
-.UR https://wiki.libsdl.org/SDL_HINT_RENDER_DRIVER
-.UE
-
 .TP
 .B \-\-render\-expired\-frames
 By default, to minimize latency, scrcpy always renders the last available decoded frame, and drops any previous ones. This flag forces to render all frames, at a cost of a possible increased latency.

-.TP
-.BI "\-\-rotation " value
-Set the initial display rotation. Possibles values are 0, 1, 2 and 3. Each increment adds a 90 degrees rotation counterclockwise.
-
 .TP
 .BI "\-s, \-\-serial " number
 The device serial number. Mandatory only if several devices are connected to adb.
@ -136,7 +120,7 @@ Turn the device screen off immediately.

 .TP
 .B \-t, \-\-show\-touches
-Enable "show touches" on start, restore the initial value on exit..
+Enable "show touches" on start, disable on quit.

 It only shows physical touches (not clicks from scrcpy).

@ -144,10 +128,6 @@ It only shows physical touches (not clicks from scrcpy).
 .B \-v, \-\-version
 Print the version of scrcpy.

-.TP
-.B \-w, \-\-stay-awake
-Keep the device on while scrcpy is running.
-
 .TP
 .B \-\-window\-borderless
 Disable window decorations (display borderless window).
@ -184,23 +164,15 @@ Default is 0 (automatic).\n

 .TP
 .B Ctrl+f
-Switch fullscreen mode
-
-.TP
-.B Ctrl+Left
-Rotate display left
-
-.TP
-.B Ctrl+Right
-Rotate display right
+switch fullscreen mode

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

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

 .TP
 .B Ctrl+h, Home, Middle\-click
@ -232,43 +204,43 @@ Click on POWER (turn screen on/off)

 .TP
 .B Right\-click (when screen is off)
-Turn screen on
+turn screen on

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

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

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

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

 .TP
 .B Ctrl+c
-Copy device clipboard to computer
+copy device clipboard to computer

 .TP
 .B Ctrl+v
-Paste computer clipboard to device
+paste computer clipboard to device

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

 .TP
 .B Ctrl+i
-Enable/disable FPS counter (print frames/second in logs)
+enable/disable FPS counter (print frames/second in logs)

 .TP
 .B Drag & drop APK file
-Install APK from computer
+install APK from computer


 .SH Environment variables
--- a/app/src/cli.c
+++ b/app/src/cli.c
@ -52,10 +52,9 @@ scrcpy_print_usage(const char *arg0) {
        "        Print this help.\n"
        "\n"
        "    --lock-video-orientation value\n"
-        "        Lock video orientation to value.\n"
-        "        Possible values are -1 (unlocked), 0, 1, 2 and 3.\n"
-        "        Natural device orientation is 0, and each increment adds a\n"
-        "        90 degrees rotation counterclockwise.\n"
+        "        Lock video orientation to value. Values are integers in the\n"
+        "        range [-1..3]. Natural device orientation is 0 and each\n"
+        "        increment adds 90 degrees counterclockwise.\n"
        "        Default is %d%s.\n"
        "\n"
        "    --max-fps value\n"
@ -75,11 +74,6 @@ scrcpy_print_usage(const char *arg0) {
        "        Do not display device (only when screen recording is\n"
        "        enabled).\n"
        "\n"
-        "    --no-mipmaps\n"
-        "        If the renderer is OpenGL 3.0+ or OpenGL ES 2.0+, then\n"
-        "        mipmaps are automatically generated to improve downscaling\n"
-        "        quality. This option disables the generation of mipmaps.\n"
-        "\n"
        "    -p, --port port[:port]\n"
        "        Set the TCP port (range) used by the client to listen.\n"
        "        Default is %d:%d.\n"
@ -104,24 +98,12 @@ scrcpy_print_usage(const char *arg0) {
        "    --record-format format\n"
        "        Force recording format (either mp4 or mkv).\n"
        "\n"
-        "    --render-driver name\n"
-        "        Request SDL to use the given render driver (this is just a\n"
-        "        hint).\n"
-        "        Supported names are currently \"direct3d\", \"opengl\",\n"
-        "        \"opengles2\", \"opengles\", \"metal\" and \"software\".\n"
-        "        <https://wiki.libsdl.org/SDL_HINT_RENDER_DRIVER>\n"
-        "\n"
        "    --render-expired-frames\n"
        "        By default, to minimize latency, scrcpy always renders the\n"
        "        last available decoded frame, and drops any previous ones.\n"
        "        This flag forces to render all frames, at a cost of a\n"
        "        possible increased latency.\n"
        "\n"
-        "    --rotation value\n"
-        "        Set the initial display rotation.\n"
-        "        Possibles values are 0, 1, 2 and 3. Each increment adds a 90\n"
-        "        degrees rotation counterclockwise.\n"
-        "\n"
        "    -s, --serial serial\n"
        "        The device serial number. Mandatory only if several devices\n"
        "        are connected to adb.\n"
@ -130,16 +112,12 @@ scrcpy_print_usage(const char *arg0) {
        "        Turn the device screen off immediately.\n"
        "\n"
        "    -t, --show-touches\n"
-        "        Enable \"show touches\" on start, restore the initial value\n"
-        "        on exit.\n"
+        "        Enable \"show touches\" on start, disable on quit.\n"
        "        It only shows physical touches (not clicks from scrcpy).\n"
        "\n"
        "    -v, --version\n"
        "        Print the version of scrcpy.\n"
        "\n"
-        "    -w, --stay-awake\n"
-        "        Keep the device on while scrcpy is running.\n"
-        "\n"
        "    --window-borderless\n"
        "        Disable window decorations (display borderless window).\n"
        "\n"
@ -165,74 +143,68 @@ scrcpy_print_usage(const char *arg0) {
        "Shortcuts:\n"
        "\n"
        "    " CTRL_OR_CMD "+f\n"
-        "        Switch fullscreen mode\n"
-        "\n"
-        "    " CTRL_OR_CMD "+Left\n"
-        "        Rotate display left\n"
-        "\n"
-        "    " CTRL_OR_CMD "+Right\n"
-        "        Rotate display right\n"
+        "        switch fullscreen mode\n"
        "\n"
        "    " CTRL_OR_CMD "+g\n"
-        "        Resize window to 1:1 (pixel-perfect)\n"
+        "        resize window to 1:1 (pixel-perfect)\n"
        "\n"
        "    " CTRL_OR_CMD "+x\n"
        "    Double-click on black borders\n"
-        "        Resize window to remove black borders\n"
+        "        resize window to remove black borders\n"
        "\n"
        "    Ctrl+h\n"
        "    Middle-click\n"
-        "        Click on HOME\n"
+        "        click on HOME\n"
        "\n"
        "    " CTRL_OR_CMD "+b\n"
        "    " CTRL_OR_CMD "+Backspace\n"
        "    Right-click (when screen is on)\n"
-        "        Click on BACK\n"
+        "        click on BACK\n"
        "\n"
        "    " CTRL_OR_CMD "+s\n"
-        "        Click on APP_SWITCH\n"
+        "        click on APP_SWITCH\n"
        "\n"
        "    Ctrl+m\n"
-        "        Click on MENU\n"
+        "        click on MENU\n"
        "\n"
        "    " CTRL_OR_CMD "+Up\n"
-        "        Click on VOLUME_UP\n"
+        "        click on VOLUME_UP\n"
        "\n"
        "    " CTRL_OR_CMD "+Down\n"
-        "        Click on VOLUME_DOWN\n"
+        "        click on VOLUME_DOWN\n"
        "\n"
        "    " CTRL_OR_CMD "+p\n"
-        "        Click on POWER (turn screen on/off)\n"
+        "        click on POWER (turn screen on/off)\n"
        "\n"
        "    Right-click (when screen is off)\n"
-        "        Power on\n"
+        "        power on\n"
        "\n"
        "    " CTRL_OR_CMD "+o\n"
-        "        Turn device screen off (keep mirroring)\n"
+        "        turn device screen off (keep mirroring)\n"
        "\n"
        "    " CTRL_OR_CMD "+r\n"
-        "        Rotate device screen\n"
+        "        rotate device screen\n"
        "\n"
        "    " CTRL_OR_CMD "+n\n"
-        "        Expand notification panel\n"
+        "       expand notification panel\n"
        "\n"
        "    " CTRL_OR_CMD "+Shift+n\n"
-        "        Collapse notification panel\n"
+        "       collapse notification panel\n"
        "\n"
        "    " CTRL_OR_CMD "+c\n"
-        "        Copy device clipboard to computer\n"
+        "        copy device clipboard to computer\n"
        "\n"
        "    " CTRL_OR_CMD "+v\n"
-        "        Paste computer clipboard to device\n"
+        "        paste computer clipboard to device\n"
        "\n"
        "    " CTRL_OR_CMD "+Shift+v\n"
-        "        Copy computer clipboard to device\n"
+        "        copy computer clipboard to device\n"
        "\n"
        "    " CTRL_OR_CMD "+i\n"
-        "        Enable/disable FPS counter (print frames/second in logs)\n"
+        "        enable/disable FPS counter (print frames/second in logs)\n"
        "\n"
        "    Drag & drop APK file\n"
-        "        Install APK from computer\n"
+        "        install APK from computer\n"
        "\n",
        arg0,
        DEFAULT_BIT_RATE,
@ -338,18 +310,6 @@ parse_lock_video_orientation(const char *s, int8_t *lock_video_orientation) {
    return true;
 }

-static bool
-parse_rotation(const char *s, uint8_t *rotation) {
-    long value;
-    bool ok = parse_integer_arg(s, &value, false, 0, 3, "rotation");
-    if (!ok) {
-        return false;
-    }
-
-    *rotation = (uint8_t) value;
-    return true;
-}
-
 static bool
 parse_window_position(const char *s, int16_t *position) {
    // special value for "auto"
@ -469,9 +429,6 @@ guess_record_format(const char *filename) {
 #define OPT_MAX_FPS                1012
 #define OPT_LOCK_VIDEO_ORIENTATION 1013
 #define OPT_DISPLAY_ID             1014
-#define OPT_ROTATION               1015
-#define OPT_RENDER_DRIVER          1016
-#define OPT_NO_MIPMAPS             1017

 bool
 scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
@ -488,20 +445,16 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
        {"max-size",               required_argument, NULL, 'm'},
        {"no-control",             no_argument,       NULL, 'n'},
        {"no-display",             no_argument,       NULL, 'N'},
-        {"no-mipmaps",             no_argument,       NULL, OPT_NO_MIPMAPS},
        {"port",                   required_argument, NULL, 'p'},
-        {"prefer-text",            no_argument,       NULL, OPT_PREFER_TEXT},
        {"push-target",            required_argument, NULL, OPT_PUSH_TARGET},
        {"record",                 required_argument, NULL, 'r'},
        {"record-format",          required_argument, NULL, OPT_RECORD_FORMAT},
-        {"render-driver",          required_argument, NULL, OPT_RENDER_DRIVER},
        {"render-expired-frames",  no_argument,       NULL,
                                                  OPT_RENDER_EXPIRED_FRAMES},
-        {"rotation",               required_argument, NULL, OPT_ROTATION},
        {"serial",                 required_argument, NULL, 's'},
        {"show-touches",           no_argument,       NULL, 't'},
-        {"stay-awake",             no_argument,       NULL, 'w'},
        {"turn-screen-off",        no_argument,       NULL, 'S'},
+        {"prefer-text",            no_argument,       NULL, OPT_PREFER_TEXT},
        {"version",                no_argument,       NULL, 'v'},
        {"window-title",           required_argument, NULL, OPT_WINDOW_TITLE},
        {"window-x",               required_argument, NULL, OPT_WINDOW_X},
@ -518,7 +471,7 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
    optind = 0; // reset to start from the first argument in tests

    int c;
-    while ((c = getopt_long(argc, argv, "b:c:fF:hm:nNp:r:s:StTvw", long_options,
+    while ((c = getopt_long(argc, argv, "b:c:fF:hm:nNp:r:s:StTv", long_options,
                            NULL)) != -1) {
        switch (c) {
            case 'b':
@ -598,9 +551,6 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
            case 'v':
                args->version = true;
                break;
-            case 'w':
-                opts->stay_awake = true;
-                break;
            case OPT_RENDER_EXPIRED_FRAMES:
                opts->render_expired_frames = true;
                break;
@ -636,17 +586,6 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
            case OPT_PREFER_TEXT:
                opts->prefer_text = true;
                break;
-            case OPT_ROTATION:
-                if (!parse_rotation(optarg, &opts->rotation)) {
-                    return false;
-                }
-                break;
-            case OPT_RENDER_DRIVER:
-                opts->render_driver = optarg;
-                break;
-            case OPT_NO_MIPMAPS:
-                opts->mipmaps = false;
-                break;
            default:
                // getopt prints the error message on stderr
                return false;
@ -658,6 +597,11 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
        return false;
    }

+    if (!opts->display && opts->fullscreen) {
+        LOGE("-f/--fullscreen-window is incompatible with -N/--no-display");
+        return false;
+    }
+
    int index = optind;
    if (index < argc) {
        LOGE("Unexpected additional argument: %s", argv[index]);
@ -683,10 +627,5 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
        return false;
    }

-    if (!opts->control && opts->stay_awake) {
-        LOGE("Could not request to stay awake if control is disabled");
-        return false;
-    }
-
    return true;
 }
--- a/app/src/control_msg.c
+++ b/app/src/control_msg.c
@ -45,9 +45,8 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
            buffer_write32be(&buf[6], msg->inject_keycode.metastate);
            return 10;
        case CONTROL_MSG_TYPE_INJECT_TEXT: {
-            size_t len =
-                write_string(msg->inject_text.text,
-                             CONTROL_MSG_INJECT_TEXT_MAX_LENGTH, &buf[1]);
+            size_t len = write_string(msg->inject_text.text,
+                                      CONTROL_MSG_TEXT_MAX_LENGTH, &buf[1]);
            return 1 + len;
        }
        case CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT:
--- a/app/src/control_msg.h
+++ b/app/src/control_msg.h
@ -10,7 +10,7 @@
 #include "android/keycodes.h"
 #include "common.h"

-#define CONTROL_MSG_INJECT_TEXT_MAX_LENGTH 300
+#define CONTROL_MSG_TEXT_MAX_LENGTH 300
 #define CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH 4093
 #define CONTROL_MSG_SERIALIZED_MAX_SIZE \
    (3 + CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH)
--- a/app/src/fps_counter.c
+++ b/app/src/fps_counter.c
@ -23,7 +23,7 @@ fps_counter_init(struct fps_counter *counter) {
    }

    counter->thread = NULL;
-    atomic_init(&counter->started, 0);
+    SDL_AtomicSet(&counter->started, 0);
    // no need to initialize the other fields, they are unused until started

    return true;
@ -35,16 +35,6 @@ fps_counter_destroy(struct fps_counter *counter) {
    SDL_DestroyMutex(counter->mutex);
 }

-static inline bool
-is_started(struct fps_counter *counter) {
-    return atomic_load_explicit(&counter->started, memory_order_acquire);
-}
-
-static inline void
-set_started(struct fps_counter *counter, bool started) {
-    atomic_store_explicit(&counter->started, started, memory_order_release);
-}
-
 // must be called with mutex locked
 static void
 display_fps(struct fps_counter *counter) {
@ -80,10 +70,10 @@ run_fps_counter(void *data) {

    mutex_lock(counter->mutex);
    while (!counter->interrupted) {
-        while (!counter->interrupted && !is_started(counter)) {
+        while (!counter->interrupted && !SDL_AtomicGet(&counter->started)) {
            cond_wait(counter->state_cond, counter->mutex);
        }
-        while (!counter->interrupted && is_started(counter)) {
+        while (!counter->interrupted && SDL_AtomicGet(&counter->started)) {
            uint32_t now = SDL_GetTicks();
            check_interval_expired(counter, now);

@ -106,7 +96,7 @@ fps_counter_start(struct fps_counter *counter) {
    counter->nr_skipped = 0;
    mutex_unlock(counter->mutex);

-    set_started(counter, true);
+    SDL_AtomicSet(&counter->started, 1);
    cond_signal(counter->state_cond);

    // counter->thread is always accessed from the same thread, no need to lock
@ -124,13 +114,13 @@ fps_counter_start(struct fps_counter *counter) {

 void
 fps_counter_stop(struct fps_counter *counter) {
-    set_started(counter, false);
+    SDL_AtomicSet(&counter->started, 0);
    cond_signal(counter->state_cond);
 }

 bool
 fps_counter_is_started(struct fps_counter *counter) {
-    return is_started(counter);
+    return SDL_AtomicGet(&counter->started);
 }

 void
@ -155,7 +145,7 @@ fps_counter_join(struct fps_counter *counter) {

 void
 fps_counter_add_rendered_frame(struct fps_counter *counter) {
-    if (!is_started(counter)) {
+    if (!SDL_AtomicGet(&counter->started)) {
        return;
    }

@ -168,7 +158,7 @@ fps_counter_add_rendered_frame(struct fps_counter *counter) {

 void
 fps_counter_add_skipped_frame(struct fps_counter *counter) {
-    if (!is_started(counter)) {
+    if (!SDL_AtomicGet(&counter->started)) {
        return;
    }

--- a/app/src/fps_counter.h
+++ b/app/src/fps_counter.h
@ -1,9 +1,9 @@
 #ifndef FPSCOUNTER_H
 #define FPSCOUNTER_H

-#include <stdatomic.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include <SDL2/SDL_atomic.h>
 #include <SDL2/SDL_mutex.h>
 #include <SDL2/SDL_thread.h>

@ -16,7 +16,7 @@ struct fps_counter {

    // atomic so that we can check without locking the mutex
    // if the FPS counter is disabled, we don't want to lock unnecessarily
-    atomic_bool started;
+    SDL_atomic_t started;

    // the following fields are protected by the mutex
    bool interrupted;
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
@ -221,18 +221,6 @@ rotate_device(struct controller *controller) {
    }
 }

-static void
-rotate_client_left(struct screen *screen) {
-    unsigned new_rotation = (screen->rotation + 1) % 4;
-    screen_set_rotation(screen, new_rotation);
-}
-
-static void
-rotate_client_right(struct screen *screen) {
-    unsigned new_rotation = (screen->rotation + 3) % 4;
-    screen_set_rotation(screen, new_rotation);
-}
-
 void
 input_manager_process_text_input(struct input_manager *im,
                                 const SDL_TextInputEvent *event) {
@ -363,16 +351,6 @@ input_manager_process_key(struct input_manager *im,
                    action_volume_up(controller, action);
                }
                return;
-            case SDLK_LEFT:
-                if (cmd && !shift && down) {
-                    rotate_client_left(im->screen);
-                }
-                return;
-            case SDLK_RIGHT:
-                if (cmd && !shift && down) {
-                    rotate_client_right(im->screen);
-                }
-                return;
            case SDLK_c:
                if (control && cmd && !shift && !repeat && down) {
                    request_device_clipboard(controller);
@ -449,8 +427,8 @@ convert_mouse_motion(const SDL_MouseMotionEvent *from, struct screen *screen,
    to->inject_touch_event.action = AMOTION_EVENT_ACTION_MOVE;
    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
    to->inject_touch_event.position.screen_size = screen->frame_size;
-    to->inject_touch_event.position.point =
-        screen_convert_to_frame_coords(screen, from->x, from->y);
+    to->inject_touch_event.position.point.x = from->x;
+    to->inject_touch_event.position.point.y = from->y;
    to->inject_touch_event.pressure = 1.f;
    to->inject_touch_event.buttons = convert_mouse_buttons(from->state);

@ -485,13 +463,13 @@ convert_touch(const SDL_TouchFingerEvent *from, struct screen *screen,
        return false;
    }

+    struct size frame_size = screen->frame_size;
+
    to->inject_touch_event.pointer_id = from->fingerId;
-    to->inject_touch_event.position.screen_size = screen->frame_size;
+    to->inject_touch_event.position.screen_size = frame_size;
    // SDL touch event coordinates are normalized in the range [0; 1]
-    float x = from->x * screen->content_size.width;
-    float y = from->y * screen->content_size.height;
-    to->inject_touch_event.position.point =
-        screen_convert_to_frame_coords(screen, x, y);
+    to->inject_touch_event.position.point.x = from->x * frame_size.width;
+    to->inject_touch_event.position.point.y = from->y * frame_size.height;
    to->inject_touch_event.pressure = from->pressure;
    to->inject_touch_event.buttons = 0;
    return true;
@ -511,8 +489,8 @@ input_manager_process_touch(struct input_manager *im,
 static bool
 is_outside_device_screen(struct input_manager *im, int x, int y)
 {
-    return x < 0 || x >= im->screen->content_size.width ||
-           y < 0 || y >= im->screen->content_size.height;
+    return x < 0 || x >= im->screen->frame_size.width ||
+           y < 0 || y >= im->screen->frame_size.height;
 }

 static bool
@ -526,8 +504,8 @@ convert_mouse_button(const SDL_MouseButtonEvent *from, struct screen *screen,

    to->inject_touch_event.pointer_id = POINTER_ID_MOUSE;
    to->inject_touch_event.position.screen_size = screen->frame_size;
-    to->inject_touch_event.position.point =
-        screen_convert_to_frame_coords(screen, from->x, from->y);
+    to->inject_touch_event.position.point.x = from->x;
+    to->inject_touch_event.position.point.y = from->y;
    to->inject_touch_event.pressure = 1.f;
    to->inject_touch_event.buttons =
        convert_mouse_buttons(SDL_BUTTON(from->button));
--- a/app/src/opengl.c
+++ b/app/src/opengl.c
@ -1,56 +0,0 @@
-#include "opengl.h"
-
-#include <assert.h>
-#include <stdio.h>
-#include "SDL2/SDL.h"
-
-void
-sc_opengl_init(struct sc_opengl *gl) {
-    gl->GetString = SDL_GL_GetProcAddress("glGetString");
-    assert(gl->GetString);
-
-    gl->TexParameterf = SDL_GL_GetProcAddress("glTexParameterf");
-    assert(gl->TexParameterf);
-
-    gl->TexParameteri = SDL_GL_GetProcAddress("glTexParameteri");
-    assert(gl->TexParameteri);
-
-    // optional
-    gl->GenerateMipmap = SDL_GL_GetProcAddress("glGenerateMipmap");
-
-    const char *version = (const char *) gl->GetString(GL_VERSION);
-    assert(version);
-    gl->version = version;
-
-#define OPENGL_ES_PREFIX "OpenGL ES "
-    /* starts with "OpenGL ES " */
-    gl->is_opengles = !strncmp(gl->version, OPENGL_ES_PREFIX,
-                               sizeof(OPENGL_ES_PREFIX) - 1);
-    if (gl->is_opengles) {
-        /* skip the prefix */
-        version += sizeof(PREFIX) - 1;
-    }
-
-    int r = sscanf(version, "%d.%d", &gl->version_major, &gl->version_minor);
-    if (r != 2) {
-        // failed to parse the version
-        gl->version_major = 0;
-        gl->version_minor = 0;
-    }
-}
-
-bool
-sc_opengl_version_at_least(struct sc_opengl *gl,
-                           int minver_major, int minver_minor,
-                           int minver_es_major, int minver_es_minor)
-{
-    if (gl->is_opengles) {
-        return gl->version_major > minver_es_major
-            || (gl->version_major == minver_es_major
-             && gl->version_minor >= minver_es_minor);
-    }
-
-    return gl->version_major > minver_major
-        || (gl->version_major == minver_major
-         && gl->version_minor >= minver_minor);
-}
--- a/app/src/opengl.h
+++ b/app/src/opengl.h
@ -1,36 +0,0 @@
-#ifndef SC_OPENGL_H
-#define SC_OPENGL_H
-
-#include <stdbool.h>
-#include <SDL2/SDL_opengl.h>
-
-#include "config.h"
-
-struct sc_opengl {
-    const char *version;
-    bool is_opengles;
-    int version_major;
-    int version_minor;
-
-    const GLubyte *
-    (*GetString)(GLenum name);
-
-    void
-    (*TexParameterf)(GLenum target, GLenum pname, GLfloat param);
-
-    void
-    (*TexParameteri)(GLenum target, GLenum pname, GLint param);
-
-    void
-    (*GenerateMipmap)(GLenum target);
-};
-
-void
-sc_opengl_init(struct sc_opengl *gl);
-
-bool
-sc_opengl_version_at_least(struct sc_opengl *gl,
-                           int minver_major, int minver_minor,
-                           int minver_es_major, int minver_es_minor);
-
-#endif
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@ -7,10 +7,6 @@
 #include <sys/time.h>
 #include <SDL2/SDL.h>

-#ifdef _WIN32
-# include <windows.h>
-#endif
-
 #include "config.h"
 #include "command.h"
 #include "common.h"
@ -49,21 +45,9 @@ static struct input_manager input_manager = {
    .prefer_text = false, // initialized later
 };

-#ifdef _WIN32
-BOOL WINAPI windows_ctrl_handler(DWORD ctrl_type) {
-    if (ctrl_type == CTRL_C_EVENT) {
-        SDL_Event event;
-        event.type = SDL_QUIT;
-        SDL_PushEvent(&event);
-        return TRUE;
-    }
-    return FALSE;
-}
-#endif // _WIN32
-
 // init SDL and set appropriate hints
 static bool
-sdl_init_and_configure(bool display, const char *render_driver) {
+sdl_init_and_configure(bool display) {
    uint32_t flags = display ? SDL_INIT_VIDEO : SDL_INIT_EVENTS;
    if (SDL_Init(flags)) {
        LOGC("Could not initialize SDL: %s", SDL_GetError());
@ -72,22 +56,10 @@ sdl_init_and_configure(bool display, const char *render_driver) {

    atexit(SDL_Quit);

-#ifdef _WIN32
-    // Clean up properly on Ctrl+C on Windows
-    bool ok = SetConsoleCtrlHandler(windows_ctrl_handler, TRUE);
-    if (!ok) {
-        LOGW("Could not set Ctrl+C handler");
-    }
-#endif // _WIN32
-
    if (!display) {
        return true;
    }

-    if (render_driver && !SDL_SetHint(SDL_HINT_RENDER_DRIVER, render_driver)) {
-        LOGW("Could not set render driver");
-    }
-
    // Linear filtering
    if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1")) {
        LOGW("Could not enable linear filtering");
@ -134,8 +106,7 @@ event_watcher(void *data, SDL_Event *event) {
    (void) data;
    if (event->type == SDL_WINDOWEVENT
            && event->window.event == SDL_WINDOWEVENT_RESIZED) {
-        // In practice, it seems to always be called from the same thread in
-        // that specific case. Anyway, it's just a workaround.
+        // called from another thread, not very safe, but it's a workaround!
        screen_render(&screen);
    }
    return 0;
@ -253,6 +224,21 @@ event_loop(bool display, bool control) {
    return false;
 }

+static process_t
+set_show_touches_enabled(const char *serial, bool enabled) {
+    const char *value = enabled ? "1" : "0";
+    const char *const adb_cmd[] = {
+        "shell", "settings", "put", "system", "show_touches", value
+    };
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+}
+
+static void
+wait_show_touches(process_t process) {
+    // reap the process, ignore the result
+    process_check_success(process, "show_touches");
+}
+
 static SDL_LogPriority
 sdl_priority_from_av_level(int level) {
    switch (level) {
@ -301,13 +287,19 @@ scrcpy(const struct scrcpy_options *options) {
        .lock_video_orientation = options->lock_video_orientation,
        .control = options->control,
        .display_id = options->display_id,
-        .show_touches = options->show_touches,
-        .stay_awake = options->stay_awake,
    };
    if (!server_start(&server, options->serial, &params)) {
        return false;
    }

+    process_t proc_show_touches = PROCESS_NONE;
+    bool show_touches_waited;
+    if (options->show_touches) {
+        LOGI("Enable show_touches");
+        proc_show_touches = set_show_touches_enabled(options->serial, true);
+        show_touches_waited = false;
+    }
+
    bool ret = false;

    bool fps_counter_initialized = false;
@ -318,7 +310,7 @@ scrcpy(const struct scrcpy_options *options) {
    bool controller_initialized = false;
    bool controller_started = false;

-    if (!sdl_init_and_configure(options->display, options->render_driver)) {
+    if (!sdl_init_and_configure(options->display)) {
        goto end;
    }

@ -404,8 +396,7 @@ scrcpy(const struct scrcpy_options *options) {
                                   options->always_on_top, options->window_x,
                                   options->window_y, options->window_width,
                                   options->window_height,
-                                   options->window_borderless,
-                                   options->rotation, options-> mipmaps)) {
+                                   options->window_borderless)) {
            goto end;
        }

@ -424,6 +415,11 @@ scrcpy(const struct scrcpy_options *options) {
        }
    }

+    if (options->show_touches) {
+        wait_show_touches(proc_show_touches);
+        show_touches_waited = true;
+    }
+
    input_manager.prefer_text = options->prefer_text;

    ret = event_loop(options->display, options->control);
@ -480,6 +476,16 @@ end:
        fps_counter_destroy(&fps_counter);
    }

+    if (options->show_touches) {
+        if (!show_touches_waited) {
+            // wait the process which enabled "show touches"
+            wait_show_touches(proc_show_touches);
+        }
+        LOGI("Disable show_touches");
+        proc_show_touches = set_show_touches_enabled(options->serial, false);
+        wait_show_touches(proc_show_touches);
+    }
+
    server_destroy(&server);

    return ret;
--- a/app/src/scrcpy.h
+++ b/app/src/scrcpy.h
@ -15,14 +15,12 @@ struct scrcpy_options {
    const char *record_filename;
    const char *window_title;
    const char *push_target;
-    const char *render_driver;
    enum recorder_format record_format;
    struct port_range port_range;
    uint16_t max_size;
    uint32_t bit_rate;
    uint16_t max_fps;
    int8_t lock_video_orientation;
-    uint8_t rotation;
    int16_t window_x; // WINDOW_POSITION_UNDEFINED for "auto"
    int16_t window_y; // WINDOW_POSITION_UNDEFINED for "auto"
    uint16_t window_width;
@ -37,8 +35,6 @@ struct scrcpy_options {
    bool render_expired_frames;
    bool prefer_text;
    bool window_borderless;
-    bool mipmaps;
-    bool stay_awake;
 };

 #define SCRCPY_OPTIONS_DEFAULT { \
@ -47,7 +43,6 @@ struct scrcpy_options {
    .record_filename = NULL, \
    .window_title = NULL, \
    .push_target = NULL, \
-    .render_driver = NULL, \
    .record_format = RECORDER_FORMAT_AUTO, \
    .port_range = { \
        .first = DEFAULT_LOCAL_PORT_RANGE_FIRST, \
@ -57,7 +52,6 @@ struct scrcpy_options {
    .bit_rate = DEFAULT_BIT_RATE, \
    .max_fps = 0, \
    .lock_video_orientation = DEFAULT_LOCK_VIDEO_ORIENTATION, \
-    .rotation = 0, \
    .window_x = WINDOW_POSITION_UNDEFINED, \
    .window_y = WINDOW_POSITION_UNDEFINED, \
    .window_width = 0, \
@ -72,8 +66,6 @@ struct scrcpy_options {
    .render_expired_frames = false, \
    .prefer_text = false, \
    .window_borderless = false, \
-    .mipmaps = true, \
-    .stay_awake = false, \
 }

 bool
--- a/app/src/screen.c
+++ b/app/src/screen.c
@ -15,19 +15,6 @@

 #define DISPLAY_MARGINS 96

-static inline struct size
-get_rotated_size(struct size size, int rotation) {
-    struct size rotated_size;
-    if (rotation & 1) {
-        rotated_size.width = size.height;
-        rotated_size.height = size.width;
-    } else {
-        rotated_size.width = size.width;
-        rotated_size.height = size.height;
-    }
-    return rotated_size;
-}
-
 // get the window size in a struct size
 static struct size
 get_window_size(SDL_Window *window) {
@ -93,8 +80,8 @@ get_preferred_display_bounds(struct size *bounds) {
 //  - it keeps the aspect ratio
 //  - it scales down to make it fit in the display_size
 static struct size
-get_optimal_size(struct size current_size, struct size content_size) {
-    if (content_size.width == 0 || content_size.height == 0) {
+get_optimal_size(struct size current_size, struct size frame_size) {
+    if (frame_size.width == 0 || frame_size.height == 0) {
        // avoid division by 0
        return current_size;
    }
@ -113,21 +100,14 @@ get_optimal_size(struct size current_size, struct size content_size) {
        h = MIN(current_size.height, display_size.height);
    }

-    if (h == w * content_size.height / content_size.width
-     || w == h * content_size.width / content_size.height) {
-        // The size is already optimal, if we ignore rounding errors due to
-        // integer window dimensions
-        return (struct size) {w, h};
-    }
-
-    bool keep_width = content_size.width * h > content_size.height * w;
+    bool keep_width = frame_size.width * h > frame_size.height * w;
    if (keep_width) {
        // remove black borders on top and bottom
-        h = content_size.height * w / content_size.width;
+        h = frame_size.height * w / frame_size.width;
    } else {
        // remove black borders on left and right (or none at all if it already
        // fits)
-        w = content_size.width * h / content_size.height;
+        w = frame_size.width * h / frame_size.height;
    }

    // w and h must fit into 16 bits
@ -137,33 +117,33 @@ get_optimal_size(struct size current_size, struct size content_size) {

 // same as get_optimal_size(), but read the current size from the window
 static inline struct size
-get_optimal_window_size(const struct screen *screen, struct size content_size) {
+get_optimal_window_size(const struct screen *screen, struct size frame_size) {
    struct size windowed_size = get_windowed_window_size(screen);
-    return get_optimal_size(windowed_size, content_size);
+    return get_optimal_size(windowed_size, frame_size);
 }

 // initially, there is no current size, so use the frame size as current size
 // req_width and req_height, if not 0, are the sizes requested by the user
 static inline struct size
-get_initial_optimal_size(struct size content_size, uint16_t req_width,
+get_initial_optimal_size(struct size frame_size, uint16_t req_width,
                         uint16_t req_height) {
    struct size window_size;
    if (!req_width && !req_height) {
-        window_size = get_optimal_size(content_size, content_size);
+        window_size = get_optimal_size(frame_size, frame_size);
    } else {
        if (req_width) {
            window_size.width = req_width;
        } else {
            // compute from the requested height
-            window_size.width = (uint32_t) req_height * content_size.width
-                              / content_size.height;
+            window_size.width = (uint32_t) req_height * frame_size.width
+                              / frame_size.height;
        }
        if (req_height) {
            window_size.height = req_height;
        } else {
            // compute from the requested width
-            window_size.height = (uint32_t) req_width * content_size.height
-                               / content_size.width;
+            window_size.height = (uint32_t) req_width * frame_size.height
+                               / frame_size.width;
        }
    }
    return window_size;
@ -175,48 +155,21 @@ screen_init(struct screen *screen) {
 }

 static inline SDL_Texture *
-create_texture(struct screen *screen) {
-    SDL_Renderer *renderer = screen->renderer;
-    struct size size = screen->frame_size;
-    SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
-                                             SDL_TEXTUREACCESS_STREAMING,
-                                             size.width, size.height);
-    if (!texture) {
-        return NULL;
-    }
-
-    if (screen->mipmaps) {
-        struct sc_opengl *gl = &screen->gl;
-
-        SDL_GL_BindTexture(texture, NULL, NULL);
-
-        // Enable trilinear filtering for downscaling
-        gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
-                          GL_LINEAR_MIPMAP_LINEAR);
-        gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -.5f);
-
-        SDL_GL_UnbindTexture(texture);
-    }
-
-    return texture;
+create_texture(SDL_Renderer *renderer, struct size frame_size) {
+    return SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
+                             SDL_TEXTUREACCESS_STREAMING,
+                             frame_size.width, frame_size.height);
 }

 bool
 screen_init_rendering(struct screen *screen, const char *window_title,
                      struct size frame_size, bool always_on_top,
                      int16_t window_x, int16_t window_y, uint16_t window_width,
-                      uint16_t window_height, bool window_borderless,
-                      uint8_t rotation, bool mipmaps) {
+                      uint16_t window_height, bool window_borderless) {
    screen->frame_size = frame_size;
-    screen->rotation = rotation;
-    if (rotation) {
-        LOGI("Initial display rotation set to %u", rotation);
-    }
-    struct size content_size = get_rotated_size(frame_size, screen->rotation);
-    screen->content_size = content_size;

    struct size window_size =
-        get_initial_optimal_size(content_size, window_width, window_height);
+        get_initial_optimal_size(frame_size, window_width, window_height);
    uint32_t window_flags = SDL_WINDOW_HIDDEN | SDL_WINDOW_RESIZABLE;
 #ifdef HIDPI_SUPPORT
    window_flags |= SDL_WINDOW_ALLOW_HIGHDPI;
@ -253,44 +206,13 @@ screen_init_rendering(struct screen *screen, const char *window_title,
        return false;
    }

-    SDL_RendererInfo renderer_info;
-    int r = SDL_GetRendererInfo(screen->renderer, &renderer_info);
-    const char *renderer_name = r ? NULL : renderer_info.name;
-    LOGI("Renderer: %s", renderer_name ? renderer_name : "(unknown)");
-
-    if (SDL_RenderSetLogicalSize(screen->renderer, content_size.width,
-                                 content_size.height)) {
+    if (SDL_RenderSetLogicalSize(screen->renderer, frame_size.width,
+                                 frame_size.height)) {
        LOGE("Could not set renderer logical size: %s", SDL_GetError());
        screen_destroy(screen);
        return false;
    }

-    // starts with "opengl"
-    screen->use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
-    if (screen->use_opengl) {
-        struct sc_opengl *gl = &screen->gl;
-        sc_opengl_init(gl);
-
-        LOGI("OpenGL version: %s", gl->version);
-
-        if (mipmaps) {
-            bool supports_mipmaps =
-                sc_opengl_version_at_least(gl, 3, 0, /* OpenGL 3.0+ */
-                                               2, 0  /* OpenGL ES 2.0+ */);
-            if (supports_mipmaps) {
-                LOGI("Trilinear filtering enabled");
-                screen->mipmaps = true;
-            } else {
-                LOGW("Trilinear filtering disabled "
-                     "(OpenGL 3.0+ or ES 2.0+ required)");
-            }
-        } else {
-            LOGI("Trilinear filtering disabled");
-        }
-    } else {
-        LOGW("Trilinear filtering disabled (not an OpenGL renderer)");
-    }
-
    SDL_Surface *icon = read_xpm(icon_xpm);
    if (icon) {
        SDL_SetWindowIcon(screen->window, icon);
@ -301,7 +223,7 @@ screen_init_rendering(struct screen *screen, const char *window_title,

    LOGI("Initial texture: %" PRIu16 "x%" PRIu16, frame_size.width,
                                                  frame_size.height);
-    screen->texture = create_texture(screen);
+    screen->texture = create_texture(screen->renderer, frame_size);
    if (!screen->texture) {
        LOGC("Could not create texture: %s", SDL_GetError());
        screen_destroy(screen);
@ -331,51 +253,13 @@ screen_destroy(struct screen *screen) {
    }
 }

-void
-screen_set_rotation(struct screen *screen, unsigned rotation) {
-    assert(rotation < 4);
-    if (rotation == screen->rotation) {
-        return;
-    }
-
-    struct size old_content_size = screen->content_size;
-    struct size new_content_size =
-        get_rotated_size(screen->frame_size, rotation);
-
-    if (SDL_RenderSetLogicalSize(screen->renderer,
-                                 new_content_size.width,
-                                 new_content_size.height)) {
-        LOGE("Could not set renderer logical size: %s", SDL_GetError());
-        return;
-    }
-
-    struct size windowed_size = get_windowed_window_size(screen);
-    struct size target_size = {
-        .width = (uint32_t) windowed_size.width * new_content_size.width
-                / old_content_size.width,
-        .height = (uint32_t) windowed_size.height * new_content_size.height
-                / old_content_size.height,
-    };
-    target_size = get_optimal_size(target_size, new_content_size);
-    set_window_size(screen, target_size);
-
-    screen->content_size = new_content_size;
-    screen->rotation = rotation;
-    LOGI("Display rotation set to %u", rotation);
-
-    screen_render(screen);
-}
-
 // recreate the texture and resize the window if the frame size has changed
 static bool
 prepare_for_frame(struct screen *screen, struct size new_frame_size) {
    if (screen->frame_size.width != new_frame_size.width
            || screen->frame_size.height != new_frame_size.height) {
-        struct size new_content_size =
-            get_rotated_size(new_frame_size, screen->rotation);
-        if (SDL_RenderSetLogicalSize(screen->renderer,
-                                     new_content_size.width,
-                                     new_content_size.height)) {
+        if (SDL_RenderSetLogicalSize(screen->renderer, new_frame_size.width,
+                                     new_frame_size.height)) {
            LOGE("Could not set renderer logical size: %s", SDL_GetError());
            return false;
        }
@ -383,23 +267,21 @@ prepare_for_frame(struct screen *screen, struct size new_frame_size) {
        // frame dimension changed, destroy texture
        SDL_DestroyTexture(screen->texture);

-        struct size content_size = screen->content_size;
        struct size windowed_size = get_windowed_window_size(screen);
        struct size target_size = {
-            (uint32_t) windowed_size.width * new_content_size.width
-                    / content_size.width,
-            (uint32_t) windowed_size.height * new_content_size.height
-                    / content_size.height,
+            (uint32_t) windowed_size.width * new_frame_size.width
+                    / screen->frame_size.width,
+            (uint32_t) windowed_size.height * new_frame_size.height
+                    / screen->frame_size.height,
        };
-        target_size = get_optimal_size(target_size, new_content_size);
+        target_size = get_optimal_size(target_size, new_frame_size);
        set_window_size(screen, target_size);

        screen->frame_size = new_frame_size;
-        screen->content_size = new_content_size;

        LOGI("New texture: %" PRIu16 "x%" PRIu16,
                     screen->frame_size.width, screen->frame_size.height);
-        screen->texture = create_texture(screen);
+        screen->texture = create_texture(screen->renderer, new_frame_size);
        if (!screen->texture) {
            LOGC("Could not create texture: %s", SDL_GetError());
            return false;
@ -416,13 +298,6 @@ update_texture(struct screen *screen, const AVFrame *frame) {
            frame->data[0], frame->linesize[0],
            frame->data[1], frame->linesize[1],
            frame->data[2], frame->linesize[2]);
-
-    if (screen->mipmaps) {
-        assert(screen->use_opengl);
-        SDL_GL_BindTexture(screen->texture, NULL, NULL);
-        screen->gl.GenerateMipmap(GL_TEXTURE_2D);
-        SDL_GL_UnbindTexture(screen->texture);
-    }
 }

 bool
@ -444,28 +319,7 @@ screen_update_frame(struct screen *screen, struct video_buffer *vb) {
 void
 screen_render(struct screen *screen) {
    SDL_RenderClear(screen->renderer);
-    if (screen->rotation == 0) {
-        SDL_RenderCopy(screen->renderer, screen->texture, NULL, NULL);
-    } else {
-        // rotation in RenderCopyEx() is clockwise, while screen->rotation is
-        // counterclockwise (to be consistent with --lock-video-orientation)
-        int cw_rotation = (4 - screen->rotation) % 4;
-        double angle = 90 * cw_rotation;
-
-        SDL_Rect *dstrect = NULL;
-        SDL_Rect rect;
-        if (screen->rotation & 1) {
-            struct size size = screen->content_size;
-            rect.x = (size.width - size.height) / 2;
-            rect.y = (size.height - size.width) / 2;
-            rect.w = size.height;
-            rect.h = size.width;
-            dstrect = &rect;
-        }
-
-        SDL_RenderCopyEx(screen->renderer, screen->texture, NULL, dstrect,
-                         angle, NULL, 0);
-    }
+    SDL_RenderCopy(screen->renderer, screen->texture, NULL, NULL);
    SDL_RenderPresent(screen->renderer);
 }

@ -496,10 +350,9 @@ screen_resize_to_fit(struct screen *screen) {
    }

    struct size optimal_size =
-        get_optimal_window_size(screen, screen->content_size);
+        get_optimal_window_size(screen, screen->frame_size);
    SDL_SetWindowSize(screen->window, optimal_size.width, optimal_size.height);
-    LOGD("Resized to optimal size: %ux%u", optimal_size.width,
-                                           optimal_size.height);
+    LOGD("Resized to optimal size");
 }

 void
@ -513,10 +366,9 @@ screen_resize_to_pixel_perfect(struct screen *screen) {
        screen->maximized = false;
    }

-    struct size content_size = screen->content_size;
-    SDL_SetWindowSize(screen->window, content_size.width, content_size.height);
-    LOGD("Resized to pixel-perfect: %ux%u", content_size.width,
-                                            content_size.height);
+    SDL_SetWindowSize(screen->window, screen->frame_size.width,
+                      screen->frame_size.height);
+    LOGD("Resized to pixel-perfect");
 }

 void
@ -560,33 +412,3 @@ screen_handle_window_event(struct screen *screen,
            break;
    }
 }
-
-struct point
-screen_convert_to_frame_coords(struct screen *screen, int32_t x, int32_t y) {
-    unsigned rotation = screen->rotation;
-    assert(rotation < 4);
-
-    int32_t w = screen->content_size.width;
-    int32_t h = screen->content_size.height;
-    struct point result;
-    switch (rotation) {
-        case 0:
-            result.x = x;
-            result.y = y;
-            break;
-        case 1:
-            result.x = h - y;
-            result.y = x;
-            break;
-        case 2:
-            result.x = w - x;
-            result.y = h - y;
-            break;
-        default:
-            assert(rotation == 3);
-            result.x = y;
-            result.y = w - x;
-            break;
-    }
-    return result;
-}
--- a/app/src/screen.h
+++ b/app/src/screen.h
@ -7,7 +7,6 @@

 #include "config.h"
 #include "common.h"
-#include "opengl.h"

 #define WINDOW_POSITION_UNDEFINED (-0x8000)

@ -17,36 +16,24 @@ struct screen {
    SDL_Window *window;
    SDL_Renderer *renderer;
    SDL_Texture *texture;
-    bool use_opengl;
-    struct sc_opengl gl;
    struct size frame_size;
-    struct size content_size; // rotated frame_size
    // The window size the last time it was not maximized or fullscreen.
    struct size windowed_window_size;
    // Since we receive the event SIZE_CHANGED before MAXIMIZED, we must be
    // able to revert the size to its non-maximized value.
    struct size windowed_window_size_backup;
-    // client rotation: 0, 1, 2 or 3 (x90 degrees counterclockwise)
-    unsigned rotation;
    bool has_frame;
    bool fullscreen;
    bool maximized;
    bool no_window;
-    bool mipmaps;
 };

 #define SCREEN_INITIALIZER { \
    .window = NULL, \
    .renderer = NULL, \
    .texture = NULL, \
-    .use_opengl = false, \
-    .gl = {0}, \
    .frame_size = { \
-        .width = 0, \
-        .height = 0, \
-    }, \
-    .content_size = { \
-        .width = 0, \
+        .width = 0,  \
        .height = 0, \
    }, \
    .windowed_window_size = { \
@ -57,12 +44,10 @@ struct screen {
        .width = 0, \
        .height = 0, \
    }, \
-    .rotation = 0, \
    .has_frame = false, \
    .fullscreen = false, \
    .maximized = false, \
    .no_window = false, \
-    .mipmaps = false, \
 }

 // initialize default values
@ -75,8 +60,7 @@ bool
 screen_init_rendering(struct screen *screen, const char *window_title,
                      struct size frame_size, bool always_on_top,
                      int16_t window_x, int16_t window_y, uint16_t window_width,
-                      uint16_t window_height, bool window_borderless,
-                      uint8_t rotation, bool mipmaps);
+                      uint16_t window_height, bool window_borderless);

 // show the window
 void
@ -106,17 +90,8 @@ screen_resize_to_fit(struct screen *screen);
 void
 screen_resize_to_pixel_perfect(struct screen *screen);

-// set the display rotation (0, 1, 2 or 3, x90 degrees counterclockwise)
-void
-screen_set_rotation(struct screen *screen, unsigned rotation);
-
 // react to window events
 void
 screen_handle_window_event(struct screen *screen, const SDL_WindowEvent *event);

-// convert point from window coordinates to frame coordinates
-// x and y are expressed in pixels
-struct point
-screen_convert_to_frame_coords(struct screen *screen, int32_t x, int32_t y);
-
 #endif
--- a/app/src/server.c
+++ b/app/src/server.c
@ -5,6 +5,7 @@
 #include <inttypes.h>
 #include <libgen.h>
 #include <stdio.h>
+#include <unistd.h>
 #include <SDL2/SDL_thread.h>
 #include <SDL2/SDL_timer.h>
 #include <SDL2/SDL_platform.h>
@ -172,7 +173,7 @@ enable_tunnel_reverse_any_port(struct server *server,
        // check before incrementing to avoid overflow on port 65535
        if (port < port_range.last) {
            LOGW("Could not listen on port %" PRIu16", retrying on %" PRIu16,
-                 port, (uint16_t) (port + 1));
+                 port, port + 1);
            port++;
            continue;
        }
@ -268,8 +269,6 @@ execute_server(struct server *server, const struct server_params *params) {
        "true", // always send frame meta (packet boundaries + timestamp)
        params->control ? "true" : "false",
        display_id_string,
-        params->show_touches ? "true" : "false",
-        params->stay_awake ? "true" : "false",
    };
 #ifdef SERVER_DEBUGGER
    LOGI("Server debugger waiting for a client on device port "
@ -320,12 +319,14 @@ connect_to_server(uint16_t port, uint32_t attempts, uint32_t delay) {
 }

 static void
-close_socket(socket_t socket) {
-    assert(socket != INVALID_SOCKET);
-    net_shutdown(socket, SHUT_RDWR);
-    if (!net_close(socket)) {
+close_socket(socket_t *socket) {
+    assert(*socket != INVALID_SOCKET);
+    net_shutdown(*socket, SHUT_RDWR);
+    if (!net_close(*socket)) {
        LOGW("Could not close socket");
+        return;
    }
+    *socket = INVALID_SOCKET;
 }

 void
@ -337,14 +338,10 @@ static int
 run_wait_server(void *data) {
    struct server *server = data;
    cmd_simple_wait(server->process, NULL); // ignore exit code
-    // no need for synchronization, server_socket is initialized before this
-    // thread was created
-    if (server->server_socket != INVALID_SOCKET
-            && !atomic_flag_test_and_set(&server->server_socket_closed)) {
-        // On Linux, accept() is unblocked by shutdown(), but on Windows, it is
-        // unblocked by closesocket(). Therefore, call both (close_socket()).
-        close_socket(server->server_socket);
-    }
+
+    // wake up any net_select_interruptible()
+    close(server->pipe_intr[1]);
+
    LOGD("Server terminated");
    return 0;
 }
@ -369,38 +366,36 @@ server_start(struct server *server, const char *serial,
        goto error1;
    }

-    // server will connect to our server socket
-    server->process = execute_server(server, params);
-    if (server->process == PROCESS_NONE) {
+    bool ok = net_pipe(server->pipe_intr);
+    if (!ok) {
+        perror("pipe");
        goto error2;
    }

-    // If the server process dies before connecting to the server socket, then
-    // the client will be stuck forever on accept(). To avoid the problem, we
-    // must be able to wake up the accept() call when the server dies. To keep
-    // things simple and multiplatform, just spawn a new thread waiting for the
-    // server process and calling shutdown()/close() on the server socket if
-    // necessary to wake up any accept() blocking call.
+    // server will connect to our server socket
+    server->process = execute_server(server, params);
+    if (server->process == PROCESS_NONE) {
+        goto error3;
+    }
+
    server->wait_server_thread =
        SDL_CreateThread(run_wait_server, "wait-server", server);
    if (!server->wait_server_thread) {
        cmd_terminate(server->process);
        cmd_simple_wait(server->process, NULL); // ignore exit code
-        goto error2;
+        goto error3;
    }

    server->tunnel_enabled = true;

    return true;

+error3:
+    close(server->pipe_intr[0]);
+    close(server->pipe_intr[1]);
 error2:
    if (!server->tunnel_forward) {
-        bool was_closed =
-            atomic_flag_test_and_set(&server->server_socket_closed);
-        // the thread is not started, the flag could not be already set
-        assert(!was_closed);
-        (void) was_closed;
-        close_socket(server->server_socket);
+        close_socket(&server->server_socket);
    }
    disable_tunnel(server);
 error1:
@ -411,23 +406,34 @@ error1:
 bool
 server_connect_to(struct server *server) {
    if (!server->tunnel_forward) {
+        bool acceptable = net_select_interruptible(server->server_socket,
+                                                   server->pipe_intr[0]);
+        if (!acceptable) {
+            // the process died, accept() would never succeed
+            return false;
+        }
+
        server->video_socket = net_accept(server->server_socket);
        if (server->video_socket == INVALID_SOCKET) {
            return false;
        }

+        acceptable = net_select_interruptible(server->server_socket,
+                                              server->pipe_intr[0]);
+        if (!acceptable) {
+            // the process died, accept() would never succeed
+            return false;
+        }
        server->control_socket = net_accept(server->server_socket);
        if (server->control_socket == INVALID_SOCKET) {
            // the video_socket will be cleaned up on destroy
            return false;
        }

+        close(server->pipe_intr[0]);
+
        // we don't need the server socket anymore
-        if (!atomic_flag_test_and_set(&server->server_socket_closed)) {
-            // close it from here
-            close_socket(server->server_socket);
-            // otherwise, it is closed by run_wait_server()
-        }
+        close_socket(&server->server_socket);
    } else {
        uint32_t attempts = 100;
        uint32_t delay = 100; // ms
@ -454,15 +460,14 @@ server_connect_to(struct server *server) {

 void
 server_stop(struct server *server) {
-    if (server->server_socket != INVALID_SOCKET
-            && !atomic_flag_test_and_set(&server->server_socket_closed)) {
-        close_socket(server->server_socket);
+    if (server->server_socket != INVALID_SOCKET) {
+        close_socket(&server->server_socket);
    }
    if (server->video_socket != INVALID_SOCKET) {
-        close_socket(server->video_socket);
+        close_socket(&server->video_socket);
    }
    if (server->control_socket != INVALID_SOCKET) {
-        close_socket(server->control_socket);
+        close_socket(&server->control_socket);
    }

    assert(server->process != PROCESS_NONE);
--- a/app/src/server.h
+++ b/app/src/server.h
@ -1,7 +1,6 @@
 #ifndef SERVER_H
 #define SERVER_H

-#include <stdatomic.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <SDL2/SDL_thread.h>
@ -15,7 +14,7 @@ struct server {
    char *serial;
    process_t process;
    SDL_Thread *wait_server_thread;
-    atomic_flag server_socket_closed;
+    int pipe_intr[2]; // to wake up blocking accept() on process exit
    socket_t server_socket; // only used if !tunnel_forward
    socket_t video_socket;
    socket_t control_socket;
@ -28,8 +27,6 @@ struct server {
 #define SERVER_INITIALIZER { \
    .serial = NULL, \
    .process = PROCESS_NONE, \
-    .wait_server_thread = NULL, \
-    .server_socket_closed = ATOMIC_FLAG_INIT, \
    .server_socket = INVALID_SOCKET, \
    .video_socket = INVALID_SOCKET, \
    .control_socket = INVALID_SOCKET, \
@ -51,8 +48,6 @@ struct server_params {
    int8_t lock_video_orientation;
    bool control;
    uint16_t display_id;
-    bool show_touches;
-    bool stay_awake;
 };

 // init default values
--- a/app/src/sys/unix/command.c
+++ b/app/src/sys/unix/command.c
@ -14,7 +14,6 @@
 #include <limits.h>
 #include <signal.h>
 #include <stdlib.h>
-#include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/stat.h>
--- a/app/src/util/net.c
+++ b/app/src/util/net.c
@ -1,16 +1,22 @@
 #include "net.h"

+#include <assert.h>
+#include <errno.h>
 #include <stdio.h>
 #include <SDL2/SDL_platform.h>

 #include "config.h"
+#include "common.h"
 #include "log.h"

 #ifdef __WINDOWS__
+# include <io.h>
+# include <winsock2.h>
  typedef int socklen_t;
 #else
-# include <sys/types.h>
+# include <sys/select.h>
 # include <sys/socket.h>
+# include <sys/types.h>
 # include <netinet/in.h>
 # include <arpa/inet.h>
 # include <unistd.h>
@ -145,3 +151,38 @@ net_close(socket_t socket) {
    return !close(socket);
 #endif
 }
+
+bool
+net_select_interruptible(int fd, int fd_intr) {
+    fd_set rfds;
+
+    FD_ZERO(&rfds);
+    FD_SET(fd, &rfds);
+    FD_SET(fd_intr, &rfds);
+
+    int nfds = MAX(fd, fd_intr) + 1;
+
+    // use select() because it's available on supported platforms
+    int r = select(nfds, &rfds, NULL, NULL, NULL);
+    if (r == -1) {
+        // failure
+        return false;
+    }
+    assert(r > 0);
+    if (FD_ISSET(fd_intr, &rfds)) {
+        // interrupted is set
+        return false;
+    }
+
+    assert(FD_ISSET(fd, &rfds));
+    return true;
+}
+
+bool
+net_pipe(int fds[static 2]) {
+#ifdef __WINDOWS__
+    return !_pipe(fds, 4096, 0);
+#else
+    return !pipe(fds);
+#endif
+}
--- a/app/src/util/net.h
+++ b/app/src/util/net.h
@ -54,4 +54,12 @@ net_shutdown(socket_t socket, int how);
 bool
 net_close(socket_t socket);

+// wait for fd or fd_intr to be readable
+// return true if fd is readable and fd_intr is not
+bool
+net_select_interruptible(int fd, int fd_intr);
+
+bool
+net_pipe(int fd[static 2]);
+
 #endif
--- a/app/tests/test_control_msg_serialize.c
+++ b/app/tests/test_control_msg_serialize.c
@ -49,20 +49,20 @@ static void test_serialize_inject_text(void) {
 static void test_serialize_inject_text_long(void) {
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
-    char text[CONTROL_MSG_INJECT_TEXT_MAX_LENGTH + 1];
+    char text[CONTROL_MSG_TEXT_MAX_LENGTH + 1];
    memset(text, 'a', sizeof(text));
-    text[CONTROL_MSG_INJECT_TEXT_MAX_LENGTH] = '\0';
+    text[CONTROL_MSG_TEXT_MAX_LENGTH] = '\0';
    msg.inject_text.text = text;

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

-    unsigned char expected[3 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH];
+    unsigned char expected[3 + CONTROL_MSG_TEXT_MAX_LENGTH];
    expected[0] = CONTROL_MSG_TYPE_INJECT_TEXT;
    expected[1] = 0x01;
    expected[2] = 0x2c; // text length (16 bits)
-    memset(&expected[3], 'a', CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);
+    memset(&expected[3], 'a', CONTROL_MSG_TEXT_MAX_LENGTH);

    assert(!memcmp(buf, expected, sizeof(expected)));
 }
--- a/build.gradle
+++ b/build.gradle
@ -7,7 +7,7 @@ buildscript {
        jcenter()
    }
    dependencies {
-        classpath 'com.android.tools.build:gradle:3.6.2'
+        classpath 'com.android.tools.build:gradle:3.4.2'

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
--- a/cross_win32.txt
+++ b/cross_win32.txt
@ -15,6 +15,6 @@ cpu = 'i686'
 endian = 'little'

 [properties]
-prebuilt_ffmpeg_shared = 'ffmpeg-4.2.2-win32-shared'
-prebuilt_ffmpeg_dev = 'ffmpeg-4.2.2-win32-dev'
-prebuilt_sdl2 = 'SDL2-2.0.12/i686-w64-mingw32'
+prebuilt_ffmpeg_shared = 'ffmpeg-4.2.1-win32-shared'
+prebuilt_ffmpeg_dev = 'ffmpeg-4.2.1-win32-dev'
+prebuilt_sdl2 = 'SDL2-2.0.10/i686-w64-mingw32'
--- a/cross_win64.txt
+++ b/cross_win64.txt
@ -15,6 +15,6 @@ cpu = 'x86_64'
 endian = 'little'

 [properties]
-prebuilt_ffmpeg_shared = 'ffmpeg-4.2.2-win64-shared'
-prebuilt_ffmpeg_dev = 'ffmpeg-4.2.2-win64-dev'
-prebuilt_sdl2 = 'SDL2-2.0.12/x86_64-w64-mingw32'
+prebuilt_ffmpeg_shared = 'ffmpeg-4.2.1-win64-shared'
+prebuilt_ffmpeg_dev = 'ffmpeg-4.2.1-win64-dev'
+prebuilt_sdl2 = 'SDL2-2.0.10/x86_64-w64-mingw32'
--- a/gradle/wrapper/gradle-wrapper.jar
+++ b/gradle/wrapper/gradle-wrapper.jar
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.5.1-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
--- a/33
+++ b/33
@ -125,8 +125,8 @@ if $darwin; then
    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
 fi

-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
    JAVACMD=`cygpath --unix "$JAVACMD"`
@ -154,19 +154,19 @@ if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
        else
            eval `echo args$i`="\"$arg\""
        fi
-        i=`expr $i + 1`
+        i=$((i+1))
    done
    case $i in
-        0) set -- ;;
-        1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
    esac
 fi

@ -175,9 +175,14 @@ save () {
    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
    echo " "
 }
-APP_ARGS=`save "$@"`
+APP_ARGS=$(save "$@")

 # Collect all arguments for the java command, following the shell quoting and substitution rules
 eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"

+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
 exec "$JAVACMD" "$@"
--- a/gradlew.bat
+++ b/gradlew.bat
@ -29,9 +29,6 @@ if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%

-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"

--- a/meson.build
+++ b/meson.build
@ -1,6 +1,6 @@
 project('scrcpy', 'c',
-        version: '1.13',
-        meson_version: '>= 0.48',
+        version: '1.12.1',
+        meson_version: '>= 0.37',
        default_options: [
            'c_std=c11',
            'warning_level=2',
--- a/prebuilt-deps/Makefile
+++ b/prebuilt-deps/Makefile
@ -10,29 +10,29 @@ prepare-win32: prepare-sdl2 prepare-ffmpeg-shared-win32 prepare-ffmpeg-dev-win32
 prepare-win64: prepare-sdl2 prepare-ffmpeg-shared-win64 prepare-ffmpeg-dev-win64 prepare-adb

 prepare-ffmpeg-shared-win32:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/shared/ffmpeg-4.2.2-win32-shared.zip \
-		ab5d603aaa54de360db2c2ffe378c82376b9343ea1175421dd644639aa07ee31 \
-		ffmpeg-4.2.2-win32-shared
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/shared/ffmpeg-4.2.1-win32-shared.zip \
+		9208255f409410d95147151d7e829b5699bf8d91bfe1e81c3f470f47c2fa66d2 \
+		ffmpeg-4.2.1-win32-shared

 prepare-ffmpeg-dev-win32:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/dev/ffmpeg-4.2.2-win32-dev.zip \
-		8d224be567a2950cad4be86f4aabdd045bfa52ad758e87c72cedd278613bc6c8 \
-		ffmpeg-4.2.2-win32-dev
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/dev/ffmpeg-4.2.1-win32-dev.zip \
+		c3469e6c5f031cbcc8cba88dee92d6548c5c6b6ff14f4097f18f72a92d0d70c4 \
+		ffmpeg-4.2.1-win32-dev

 prepare-ffmpeg-shared-win64:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/shared/ffmpeg-4.2.2-win64-shared.zip \
-		5aedf268952b7d9f6541dbfcb47cd86a7e7881a3b7ba482fd3bc4ca33bda7bf5 \
-		ffmpeg-4.2.2-win64-shared
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/shared/ffmpeg-4.2.1-win64-shared.zip \
+		55063d3cf750a75485c7bf196031773d81a1b25d0980c7db48ecfc7701a42331 \
+		ffmpeg-4.2.1-win64-shared

 prepare-ffmpeg-dev-win64:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/dev/ffmpeg-4.2.2-win64-dev.zip \
-		f4885f859c5b0d6663c2a0a4c1cf035b1c60b146402790b796bd3ad84f4f3ca2 \
-		ffmpeg-4.2.2-win64-dev
+	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/dev/ffmpeg-4.2.1-win64-dev.zip \
+		5af393be5f25c0a71aa29efce768e477c35347f7f8e0d9696767d5b9d405b74e \
+		ffmpeg-4.2.1-win64-dev

 prepare-sdl2:
-	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.12-mingw.tar.gz \
-		e614a60f797e35ef9f3f96aef3dc6a1d786de3cc7ca6216f97e435c0b6aafc46 \
-		SDL2-2.0.12
+	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.10-mingw.tar.gz \
+		a90a7cddaec4996f4d7be6d80c57ec69b062e132bffc513965f99217f603274a \
+		SDL2-2.0.10

 prepare-adb:
 	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r29.0.5-windows.zip \
--- a/server/build.gradle
+++ b/server/build.gradle
@ -6,8 +6,8 @@ android {
        applicationId "com.genymobile.scrcpy"
        minSdkVersion 21
        targetSdkVersion 29
-        versionCode 15
-        versionName "1.13"
+        versionCode 14
+        versionName "1.12.1"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
--- a/server/build_without_gradle.sh
+++ b/server/build_without_gradle.sh
@ -12,7 +12,7 @@
 set -e

 SCRCPY_DEBUG=false
-SCRCPY_VERSION_NAME=1.13
+SCRCPY_VERSION_NAME=1.12.1

 PLATFORM=${ANDROID_PLATFORM:-29}
 BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-29.0.2}
--- a/server/meson.build
+++ b/server/meson.build
@ -3,9 +3,7 @@
 prebuilt_server = get_option('prebuilt_server')
 if prebuilt_server == ''
    custom_target('scrcpy-server',
-                  # gradle is responsible for tracking source changes
-                  build_by_default: true,
-                  build_always_stale: true,
+                  build_always: true,  # gradle is responsible for tracking source changes
                  output: 'scrcpy-server',
                  command: [find_program('./scripts/build-wrapper.sh'), meson.current_source_dir(), '@OUTPUT@', get_option('buildtype')],
                  console: true,
--- a/server/src/main/aidl/android/content/IOnPrimaryClipChangedListener.aidl
+++ b/server/src/main/aidl/android/content/IOnPrimaryClipChangedListener.aidl
@ -1,24 +0,0 @@
-/**
- * Copyright (c) 2008, The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.content;
-
-/**
- * {@hide}
- */
-oneway interface IOnPrimaryClipChangedListener {
-    void dispatchPrimaryClipChanged();
-}
--- a/server/src/main/java/com/genymobile/scrcpy/CleanUp.java
+++ b/server/src/main/java/com/genymobile/scrcpy/CleanUp.java
@ -1,77 +0,0 @@
-package com.genymobile.scrcpy;
-
-import com.genymobile.scrcpy.wrappers.ContentProvider;
-import com.genymobile.scrcpy.wrappers.ServiceManager;
-
-import java.io.File;
-import java.io.IOException;
-
-/**
- * Handle the cleanup of scrcpy, even if the main process is killed.
- * <p>
- * This is useful to restore some state when scrcpy is closed, even on device disconnection (which kills the scrcpy process).
- */
-public final class CleanUp {
-
-    public static final String SERVER_PATH = "/data/local/tmp/scrcpy-server.jar";
-
-    private CleanUp() {
-        // not instantiable
-    }
-
-    public static void configure(boolean disableShowTouches, int restoreStayOn) throws IOException {
-        boolean needProcess = disableShowTouches || restoreStayOn != -1;
-        if (needProcess) {
-            startProcess(disableShowTouches, restoreStayOn);
-        } else {
-            // There is no additional clean up to do when scrcpy dies
-            unlinkSelf();
-        }
-    }
-
-    private static void startProcess(boolean disableShowTouches, int restoreStayOn) throws IOException {
-        String[] cmd = {"app_process", "/", CleanUp.class.getName(), String.valueOf(disableShowTouches), String.valueOf(restoreStayOn)};
-
-        ProcessBuilder builder = new ProcessBuilder(cmd);
-        builder.environment().put("CLASSPATH", SERVER_PATH);
-        builder.start();
-    }
-
-    private static void unlinkSelf() {
-        try {
-            new File(SERVER_PATH).delete();
-        } catch (Exception e) {
-            Ln.e("Could not unlink server", e);
-        }
-    }
-
-    public static void main(String... args) {
-        unlinkSelf();
-
-        try {
-            // Wait for the server to die
-            System.in.read();
-        } catch (IOException e) {
-            // Expected when the server is dead
-        }
-
-        Ln.i("Cleaning up");
-
-        boolean disableShowTouches = Boolean.parseBoolean(args[0]);
-        int restoreStayOn = Integer.parseInt(args[1]);
-
-        if (disableShowTouches || restoreStayOn != -1) {
-            ServiceManager serviceManager = new ServiceManager();
-            try (ContentProvider settings = serviceManager.getActivityManager().createSettingsProvider()) {
-                if (disableShowTouches) {
-                    Ln.i("Disabling \"show touches\"");
-                    settings.putValue(ContentProvider.TABLE_SYSTEM, "show_touches", "0");
-                }
-                if (restoreStayOn != -1) {
-                    Ln.i("Restoring \"stay awake\"");
-                    settings.putValue(ContentProvider.TABLE_GLOBAL, "stay_on_while_plugged_in", String.valueOf(restoreStayOn));
-                }
-            }
-        }
-    }
-}
--- a/server/src/main/java/com/genymobile/scrcpy/ControlMessageReader.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ControlMessageReader.java
@ -13,8 +13,8 @@ public class ControlMessageReader {
    static final int INJECT_SCROLL_EVENT_PAYLOAD_LENGTH = 20;
    static final int SET_SCREEN_POWER_MODE_PAYLOAD_LENGTH = 1;

+    public static final int TEXT_MAX_LENGTH = 300;
    public static final int CLIPBOARD_TEXT_MAX_LENGTH = 4093;
-    public static final int INJECT_TEXT_MAX_LENGTH = 300;
    private static final int RAW_BUFFER_SIZE = 1024;

    private final byte[] rawBuffer = new byte[RAW_BUFFER_SIZE];
--- a/server/src/main/java/com/genymobile/scrcpy/Controller.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Controller.java
@ -215,7 +215,7 @@ public class Controller {

        MotionEvent event = MotionEvent
                .obtain(lastTouchDown, now, MotionEvent.ACTION_SCROLL, 1, pointerProperties, pointerCoords, 0, 0, 1f, 1f, DEVICE_ID_VIRTUAL, 0,
-                        InputDevice.SOURCE_TOUCHSCREEN, 0);
+                        InputDevice.SOURCE_MOUSE, 0);
        return injectEvent(event);
    }

--- a/server/src/main/java/com/genymobile/scrcpy/Device.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Device.java
@ -1,12 +1,10 @@
 package com.genymobile.scrcpy;

-import com.genymobile.scrcpy.wrappers.ContentProvider;
 import com.genymobile.scrcpy.wrappers.InputManager;
 import com.genymobile.scrcpy.wrappers.ServiceManager;
 import com.genymobile.scrcpy.wrappers.SurfaceControl;
 import com.genymobile.scrcpy.wrappers.WindowManager;

-import android.content.IOnPrimaryClipChangedListener;
 import android.graphics.Rect;
 import android.os.Build;
 import android.os.IBinder;
@ -38,7 +36,10 @@ public final class Device {
     */
    private final int layerStack;

-    private final boolean supportsInputEvents;
+    /**
+     * The FLAG_PRESENTATION from the DisplayInfo
+     */
+    private final boolean isPresentationDisplay;

    public Device(Options options) {
        displayId = options.getDisplayId();
@ -52,6 +53,7 @@ public final class Device {

        screenInfo = ScreenInfo.computeScreenInfo(displayInfo, options.getCrop(), options.getMaxSize(), options.getLockedVideoOrientation());
        layerStack = displayInfo.getLayerStack();
+        isPresentationDisplay = (displayInfoFlags & DisplayInfo.FLAG_PRESENTATION) != 0;

        registerRotationWatcher(new IRotationWatcher.Stub() {
            @Override
@ -65,24 +67,14 @@ public final class Device {
                    }
                }
            }
-        }, displayId);
-
-        serviceManager.getClipboardManager().addPrimaryClipChangedListener(new IOnPrimaryClipChangedListener.Stub() {
-            @Override
-            public void dispatchPrimaryClipChanged() {
-                String s = getClipboardText();
-                Ln.i("clipboard changed = " + s);
-            }
        });

        if ((displayInfoFlags & DisplayInfo.FLAG_SUPPORTS_PROTECTED_BUFFERS) == 0) {
            Ln.w("Display doesn't have FLAG_SUPPORTS_PROTECTED_BUFFERS flag, mirroring can be restricted");
        }

-        // main display or any display on Android >= Q
-        supportsInputEvents = displayId == 0 || Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q;
-        if (!supportsInputEvents) {
-            Ln.w("Input events are not supported for secondary displays before Android 10");
+        if (!supportsInputEvents()) {
+            Ln.w("Input events are not supported for displays with FLAG_PRESENTATION enabled for devices with API lower than 29");
        }
    }

@ -124,7 +116,10 @@ public final class Device {
    }

    public boolean supportsInputEvents() {
-        return supportsInputEvents;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            return true;
+        }
+        return !isPresentationDisplay;
    }

    public boolean injectInputEvent(InputEvent inputEvent, int mode) {
@ -143,8 +138,8 @@ public final class Device {
        return serviceManager.getPowerManager().isScreenOn();
    }

-    public void registerRotationWatcher(IRotationWatcher rotationWatcher, int displayId) {
-        serviceManager.getWindowManager().registerRotationWatcher(rotationWatcher, displayId);
+    public void registerRotationWatcher(IRotationWatcher rotationWatcher) {
+        serviceManager.getWindowManager().registerRotationWatcher(rotationWatcher);
    }

    public synchronized void setRotationListener(RotationListener rotationListener) {
@ -168,10 +163,8 @@ public final class Device {
    }

    public void setClipboardText(String text) {
-        boolean ok = serviceManager.getClipboardManager().setText(text);
-        if (ok) {
-            Ln.i("Device clipboard set");
-        }
+        serviceManager.getClipboardManager().setText(text);
+        Ln.i("Device clipboard set");
    }

    /**
@ -183,10 +176,8 @@ public final class Device {
            Ln.e("Could not get built-in display");
            return;
        }
-        boolean ok = SurfaceControl.setDisplayPowerMode(d, mode);
-        if (ok) {
-            Ln.i("Device screen turned " + (mode == Device.POWER_MODE_OFF ? "off" : "on"));
-        }
+        SurfaceControl.setDisplayPowerMode(d, mode);
+        Ln.i("Device screen turned " + (mode == Device.POWER_MODE_OFF ? "off" : "on"));
    }

    /**
@ -209,8 +200,4 @@ public final class Device {
            wm.thawRotation();
        }
    }
-
-    public ContentProvider createSettingsProvider() {
-        return serviceManager.getActivityManager().createSettingsProvider();
-    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/DisplayInfo.java
+++ b/server/src/main/java/com/genymobile/scrcpy/DisplayInfo.java
@ -8,6 +8,7 @@ public final class DisplayInfo {
    private final int flags;

    public static final int FLAG_SUPPORTS_PROTECTED_BUFFERS = 0x00000001;
+    public static final int FLAG_PRESENTATION = 0x00000008;

    public DisplayInfo(int displayId, Size size, int rotation, int layerStack, int flags) {
        this.displayId = displayId;
--- a/server/src/main/java/com/genymobile/scrcpy/Options.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Options.java
@ -12,8 +12,6 @@ public class Options {
    private boolean sendFrameMeta; // send PTS so that the client may record properly
    private boolean control;
    private int displayId;
-    private boolean showTouches;
-    private boolean stayAwake;

    public int getMaxSize() {
        return maxSize;
@ -86,20 +84,4 @@ public class Options {
    public void setDisplayId(int displayId) {
        this.displayId = displayId;
    }
-
-    public boolean getShowTouches() {
-        return showTouches;
-    }
-
-    public void setShowTouches(boolean showTouches) {
-        this.showTouches = showTouches;
-    }
-
-    public boolean getStayAwake() {
-        return stayAwake;
-    }
-
-    public void setStayAwake(boolean stayAwake) {
-        this.stayAwake = stayAwake;
-    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
@ -27,13 +27,21 @@ public class ScreenEncoder implements Device.RotationListener {

    private int bitRate;
    private int maxFps;
+    private int lockedVideoOrientation;
+    private int iFrameInterval;
    private boolean sendFrameMeta;
    private long ptsOrigin;

-    public ScreenEncoder(boolean sendFrameMeta, int bitRate, int maxFps) {
+    public ScreenEncoder(boolean sendFrameMeta, int bitRate, int maxFps, int lockedVideoOrientation, int iFrameInterval) {
        this.sendFrameMeta = sendFrameMeta;
        this.bitRate = bitRate;
        this.maxFps = maxFps;
+        this.lockedVideoOrientation = lockedVideoOrientation;
+        this.iFrameInterval = iFrameInterval;
+    }
+
+    public ScreenEncoder(boolean sendFrameMeta, int bitRate, int maxFps, int lockedVideoOrientation) {
+        this(sendFrameMeta, bitRate, maxFps, lockedVideoOrientation, DEFAULT_I_FRAME_INTERVAL);
    }

    @Override
@ -47,21 +55,9 @@ public class ScreenEncoder implements Device.RotationListener {

    public void streamScreen(Device device, FileDescriptor fd) throws IOException {
        Workarounds.prepareMainLooper();
+        Workarounds.fillAppInfo();

-        try {
-            internalStreamScreen(device, fd);
-        } catch (NullPointerException e) {
-            // Retry with workarounds enabled:
-            // <https://github.com/Genymobile/scrcpy/issues/365>
-            // <https://github.com/Genymobile/scrcpy/issues/940>
-            Ln.d("Applying workarounds to avoid NullPointerException");
-            Workarounds.fillAppInfo();
-            internalStreamScreen(device, fd);
-        }
-    }
-
-    private void internalStreamScreen(Device device, FileDescriptor fd) throws IOException {
-        MediaFormat format = createFormat(bitRate, maxFps);
+        MediaFormat format = createFormat(bitRate, maxFps, iFrameInterval);
        device.setRotationListener(this);
        boolean alive;
        try {
@ -148,17 +144,17 @@ public class ScreenEncoder implements Device.RotationListener {
    }

    private static MediaCodec createCodec() throws IOException {
-        return MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC);
+        return MediaCodec.createEncoderByType("video/avc");
    }

-    private static MediaFormat createFormat(int bitRate, int maxFps) {
+    private static MediaFormat createFormat(int bitRate, int maxFps, int iFrameInterval) {
        MediaFormat format = new MediaFormat();
-        format.setString(MediaFormat.KEY_MIME, MediaFormat.MIMETYPE_VIDEO_AVC);
+        format.setString(MediaFormat.KEY_MIME, "video/avc");
        format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
        // must be present to configure the encoder, but does not impact the actual frame rate, which is variable
        format.setInteger(MediaFormat.KEY_FRAME_RATE, 60);
        format.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
-        format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, DEFAULT_I_FRAME_INTERVAL);
+        format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, iFrameInterval);
        // display the very first frame, and recover from bad quality when no new frames
        format.setLong(MediaFormat.KEY_REPEAT_PREVIOUS_FRAME_AFTER, REPEAT_FRAME_DELAY_US); // µs
        if (maxFps > 0) {
@ -171,7 +167,7 @@ public class ScreenEncoder implements Device.RotationListener {
    }

    private static IBinder createDisplay() {
-        return SurfaceControl.createDisplay("scrcpy", false);
+        return SurfaceControl.createDisplay("scrcpy", true);
    }

    private static void configure(MediaCodec codec, MediaFormat format) {
--- a/server/src/main/java/com/genymobile/scrcpy/Server.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Server.java
@ -1,16 +1,15 @@
 package com.genymobile.scrcpy;

-import com.genymobile.scrcpy.wrappers.ContentProvider;
-
 import android.graphics.Rect;
 import android.media.MediaCodec;
-import android.os.BatteryManager;
 import android.os.Build;

+import java.io.File;
 import java.io.IOException;

 public final class Server {

+    private static final String SERVER_PATH = "/data/local/tmp/scrcpy-server.jar";

    private Server() {
        // not instantiable
@ -19,38 +18,10 @@ public final class Server {
    private static void scrcpy(Options options) throws IOException {
        Ln.i("Device: " + Build.MANUFACTURER + " " + Build.MODEL + " (Android " + Build.VERSION.RELEASE + ")");
        final Device device = new Device(options);
-
-        boolean mustDisableShowTouchesOnCleanUp = false;
-        int restoreStayOn = -1;
-        if (options.getShowTouches() || options.getStayAwake()) {
-            try (ContentProvider settings = device.createSettingsProvider()) {
-                if (options.getShowTouches()) {
-                    String oldValue = settings.getAndPutValue(ContentProvider.TABLE_SYSTEM, "show_touches", "1");
-                    // If "show touches" was disabled, it must be disabled back on clean up
-                    mustDisableShowTouchesOnCleanUp = !"1".equals(oldValue);
-                }
-
-                if (options.getStayAwake()) {
-                    int stayOn = BatteryManager.BATTERY_PLUGGED_AC | BatteryManager.BATTERY_PLUGGED_USB | BatteryManager.BATTERY_PLUGGED_WIRELESS;
-                    String oldValue = settings.getAndPutValue(ContentProvider.TABLE_GLOBAL, "stay_on_while_plugged_in", String.valueOf(stayOn));
-                    try {
-                        restoreStayOn = Integer.parseInt(oldValue);
-                        if (restoreStayOn == stayOn) {
-                            // No need to restore
-                            restoreStayOn = -1;
-                        }
-                    } catch (NumberFormatException e) {
-                        restoreStayOn = 0;
-                    }
-                }
-            }
-        }
-
-        CleanUp.configure(mustDisableShowTouchesOnCleanUp, restoreStayOn);
-
        boolean tunnelForward = options.isTunnelForward();
        try (DesktopConnection connection = DesktopConnection.open(device, tunnelForward)) {
-            ScreenEncoder screenEncoder = new ScreenEncoder(options.getSendFrameMeta(), options.getBitRate(), options.getMaxFps());
+            ScreenEncoder screenEncoder = new ScreenEncoder(options.getSendFrameMeta(), options.getBitRate(), options.getMaxFps(),
+                    options.getLockedVideoOrientation());

            if (options.getControl()) {
                Controller controller = new Controller(device, connection);
@ -109,9 +80,8 @@ public final class Server {
                    "The server version (" + BuildConfig.VERSION_NAME + ") does not match the client " + "(" + clientVersion + ")");
        }

-        final int expectedParameters = 12;
-        if (args.length != expectedParameters) {
-            throw new IllegalArgumentException("Expecting " + expectedParameters + " parameters");
+        if (args.length != 10) {
+            throw new IllegalArgumentException("Expecting 10 parameters");
        }

        Options options = new Options();
@ -144,12 +114,6 @@ public final class Server {
        int displayId = Integer.parseInt(args[9]);
        options.setDisplayId(displayId);

-        boolean showTouches = Boolean.parseBoolean(args[10]);
-        options.setShowTouches(showTouches);
-
-        boolean stayAwake = Boolean.parseBoolean(args[11]);
-        options.setStayAwake(stayAwake);
-
        return options;
    }

@ -169,6 +133,14 @@ public final class Server {
        return new Rect(x, y, x + width, y + height);
    }

+    private static void unlinkSelf() {
+        try {
+            new File(SERVER_PATH).delete();
+        } catch (Exception e) {
+            Ln.e("Could not unlink server", e);
+        }
+    }
+
    private static void suggestFix(Throwable e) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if (e instanceof MediaCodec.CodecException) {
@ -201,6 +173,7 @@ public final class Server {
            }
        });

+        unlinkSelf();
        Options options = createOptions(args);
        scrcpy(options);
    }
--- a/server/src/main/java/com/genymobile/scrcpy/Workarounds.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Workarounds.java
@ -28,7 +28,7 @@ public final class Workarounds {
        Looper.prepareMainLooper();
    }

-    @SuppressLint("PrivateApi,DiscouragedPrivateApi")
+    @SuppressLint("PrivateApi")
    public static void fillAppInfo() {
        try {
            // ActivityThread activityThread = new ActivityThread();
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/ActivityManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/ActivityManager.java
@ -1,87 +0,0 @@
-package com.genymobile.scrcpy.wrappers;
-
-import com.genymobile.scrcpy.Ln;
-
-import android.os.Binder;
-import android.os.IBinder;
-import android.os.IInterface;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-
-public class ActivityManager {
-
-    private final IInterface manager;
-    private Method getContentProviderExternalMethod;
-    private boolean getContentProviderExternalMethodLegacy;
-    private Method removeContentProviderExternalMethod;
-
-    public ActivityManager(IInterface manager) {
-        this.manager = manager;
-    }
-
-    private Method getGetContentProviderExternalMethod() throws NoSuchMethodException {
-        if (getContentProviderExternalMethod == null) {
-            try {
-                getContentProviderExternalMethod = manager.getClass()
-                        .getMethod("getContentProviderExternal", String.class, int.class, IBinder.class, String.class);
-            } catch (NoSuchMethodException e) {
-                // old version
-                getContentProviderExternalMethod = manager.getClass().getMethod("getContentProviderExternal", String.class, int.class, IBinder.class);
-                getContentProviderExternalMethodLegacy = true;
-            }
-        }
-        return getContentProviderExternalMethod;
-    }
-
-    private Method getRemoveContentProviderExternalMethod() throws NoSuchMethodException {
-        if (removeContentProviderExternalMethod == null) {
-            removeContentProviderExternalMethod = manager.getClass().getMethod("removeContentProviderExternal", String.class, IBinder.class);
-        }
-        return removeContentProviderExternalMethod;
-    }
-
-    private ContentProvider getContentProviderExternal(String name, IBinder token) {
-        try {
-            Method method = getGetContentProviderExternalMethod();
-            Object[] args;
-            if (!getContentProviderExternalMethodLegacy) {
-                // new version
-                args = new Object[]{name, ServiceManager.USER_ID, token, null};
-            } else {
-                // old version
-                args = new Object[]{name, ServiceManager.USER_ID, token};
-            }
-            // ContentProviderHolder providerHolder = getContentProviderExternal(...);
-            Object providerHolder = method.invoke(manager, args);
-            if (providerHolder == null) {
-                return null;
-            }
-            // IContentProvider provider = providerHolder.provider;
-            Field providerField = providerHolder.getClass().getDeclaredField("provider");
-            providerField.setAccessible(true);
-            Object provider = providerField.get(providerHolder);
-            if (provider == null) {
-                return null;
-            }
-            return new ContentProvider(this, provider, name, token);
-        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException | NoSuchFieldException e) {
-            Ln.e("Could not invoke method", e);
-            return null;
-        }
-    }
-
-    void removeContentProviderExternal(String name, IBinder token) {
-        try {
-            Method method = getRemoveContentProviderExternalMethod();
-            method.invoke(manager, name, token);
-        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
-            Ln.e("Could not invoke method", e);
-        }
-    }
-
-    public ContentProvider createSettingsProvider() {
-        return getContentProviderExternal("settings", new Binder());
-    }
-}
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/ClipboardManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/ClipboardManager.java
@ -3,7 +3,6 @@ package com.genymobile.scrcpy.wrappers;
 import com.genymobile.scrcpy.Ln;

 import android.content.ClipData;
-import android.content.IOnPrimaryClipChangedListener;
 import android.os.Build;
 import android.os.IInterface;

@ -11,10 +10,13 @@ import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;

 public class ClipboardManager {
+
+    private static final String PACKAGE_NAME = "com.android.shell";
+    private static final int USER_ID = 0;
+
    private final IInterface manager;
    private Method getPrimaryClipMethod;
    private Method setPrimaryClipMethod;
-    private Method addPrimaryClipChangedListener;

    public ClipboardManager(IInterface manager) {
        this.manager = manager;
@ -44,17 +46,17 @@ public class ClipboardManager {

    private static ClipData getPrimaryClip(Method method, IInterface manager) throws InvocationTargetException, IllegalAccessException {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-            return (ClipData) method.invoke(manager, ServiceManager.PACKAGE_NAME);
+            return (ClipData) method.invoke(manager, PACKAGE_NAME);
        }
-        return (ClipData) method.invoke(manager, ServiceManager.PACKAGE_NAME, ServiceManager.USER_ID);
+        return (ClipData) method.invoke(manager, PACKAGE_NAME, USER_ID);
    }

    private static void setPrimaryClip(Method method, IInterface manager, ClipData clipData)
            throws InvocationTargetException, IllegalAccessException {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-            method.invoke(manager, clipData, ServiceManager.PACKAGE_NAME);
+            method.invoke(manager, clipData, PACKAGE_NAME);
        } else {
-            method.invoke(manager, clipData, ServiceManager.PACKAGE_NAME, ServiceManager.USER_ID);
+            method.invoke(manager, clipData, PACKAGE_NAME, USER_ID);
        }
    }

@ -72,48 +74,13 @@ public class ClipboardManager {
        }
    }

-    public boolean setText(CharSequence text) {
+    public void setText(CharSequence text) {
        try {
            Method method = getSetPrimaryClipMethod();
            ClipData clipData = ClipData.newPlainText(null, text);
            setPrimaryClip(method, manager, clipData);
-            return true;
        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
-            return false;
-        }
-    }
-
-    private static void addPrimaryClipChangedListener(Method method, IInterface manager, IOnPrimaryClipChangedListener listener)
-            throws InvocationTargetException, IllegalAccessException {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-            method.invoke(manager, listener, ServiceManager.PACKAGE_NAME);
-        } else {
-            method.invoke(manager, listener, ServiceManager.PACKAGE_NAME, ServiceManager.USER_ID);
-        }
-    }
-
-    private Method getAddPrimaryClipChangedListener() throws NoSuchMethodException {
-        if (addPrimaryClipChangedListener == null) {
-            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-                addPrimaryClipChangedListener = manager.getClass()
-                        .getMethod("addPrimaryClipChangedListener", IOnPrimaryClipChangedListener.class, String.class);
-            } else {
-                addPrimaryClipChangedListener = manager.getClass()
-                        .getMethod("addPrimaryClipChangedListener", IOnPrimaryClipChangedListener.class, String.class, int.class);
-            }
-        }
-        return addPrimaryClipChangedListener;
-    }
-
-    public boolean addPrimaryClipChangedListener(IOnPrimaryClipChangedListener listener) {
-        try {
-            Method method = getAddPrimaryClipChangedListener();
-            addPrimaryClipChangedListener(method, manager, listener);
-            return true;
-        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
-            Ln.e("Could not invoke method", e);
-            return false;
        }
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/ContentProvider.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/ContentProvider.java
@ -1,132 +0,0 @@
-package com.genymobile.scrcpy.wrappers;
-
-import com.genymobile.scrcpy.Ln;
-
-import android.os.Bundle;
-import android.os.IBinder;
-
-import java.io.Closeable;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-
-public class ContentProvider implements Closeable {
-
-    public static final String TABLE_SYSTEM = "system";
-    public static final String TABLE_SECURE = "secure";
-    public static final String TABLE_GLOBAL = "global";
-
-    // See android/providerHolder/Settings.java
-    private static final String CALL_METHOD_GET_SYSTEM = "GET_system";
-    private static final String CALL_METHOD_GET_SECURE = "GET_secure";
-    private static final String CALL_METHOD_GET_GLOBAL = "GET_global";
-
-    private static final String CALL_METHOD_PUT_SYSTEM = "PUT_system";
-    private static final String CALL_METHOD_PUT_SECURE = "PUT_secure";
-    private static final String CALL_METHOD_PUT_GLOBAL = "PUT_global";
-
-    private static final String CALL_METHOD_USER_KEY = "_user";
-
-    private static final String NAME_VALUE_TABLE_VALUE = "value";
-
-    private final ActivityManager manager;
-    // android.content.IContentProvider
-    private final Object provider;
-    private final String name;
-    private final IBinder token;
-
-    private Method callMethod;
-    private boolean callMethodLegacy;
-
-    ContentProvider(ActivityManager manager, Object provider, String name, IBinder token) {
-        this.manager = manager;
-        this.provider = provider;
-        this.name = name;
-        this.token = token;
-    }
-
-    private Method getCallMethod() throws NoSuchMethodException {
-        if (callMethod == null) {
-            try {
-                callMethod = provider.getClass().getMethod("call", String.class, String.class, String.class, String.class, Bundle.class);
-            } catch (NoSuchMethodException e) {
-                // old version
-                callMethod = provider.getClass().getMethod("call", String.class, String.class, String.class, Bundle.class);
-                callMethodLegacy = true;
-            }
-        }
-        return callMethod;
-    }
-
-    private Bundle call(String callMethod, String arg, Bundle extras) {
-        try {
-            Method method = getCallMethod();
-            Object[] args;
-            if (!callMethodLegacy) {
-                args = new Object[]{ServiceManager.PACKAGE_NAME, "settings", callMethod, arg, extras};
-            } else {
-                args = new Object[]{ServiceManager.PACKAGE_NAME, callMethod, arg, extras};
-            }
-            return (Bundle) method.invoke(provider, args);
-        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
-            Ln.e("Could not invoke method", e);
-            return null;
-        }
-    }
-
-    public void close() {
-        manager.removeContentProviderExternal(name, token);
-    }
-
-    private static String getGetMethod(String table) {
-        switch (table) {
-            case TABLE_SECURE:
-                return CALL_METHOD_GET_SECURE;
-            case TABLE_SYSTEM:
-                return CALL_METHOD_GET_SYSTEM;
-            case TABLE_GLOBAL:
-                return CALL_METHOD_GET_GLOBAL;
-            default:
-                throw new IllegalArgumentException("Invalid table: " + table);
-        }
-    }
-
-    private static String getPutMethod(String table) {
-        switch (table) {
-            case TABLE_SECURE:
-                return CALL_METHOD_PUT_SECURE;
-            case TABLE_SYSTEM:
-                return CALL_METHOD_PUT_SYSTEM;
-            case TABLE_GLOBAL:
-                return CALL_METHOD_PUT_GLOBAL;
-            default:
-                throw new IllegalArgumentException("Invalid table: " + table);
-        }
-    }
-
-    public String getValue(String table, String key) {
-        String method = getGetMethod(table);
-        Bundle arg = new Bundle();
-        arg.putInt(CALL_METHOD_USER_KEY, ServiceManager.USER_ID);
-        Bundle bundle = call(method, key, arg);
-        if (bundle == null) {
-            return null;
-        }
-        return bundle.getString("value");
-    }
-
-    public void putValue(String table, String key, String value) {
-        String method = getPutMethod(table);
-        Bundle arg = new Bundle();
-        arg.putInt(CALL_METHOD_USER_KEY, ServiceManager.USER_ID);
-        arg.putString(NAME_VALUE_TABLE_VALUE, value);
-        call(method, key, arg);
-    }
-
-    public String getAndPutValue(String table, String key, String value) {
-        String oldValue = getValue(table, key);
-        if (!value.equals(oldValue)) {
-            putValue(table, key, value);
-        }
-        return oldValue;
-    }
-}
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java
@ -53,7 +53,8 @@ public final class InputManager {
            method.invoke(inputEvent, displayId);
            return true;
        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
-            Ln.e("Cannot associate a display id to the input event", e);
+            // just a warning, it might happen on old devices
+            Ln.w("Cannot associate a display id to the input event");
            return false;
        }
    }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/ServiceManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/ServiceManager.java
@ -6,12 +6,8 @@ import android.os.IInterface;

 import java.lang.reflect.Method;

-@SuppressLint("PrivateApi,DiscouragedPrivateApi")
+@SuppressLint("PrivateApi")
 public final class ServiceManager {
-
-    public static final String PACKAGE_NAME = "com.android.shell";
-    public static final int USER_ID = 0;
-
    private final Method getServiceMethod;

    private WindowManager windowManager;
@ -20,7 +16,6 @@ public final class ServiceManager {
    private PowerManager powerManager;
    private StatusBarManager statusBarManager;
    private ClipboardManager clipboardManager;
-    private ActivityManager activityManager;

    public ServiceManager() {
        try {
@ -81,21 +76,4 @@ public final class ServiceManager {
        }
        return clipboardManager;
    }
-
-    public ActivityManager getActivityManager() {
-        if (activityManager == null) {
-            try {
-                // On old Android versions, the ActivityManager is not exposed via AIDL,
-                // so use ActivityManagerNative.getDefault()
-                Class<?> cls = Class.forName("android.app.ActivityManagerNative");
-                Method getDefaultMethod = cls.getDeclaredMethod("getDefault");
-                IInterface am = (IInterface) getDefaultMethod.invoke(null);
-                activityManager = new ActivityManager(am);
-            } catch (Exception e) {
-                throw new AssertionError(e);
-            }
-        }
-
-        return activityManager;
-    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/SurfaceControl.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/SurfaceControl.java
@ -121,14 +121,12 @@ public final class SurfaceControl {
        return setDisplayPowerModeMethod;
    }

-    public static boolean setDisplayPowerMode(IBinder displayToken, int mode) {
+    public static void setDisplayPowerMode(IBinder displayToken, int mode) {
        try {
            Method method = getSetDisplayPowerModeMethod();
            method.invoke(null, displayToken, mode);
-            return true;
        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
-            return false;
        }
    }

--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/WindowManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/WindowManager.java
@ -93,13 +93,13 @@ public final class WindowManager {
        }
    }

-    public void registerRotationWatcher(IRotationWatcher rotationWatcher, int displayId) {
+    public void registerRotationWatcher(IRotationWatcher rotationWatcher) {
        try {
            Class<?> cls = manager.getClass();
            try {
                // display parameter added since this commit:
                // https://android.googlesource.com/platform/frameworks/base/+/35fa3c26adcb5f6577849fd0df5228b1f67cf2c6%5E%21/#F1
-                cls.getMethod("watchRotation", IRotationWatcher.class, int.class).invoke(manager, rotationWatcher, displayId);
+                cls.getMethod("watchRotation", IRotationWatcher.class, int.class).invoke(manager, rotationWatcher, 0);
            } catch (NoSuchMethodException e) {
                // old version
                cls.getMethod("watchRotation", IRotationWatcher.class).invoke(manager, rotationWatcher);
--- a/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java
+++ b/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java
@ -66,7 +66,7 @@ public class ControlMessageReaderTest {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(bos);
        dos.writeByte(ControlMessage.TYPE_INJECT_TEXT);
-        byte[] text = new byte[ControlMessageReader.INJECT_TEXT_MAX_LENGTH];
+        byte[] text = new byte[ControlMessageReader.TEXT_MAX_LENGTH];
        Arrays.fill(text, (byte) 'a');
        dos.writeShort(text.length);
        dos.write(text);
Author	SHA1	Message	Date
Romain Vimont	73d098872c	Do not warn on terminating the server If the server is already dead, terminating it fails. This is expected.	2020-03-29 11:24:11 +02:00
Romain Vimont	943d264b35	Do not block on accept() if server died The server may die before connecting to the client. In that case, the client was blocked indefinitely (until Ctrl+C) on accept(). To avoid the problem, use a pipe and a select() before calling accept(), so that the blocking call can be interrupted. Once accept() is called, it is guaranteed not to block.	2020-03-29 11:24:11 +02:00
Romain Vimont	32dc192883	Wait server from a separate thread Create a thread just to wait for the server process exit. This paves the way to simply wake up a blocking accept() in a portable way.	2020-03-28 23:56:37 +01:00
Romain Vimont	7732f1097b	Refactor server_start() error handling This will avoid more cleanup duplication.	2020-03-28 23:56:37 +01:00
e_vigurskiy	429153abfb	Add display id parameter Add --display command line parameter to specify a display id.	2020-03-28 23:56:37 +01:00