Compare commits
5 Commits
issue15
...
threadwait
| Author | SHA1 | Date | |
|---|---|---|---|
| d76c7c3029 | |||
| f2f032a494 | |||
| 728b976aae | |||
| ff583bdde8 | |||
| 429153abfb |
25
.github/ISSUE_TEMPLATE/bug_report.md
vendored
25
.github/ISSUE_TEMPLATE/bug_report.md
vendored
@ -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.
|
||||
22
.github/ISSUE_TEMPLATE/feature_request.md
vendored
22
.github/ISSUE_TEMPLATE/feature_request.md
vendored
@ -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.
|
||||
1
.gitignore
vendored
1
.gitignore
vendored
@ -2,4 +2,3 @@ build/
|
||||
/dist/
|
||||
.idea/
|
||||
.gradle/
|
||||
/x/
|
||||
|
||||
19
BUILD.md
19
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
|
||||
|
||||
@ -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).
|
||||
|
||||
167
FAQ.md
167
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:
|
||||
|
||||
|
||||
44
README.md
44
README.md
@ -66,12 +66,15 @@ 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-win32-v1.12.1.zip`][direct-win32]
|
||||
_(SHA-256: 0f4b3b063536b50a2df05dc42c760f9cc0093a9a26dbdf02d8232c74dab43480)_
|
||||
- [`scrcpy-win64-v1.12.1.zip`][direct-win64]
|
||||
_(SHA-256: 57d34b6d16cfd9fe169bc37c4df58ebd256d05c1ea3febc63d9cb0a027ab47c9)_
|
||||
|
||||
[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].
|
||||
|
||||
|
||||
@ -341,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
|
||||
|
||||
@ -519,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_
|
||||
|
||||
@ -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',
|
||||
|
||||
52
app/scrcpy.1
52
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.
|
||||
@ -180,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
|
||||
@ -228,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
|
||||
|
||||
104
app/src/cli.c
104
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"
|
||||
@ -161,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,
|
||||
@ -334,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"
|
||||
@ -465,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[]) {
|
||||
@ -484,15 +445,12 @@ 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'},
|
||||
{"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'},
|
||||
{"turn-screen-off", no_argument, NULL, 'S'},
|
||||
@ -628,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;
|
||||
@ -650,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]);
|
||||
|
||||
@ -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:
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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));
|
||||
|
||||
@ -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);
|
||||
}
|
||||
@ -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
|
||||
@ -47,7 +47,7 @@ static struct input_manager input_manager = {
|
||||
|
||||
// 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());
|
||||
@ -60,10 +60,6 @@ sdl_init_and_configure(bool display, const char *render_driver) {
|
||||
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");
|
||||
@ -109,10 +105,9 @@ static int
|
||||
event_watcher(void *data, SDL_Event *event) {
|
||||
(void) data;
|
||||
if (event->type == SDL_WINDOWEVENT
|
||||
&& event->window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
|
||||
// In practice, it seems to always be called from the same thread in
|
||||
// that specific case. Anyway, it's just a workaround.
|
||||
screen_handle_window_event(&screen, &event->window);
|
||||
&& event->window.event == SDL_WINDOWEVENT_RESIZED) {
|
||||
// called from another thread, not very safe, but it's a workaround!
|
||||
screen_render(&screen);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@ -315,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;
|
||||
}
|
||||
|
||||
@ -401,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;
|
||||
}
|
||||
|
||||
|
||||
@ -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,7 +35,6 @@ struct scrcpy_options {
|
||||
bool render_expired_frames;
|
||||
bool prefer_text;
|
||||
bool window_borderless;
|
||||
bool mipmaps;
|
||||
};
|
||||
|
||||
#define SCRCPY_OPTIONS_DEFAULT { \
|
||||
@ -46,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, \
|
||||
@ -56,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, \
|
||||
@ -71,7 +66,6 @@ struct scrcpy_options {
|
||||
.render_expired_frames = false, \
|
||||
.prefer_text = false, \
|
||||
.window_borderless = false, \
|
||||
.mipmaps = true, \
|
||||
}
|
||||
|
||||
bool
|
||||
|
||||
263
app/src/screen.c
263
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;
|
||||
}
|
||||
|
||||
// stats 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 = ▭
|
||||
}
|
||||
|
||||
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,19 +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);
|
||||
}
|
||||
|
||||
static void
|
||||
screen_reset_logical_size(struct screen *screen) {
|
||||
// Re-apply the current logical size.
|
||||
if (SDL_RenderSetLogicalSize(screen->renderer, screen->content_size.width,
|
||||
screen->content_size.height)) {
|
||||
LOGE("Could not reset renderer logical size: %s", SDL_GetError());
|
||||
}
|
||||
SDL_SetWindowSize(screen->window, screen->frame_size.width,
|
||||
screen->frame_size.height);
|
||||
LOGD("Resized to pixel-perfect");
|
||||
}
|
||||
|
||||
void
|
||||
@ -533,10 +376,6 @@ screen_handle_window_event(struct screen *screen,
|
||||
const SDL_WindowEvent *event) {
|
||||
switch (event->event) {
|
||||
case SDL_WINDOWEVENT_EXPOSED:
|
||||
// Re-apply the current logical size, in case the window has been
|
||||
// moved to a screen with a different HiDPI scaling
|
||||
// <https://github.com/Genymobile/scrcpy/issues/15>
|
||||
screen_reset_logical_size(screen);
|
||||
screen_render(screen);
|
||||
break;
|
||||
case SDL_WINDOWEVENT_SIZE_CHANGED:
|
||||
@ -573,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;
|
||||
}
|
||||
|
||||
@ -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
|
||||
|
||||
@ -172,7 +172,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;
|
||||
}
|
||||
@ -338,7 +338,7 @@ run_wait_server(void *data) {
|
||||
// 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)) {
|
||||
&& SDL_AtomicCAS(&server->server_socket_closed, 0, 1)) {
|
||||
// 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);
|
||||
@ -393,11 +393,8 @@ server_start(struct server *server, const char *serial,
|
||||
|
||||
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;
|
||||
// the wait server thread is not started, SDL_AtomicSet() is sufficient
|
||||
SDL_AtomicSet(&server->server_socket_closed, 1);
|
||||
close_socket(server->server_socket);
|
||||
}
|
||||
disable_tunnel(server);
|
||||
@ -421,7 +418,7 @@ server_connect_to(struct server *server) {
|
||||
}
|
||||
|
||||
// we don't need the server socket anymore
|
||||
if (!atomic_flag_test_and_set(&server->server_socket_closed)) {
|
||||
if (SDL_AtomicCAS(&server->server_socket_closed, 0, 1)) {
|
||||
// close it from here
|
||||
close_socket(server->server_socket);
|
||||
// otherwise, it is closed by run_wait_server()
|
||||
@ -453,7 +450,7 @@ 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)) {
|
||||
&& SDL_AtomicCAS(&server->server_socket_closed, 0, 1)) {
|
||||
close_socket(server->server_socket);
|
||||
}
|
||||
if (server->video_socket != INVALID_SOCKET) {
|
||||
|
||||
@ -1,9 +1,9 @@
|
||||
#ifndef SERVER_H
|
||||
#define SERVER_H
|
||||
|
||||
#include <stdatomic.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include <SDL2/SDL_atomic.h>
|
||||
#include <SDL2/SDL_thread.h>
|
||||
|
||||
#include "config.h"
|
||||
@ -15,7 +15,7 @@ struct server {
|
||||
char *serial;
|
||||
process_t process;
|
||||
SDL_Thread *wait_server_thread;
|
||||
atomic_flag server_socket_closed;
|
||||
SDL_atomic_t server_socket_closed;
|
||||
socket_t server_socket; // only used if !tunnel_forward
|
||||
socket_t video_socket;
|
||||
socket_t control_socket;
|
||||
@ -29,7 +29,7 @@ struct server {
|
||||
.serial = NULL, \
|
||||
.process = PROCESS_NONE, \
|
||||
.wait_server_thread = NULL, \
|
||||
.server_socket_closed = ATOMIC_FLAG_INIT, \
|
||||
.server_socket_closed = {0}, \
|
||||
.server_socket = INVALID_SOCKET, \
|
||||
.video_socket = INVALID_SOCKET, \
|
||||
.control_socket = INVALID_SOCKET, \
|
||||
|
||||
@ -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>
|
||||
|
||||
@ -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)));
|
||||
}
|
||||
|
||||
@ -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
|
||||
|
||||
BIN
gradle/wrapper/gradle-wrapper.jar
vendored
BIN
gradle/wrapper/gradle-wrapper.jar
vendored
Binary file not shown.
2
gradle/wrapper/gradle-wrapper.properties
vendored
2
gradle/wrapper/gradle-wrapper.properties
vendored
@ -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
|
||||
|
||||
33
gradlew
vendored
33
gradlew
vendored
@ -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" "$@"
|
||||
|
||||
3
gradlew.bat
vendored
3
gradlew.bat
vendored
@ -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"
|
||||
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
project('scrcpy', 'c',
|
||||
version: '1.12.1',
|
||||
meson_version: '>= 0.48',
|
||||
meson_version: '>= 0.37',
|
||||
default_options: [
|
||||
'c_std=c11',
|
||||
'warning_level=2',
|
||||
|
||||
@ -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,
|
||||
|
||||
@ -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];
|
||||
|
||||
@ -36,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();
|
||||
@ -50,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
|
||||
@ -63,16 +67,14 @@ public final class Device {
|
||||
}
|
||||
}
|
||||
}
|
||||
}, displayId);
|
||||
});
|
||||
|
||||
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");
|
||||
}
|
||||
}
|
||||
|
||||
@ -114,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) {
|
||||
@ -133,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) {
|
||||
@ -158,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");
|
||||
}
|
||||
|
||||
/**
|
||||
@ -173,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"));
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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
|
||||
@ -49,7 +57,7 @@ public class ScreenEncoder implements Device.RotationListener {
|
||||
Workarounds.prepareMainLooper();
|
||||
Workarounds.fillAppInfo();
|
||||
|
||||
MediaFormat format = createFormat(bitRate, maxFps, DEFAULT_I_FRAME_INTERVAL);
|
||||
MediaFormat format = createFormat(bitRate, maxFps, iFrameInterval);
|
||||
device.setRotationListener(this);
|
||||
boolean alive;
|
||||
try {
|
||||
@ -136,12 +144,12 @@ 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, 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);
|
||||
|
||||
@ -20,7 +20,8 @@ public final class Server {
|
||||
final Device device = new Device(options);
|
||||
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);
|
||||
|
||||
@ -28,7 +28,7 @@ public final class Workarounds {
|
||||
Looper.prepareMainLooper();
|
||||
}
|
||||
|
||||
@SuppressLint("PrivateApi,DiscouragedPrivateApi")
|
||||
@SuppressLint("PrivateApi")
|
||||
public static void fillAppInfo() {
|
||||
try {
|
||||
// ActivityThread activityThread = new ActivityThread();
|
||||
|
||||
@ -74,15 +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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
@ -6,7 +6,7 @@ import android.os.IInterface;
|
||||
|
||||
import java.lang.reflect.Method;
|
||||
|
||||
@SuppressLint("PrivateApi,DiscouragedPrivateApi")
|
||||
@SuppressLint("PrivateApi")
|
||||
public final class ServiceManager {
|
||||
private final Method getServiceMethod;
|
||||
|
||||
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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);
|
||||
|
||||
Reference in New Issue
Block a user