Compare commits
145 Commits
v1.0
...
logicalsca
Author | SHA1 | Date | |
---|---|---|---|
e3a07c3309 | |||
2e40285244 | |||
eca99d5af7 | |||
6a1fb070f7 | |||
27bed948d4 | |||
66def38b73 | |||
a60aef5aaf | |||
28015c3ee4 | |||
af9808cf02 | |||
34550311be | |||
55d33ddd5f | |||
6d2d803003 | |||
3b5e54278e | |||
dd3ba685e4 | |||
89e0203682 | |||
536b31829a | |||
f3f704d1ed | |||
6581f9feb9 | |||
359685b1db | |||
4527be4cde | |||
92d1aff85f | |||
66f45f9dae | |||
aa97eed24b | |||
2daeb1fd5f | |||
cde0b3d248 | |||
6fa209fa82 | |||
b37c0f6cd6 | |||
c4a1fc746b | |||
a3ab92226d | |||
ec66b3be82 | |||
f8ef4f1cf7 | |||
9e683b7dac | |||
7e42358a7b | |||
caa9e30004 | |||
e85010fbc2 | |||
820cd2bb54 | |||
8793c104ee | |||
fca806e095 | |||
280891837e | |||
49b2e63d13 | |||
c12c64ed41 | |||
2f66acd75d | |||
1846d2f078 | |||
1a0139321b | |||
8890750681 | |||
aac9d5057f | |||
f705a73149 | |||
27a9bd3424 | |||
cf121a0f65 | |||
c8a5f9dc63 | |||
8106bb8215 | |||
f1b3a40375 | |||
a63dd47f2d | |||
6b4bbb1fb3 | |||
aedc2c2da9 | |||
106b87a4d2 | |||
7d68316f45 | |||
e729b76176 | |||
6274cc3767 | |||
9c6f9b24f9 | |||
e2a2973990 | |||
41419a2e77 | |||
e3d0a59c80 | |||
bb3a7f05ac | |||
ec02823045 | |||
435a7fe314 | |||
78da66f126 | |||
9aa88b6fc3 | |||
f8ad7df3be | |||
0871bca9c7 | |||
b2b5404883 | |||
1bddb80b5f | |||
6323f3974f | |||
16a3de1796 | |||
6161f7688c | |||
2a02fb3611 | |||
71f50fb697 | |||
82efff34e8 | |||
860006e082 | |||
57eaf05289 | |||
dd2a5c1ecf | |||
66ec252893 | |||
b13d25b9f4 | |||
b449c09442 | |||
8b84492830 | |||
4d50832f8e | |||
e0e8dfeb3b | |||
f4d6449af7 | |||
64963fff62 | |||
b7d9b8739c | |||
88f6b43c8f | |||
324a264233 | |||
3bb2cda955 | |||
35298bb0c6 | |||
73c332e3e4 | |||
15014f2689 | |||
29b5c5b8f4 | |||
88ee6bc928 | |||
35e9a64c34 | |||
9cac38fe58 | |||
301c52b603 | |||
f00c6c5b13 | |||
3b3803da0d | |||
f5cf6c1b2c | |||
2573df9727 | |||
c65cb36d3b | |||
821ec9843c | |||
f16bd88802 | |||
f3e8834a3c | |||
080df5eb5d | |||
047179f232 | |||
2992dda497 | |||
6406f64edc | |||
f3f19d4e1d | |||
d744837f13 | |||
f7bc0bd5b5 | |||
8a3c6a3ae7 | |||
c530d95881 | |||
0b1e59186f | |||
e69f6f710d | |||
b858204786 | |||
e8510a8cc3 | |||
1038bad385 | |||
2b3ed5bcdb | |||
9e328ef98b | |||
f9a63ec272 | |||
f6d0893316 | |||
ed65cd72fd | |||
70599998eb | |||
e87cd175cc | |||
c075ad0a1e | |||
dac7196bd6 | |||
14b15ceb06 | |||
b9bb4ff740 | |||
cc4a015256 | |||
8476b4aab8 | |||
a1491862e4 | |||
c87d94ee27 | |||
675704c71c | |||
9396ea6d42 | |||
f9562f537a | |||
a34fbd23e9 | |||
e8b8a570e7 | |||
0e9a76c0c4 | |||
f9f305d19d |
69
FAQ.md
Normal file
69
FAQ.md
Normal file
@ -0,0 +1,69 @@
|
||||
# Frequently Asked Questions
|
||||
|
||||
## Common issues
|
||||
|
||||
The application is very young, it is not unlikely that you encounter problems
|
||||
with it.
|
||||
|
||||
Here are the common reported problems and their status.
|
||||
|
||||
|
||||
### On Windows, my device is not detected
|
||||
|
||||
The most common is your device not being detected by `adb`, or is unauthorized.
|
||||
Check everything is ok by calling:
|
||||
|
||||
adb devices
|
||||
|
||||
Windows may need some [drivers] to detect your device.
|
||||
|
||||
[drivers]: https://developer.android.com/studio/run/oem-usb.html
|
||||
|
||||
If you still encounter problems, please see [issue 9].
|
||||
|
||||
[issue 9]: https://github.com/Genymobile/scrcpy/issues/9
|
||||
|
||||
|
||||
### I get a black screen for some applications like Silence
|
||||
|
||||
This is expected, they requested to protect the screen.
|
||||
|
||||
In [Silence], you can disable it in settings → Privacy → Screen security.
|
||||
|
||||
[silence]: https://f-droid.org/en/packages/org.smssecure.smssecure/
|
||||
|
||||
See [issue 36].
|
||||
|
||||
[issue 36]: https://github.com/Genymobile/scrcpy/issues/36
|
||||
|
||||
|
||||
### Mouse clicks do not work
|
||||
|
||||
On some devices, you may need to enable an option to allow [simulating input].
|
||||
|
||||
[simulating input]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
|
||||
|
||||
|
||||
### Mouse clicks at wrong location
|
||||
|
||||
On MacOS, with HiDPI support and multiple screens, input location are wrongly
|
||||
scaled. See [issue 15].
|
||||
|
||||
[issue 15]: https://github.com/Genymobile/scrcpy/issues/15
|
||||
|
||||
A workaround is to build with HiDPI support disabled:
|
||||
|
||||
```bash
|
||||
meson x --buildtype release -Dhidpi_support=false
|
||||
```
|
||||
|
||||
However, the video will be displayed at lower resolution.
|
||||
|
||||
|
||||
### KWin compositor crashes
|
||||
|
||||
On Plasma Desktop, compositor is disabled while _scrcpy_ is running.
|
||||
|
||||
As a workaround, [disable "Block compositing"][kwin].
|
||||
|
||||
[kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613
|
62
Makefile
62
Makefile
@ -1,62 +0,0 @@
|
||||
# This makefile provides recipes to build a "portable" version of scrcpy.
|
||||
#
|
||||
# Here, "portable" means that the client and server binaries are expected to be
|
||||
# anywhere, but in the same directory, instead of well-defined separate
|
||||
# locations (e.g. /usr/bin/scrcpy and /usr/share/scrcpy/scrcpy-server.jar).
|
||||
#
|
||||
# In particular, this implies to change the location from where the client push
|
||||
# the server to the device.
|
||||
#
|
||||
# "make release-portable" builds a zip containing the client and the server.
|
||||
#
|
||||
# This is a simple Makefile because Meson is not flexible enough to execute some
|
||||
# arbitrary commands.
|
||||
|
||||
.PHONY: default clean build-portable release-portable dist-portable dist-portable-zip sums test check
|
||||
|
||||
GRADLE ?= ./gradlew
|
||||
|
||||
PORTABLE_BUILD_DIR := build-portable
|
||||
DIST := dist
|
||||
TARGET_DIR := scrcpy
|
||||
|
||||
VERSION := $(shell git describe --tags --always)
|
||||
TARGET := $(TARGET_DIR)-$(VERSION).zip
|
||||
|
||||
default:
|
||||
@echo 'You must specify a target. Try: make release-portable'
|
||||
|
||||
clean:
|
||||
$(GRADLE) clean
|
||||
rm -rf "$(PORTABLE_BUILD_DIR)" "$(DIST)"
|
||||
|
||||
build-portable:
|
||||
[ -d "$(PORTABLE_BUILD_DIR)" ] || ( mkdir "$(PORTABLE_BUILD_DIR)" && \
|
||||
meson "$(PORTABLE_BUILD_DIR)" \
|
||||
--buildtype release --strip -Db_lto=true \
|
||||
-Doverride_server_path=scrcpy-server.jar )
|
||||
ninja -C "$(PORTABLE_BUILD_DIR)"
|
||||
|
||||
release-portable: clean dist-portable-zip sums
|
||||
@echo "Release created in $(DIST)/."
|
||||
|
||||
dist-portable: build-portable
|
||||
mkdir -p "$(DIST)/$(TARGET_DIR)"
|
||||
cp "$(PORTABLE_BUILD_DIR)"/server/scrcpy-server.jar "$(DIST)/$(TARGET_DIR)/"
|
||||
cp "$(PORTABLE_BUILD_DIR)"/app/scrcpy "$(DIST)/$(TARGET_DIR)/"
|
||||
|
||||
dist-portable-zip: dist-portable
|
||||
cd "$(DIST)"; \
|
||||
zip -r "$(TARGET)" "$(TARGET_DIR)"
|
||||
|
||||
sums:
|
||||
cd "$(DIST)"; \
|
||||
sha256sum *.zip > SHA256SUM.txt
|
||||
|
||||
test: build-portable
|
||||
$(GRADLE) test
|
||||
ninja -C "$(PORTABLE_BUILD_DIR)" test
|
||||
|
||||
check: build-portable
|
||||
$(GRADLE) check
|
||||
ninja -C "$(PORTABLE_BUILD_DIR)" test
|
136
Makefile.CrossWindows
Normal file
136
Makefile.CrossWindows
Normal file
@ -0,0 +1,136 @@
|
||||
# This makefile provides recipes to build a "portable" version of scrcpy for
|
||||
# Windows.
|
||||
#
|
||||
# Here, "portable" means that the client and server binaries are expected to be
|
||||
# anywhere, but in the same directory, instead of well-defined separate
|
||||
# locations (e.g. /usr/bin/scrcpy and /usr/share/scrcpy/scrcpy-server.jar).
|
||||
#
|
||||
# In particular, this implies to change the location from where the client push
|
||||
# the server to the device.
|
||||
|
||||
.PHONY: default clean \
|
||||
build-server \
|
||||
prepare-deps-win32 prepare-deps-win64 \
|
||||
build-win32 build-win32-noconsole \
|
||||
build-win64 build-win64-noconsole \
|
||||
dist-win32 dist-win64 \
|
||||
zip-win32 zip-win64 \
|
||||
sums release
|
||||
|
||||
GRADLE ?= ./gradlew
|
||||
|
||||
SERVER_BUILD_DIR := build-server
|
||||
WIN32_BUILD_DIR := build-win32
|
||||
WIN32_NOCONSOLE_BUILD_DIR := build-win32-noconsole
|
||||
WIN64_BUILD_DIR := build-win64
|
||||
WIN64_NOCONSOLE_BUILD_DIR := build-win64-noconsole
|
||||
|
||||
DIST := dist
|
||||
WIN32_TARGET_DIR := scrcpy-win32
|
||||
WIN64_TARGET_DIR := scrcpy-win64
|
||||
|
||||
VERSION := $(shell git describe --tags --always)
|
||||
WIN32_TARGET := $(WIN32_TARGET_DIR)-$(VERSION).zip
|
||||
WIN64_TARGET := $(WIN64_TARGET_DIR)-$(VERSION).zip
|
||||
|
||||
release: clean zip-win32 zip-win64 sums
|
||||
@echo "Release created in $(DIST)/."
|
||||
|
||||
clean:
|
||||
$(GRADLE) clean
|
||||
rm -rf "$(SERVER_BUILD_DIR)" "$(WIN32_BUILD_DIR)" "$(WIN64_BUILD_DIR)" \
|
||||
"$(WIN32_NOCONSOLE_BUILD_DIR)" "$(WIN64_NOCONSOLE_BUILD_DIR)" "$(DIST)"
|
||||
|
||||
build-server:
|
||||
[ -d "$(SERVER_BUILD_DIR)" ] || ( mkdir "$(SERVER_BUILD_DIR)" && \
|
||||
meson "$(SERVER_BUILD_DIR)" \
|
||||
--buildtype release -Dbuild_app=false )
|
||||
ninja -C "$(SERVER_BUILD_DIR)"
|
||||
|
||||
prepare-deps-win32:
|
||||
-$(MAKE) -C prebuilt-deps prepare-win32
|
||||
|
||||
build-win32: prepare-deps-win32
|
||||
[ -d "$(WIN32_BUILD_DIR)" ] || ( mkdir "$(WIN32_BUILD_DIR)" && \
|
||||
meson "$(WIN32_BUILD_DIR)" \
|
||||
--cross-file cross_win32.txt \
|
||||
--buildtype release --strip -Db_lto=true \
|
||||
-Dcrossbuild_windows=true \
|
||||
-Dbuild_server=false \
|
||||
-Doverride_server_path=scrcpy-server.jar )
|
||||
ninja -C "$(WIN32_BUILD_DIR)"
|
||||
|
||||
build-win32-noconsole: prepare-deps-win32
|
||||
[ -d "$(WIN32_NOCONSOLE_BUILD_DIR)" ] || ( mkdir "$(WIN32_NOCONSOLE_BUILD_DIR)" && \
|
||||
meson "$(WIN32_NOCONSOLE_BUILD_DIR)" \
|
||||
--cross-file cross_win32.txt \
|
||||
--buildtype release --strip -Db_lto=true \
|
||||
-Dcrossbuild_windows=true \
|
||||
-Dbuild_server=false \
|
||||
-Dwindows_noconsole=true \
|
||||
-Doverride_server_path=scrcpy-server.jar )
|
||||
ninja -C "$(WIN32_NOCONSOLE_BUILD_DIR)"
|
||||
|
||||
prepare-deps-win64:
|
||||
-$(MAKE) -C prebuilt-deps prepare-win64
|
||||
|
||||
build-win64: prepare-deps-win64
|
||||
[ -d "$(WIN64_BUILD_DIR)" ] || ( mkdir "$(WIN64_BUILD_DIR)" && \
|
||||
meson "$(WIN64_BUILD_DIR)" \
|
||||
--cross-file cross_win64.txt \
|
||||
--buildtype release --strip -Db_lto=true \
|
||||
-Dcrossbuild_windows=true \
|
||||
-Dbuild_server=false \
|
||||
-Doverride_server_path=scrcpy-server.jar )
|
||||
ninja -C "$(WIN64_BUILD_DIR)"
|
||||
|
||||
build-win64-noconsole: prepare-deps-win64
|
||||
[ -d "$(WIN64_NOCONSOLE_BUILD_DIR)" ] || ( mkdir "$(WIN64_NOCONSOLE_BUILD_DIR)" && \
|
||||
meson "$(WIN64_NOCONSOLE_BUILD_DIR)" \
|
||||
--cross-file cross_win64.txt \
|
||||
--buildtype release --strip -Db_lto=true \
|
||||
-Dcrossbuild_windows=true \
|
||||
-Dbuild_server=false \
|
||||
-Dwindows_noconsole=true \
|
||||
-Doverride_server_path=scrcpy-server.jar )
|
||||
ninja -C "$(WIN64_NOCONSOLE_BUILD_DIR)"
|
||||
|
||||
dist-win32: build-server build-win32 build-win32-noconsole
|
||||
mkdir -p "$(DIST)/$(WIN32_TARGET_DIR)"
|
||||
cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server.jar "$(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.0.2-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
|
||||
cp prebuilt-deps/ffmpeg-4.0.2-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
|
||||
cp prebuilt-deps/ffmpeg-4.0.2-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
|
||||
cp prebuilt-deps/ffmpeg-4.0.2-win32-shared/bin/swresample-3.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.8/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.jar "$(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.0.2-win64-shared/bin/avutil-56.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
|
||||
cp prebuilt-deps/ffmpeg-4.0.2-win64-shared/bin/avcodec-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
|
||||
cp prebuilt-deps/ffmpeg-4.0.2-win64-shared/bin/avformat-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
|
||||
cp prebuilt-deps/ffmpeg-4.0.2-win64-shared/bin/swresample-3.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.8/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
|
||||
|
||||
zip-win32: dist-win32
|
||||
cd "$(DIST)"; \
|
||||
zip -r "$(WIN32_TARGET)" "$(WIN32_TARGET_DIR)"
|
||||
|
||||
zip-win64: dist-win64
|
||||
cd "$(DIST)"; \
|
||||
zip -r "$(WIN64_TARGET)" "$(WIN64_TARGET_DIR)"
|
||||
|
||||
sums:
|
||||
cd "$(DIST)"; \
|
||||
sha256sum *.zip > SHA256SUMS.txt
|
332
README.md
332
README.md
@ -1,8 +1,8 @@
|
||||
# scrcpy
|
||||
# scrcpy (v1.3)
|
||||
|
||||
This application provides display and control of Android devices connected on
|
||||
USB. It does not require any _root_ access. It works on _GNU/Linux_, _Windows_
|
||||
and _Mac OS_.
|
||||
USB (or [over TCP/IP][article-tcpip]). It does not require any _root_ access.
|
||||
It works on _GNU/Linux_, _Windows_ and _MacOS_.
|
||||
|
||||

|
||||
|
||||
@ -11,25 +11,22 @@ and _Mac OS_.
|
||||
|
||||
The Android part requires at least API 21 (Android 5.0).
|
||||
|
||||
You need [adb] (recent enough so that `adb reverse` is implemented, it works
|
||||
with 1.0.36). It is available in the [Android SDK platform
|
||||
tools][platform-tools], on packaged in your distribution (`android-adb-tools`).
|
||||
You need [adb]. It is available in the [Android SDK platform
|
||||
tools][platform-tools], or packaged in your distribution (`android-adb-tools`).
|
||||
|
||||
On Windows, just download the [platform-tools][platform-tools-windows] and
|
||||
extract the following files to a directory accessible from your `PATH`:
|
||||
- `adb.exe`
|
||||
- `AdbWinApi.dll`
|
||||
- `AdbWinUsbApi.dll`
|
||||
On Windows, just [download scrcpy for Windows](#windows), `adb` is included.
|
||||
|
||||
Make sure you [enabled adb debugging][enable-adb] on your device(s).
|
||||
|
||||
The client requires [FFmpeg] and [LibSDL2]. On Windows, they are included in the
|
||||
[prebuilt application](#windows).
|
||||
|
||||
[adb]: https://developer.android.com/studio/command-line/adb.html
|
||||
[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
|
||||
[platform-tools]: https://developer.android.com/studio/releases/platform-tools.html
|
||||
[platform-tools-windows]: https://dl.google.com/android/repository/platform-tools-latest-windows.zip
|
||||
|
||||
The client requires _FFmpeg_ and _LibSDL2_.
|
||||
|
||||
[ffmpeg]: https://en.wikipedia.org/wiki/FFmpeg
|
||||
[LibSDL2]: https://en.wikipedia.org/wiki/Simple_DirectMedia_Layer
|
||||
|
||||
## Build and install
|
||||
|
||||
@ -37,68 +34,166 @@ The client requires _FFmpeg_ and _LibSDL2_.
|
||||
|
||||
#### Linux
|
||||
|
||||
Install the required packages from your package manager (here, for Debian):
|
||||
Install the required packages from your package manager.
|
||||
|
||||
# runtime dependencies
|
||||
sudo apt install ffmpeg libsdl2-2.0.0
|
||||
##### Debian/Ubuntu
|
||||
|
||||
# build dependencies
|
||||
sudo apt install make gcc openjdk-8-jdk pkg-config meson zip \
|
||||
libavcodec-dev libavformat-dev libavutil-dev \
|
||||
libsdl2-dev
|
||||
```bash
|
||||
# runtime dependencies
|
||||
sudo apt install ffmpeg libsdl2-2.0.0
|
||||
|
||||
# client build dependencies
|
||||
sudo apt install make gcc pkg-config meson \
|
||||
libavcodec-dev libavformat-dev libavutil-dev \
|
||||
libsdl2-dev
|
||||
|
||||
# server build dependencies
|
||||
sudo apt install openjdk-8-jdk
|
||||
```
|
||||
|
||||
##### Fedora
|
||||
|
||||
```bash
|
||||
# enable RPM fusion free
|
||||
sudo dnf install https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm
|
||||
|
||||
# client build dependencies
|
||||
sudo dnf install SDL2-devel ffms2-devel meson gcc make
|
||||
|
||||
# server build dependencies
|
||||
sudo dnf install java
|
||||
```
|
||||
|
||||
##### Arch Linux
|
||||
|
||||
Two [AUR] packages have been created by users:
|
||||
|
||||
- [`scrcpy`](https://aur.archlinux.org/packages/scrcpy/)
|
||||
- [`scrcpy-prebuiltserver`](https://aur.archlinux.org/packages/scrcpy-prebuiltserver/)
|
||||
|
||||
[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
|
||||
|
||||
|
||||
#### 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-windows-with-deps-v1.0.zip`][direct-windows-with-deps].
|
||||
_(SHA-256: TODO)_
|
||||
- [`scrcpy-win32-v1.3.zip`][direct-win32].
|
||||
_(SHA-256: 51a2990e631ed469a7a86ff38107d517a91d313fb3f8327eb7bc71dde40870b5)_
|
||||
- [`scrcpy-win64-v1.3.zip`][direct-win64].
|
||||
_(SHA-256: 0768a80d3d600d0bbcd220ca150ae88a3a58d1fe85c308a8c61f44480b711e43)_
|
||||
|
||||
[direct-windows-with-deps]: https://github.com/Genymobile/scrcpy/releases/download/v1.0/scrcpy-windows-with-deps-v1.0.zip
|
||||
[direct-win32]: https://github.com/Genymobile/scrcpy/releases/download/v1.3/scrcpy-win32-v1.3.zip
|
||||
[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.3/scrcpy-win64-v1.3.zip
|
||||
|
||||
_(It's just a portable version including _dll_ copied from MSYS2.)_
|
||||
Instead, you may want to build it manually.
|
||||
|
||||
Instead, you may want to build it manually. You need [MSYS2] to build the
|
||||
project. From an MSYS2 terminal, install the required packages:
|
||||
In that case, download the [platform-tools][platform-tools-windows] and extract
|
||||
the following files to a directory accessible from your `PATH`:
|
||||
- `adb.exe`
|
||||
- `AdbWinApi.dll`
|
||||
- `AdbWinUsbApi.dll`
|
||||
|
||||
##### Cross-compile from Linux
|
||||
|
||||
This is the preferred method (and the way the release is built).
|
||||
|
||||
From _Debian_, install _mingw_:
|
||||
|
||||
```bash
|
||||
sudo apt install mingw-w64 mingw-w64-tools
|
||||
```
|
||||
|
||||
You also need the JDK to build the server:
|
||||
|
||||
```bash
|
||||
sudo apt install openjdk-8-jdk
|
||||
```
|
||||
|
||||
Then generate the releases:
|
||||
|
||||
```bash
|
||||
make -f Makefile.CrossWindows
|
||||
```
|
||||
|
||||
It will generate win32 and win64 releases into `dist/`.
|
||||
|
||||
|
||||
##### In MSYS2
|
||||
|
||||
From Windows, you need [MSYS2] to build the project. From an MSYS2 terminal,
|
||||
install the required packages:
|
||||
|
||||
[MSYS2]: http://www.msys2.org/
|
||||
|
||||
# runtime dependencies
|
||||
pacman -S mingw-w64-x86_64-SDL2 \
|
||||
mingw-w64-x86_64-ffmpeg
|
||||
```bash
|
||||
# runtime dependencies
|
||||
pacman -S mingw-w64-x86_64-SDL2 \
|
||||
mingw-w64-x86_64-ffmpeg
|
||||
|
||||
# build dependencies
|
||||
pacman -S mingw-w64-x86_64-make \
|
||||
mingw-w64-x86_64-gcc \
|
||||
mingw-w64-x86_64-pkg-config \
|
||||
mingw-w64-x86_64-meson \
|
||||
zip
|
||||
# client build dependencies
|
||||
pacman -S mingw-w64-x86_64-make \
|
||||
mingw-w64-x86_64-gcc \
|
||||
mingw-w64-x86_64-pkg-config \
|
||||
mingw-w64-x86_64-meson
|
||||
```
|
||||
|
||||
For a 32 bits version, replace `x86_64` by `i686`:
|
||||
|
||||
```bash
|
||||
# runtime dependencies
|
||||
pacman -S mingw-w64-i686-SDL2 \
|
||||
mingw-w64-i686-ffmpeg
|
||||
|
||||
# client build dependencies
|
||||
pacman -S mingw-w64-i686-make \
|
||||
mingw-w64-i686-gcc \
|
||||
mingw-w64-i686-pkg-config \
|
||||
mingw-w64-i686-meson
|
||||
```
|
||||
|
||||
Java (>= 7) is not available in MSYS2, so if you plan to build the server,
|
||||
install it manually and make it available from the `PATH`:
|
||||
|
||||
export PATH="$JAVA_HOME/bin:$PATH"
|
||||
|
||||
```bash
|
||||
export PATH="$JAVA_HOME/bin:$PATH"
|
||||
```
|
||||
|
||||
#### Mac OS
|
||||
|
||||
Use [Homebrew] to install the packages:
|
||||
The application is available in [Homebrew]. Just install it:
|
||||
|
||||
[Homebrew]: https://brew.sh/
|
||||
|
||||
# runtime dependencies
|
||||
brew install sdl2 ffmpeg
|
||||
```bash
|
||||
brew install scrcpy
|
||||
```
|
||||
|
||||
# build dependencies
|
||||
brew install gcc pkg-config meson zip
|
||||
Instead, you may want to build it manually. Install the packages:
|
||||
|
||||
Java (>= 7) is not available in Homebrew, so if you plan to build the server,
|
||||
install it manually and make it available from the `PATH`:
|
||||
|
||||
export PATH="$JAVA_HOME/bin:$PATH"
|
||||
```bash
|
||||
# runtime dependencies
|
||||
brew install sdl2 ffmpeg
|
||||
|
||||
# client build dependencies
|
||||
brew install pkg-config meson
|
||||
```
|
||||
|
||||
Additionally, if you want to build the server, install Java 8 from Caskroom, and
|
||||
make it avaliable from the `PATH`:
|
||||
|
||||
```bash
|
||||
brew tap caskroom/versions
|
||||
brew cask install java8
|
||||
export JAVA_HOME="$(/usr/libexec/java_home --version 1.8)"
|
||||
export PATH="$JAVA_HOME/bin:$PATH"
|
||||
```
|
||||
|
||||
#### Docker
|
||||
|
||||
See [pierlon/scrcpy-docker](https://github.com/pierlon/scrcpy-docker).
|
||||
|
||||
### Common steps
|
||||
|
||||
@ -107,21 +202,36 @@ its directory. For example:
|
||||
|
||||
[Android SDK]: https://developer.android.com/studio/index.html
|
||||
|
||||
export ANDROID_HOME=~/android/sdk
|
||||
```bash
|
||||
export ANDROID_HOME=~/android/sdk
|
||||
```
|
||||
|
||||
Then, build `scrcpy`:
|
||||
Clone the project:
|
||||
|
||||
meson x --buildtype release --strip -Db_lto=true
|
||||
cd x
|
||||
ninja
|
||||
```bash
|
||||
git clone https://github.com/Genymobile/scrcpy
|
||||
cd scrcpy
|
||||
```
|
||||
|
||||
Then, build:
|
||||
|
||||
```bash
|
||||
meson x --buildtype release --strip -Db_lto=true
|
||||
cd x
|
||||
ninja
|
||||
```
|
||||
|
||||
You can test it from here:
|
||||
|
||||
ninja run
|
||||
```bash
|
||||
ninja run
|
||||
```
|
||||
|
||||
Or you can install it on the system:
|
||||
|
||||
sudo ninja install # without sudo on Windows
|
||||
```bash
|
||||
sudo ninja install # without sudo on Windows
|
||||
```
|
||||
|
||||
This installs two files:
|
||||
|
||||
@ -137,22 +247,23 @@ Since the server binary, that will be pushed to the Android device, does not
|
||||
depend on your system and architecture, you may want to use the prebuilt binary
|
||||
instead:
|
||||
|
||||
- [`scrcpy-server-v1.0.jar`][direct-scrcpy-server].
|
||||
_(SHA-256: TODO)_
|
||||
- [`scrcpy-server-v1.3.jar`][direct-scrcpy-server].
|
||||
_(SHA-256: 0f9a5a217f33f0ed7a1498ceb3c0cccf31c53533893aa952e674c1571d2740c1)_
|
||||
|
||||
[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.0/scrcpy-server-v1.0.jar
|
||||
[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.3/scrcpy-server-v1.3.jar
|
||||
|
||||
In that case, the build does not require Java or the Android SDK.
|
||||
|
||||
Download the prebuilt server somewhere, and specify its path during the Meson
|
||||
configuration:
|
||||
|
||||
meson x --buildtype release --strip -Db_lto=true \
|
||||
-Dprebuilt_server=/path/to/scrcpy-server.jar
|
||||
cd x
|
||||
ninja
|
||||
sudo ninja install
|
||||
|
||||
```bash
|
||||
meson x --buildtype release --strip -Db_lto=true \
|
||||
-Dprebuilt_server=/path/to/scrcpy-server.jar
|
||||
cd x
|
||||
ninja
|
||||
sudo ninja install
|
||||
```
|
||||
|
||||
## Run
|
||||
|
||||
@ -160,42 +271,84 @@ _At runtime, `adb` must be accessible from your `PATH`._
|
||||
|
||||
If everything is ok, just plug an Android device, and execute:
|
||||
|
||||
scrcpy
|
||||
```bash
|
||||
scrcpy
|
||||
```
|
||||
|
||||
It accepts command-line arguments, listed by:
|
||||
|
||||
scrcpy --help
|
||||
```bash
|
||||
scrcpy --help
|
||||
```
|
||||
|
||||
For example, to decrease video bitrate to 2Mbps (default is 8Mbps):
|
||||
|
||||
scrcpy -b 2M
|
||||
```bash
|
||||
scrcpy -b 2M
|
||||
```
|
||||
|
||||
To limit the video dimensions (e.g. if the device is 2540×1440, but the host
|
||||
screen is smaller, or cannot decode such a high definition):
|
||||
|
||||
scrcpy -m 1024
|
||||
```bash
|
||||
scrcpy -m 1024
|
||||
```
|
||||
|
||||
The device screen may be cropped to mirror only part of the screen:
|
||||
|
||||
```bash
|
||||
scrcpy -c 1224:1440:0:0 # 1224x1440 at offset (0,0)
|
||||
```
|
||||
|
||||
If several devices are listed in `adb devices`, you must specify the _serial_:
|
||||
|
||||
scrcpy -s 0123456789abcdef
|
||||
```bash
|
||||
scrcpy -s 0123456789abcdef
|
||||
```
|
||||
|
||||
To show physical touches while scrcpy is running:
|
||||
|
||||
```bash
|
||||
scrcpy -t
|
||||
```
|
||||
|
||||
The app may be started directly in fullscreen:
|
||||
|
||||
```
|
||||
scrcpy -f
|
||||
```
|
||||
|
||||
To run without installing:
|
||||
|
||||
```bash
|
||||
./run x [options]
|
||||
```
|
||||
|
||||
(where `x` is your build directory).
|
||||
|
||||
|
||||
## Shortcuts
|
||||
|
||||
| Action | Shortcut |
|
||||
| ------------------------------------- | -------------:|
|
||||
| switch fullscreen mode | `Ctrl`+`f` |
|
||||
| resize window to 1:1 (pixel-perfect) | `Ctrl`+`g` |
|
||||
| resize window to remove black borders | `Ctrl`+`x` |
|
||||
| click on `HOME` | `Ctrl`+`h` |
|
||||
| click on `BACK` | `Ctrl`+`b` |
|
||||
| click on `APP_SWITCH` | `Ctrl`+`m` |
|
||||
| click on `VOLUME_UP` | `Ctrl`+`+` |
|
||||
| click on `VOLUME_DOWN` | `Ctrl`+`-` |
|
||||
| click on `POWER` | `Ctrl`+`p` |
|
||||
| turn screen on | _Right-click_ |
|
||||
| paste computer clipboard to device | `Ctrl`+`v` |
|
||||
| enable/disable FPS counter (on stdout) | `Ctrl`+`i` |
|
||||
| Action | Shortcut |
|
||||
| -------------------------------------- |:---------------------------- |
|
||||
| switch fullscreen mode | `Ctrl`+`f` |
|
||||
| resize window to 1:1 (pixel-perfect) | `Ctrl`+`g` |
|
||||
| resize window to remove black borders | `Ctrl`+`x` \| _Double-click¹_ |
|
||||
| click on `HOME` | `Ctrl`+`h` \| _Middle-click_ |
|
||||
| click on `BACK` | `Ctrl`+`b` \| _Right-click²_ |
|
||||
| click on `APP_SWITCH` | `Ctrl`+`s` |
|
||||
| click on `MENU` | `Ctrl`+`m` |
|
||||
| click on `VOLUME_UP` | `Ctrl`+`↑` _(up)_ |
|
||||
| click on `VOLUME_DOWN` | `Ctrl`+`↓` _(down)_ |
|
||||
| click on `POWER` | `Ctrl`+`p` |
|
||||
| turn screen on | _Right-click²_ |
|
||||
| paste computer clipboard to device | `Ctrl`+`v` |
|
||||
| enable/disable FPS counter (on stdout) | `Ctrl`+`i` |
|
||||
| install APK from computer | drag & drop APK file |
|
||||
| push file to `/sdcard/` | drag & drop non-APK file |
|
||||
|
||||
_¹Double-click on black borders to remove them._
|
||||
_²Right-click turns the screen on if it was off, presses BACK otherwise._
|
||||
|
||||
|
||||
## Why _scrcpy_?
|
||||
@ -208,6 +361,11 @@ A colleague challenged me to find a name as unpronounceable as [gnirehtet].
|
||||
[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
|
||||
|
||||
|
||||
## Common issues
|
||||
|
||||
See the [FAQ](FAQ.md).
|
||||
|
||||
|
||||
## Developers
|
||||
|
||||
Read the [developers page].
|
||||
@ -230,3 +388,11 @@ Read the [developers page].
|
||||
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.
|
||||
|
||||
## Articles
|
||||
|
||||
- [Introducing scrcpy][article-intro]
|
||||
- [Scrcpy now works wirelessly][article-tcpip]
|
||||
|
||||
[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
|
||||
[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
|
||||
|
@ -1,29 +1,72 @@
|
||||
src = [
|
||||
'src/main.c',
|
||||
'src/command.c',
|
||||
'src/controlevent.c',
|
||||
'src/control_event.c',
|
||||
'src/controller.c',
|
||||
'src/convert.c',
|
||||
'src/decoder.c',
|
||||
'src/device.c',
|
||||
'src/fpscounter.c',
|
||||
'src/file_handler.c',
|
||||
'src/fps_counter.c',
|
||||
'src/frames.c',
|
||||
'src/inputmanager.c',
|
||||
'src/lockutil.c',
|
||||
'src/input_manager.c',
|
||||
'src/lock_util.c',
|
||||
'src/net.c',
|
||||
'src/scrcpy.c',
|
||||
'src/screen.c',
|
||||
'src/server.c',
|
||||
'src/strutil.c',
|
||||
'src/tinyxpm.c',
|
||||
'src/str_util.c',
|
||||
'src/tiny_xpm.c',
|
||||
]
|
||||
|
||||
dependencies = [
|
||||
dependency('libavformat'),
|
||||
dependency('libavcodec'),
|
||||
dependency('libavutil'),
|
||||
dependency('sdl2'),
|
||||
]
|
||||
if not get_option('crossbuild_windows')
|
||||
|
||||
# native build
|
||||
dependencies = [
|
||||
dependency('libavformat'),
|
||||
dependency('libavcodec'),
|
||||
dependency('libavutil'),
|
||||
dependency('sdl2'),
|
||||
]
|
||||
|
||||
else
|
||||
|
||||
# cross-compile mingw32 build (from Linux to Windows)
|
||||
cc = meson.get_compiler('c')
|
||||
|
||||
prebuilt_sdl2 = meson.get_cross_property('prebuilt_sdl2')
|
||||
sdl2_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/bin'
|
||||
sdl2_lib_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/lib'
|
||||
sdl2_include_dir = '../prebuilt-deps/' + prebuilt_sdl2 + '/include'
|
||||
|
||||
sdl2 = declare_dependency(
|
||||
dependencies: [
|
||||
cc.find_library('SDL2', dirs: sdl2_bin_dir),
|
||||
cc.find_library('SDL2main', dirs: sdl2_lib_dir),
|
||||
],
|
||||
include_directories: include_directories(sdl2_include_dir)
|
||||
)
|
||||
|
||||
prebuilt_ffmpeg_shared = meson.get_cross_property('prebuilt_ffmpeg_shared')
|
||||
prebuilt_ffmpeg_dev = meson.get_cross_property('prebuilt_ffmpeg_dev')
|
||||
ffmpeg_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_ffmpeg_shared + '/bin'
|
||||
ffmpeg_include_dir = '../prebuilt-deps/' + prebuilt_ffmpeg_dev + '/include'
|
||||
ffmpeg = declare_dependency(
|
||||
dependencies: [
|
||||
cc.find_library('avcodec-58', dirs: ffmpeg_bin_dir),
|
||||
cc.find_library('avformat-58', dirs: ffmpeg_bin_dir),
|
||||
cc.find_library('avutil-56', dirs: ffmpeg_bin_dir),
|
||||
],
|
||||
include_directories: include_directories(ffmpeg_include_dir)
|
||||
)
|
||||
|
||||
dependencies = [
|
||||
ffmpeg,
|
||||
sdl2,
|
||||
cc.find_library('mingw32')
|
||||
]
|
||||
|
||||
endif
|
||||
|
||||
cc = meson.get_compiler('c')
|
||||
|
||||
@ -42,7 +85,7 @@ conf = configuration_data()
|
||||
conf.set('BUILD_DEBUG', get_option('buildtype') == 'debug')
|
||||
|
||||
# the version, updated on release
|
||||
conf.set_quoted('SCRCPY_VERSION', '1.0')
|
||||
conf.set_quoted('SCRCPY_VERSION', '1.3')
|
||||
|
||||
# the prefix used during configuration (meson --prefix=PREFIX)
|
||||
conf.set_quoted('PREFIX', get_option('prefix'))
|
||||
@ -83,21 +126,32 @@ conf.set('SKIP_FRAMES', get_option('skip_frames'))
|
||||
# enable High DPI support
|
||||
conf.set('HIDPI_SUPPORT', get_option('hidpi_support'))
|
||||
|
||||
# disable console on Windows
|
||||
conf.set('WINDOWS_NOCONSOLE', get_option('windows_noconsole'))
|
||||
|
||||
configure_file(configuration: conf, output: 'config.h')
|
||||
|
||||
executable('scrcpy', src, dependencies: dependencies, install: true)
|
||||
src_dir = include_directories('src')
|
||||
|
||||
if get_option('windows_noconsole')
|
||||
c_args = [ '-mwindows' ]
|
||||
link_args = [ '-mwindows' ]
|
||||
else
|
||||
c_args = []
|
||||
link_args = []
|
||||
endif
|
||||
|
||||
executable('scrcpy', src, dependencies: dependencies, include_directories: src_dir, install: true, c_args: c_args, link_args: link_args)
|
||||
|
||||
|
||||
### TESTS
|
||||
|
||||
tests = [
|
||||
['test_control_event_queue', ['tests/test_control_event_queue.c', 'src/controlevent.c']],
|
||||
['test_control_event_serialize', ['tests/test_control_event_serialize.c', 'src/controlevent.c']],
|
||||
['test_strutil', ['tests/test_strutil.c', 'src/strutil.c']],
|
||||
['test_control_event_queue', ['tests/test_control_event_queue.c', 'src/control_event.c']],
|
||||
['test_control_event_serialize', ['tests/test_control_event_serialize.c', 'src/control_event.c']],
|
||||
['test_strutil', ['tests/test_strutil.c', 'src/str_util.c']],
|
||||
]
|
||||
|
||||
src_dir = include_directories('src')
|
||||
|
||||
foreach t : tests
|
||||
exe = executable(t[0], t[1], include_directories: src_dir, dependencies: dependencies)
|
||||
test(t[0], exe)
|
||||
|
@ -777,9 +777,6 @@ enum android_input_source {
|
||||
AINPUT_SOURCE_JOYSTICK = 0x01000000 | AINPUT_SOURCE_CLASS_JOYSTICK,
|
||||
/** rotary encoder */
|
||||
AINPUT_SOURCE_ROTARY_ENCODER = 0x00400000 | AINPUT_SOURCE_CLASS_NONE,
|
||||
|
||||
/** any */
|
||||
AINPUT_SOURCE_ANY = 0xffffff00,
|
||||
};
|
||||
|
||||
/**
|
||||
|
@ -4,10 +4,9 @@
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "common.h"
|
||||
#include "log.h"
|
||||
|
||||
#define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0]))
|
||||
|
||||
static const char *adb_command;
|
||||
|
||||
static inline const char *get_adb_command() {
|
||||
@ -19,9 +18,25 @@ static inline const char *get_adb_command() {
|
||||
return adb_command;
|
||||
}
|
||||
|
||||
static void show_adb_err_msg(enum process_result err) {
|
||||
switch (err) {
|
||||
case PROCESS_ERROR_GENERIC:
|
||||
LOGE("Failed to execute adb");
|
||||
break;
|
||||
case PROCESS_ERROR_MISSING_BINARY:
|
||||
LOGE("'adb' command not found (make it accessible from your PATH "
|
||||
"or define its full path in the ADB environment variable)");
|
||||
break;
|
||||
case PROCESS_SUCCESS:
|
||||
/* do nothing */
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
process_t adb_execute(const char *serial, const char *const adb_cmd[], int len) {
|
||||
const char *cmd[len + 4];
|
||||
int i;
|
||||
process_t process;
|
||||
cmd[0] = get_adb_command();
|
||||
if (serial) {
|
||||
cmd[1] = "-s";
|
||||
@ -33,7 +48,12 @@ process_t adb_execute(const char *serial, const char *const adb_cmd[], int len)
|
||||
|
||||
memcpy(&cmd[i], adb_cmd, len * sizeof(const char *));
|
||||
cmd[len + i] = NULL;
|
||||
return cmd_execute(cmd[0], cmd);
|
||||
enum process_result r = cmd_execute(cmd[0], cmd, &process);
|
||||
if (r != PROCESS_SUCCESS) {
|
||||
show_adb_err_msg(r);
|
||||
return PROCESS_NONE;
|
||||
}
|
||||
return process;
|
||||
}
|
||||
|
||||
process_t adb_forward(const char *serial, uint16_t local_port, const char *device_socket_name) {
|
||||
@ -45,6 +65,13 @@ process_t adb_forward(const char *serial, uint16_t local_port, const char *devic
|
||||
return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
|
||||
}
|
||||
|
||||
process_t adb_forward_remove(const char *serial, uint16_t local_port) {
|
||||
char local[4 + 5 + 1]; // tcp:PORT
|
||||
sprintf(local, "tcp:%" PRIu16, local_port);
|
||||
const char *const adb_cmd[] = {"forward", "--remove", local};
|
||||
return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
|
||||
}
|
||||
|
||||
process_t adb_reverse(const char *serial, const char *device_socket_name, uint16_t local_port) {
|
||||
char local[4 + 5 + 1]; // tcp:PORT
|
||||
char remote[108 + 14 + 1]; // localabstract:NAME
|
||||
@ -66,6 +93,21 @@ process_t adb_push(const char *serial, const char *local, const char *remote) {
|
||||
return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
|
||||
}
|
||||
|
||||
process_t adb_install(const char *serial, const char *local) {
|
||||
#ifdef __WINDOWS__
|
||||
// Windows will parse the string, so the local name must be quoted (see sys/win/command.c)
|
||||
size_t len = strlen(local);
|
||||
char quoted[len + 3];
|
||||
memcpy("ed[1], local, len);
|
||||
quoted[0] = '"';
|
||||
quoted[len + 1] = '"';
|
||||
quoted[len + 2] = '\0';
|
||||
local = quoted;
|
||||
#endif
|
||||
const char *const adb_cmd[] = {"install", "-r", local};
|
||||
return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
|
||||
}
|
||||
|
||||
process_t adb_remove_path(const char *serial, const char *path) {
|
||||
const char *const adb_cmd[] = {"shell", "rm", path};
|
||||
return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
|
||||
|
@ -7,12 +7,11 @@
|
||||
|
||||
// <https://stackoverflow.com/a/44383330/1987178>
|
||||
#ifdef _WIN32
|
||||
# define PRIexitcode "lu"
|
||||
# ifdef _WIN64
|
||||
# define PRIsizet PRIu64
|
||||
# define PRIexitcode "lu"
|
||||
# else
|
||||
# define PRIsizet PRIu32
|
||||
# define PRIexitcode "u"
|
||||
# endif
|
||||
#else
|
||||
# define PRIsizet "zu"
|
||||
@ -33,15 +32,23 @@
|
||||
#endif
|
||||
# define NO_EXIT_CODE -1
|
||||
|
||||
process_t cmd_execute(const char *path, const char *const argv[]);
|
||||
enum process_result {
|
||||
PROCESS_SUCCESS,
|
||||
PROCESS_ERROR_GENERIC,
|
||||
PROCESS_ERROR_MISSING_BINARY,
|
||||
};
|
||||
|
||||
enum process_result cmd_execute(const char *path, const char *const argv[], process_t *process);
|
||||
SDL_bool cmd_terminate(process_t pid);
|
||||
SDL_bool cmd_simple_wait(process_t pid, exit_code_t *exit_code);
|
||||
|
||||
process_t adb_execute(const char *serial, const char *const adb_cmd[], int len);
|
||||
process_t adb_forward(const char *serial, uint16_t local_port, const char *device_socket_name);
|
||||
process_t adb_forward_remove(const char *serial, uint16_t local_port);
|
||||
process_t adb_reverse(const char *serial, const char *device_socket_name, uint16_t local_port);
|
||||
process_t adb_reverse_remove(const char *serial, const char *device_socket_name);
|
||||
process_t adb_push(const char *serial, const char *local, const char *remote);
|
||||
process_t adb_install(const char *serial, const char *local);
|
||||
process_t adb_remove_path(const char *serial, const char *path);
|
||||
|
||||
// convenience function to wait for a successful process execution
|
||||
|
@ -3,6 +3,7 @@
|
||||
|
||||
#include <SDL2/SDL_stdinc.h>
|
||||
|
||||
#define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0]))
|
||||
#define MIN(X,Y) (X) < (Y) ? (X) : (Y)
|
||||
#define MAX(X,Y) (X) > (Y) ? (X) : (Y)
|
||||
|
||||
|
@ -1,8 +1,9 @@
|
||||
#include "controlevent.h"
|
||||
#include "control_event.h"
|
||||
|
||||
#include <SDL2/SDL_stdinc.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "lockutil.h"
|
||||
#include "lock_util.h"
|
||||
#include "log.h"
|
||||
|
||||
static inline void write16(Uint8 *buf, Uint16 value) {
|
||||
@ -39,9 +40,9 @@ int control_event_serialize(const struct control_event *event, unsigned char *bu
|
||||
// injecting a text takes time, so limit the text length
|
||||
len = TEXT_MAX_LENGTH;
|
||||
}
|
||||
buf[1] = (Uint8) len;
|
||||
memcpy(&buf[2], event->text_event.text, len);
|
||||
return 2 + len;
|
||||
write16(&buf[1], (Uint16) len);
|
||||
memcpy(&buf[3], event->text_event.text, len);
|
||||
return 3 + len;
|
||||
}
|
||||
case CONTROL_EVENT_TYPE_MOUSE:
|
||||
buf[1] = event->mouse_event.action;
|
@ -9,8 +9,8 @@
|
||||
#include "common.h"
|
||||
|
||||
#define CONTROL_EVENT_QUEUE_SIZE 64
|
||||
#define SERIALIZED_EVENT_MAX_SIZE 33
|
||||
#define TEXT_MAX_LENGTH 256
|
||||
#define TEXT_MAX_LENGTH 300
|
||||
#define SERIALIZED_EVENT_MAX_SIZE 3 + TEXT_MAX_LENGTH
|
||||
|
||||
enum control_event_type {
|
||||
CONTROL_EVENT_TYPE_KEYCODE,
|
||||
@ -20,7 +20,7 @@ enum control_event_type {
|
||||
CONTROL_EVENT_TYPE_COMMAND,
|
||||
};
|
||||
|
||||
#define CONTROL_EVENT_COMMAND_SCREEN_ON 0
|
||||
#define CONTROL_EVENT_COMMAND_BACK_OR_SCREEN_ON 0
|
||||
|
||||
struct control_event {
|
||||
enum control_event_type type;
|
@ -1,6 +1,8 @@
|
||||
#include "controller.h"
|
||||
|
||||
#include "lockutil.h"
|
||||
#include <SDL2/SDL_assert.h>
|
||||
#include "config.h"
|
||||
#include "lock_util.h"
|
||||
#include "log.h"
|
||||
|
||||
SDL_bool controller_init(struct controller *controller, socket_t video_socket) {
|
||||
@ -54,27 +56,28 @@ static SDL_bool process_event(struct controller *controller, const struct contro
|
||||
static int run_controller(void *data) {
|
||||
struct controller *controller = data;
|
||||
|
||||
mutex_lock(controller->mutex);
|
||||
for (;;) {
|
||||
mutex_lock(controller->mutex);
|
||||
while (!controller->stopped && control_event_queue_is_empty(&controller->queue)) {
|
||||
cond_wait(controller->event_cond, controller->mutex);
|
||||
}
|
||||
if (controller->stopped) {
|
||||
// stop immediately, do not process further events
|
||||
mutex_unlock(controller->mutex);
|
||||
break;
|
||||
}
|
||||
struct control_event event;
|
||||
while (control_event_queue_take(&controller->queue, &event)) {
|
||||
SDL_bool ok = process_event(controller, &event);
|
||||
control_event_destroy(&event);
|
||||
if (!ok) {
|
||||
LOGD("Cannot write event to socket");
|
||||
goto end;
|
||||
}
|
||||
SDL_bool non_empty = control_event_queue_take(&controller->queue, &event);
|
||||
SDL_assert(non_empty);
|
||||
mutex_unlock(controller->mutex);
|
||||
|
||||
SDL_bool ok = process_event(controller, &event);
|
||||
control_event_destroy(&event);
|
||||
if (!ok) {
|
||||
LOGD("Cannot write event to socket");
|
||||
break;
|
||||
}
|
||||
}
|
||||
end:
|
||||
mutex_unlock(controller->mutex);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -1,7 +1,7 @@
|
||||
#ifndef CONTROL_H
|
||||
#define CONTROL_H
|
||||
|
||||
#include "controlevent.h"
|
||||
#include "control_event.h"
|
||||
|
||||
#include <SDL2/SDL_mutex.h>
|
||||
#include <SDL2/SDL_stdinc.h>
|
||||
|
@ -73,6 +73,7 @@ static enum android_metastate convert_meta_state(SDL_Keymod mod) {
|
||||
static SDL_bool convert_keycode(SDL_Keycode from, enum android_keycode *to) {
|
||||
switch (from) {
|
||||
MAP(SDLK_RETURN, AKEYCODE_ENTER);
|
||||
MAP(SDLK_KP_ENTER, AKEYCODE_NUMPAD_ENTER);
|
||||
MAP(SDLK_ESCAPE, AKEYCODE_ESCAPE);
|
||||
MAP(SDLK_BACKSPACE, AKEYCODE_DEL);
|
||||
MAP(SDLK_TAB, AKEYCODE_TAB);
|
||||
@ -145,8 +146,8 @@ SDL_bool mouse_button_from_sdl_to_android(const SDL_MouseButtonEvent *from,
|
||||
|
||||
to->mouse_event.buttons = convert_mouse_buttons(SDL_BUTTON(from->button));
|
||||
to->mouse_event.position.screen_size = screen_size;
|
||||
to->mouse_event.position.point.x = (Uint16) from->x;
|
||||
to->mouse_event.position.point.y = (Uint16) from->y;
|
||||
to->mouse_event.position.point.x = from->x;
|
||||
to->mouse_event.position.point.y = from->y;
|
||||
|
||||
return SDL_TRUE;
|
||||
}
|
||||
@ -172,7 +173,10 @@ SDL_bool mouse_wheel_from_sdl_to_android(const SDL_MouseWheelEvent *from,
|
||||
to->scroll_event.position = position;
|
||||
|
||||
int mul = from->direction == SDL_MOUSEWHEEL_NORMAL ? 1 : -1;
|
||||
to->scroll_event.hscroll = mul * from->x;
|
||||
// SDL behavior seems inconsistent between horizontal and vertical scrolling
|
||||
// so reverse the horizontal
|
||||
// <https://wiki.libsdl.org/SDL_MouseWheelEvent#Remarks>
|
||||
to->scroll_event.hscroll = -mul * from->x;
|
||||
to->scroll_event.vscroll = mul * from->y;
|
||||
|
||||
return SDL_TRUE;
|
||||
|
@ -3,7 +3,7 @@
|
||||
|
||||
#include <SDL2/SDL_stdinc.h>
|
||||
#include <SDL2/SDL_events.h>
|
||||
#include "controlevent.h"
|
||||
#include "control_event.h"
|
||||
|
||||
struct complete_mouse_motion_event {
|
||||
SDL_MouseMotionEvent *mouse_motion_event;
|
||||
|
@ -9,7 +9,7 @@
|
||||
#include "config.h"
|
||||
#include "events.h"
|
||||
#include "frames.h"
|
||||
#include "lockutil.h"
|
||||
#include "lock_util.h"
|
||||
#include "log.h"
|
||||
|
||||
#define BUFSIZE 0x10000
|
||||
@ -91,7 +91,7 @@ static int run_decoder(void *data) {
|
||||
packet.data = NULL;
|
||||
packet.size = 0;
|
||||
|
||||
while (!av_read_frame(format_ctx, &packet) && !avio_ctx->eof_reached) {
|
||||
while (!av_read_frame(format_ctx, &packet)) {
|
||||
// the new decoding/encoding API has been introduced by:
|
||||
// <http://git.videolan.org/?p=ffmpeg.git;a=commitdiff;h=7fc329e2dd6226dfecaa4a1d7adf353bf2773726>
|
||||
#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 37, 0)
|
||||
@ -106,6 +106,7 @@ static int run_decoder(void *data) {
|
||||
push_frame(decoder);
|
||||
} else if (ret != AVERROR(EAGAIN)) {
|
||||
LOGE("Could not receive video frame: %d", ret);
|
||||
av_packet_unref(&packet);
|
||||
goto run_quit;
|
||||
}
|
||||
#else
|
||||
@ -123,6 +124,11 @@ static int run_decoder(void *data) {
|
||||
packet.data += len;
|
||||
}
|
||||
#endif
|
||||
av_packet_unref(&packet);
|
||||
|
||||
if (avio_ctx->eof_reached) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
LOGD("End of frames");
|
||||
|
@ -7,6 +7,7 @@
|
||||
#include "net.h"
|
||||
|
||||
#define DEVICE_NAME_FIELD_LENGTH 64
|
||||
#define DEVICE_SDCARD_PATH "/sdcard/"
|
||||
|
||||
// name must be at least DEVICE_NAME_FIELD_LENGTH bytes
|
||||
SDL_bool device_read_info(socket_t device_socket, char *name, struct size *frame_size);
|
||||
|
231
app/src/file_handler.c
Normal file
231
app/src/file_handler.c
Normal file
@ -0,0 +1,231 @@
|
||||
#include "file_handler.h"
|
||||
|
||||
#include <string.h>
|
||||
#include <SDL2/SDL_assert.h>
|
||||
#include "config.h"
|
||||
#include "command.h"
|
||||
#include "device.h"
|
||||
#include "lock_util.h"
|
||||
#include "log.h"
|
||||
|
||||
struct request {
|
||||
file_handler_action_t action;
|
||||
const char *file;
|
||||
};
|
||||
|
||||
static struct request *request_new(file_handler_action_t action, const char *file) {
|
||||
struct request *req = SDL_malloc(sizeof(*req));
|
||||
if (!req) {
|
||||
return NULL;
|
||||
}
|
||||
req->action = action;
|
||||
req->file = file;
|
||||
return req;
|
||||
}
|
||||
|
||||
static void request_free(struct request *req) {
|
||||
if (!req) {
|
||||
return;
|
||||
}
|
||||
SDL_free((void *) req->file);
|
||||
SDL_free((void *) req);
|
||||
}
|
||||
|
||||
static SDL_bool request_queue_is_empty(const struct request_queue *queue) {
|
||||
return queue->head == queue->tail;
|
||||
}
|
||||
|
||||
static SDL_bool request_queue_is_full(const struct request_queue *queue) {
|
||||
return (queue->head + 1) % REQUEST_QUEUE_SIZE == queue->tail;
|
||||
}
|
||||
|
||||
static SDL_bool request_queue_init(struct request_queue *queue) {
|
||||
queue->head = 0;
|
||||
queue->tail = 0;
|
||||
return SDL_TRUE;
|
||||
}
|
||||
|
||||
static void request_queue_destroy(struct request_queue *queue) {
|
||||
int i = queue->tail;
|
||||
while (i != queue->head) {
|
||||
request_free(queue->reqs[i]);
|
||||
i = (i + 1) % REQUEST_QUEUE_SIZE;
|
||||
}
|
||||
}
|
||||
|
||||
static SDL_bool request_queue_push(struct request_queue *queue, struct request *req) {
|
||||
if (request_queue_is_full(queue)) {
|
||||
return SDL_FALSE;
|
||||
}
|
||||
queue->reqs[queue->head] = req;
|
||||
queue->head = (queue->head + 1) % REQUEST_QUEUE_SIZE;
|
||||
return SDL_TRUE;
|
||||
}
|
||||
|
||||
static SDL_bool request_queue_take(struct request_queue *queue, struct request **req) {
|
||||
if (request_queue_is_empty(queue)) {
|
||||
return SDL_FALSE;
|
||||
}
|
||||
// transfer ownership
|
||||
*req = queue->reqs[queue->tail];
|
||||
queue->tail = (queue->tail + 1) % REQUEST_QUEUE_SIZE;
|
||||
return SDL_TRUE;
|
||||
}
|
||||
|
||||
SDL_bool file_handler_init(struct file_handler *file_handler, const char *serial) {
|
||||
|
||||
if (!request_queue_init(&file_handler->queue)) {
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
if (!(file_handler->mutex = SDL_CreateMutex())) {
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
if (!(file_handler->event_cond = SDL_CreateCond())) {
|
||||
SDL_DestroyMutex(file_handler->mutex);
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
if (serial) {
|
||||
file_handler->serial = SDL_strdup(serial);
|
||||
if (!file_handler->serial) {
|
||||
LOGW("Cannot strdup serial");
|
||||
SDL_DestroyMutex(file_handler->mutex);
|
||||
return SDL_FALSE;
|
||||
}
|
||||
} else {
|
||||
file_handler->serial = NULL;
|
||||
}
|
||||
|
||||
// lazy initialization
|
||||
file_handler->initialized = SDL_FALSE;
|
||||
|
||||
file_handler->stopped = SDL_FALSE;
|
||||
file_handler->current_process = PROCESS_NONE;
|
||||
|
||||
return SDL_TRUE;
|
||||
}
|
||||
|
||||
void file_handler_destroy(struct file_handler *file_handler) {
|
||||
SDL_DestroyCond(file_handler->event_cond);
|
||||
SDL_DestroyMutex(file_handler->mutex);
|
||||
request_queue_destroy(&file_handler->queue);
|
||||
SDL_free((void *) file_handler->serial);
|
||||
}
|
||||
|
||||
static process_t install_apk(const char *serial, const char *file) {
|
||||
return adb_install(serial, file);
|
||||
}
|
||||
|
||||
static process_t push_file(const char *serial, const char *file) {
|
||||
return adb_push(serial, file, DEVICE_SDCARD_PATH);
|
||||
}
|
||||
|
||||
SDL_bool file_handler_request(struct file_handler *file_handler,
|
||||
file_handler_action_t action,
|
||||
const char *file) {
|
||||
SDL_bool res;
|
||||
|
||||
// start file_handler if it's used for the first time
|
||||
if (!file_handler->initialized) {
|
||||
if (!file_handler_start(file_handler)) {
|
||||
return SDL_FALSE;
|
||||
}
|
||||
file_handler->initialized = SDL_TRUE;
|
||||
}
|
||||
|
||||
LOGI("Request to %s %s", action == ACTION_INSTALL_APK ? "install" : "push", file);
|
||||
struct request *req = request_new(action, file);
|
||||
if (!req) {
|
||||
LOGE("Could not create request");
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
mutex_lock(file_handler->mutex);
|
||||
SDL_bool was_empty = request_queue_is_empty(&file_handler->queue);
|
||||
res = request_queue_push(&file_handler->queue, req);
|
||||
if (was_empty) {
|
||||
cond_signal(file_handler->event_cond);
|
||||
}
|
||||
mutex_unlock(file_handler->mutex);
|
||||
return res;
|
||||
}
|
||||
|
||||
static int run_file_handler(void *data) {
|
||||
struct file_handler *file_handler = data;
|
||||
|
||||
for (;;) {
|
||||
mutex_lock(file_handler->mutex);
|
||||
file_handler->current_process = PROCESS_NONE;
|
||||
while (!file_handler->stopped && request_queue_is_empty(&file_handler->queue)) {
|
||||
cond_wait(file_handler->event_cond, file_handler->mutex);
|
||||
}
|
||||
if (file_handler->stopped) {
|
||||
// stop immediately, do not process further events
|
||||
mutex_unlock(file_handler->mutex);
|
||||
break;
|
||||
}
|
||||
struct request *req;
|
||||
SDL_bool non_empty = request_queue_take(&file_handler->queue, &req);
|
||||
SDL_assert(non_empty);
|
||||
|
||||
process_t process;
|
||||
if (req->action == ACTION_INSTALL_APK) {
|
||||
LOGI("Installing %s...", req->file);
|
||||
process = install_apk(file_handler->serial, req->file);
|
||||
} else {
|
||||
LOGI("Pushing %s...", req->file);
|
||||
process = push_file(file_handler->serial, req->file);
|
||||
}
|
||||
file_handler->current_process = process;
|
||||
mutex_unlock(file_handler->mutex);
|
||||
|
||||
if (req->action == ACTION_INSTALL_APK) {
|
||||
if (process_check_success(process, "adb install")) {
|
||||
LOGI("%s successfully installed", req->file);
|
||||
} else {
|
||||
LOGE("Failed to install %s", req->file);
|
||||
}
|
||||
} else {
|
||||
if (process_check_success(process, "adb push")) {
|
||||
LOGI("%s successfully pushed to /sdcard/", req->file);
|
||||
} else {
|
||||
LOGE("Failed to push %s to /sdcard/", req->file);
|
||||
}
|
||||
}
|
||||
|
||||
request_free(req);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
SDL_bool file_handler_start(struct file_handler *file_handler) {
|
||||
LOGD("Starting file_handler thread");
|
||||
|
||||
file_handler->thread = SDL_CreateThread(run_file_handler, "file_handler", file_handler);
|
||||
if (!file_handler->thread) {
|
||||
LOGC("Could not start file_handler thread");
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
return SDL_TRUE;
|
||||
}
|
||||
|
||||
void file_handler_stop(struct file_handler *file_handler) {
|
||||
mutex_lock(file_handler->mutex);
|
||||
file_handler->stopped = SDL_TRUE;
|
||||
cond_signal(file_handler->event_cond);
|
||||
if (file_handler->current_process != PROCESS_NONE) {
|
||||
if (!cmd_terminate(file_handler->current_process)) {
|
||||
LOGW("Cannot terminate install process");
|
||||
}
|
||||
cmd_simple_wait(file_handler->current_process, NULL);
|
||||
file_handler->current_process = PROCESS_NONE;
|
||||
}
|
||||
mutex_unlock(file_handler->mutex);
|
||||
}
|
||||
|
||||
void file_handler_join(struct file_handler *file_handler) {
|
||||
SDL_WaitThread(file_handler->thread, NULL);
|
||||
}
|
44
app/src/file_handler.h
Normal file
44
app/src/file_handler.h
Normal file
@ -0,0 +1,44 @@
|
||||
#ifndef FILE_HANDLER_H
|
||||
#define FILE_HANDLER_H
|
||||
|
||||
#include <SDL2/SDL_mutex.h>
|
||||
#include <SDL2/SDL_stdinc.h>
|
||||
#include <SDL2/SDL_thread.h>
|
||||
#include "command.h"
|
||||
|
||||
#define REQUEST_QUEUE_SIZE 16
|
||||
|
||||
typedef enum {
|
||||
ACTION_INSTALL_APK,
|
||||
ACTION_PUSH_FILE,
|
||||
} file_handler_action_t;
|
||||
|
||||
struct request_queue {
|
||||
struct request *reqs[REQUEST_QUEUE_SIZE];
|
||||
int tail;
|
||||
int head;
|
||||
};
|
||||
|
||||
struct file_handler {
|
||||
const char *serial;
|
||||
SDL_Thread *thread;
|
||||
SDL_mutex *mutex;
|
||||
SDL_cond *event_cond;
|
||||
SDL_bool stopped;
|
||||
SDL_bool initialized;
|
||||
process_t current_process;
|
||||
struct request_queue queue;
|
||||
};
|
||||
|
||||
SDL_bool file_handler_init(struct file_handler *file_handler, const char *serial);
|
||||
void file_handler_destroy(struct file_handler *file_handler);
|
||||
|
||||
SDL_bool file_handler_start(struct file_handler *file_handler);
|
||||
void file_handler_stop(struct file_handler *file_handler);
|
||||
void file_handler_join(struct file_handler *file_handler);
|
||||
|
||||
SDL_bool file_handler_request(struct file_handler *file_handler,
|
||||
file_handler_action_t action,
|
||||
const char *file);
|
||||
|
||||
#endif
|
@ -1,4 +1,4 @@
|
||||
#include "fpscounter.h"
|
||||
#include "fps_counter.h"
|
||||
|
||||
#include <SDL2/SDL_timer.h>
|
||||
|
@ -6,7 +6,7 @@
|
||||
#include <libavformat/avformat.h>
|
||||
|
||||
#include "config.h"
|
||||
#include "lockutil.h"
|
||||
#include "lock_util.h"
|
||||
#include "log.h"
|
||||
|
||||
SDL_bool frames_init(struct frames *frames) {
|
||||
|
@ -5,7 +5,7 @@
|
||||
#include <SDL2/SDL_stdinc.h>
|
||||
|
||||
#include "config.h"
|
||||
#include "fpscounter.h"
|
||||
#include "fps_counter.h"
|
||||
|
||||
// forward declarations
|
||||
typedef struct AVFrame AVFrame;
|
||||
|
@ -1,7 +1,7 @@
|
||||
#include "inputmanager.h"
|
||||
#include "input_manager.h"
|
||||
|
||||
#include "convert.h"
|
||||
#include "lockutil.h"
|
||||
#include "lock_util.h"
|
||||
#include "log.h"
|
||||
|
||||
// Convert window coordinates (as provided by SDL_GetMouseState() to renderer coordinates (as provided in SDL mouse events)
|
||||
@ -29,59 +29,65 @@ static struct point get_mouse_point(struct screen *screen) {
|
||||
};
|
||||
}
|
||||
|
||||
static SDL_bool is_ctrl_down(void) {
|
||||
const Uint8 *state = SDL_GetKeyboardState(NULL);
|
||||
return state[SDL_SCANCODE_LCTRL] || state[SDL_SCANCODE_RCTRL];
|
||||
}
|
||||
static const int ACTION_DOWN = 1;
|
||||
static const int ACTION_UP = 1 << 1;
|
||||
|
||||
static void send_keycode(struct controller *controller, enum android_keycode keycode, const char *name) {
|
||||
static void send_keycode(struct controller *controller, enum android_keycode keycode, int actions, const char *name) {
|
||||
// send DOWN event
|
||||
struct control_event control_event;
|
||||
control_event.type = CONTROL_EVENT_TYPE_KEYCODE;
|
||||
control_event.keycode_event.action = AKEY_EVENT_ACTION_DOWN;
|
||||
control_event.keycode_event.keycode = keycode;
|
||||
control_event.keycode_event.metastate = 0;
|
||||
|
||||
if (!controller_push_event(controller, &control_event)) {
|
||||
LOGW("Cannot send %s (DOWN)", name);
|
||||
return;
|
||||
if (actions & ACTION_DOWN) {
|
||||
control_event.keycode_event.action = AKEY_EVENT_ACTION_DOWN;
|
||||
if (!controller_push_event(controller, &control_event)) {
|
||||
LOGW("Cannot send %s (DOWN)", name);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// send UP event
|
||||
control_event.keycode_event.action = AKEY_EVENT_ACTION_UP;
|
||||
if (!controller_push_event(controller, &control_event)) {
|
||||
LOGW("Cannot send %s (UP)", name);
|
||||
if (actions & ACTION_UP) {
|
||||
control_event.keycode_event.action = AKEY_EVENT_ACTION_UP;
|
||||
if (!controller_push_event(controller, &control_event)) {
|
||||
LOGW("Cannot send %s (UP)", name);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static inline void action_home(struct controller *controller) {
|
||||
send_keycode(controller, AKEYCODE_HOME, "HOME");
|
||||
static inline void action_home(struct controller *controller, int actions) {
|
||||
send_keycode(controller, AKEYCODE_HOME, actions, "HOME");
|
||||
}
|
||||
|
||||
static inline void action_back(struct controller *controller) {
|
||||
send_keycode(controller, AKEYCODE_BACK, "BACK");
|
||||
static inline void action_back(struct controller *controller, int actions) {
|
||||
send_keycode(controller, AKEYCODE_BACK, actions, "BACK");
|
||||
}
|
||||
|
||||
static inline void action_app_switch(struct controller *controller) {
|
||||
send_keycode(controller, AKEYCODE_APP_SWITCH, "APP_SWITCH");
|
||||
static inline void action_app_switch(struct controller *controller, int actions) {
|
||||
send_keycode(controller, AKEYCODE_APP_SWITCH, actions, "APP_SWITCH");
|
||||
}
|
||||
|
||||
static inline void action_power(struct controller *controller) {
|
||||
send_keycode(controller, AKEYCODE_POWER, "POWER");
|
||||
static inline void action_power(struct controller *controller, int actions) {
|
||||
send_keycode(controller, AKEYCODE_POWER, actions, "POWER");
|
||||
}
|
||||
|
||||
static inline void action_volume_up(struct controller *controller) {
|
||||
send_keycode(controller, AKEYCODE_VOLUME_UP, "VOLUME_UP");
|
||||
static inline void action_volume_up(struct controller *controller, int actions) {
|
||||
send_keycode(controller, AKEYCODE_VOLUME_UP, actions, "VOLUME_UP");
|
||||
}
|
||||
|
||||
static inline void action_volume_down(struct controller *controller) {
|
||||
send_keycode(controller, AKEYCODE_VOLUME_DOWN, "VOLUME_DOWN");
|
||||
static inline void action_volume_down(struct controller *controller, int actions) {
|
||||
send_keycode(controller, AKEYCODE_VOLUME_DOWN, actions, "VOLUME_DOWN");
|
||||
}
|
||||
|
||||
static void turn_screen_on(struct controller *controller) {
|
||||
static inline void action_menu(struct controller *controller, int actions) {
|
||||
send_keycode(controller, AKEYCODE_MENU, actions, "MENU");
|
||||
}
|
||||
|
||||
// turn the screen on if it was off, press BACK otherwise
|
||||
static void press_back_or_turn_screen_on(struct controller *controller) {
|
||||
struct control_event control_event;
|
||||
control_event.type = CONTROL_EVENT_TYPE_COMMAND;
|
||||
control_event.command_event.action = CONTROL_EVENT_COMMAND_SCREEN_ON;
|
||||
control_event.command_event.action = CONTROL_EVENT_COMMAND_BACK_OR_SCREEN_ON;
|
||||
|
||||
if (!controller_push_event(controller, &control_event)) {
|
||||
LOGW("Cannot turn screen on");
|
||||
@ -123,18 +129,6 @@ static void clipboard_paste(struct controller *controller) {
|
||||
|
||||
void input_manager_process_text_input(struct input_manager *input_manager,
|
||||
const SDL_TextInputEvent *event) {
|
||||
if (is_ctrl_down()) {
|
||||
switch (event->text[0]) {
|
||||
case '+':
|
||||
action_volume_up(input_manager->controller);
|
||||
break;
|
||||
case '-':
|
||||
action_volume_down(input_manager->controller);
|
||||
break;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
struct control_event control_event;
|
||||
control_event.type = CONTROL_EVENT_TYPE_TEXT;
|
||||
control_event.text_event.text = SDL_strdup(event->text);
|
||||
@ -153,48 +147,74 @@ void input_manager_process_key(struct input_manager *input_manager,
|
||||
|
||||
// capture all Ctrl events
|
||||
if (ctrl) {
|
||||
SDL_bool repeat = event->repeat;
|
||||
|
||||
// only consider keydown events, and ignore repeated events
|
||||
if (repeat || event->type != SDL_KEYDOWN) {
|
||||
return;
|
||||
}
|
||||
|
||||
SDL_bool shift = event->keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT);
|
||||
if (shift) {
|
||||
// currently, there is no shortcut implying SHIFT
|
||||
// currently, there is no shortcut involving SHIFT
|
||||
return;
|
||||
}
|
||||
|
||||
SDL_Keycode keycode = event->keysym.sym;
|
||||
int action = event->type == SDL_KEYDOWN ? ACTION_DOWN : ACTION_UP;
|
||||
SDL_bool repeat = event->repeat;
|
||||
switch (keycode) {
|
||||
case SDLK_h:
|
||||
action_home(input_manager->controller);
|
||||
if (!repeat) {
|
||||
action_home(input_manager->controller, action);
|
||||
}
|
||||
return;
|
||||
case SDLK_b: // fall-through
|
||||
case SDLK_BACKSPACE:
|
||||
action_back(input_manager->controller);
|
||||
if (!repeat) {
|
||||
action_back(input_manager->controller, action);
|
||||
}
|
||||
return;
|
||||
case SDLK_s:
|
||||
if (!repeat) {
|
||||
action_app_switch(input_manager->controller, action);
|
||||
}
|
||||
return;
|
||||
case SDLK_m:
|
||||
action_app_switch(input_manager->controller);
|
||||
if (!repeat) {
|
||||
action_menu(input_manager->controller, action);
|
||||
}
|
||||
return;
|
||||
case SDLK_p:
|
||||
action_power(input_manager->controller);
|
||||
if (!repeat) {
|
||||
action_power(input_manager->controller, action);
|
||||
}
|
||||
return;
|
||||
case SDLK_DOWN:
|
||||
// forward repeated events
|
||||
action_volume_down(input_manager->controller, action);
|
||||
return;
|
||||
case SDLK_UP:
|
||||
// forward repeated events
|
||||
action_volume_up(input_manager->controller, action);
|
||||
return;
|
||||
case SDLK_v:
|
||||
clipboard_paste(input_manager->controller);
|
||||
if (!repeat && event->type == SDL_KEYDOWN) {
|
||||
clipboard_paste(input_manager->controller);
|
||||
}
|
||||
return;
|
||||
case SDLK_f:
|
||||
screen_switch_fullscreen(input_manager->screen);
|
||||
if (!repeat && event->type == SDL_KEYDOWN) {
|
||||
screen_switch_fullscreen(input_manager->screen);
|
||||
}
|
||||
return;
|
||||
case SDLK_x:
|
||||
screen_resize_to_fit(input_manager->screen);
|
||||
if (!repeat && event->type == SDL_KEYDOWN) {
|
||||
screen_resize_to_fit(input_manager->screen);
|
||||
}
|
||||
return;
|
||||
case SDLK_g:
|
||||
screen_resize_to_pixel_perfect(input_manager->screen);
|
||||
if (!repeat && event->type == SDL_KEYDOWN) {
|
||||
screen_resize_to_pixel_perfect(input_manager->screen);
|
||||
}
|
||||
return;
|
||||
case SDLK_i:
|
||||
switch_fps_counter_state(input_manager->frames);
|
||||
if (!repeat && event->type == SDL_KEYDOWN) {
|
||||
switch_fps_counter_state(input_manager->frames);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
@ -225,10 +245,27 @@ void input_manager_process_mouse_motion(struct input_manager *input_manager,
|
||||
|
||||
void input_manager_process_mouse_button(struct input_manager *input_manager,
|
||||
const SDL_MouseButtonEvent *event) {
|
||||
if (event->button == SDL_BUTTON_RIGHT && event->type == SDL_MOUSEBUTTONDOWN) {
|
||||
turn_screen_on(input_manager->controller);
|
||||
return;
|
||||
};
|
||||
if (event->type == SDL_MOUSEBUTTONDOWN) {
|
||||
if (event->button == SDL_BUTTON_RIGHT) {
|
||||
press_back_or_turn_screen_on(input_manager->controller);
|
||||
return;
|
||||
}
|
||||
if (event->button == SDL_BUTTON_MIDDLE) {
|
||||
action_home(input_manager->controller, ACTION_DOWN | ACTION_UP);
|
||||
return;
|
||||
}
|
||||
// double-click on black borders resize to fit the device screen
|
||||
if (event->button == SDL_BUTTON_LEFT && event->clicks == 2) {
|
||||
SDL_bool outside_device_screen =
|
||||
event->x < 0 || event->x >= input_manager->screen->frame_size.width ||
|
||||
event->y < 0 || event->y >= input_manager->screen->frame_size.height;
|
||||
if (outside_device_screen) {
|
||||
screen_resize_to_fit(input_manager->screen);
|
||||
return;
|
||||
}
|
||||
// otherwise, send the click event to the device
|
||||
}
|
||||
}
|
||||
struct control_event control_event;
|
||||
if (mouse_button_from_sdl_to_android(event, input_manager->screen->frame_size, &control_event)) {
|
||||
if (!controller_push_event(input_manager->controller, &control_event)) {
|
||||
@ -246,7 +283,7 @@ void input_manager_process_mouse_wheel(struct input_manager *input_manager,
|
||||
struct control_event control_event;
|
||||
if (mouse_wheel_from_sdl_to_android(event, position, &control_event)) {
|
||||
if (!controller_push_event(input_manager->controller, &control_event)) {
|
||||
LOGW("Cannot send wheel button event");
|
||||
LOGW("Cannot send mouse wheel event");
|
||||
}
|
||||
}
|
||||
}
|
@ -3,7 +3,7 @@
|
||||
|
||||
#include "common.h"
|
||||
#include "controller.h"
|
||||
#include "fpscounter.h"
|
||||
#include "fps_counter.h"
|
||||
#include "frames.h"
|
||||
#include "screen.h"
|
||||
|
@ -1,3 +1,4 @@
|
||||
#include <lock_util.h>
|
||||
#include <stdlib.h>
|
||||
#include <SDL2/SDL_mutex.h>
|
||||
|
100
app/src/main.c
100
app/src/main.c
@ -10,8 +10,11 @@
|
||||
|
||||
struct args {
|
||||
const char *serial;
|
||||
const char *crop;
|
||||
SDL_bool fullscreen;
|
||||
SDL_bool help;
|
||||
SDL_bool version;
|
||||
SDL_bool show_touches;
|
||||
Uint16 port;
|
||||
Uint16 max_size;
|
||||
Uint32 bit_rate;
|
||||
@ -28,6 +31,15 @@ static void usage(const char *arg0) {
|
||||
" Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
|
||||
" Default is %d.\n"
|
||||
"\n"
|
||||
" -c, --crop width:height:x:y\n"
|
||||
" Crop the device screen on the server.\n"
|
||||
" The values are expressed in the device natural orientation\n"
|
||||
" (typically, portrait for a phone, landscape for a tablet).\n"
|
||||
" Any --max-size value is computed on the cropped size.\n"
|
||||
"\n"
|
||||
" -f, --fullscreen\n"
|
||||
" Start in fullscreen.\n"
|
||||
"\n"
|
||||
" -h, --help\n"
|
||||
" Print this help.\n"
|
||||
"\n"
|
||||
@ -45,6 +57,10 @@ static void usage(const char *arg0) {
|
||||
" The device serial number. Mandatory only if several devices\n"
|
||||
" are connected to adb.\n"
|
||||
"\n"
|
||||
" -t, --show-touches\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"
|
||||
@ -57,29 +73,35 @@ static void usage(const char *arg0) {
|
||||
" resize window to 1:1 (pixel-perfect)\n"
|
||||
"\n"
|
||||
" Ctrl+x\n"
|
||||
" Double-click on black borders\n"
|
||||
" resize window to remove black borders\n"
|
||||
"\n"
|
||||
" Ctrl+h\n"
|
||||
" Home\n"
|
||||
" Middle-click\n"
|
||||
" click on HOME\n"
|
||||
"\n"
|
||||
" Ctrl+b\n"
|
||||
" Ctrl+Backspace\n"
|
||||
" Right-click (when screen is on)\n"
|
||||
" click on BACK\n"
|
||||
"\n"
|
||||
" Ctrl+m\n"
|
||||
" Ctrl+s\n"
|
||||
" click on APP_SWITCH\n"
|
||||
"\n"
|
||||
" Ctrl+'+'\n"
|
||||
" Ctrl+m\n"
|
||||
" click on MENU\n"
|
||||
"\n"
|
||||
" Ctrl+Up\n"
|
||||
" click on VOLUME_UP\n"
|
||||
"\n"
|
||||
" Ctrl+'-'\n"
|
||||
" Ctrl+Down\n"
|
||||
" click on VOLUME_DOWN\n"
|
||||
"\n"
|
||||
" Ctrl+p\n"
|
||||
" click on POWER (turn screen on/off)\n"
|
||||
"\n"
|
||||
" Right-click\n"
|
||||
" Right-click (when screen is off)\n"
|
||||
" turn screen on\n"
|
||||
"\n"
|
||||
" Ctrl+v\n"
|
||||
@ -87,6 +109,9 @@ static void usage(const char *arg0) {
|
||||
"\n"
|
||||
" Ctrl+i\n"
|
||||
" enable/disable FPS counter (print frames/second in logs)\n"
|
||||
"\n"
|
||||
" Drag & drop APK file\n"
|
||||
" install APK from computer\n"
|
||||
"\n",
|
||||
arg0,
|
||||
DEFAULT_BIT_RATE,
|
||||
@ -177,47 +202,53 @@ static SDL_bool parse_port(char *optarg, Uint16 *port) {
|
||||
|
||||
static SDL_bool parse_args(struct args *args, int argc, char *argv[]) {
|
||||
static const struct option long_options[] = {
|
||||
{"bit-rate", required_argument, NULL, 'b'},
|
||||
{"help", no_argument, NULL, 'h'},
|
||||
{"max-size", required_argument, NULL, 'm'},
|
||||
{"port", required_argument, NULL, 'p'},
|
||||
{"serial", required_argument, NULL, 's'},
|
||||
{"version", no_argument, NULL, 'v'},
|
||||
{NULL, 0, NULL, 0 },
|
||||
{"bit-rate", required_argument, NULL, 'b'},
|
||||
{"crop", required_argument, NULL, 'c'},
|
||||
{"fullscreen", no_argument, NULL, 'f'},
|
||||
{"help", no_argument, NULL, 'h'},
|
||||
{"max-size", required_argument, NULL, 'm'},
|
||||
{"port", required_argument, NULL, 'p'},
|
||||
{"serial", required_argument, NULL, 's'},
|
||||
{"show-touches", no_argument, NULL, 't'},
|
||||
{"version", no_argument, NULL, 'v'},
|
||||
{NULL, 0, NULL, 0 },
|
||||
};
|
||||
int c;
|
||||
while ((c = getopt_long(argc, argv, "b:hm:p:s:v", long_options, NULL)) != -1) {
|
||||
while ((c = getopt_long(argc, argv, "b:c:fhm:p:s:tv", long_options, NULL)) != -1) {
|
||||
switch (c) {
|
||||
case 'b': {
|
||||
case 'b':
|
||||
if (!parse_bit_rate(optarg, &args->bit_rate)) {
|
||||
return SDL_FALSE;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'h': {
|
||||
case 'c':
|
||||
args->crop = optarg;
|
||||
break;
|
||||
case 'f':
|
||||
args->fullscreen = SDL_TRUE;
|
||||
break;
|
||||
case 'h':
|
||||
args->help = SDL_TRUE;
|
||||
break;
|
||||
}
|
||||
case 'm': {
|
||||
case 'm':
|
||||
if (!parse_max_size(optarg, &args->max_size)) {
|
||||
return SDL_FALSE;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'p': {
|
||||
case 'p':
|
||||
if (!parse_port(optarg, &args->port)) {
|
||||
return SDL_FALSE;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 's': {
|
||||
case 's':
|
||||
args->serial = optarg;
|
||||
break;
|
||||
}
|
||||
case 'v': {
|
||||
case 't':
|
||||
args->show_touches = SDL_TRUE;
|
||||
break;
|
||||
case 'v':
|
||||
args->version = SDL_TRUE;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
// getopt prints the error message on stderr
|
||||
return SDL_FALSE;
|
||||
@ -233,10 +264,18 @@ static SDL_bool parse_args(struct args *args, int argc, char *argv[]) {
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
#ifdef __WINDOWS__
|
||||
// disable buffering, we want logs immediately
|
||||
// even line buffering (setvbuf() with mode _IOLBF) is not sufficient
|
||||
setbuf(stdout, NULL);
|
||||
setbuf(stderr, NULL);
|
||||
#endif
|
||||
struct args args = {
|
||||
.serial = NULL,
|
||||
.crop = NULL,
|
||||
.help = SDL_FALSE,
|
||||
.version = SDL_FALSE,
|
||||
.show_touches = SDL_FALSE,
|
||||
.port = DEFAULT_LOCAL_PORT,
|
||||
.max_size = DEFAULT_MAX_SIZE,
|
||||
.bit_rate = DEFAULT_BIT_RATE,
|
||||
@ -255,7 +294,9 @@ int main(int argc, char *argv[]) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58, 9, 100)
|
||||
av_register_all();
|
||||
#endif
|
||||
|
||||
if (avformat_network_init()) {
|
||||
return 1;
|
||||
@ -265,7 +306,16 @@ int main(int argc, char *argv[]) {
|
||||
SDL_LogSetAllPriority(SDL_LOG_PRIORITY_DEBUG);
|
||||
#endif
|
||||
|
||||
int res = scrcpy(args.serial, args.port, args.max_size, args.bit_rate) ? 0 : 1;
|
||||
struct scrcpy_options options = {
|
||||
.serial = args.serial,
|
||||
.crop = args.crop,
|
||||
.port = args.port,
|
||||
.max_size = args.max_size,
|
||||
.bit_rate = args.bit_rate,
|
||||
.show_touches = args.show_touches,
|
||||
.fullscreen = args.fullscreen,
|
||||
};
|
||||
int res = scrcpy(&options) ? 0 : 1;
|
||||
|
||||
avformat_network_deinit(); // ignore failure
|
||||
|
||||
|
@ -18,6 +18,26 @@
|
||||
typedef struct in_addr IN_ADDR;
|
||||
#endif
|
||||
|
||||
socket_t net_connect(Uint32 addr, Uint16 port) {
|
||||
socket_t sock = socket(AF_INET, SOCK_STREAM, 0);
|
||||
if (sock == INVALID_SOCKET) {
|
||||
perror("socket");
|
||||
return INVALID_SOCKET;
|
||||
}
|
||||
|
||||
SOCKADDR_IN sin;
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_addr.s_addr = htonl(addr);
|
||||
sin.sin_port = htons(port);
|
||||
|
||||
if (connect(sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
|
||||
perror("connect");
|
||||
return INVALID_SOCKET;
|
||||
}
|
||||
|
||||
return sock;
|
||||
}
|
||||
|
||||
socket_t net_listen(Uint32 addr, Uint16 port, int backlog) {
|
||||
socket_t sock = socket(AF_INET, SOCK_STREAM, 0);
|
||||
if (sock == INVALID_SOCKET) {
|
||||
@ -62,19 +82,19 @@ ssize_t net_recv_all(socket_t socket, void *buf, size_t len) {
|
||||
return recv(socket, buf, len, MSG_WAITALL);
|
||||
}
|
||||
|
||||
ssize_t net_send(socket_t socket, void *buf, size_t len) {
|
||||
ssize_t net_send(socket_t socket, const void *buf, size_t len) {
|
||||
return send(socket, buf, len, 0);
|
||||
}
|
||||
|
||||
ssize_t net_send_all(socket_t socket, void *buf, size_t len) {
|
||||
ssize_t w;
|
||||
ssize_t net_send_all(socket_t socket, const void *buf, size_t len) {
|
||||
ssize_t w = 0;
|
||||
while (len > 0) {
|
||||
w = send(socket, buf, len, 0);
|
||||
if (w == -1) {
|
||||
return -1;
|
||||
}
|
||||
len -= w;
|
||||
buf += w;
|
||||
buf = (char *) buf + w;
|
||||
}
|
||||
return w;
|
||||
}
|
||||
|
@ -9,8 +9,6 @@
|
||||
#define SHUT_RD SD_RECEIVE
|
||||
#define SHUT_WR SD_SEND
|
||||
#define SHUT_RDWR SD_BOTH
|
||||
typedef SIZE_T size_t;
|
||||
typedef SSIZE_T ssize_t;
|
||||
typedef SOCKET socket_t;
|
||||
#else
|
||||
# include <sys/socket.h>
|
||||
@ -21,14 +19,15 @@
|
||||
SDL_bool net_init(void);
|
||||
void net_cleanup(void);
|
||||
|
||||
socket_t net_connect(Uint32 addr, Uint16 port);
|
||||
socket_t net_listen(Uint32 addr, Uint16 port, int backlog);
|
||||
socket_t net_accept(socket_t server_socket);
|
||||
|
||||
// the _all versions wait/retry until len bytes have been written/read
|
||||
ssize_t net_recv(socket_t socket, void *buf, size_t len);
|
||||
ssize_t net_recv_all(socket_t socket, void *buf, size_t len);
|
||||
ssize_t net_send(socket_t socket, void *buf, size_t len);
|
||||
ssize_t net_send_all(socket_t socket, void *buf, size_t len);
|
||||
ssize_t net_send(socket_t socket, const void *buf, size_t len);
|
||||
ssize_t net_send_all(socket_t socket, const void *buf, size_t len);
|
||||
// how is SHUT_RD (read), SHUT_WR (write) or SHUT_RDWR (both)
|
||||
SDL_bool net_shutdown(socket_t socket, int how);
|
||||
SDL_bool net_close(socket_t socket);
|
||||
|
152
app/src/scrcpy.c
152
app/src/scrcpy.c
@ -13,21 +13,23 @@
|
||||
#include "decoder.h"
|
||||
#include "device.h"
|
||||
#include "events.h"
|
||||
#include "file_handler.h"
|
||||
#include "frames.h"
|
||||
#include "fpscounter.h"
|
||||
#include "inputmanager.h"
|
||||
#include "fps_counter.h"
|
||||
#include "input_manager.h"
|
||||
#include "log.h"
|
||||
#include "lockutil.h"
|
||||
#include "lock_util.h"
|
||||
#include "net.h"
|
||||
#include "screen.h"
|
||||
#include "server.h"
|
||||
#include "tinyxpm.h"
|
||||
#include "tiny_xpm.h"
|
||||
|
||||
static struct server server = SERVER_INITIALIZER;
|
||||
static struct screen screen = SCREEN_INITIALIZER;
|
||||
static struct frames frames;
|
||||
static struct decoder decoder;
|
||||
static struct controller controller;
|
||||
static struct file_handler file_handler;
|
||||
|
||||
static struct input_manager input_manager = {
|
||||
.controller = &controller,
|
||||
@ -35,16 +37,43 @@ static struct input_manager input_manager = {
|
||||
.screen = &screen,
|
||||
};
|
||||
|
||||
static void event_loop(void) {
|
||||
#if defined(__APPLE__) || defined(__WINDOWS__)
|
||||
# define CONTINUOUS_RESIZING_WORKAROUND
|
||||
#endif
|
||||
|
||||
#ifdef CONTINUOUS_RESIZING_WORKAROUND
|
||||
// On Windows and MacOS, resizing blocks the event loop, so resizing events are
|
||||
// not triggered. As a workaround, handle them in an event handler.
|
||||
//
|
||||
// <https://bugzilla.libsdl.org/show_bug.cgi?id=2077>
|
||||
// <https://stackoverflow.com/a/40693139/1987178>
|
||||
static int event_watcher(void *data, SDL_Event *event) {
|
||||
if (event->type == SDL_WINDOWEVENT && event->window.event == SDL_WINDOWEVENT_RESIZED) {
|
||||
// called from another thread, not very safe, but it's a workaround!
|
||||
screen_render(&screen);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
static SDL_bool is_apk(const char *file) {
|
||||
const char *ext = strrchr(file, '.');
|
||||
return ext && !strcmp(ext, ".apk");
|
||||
}
|
||||
|
||||
static SDL_bool event_loop(void) {
|
||||
#ifdef CONTINUOUS_RESIZING_WORKAROUND
|
||||
SDL_AddEventWatch(event_watcher, NULL);
|
||||
#endif
|
||||
SDL_Event event;
|
||||
while (SDL_WaitEvent(&event)) {
|
||||
switch (event.type) {
|
||||
case EVENT_DECODER_STOPPED:
|
||||
LOGD("Video decoder stopped");
|
||||
return;
|
||||
return SDL_FALSE;
|
||||
case SDL_QUIT:
|
||||
LOGD("User requested to quit");
|
||||
return;
|
||||
return SDL_TRUE;
|
||||
case EVENT_NEW_FRAME:
|
||||
if (!screen.has_frame) {
|
||||
screen.has_frame = SDL_TRUE;
|
||||
@ -52,21 +81,21 @@ static void event_loop(void) {
|
||||
screen_show_window(&screen);
|
||||
}
|
||||
if (!screen_update_frame(&screen, &frames)) {
|
||||
return;
|
||||
return SDL_FALSE;
|
||||
}
|
||||
break;
|
||||
case SDL_WINDOWEVENT:
|
||||
switch (event.window.event) {
|
||||
case SDL_WINDOWEVENT_EXPOSED:
|
||||
case SDL_WINDOWEVENT_SIZE_CHANGED:
|
||||
screen_render(&screen);
|
||||
break;
|
||||
case SDL_WINDOWEVENT_EXPOSED:
|
||||
case SDL_WINDOWEVENT_SIZE_CHANGED:
|
||||
screen_update_scale(&screen);
|
||||
screen_render(&screen);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case SDL_TEXTINPUT: {
|
||||
case SDL_TEXTINPUT:
|
||||
input_manager_process_text_input(&input_manager, &event.text);
|
||||
break;
|
||||
}
|
||||
case SDL_KEYDOWN:
|
||||
case SDL_KEYUP:
|
||||
input_manager_process_key(&input_manager, &event.key);
|
||||
@ -74,38 +103,69 @@ static void event_loop(void) {
|
||||
case SDL_MOUSEMOTION:
|
||||
input_manager_process_mouse_motion(&input_manager, &event.motion);
|
||||
break;
|
||||
case SDL_MOUSEWHEEL: {
|
||||
case SDL_MOUSEWHEEL:
|
||||
input_manager_process_mouse_wheel(&input_manager, &event.wheel);
|
||||
break;
|
||||
}
|
||||
case SDL_MOUSEBUTTONDOWN:
|
||||
case SDL_MOUSEBUTTONUP: {
|
||||
case SDL_MOUSEBUTTONUP:
|
||||
input_manager_process_mouse_button(&input_manager, &event.button);
|
||||
break;
|
||||
case SDL_DROPFILE: {
|
||||
file_handler_action_t action;
|
||||
if (is_apk(event.drop.file)) {
|
||||
action = ACTION_INSTALL_APK;
|
||||
} else {
|
||||
action = ACTION_PUSH_FILE;
|
||||
}
|
||||
file_handler_request(&file_handler, action, event.drop.file);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
SDL_bool scrcpy(const char *serial, Uint16 local_port, Uint16 max_size, Uint32 bit_rate) {
|
||||
if (!server_start(&server, serial, local_port, max_size, bit_rate)) {
|
||||
static process_t set_show_touches_enabled(const char *serial, SDL_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");
|
||||
}
|
||||
|
||||
SDL_bool scrcpy(const struct scrcpy_options *options) {
|
||||
if (!server_start(&server, options->serial, options->port,
|
||||
options->max_size, options->bit_rate, options->crop)) {
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
process_t proc_show_touches = PROCESS_NONE;
|
||||
SDL_bool show_touches_waited;
|
||||
if (options->show_touches) {
|
||||
LOGI("Enable show_touches");
|
||||
proc_show_touches = set_show_touches_enabled(options->serial, SDL_TRUE);
|
||||
show_touches_waited = SDL_FALSE;
|
||||
}
|
||||
|
||||
SDL_bool ret = SDL_TRUE;
|
||||
|
||||
if (!SDL_SetHint(SDL_HINT_NO_SIGNAL_HANDLERS, "1")) {
|
||||
LOGW("Cannot request to keep default signal handlers");
|
||||
}
|
||||
|
||||
if (!sdl_init_and_configure()) {
|
||||
ret = SDL_FALSE;
|
||||
goto finally_destroy_server;
|
||||
}
|
||||
|
||||
// SDL initialization replace the signal handler for SIGTERM, so Ctrl+C is
|
||||
// managed by the event loop. This blocking call blocks the event loop, so
|
||||
// timeout the connection not to block indefinitely in case of SIGTERM.
|
||||
#define SERVER_CONNECT_TIMEOUT_MS 2000
|
||||
socket_t device_socket = server_connect_to(&server, serial, SERVER_CONNECT_TIMEOUT_MS);
|
||||
socket_t device_socket = server_connect_to(&server);
|
||||
if (device_socket == INVALID_SOCKET) {
|
||||
server_stop(&server, serial);
|
||||
server_stop(&server);
|
||||
ret = SDL_FALSE;
|
||||
goto finally_destroy_server;
|
||||
}
|
||||
@ -117,25 +177,31 @@ SDL_bool scrcpy(const char *serial, Uint16 local_port, Uint16 max_size, Uint32 b
|
||||
// therefore, we transmit the screen size before the video stream, to be able
|
||||
// to init the window immediately
|
||||
if (!device_read_info(device_socket, device_name, &frame_size)) {
|
||||
server_stop(&server, serial);
|
||||
server_stop(&server);
|
||||
ret = SDL_FALSE;
|
||||
goto finally_destroy_server;
|
||||
}
|
||||
|
||||
if (!frames_init(&frames)) {
|
||||
server_stop(&server, serial);
|
||||
server_stop(&server);
|
||||
ret = SDL_FALSE;
|
||||
goto finally_destroy_server;
|
||||
}
|
||||
|
||||
if (!file_handler_init(&file_handler, server.serial)) {
|
||||
ret = SDL_FALSE;
|
||||
server_stop(&server);
|
||||
goto finally_destroy_frames;
|
||||
}
|
||||
|
||||
decoder_init(&decoder, &frames, device_socket);
|
||||
|
||||
// now we consumed the header values, the socket receives the video stream
|
||||
// start the decoder
|
||||
if (!decoder_start(&decoder)) {
|
||||
ret = SDL_FALSE;
|
||||
server_stop(&server, serial);
|
||||
goto finally_destroy_frames;
|
||||
server_stop(&server);
|
||||
goto finally_destroy_file_handler;
|
||||
}
|
||||
|
||||
if (!controller_init(&controller, device_socket)) {
|
||||
@ -153,10 +219,20 @@ SDL_bool scrcpy(const char *serial, Uint16 local_port, Uint16 max_size, Uint32 b
|
||||
goto finally_stop_and_join_controller;
|
||||
}
|
||||
|
||||
event_loop();
|
||||
if (options->show_touches) {
|
||||
wait_show_touches(proc_show_touches);
|
||||
show_touches_waited = SDL_TRUE;
|
||||
}
|
||||
|
||||
if (options->fullscreen) {
|
||||
screen_switch_fullscreen(&screen);
|
||||
}
|
||||
|
||||
ret = event_loop();
|
||||
LOGD("quit...");
|
||||
|
||||
screen_destroy(&screen);
|
||||
|
||||
finally_stop_and_join_controller:
|
||||
controller_stop(&controller);
|
||||
controller_join(&controller);
|
||||
@ -165,11 +241,25 @@ finally_destroy_controller:
|
||||
finally_stop_decoder:
|
||||
decoder_stop(&decoder);
|
||||
// stop the server before decoder_join() to wake up the decoder
|
||||
server_stop(&server, serial);
|
||||
server_stop(&server);
|
||||
decoder_join(&decoder);
|
||||
finally_destroy_file_handler:
|
||||
file_handler_stop(&file_handler);
|
||||
file_handler_join(&file_handler);
|
||||
file_handler_destroy(&file_handler);
|
||||
finally_destroy_frames:
|
||||
frames_destroy(&frames);
|
||||
finally_destroy_server:
|
||||
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, SDL_FALSE);
|
||||
wait_show_touches(proc_show_touches);
|
||||
}
|
||||
|
||||
server_destroy(&server);
|
||||
|
||||
return ret;
|
||||
|
@ -3,6 +3,16 @@
|
||||
|
||||
#include <SDL2/SDL_stdinc.h>
|
||||
|
||||
SDL_bool scrcpy(const char *serial, Uint16 local_port, Uint16 max_size, Uint32 bit_rate);
|
||||
struct scrcpy_options {
|
||||
const char *serial;
|
||||
const char *crop;
|
||||
Uint16 port;
|
||||
Uint16 max_size;
|
||||
Uint32 bit_rate;
|
||||
SDL_bool show_touches;
|
||||
SDL_bool fullscreen;
|
||||
};
|
||||
|
||||
SDL_bool scrcpy(const struct scrcpy_options *options);
|
||||
|
||||
#endif
|
||||
|
@ -4,9 +4,9 @@
|
||||
#include <string.h>
|
||||
|
||||
#include "icon.xpm"
|
||||
#include "lockutil.h"
|
||||
#include "lock_util.h"
|
||||
#include "log.h"
|
||||
#include "tinyxpm.h"
|
||||
#include "tiny_xpm.h"
|
||||
|
||||
#define DISPLAY_MARGINS 96
|
||||
|
||||
@ -18,8 +18,8 @@ SDL_bool sdl_init_and_configure(void) {
|
||||
|
||||
atexit(SDL_Quit);
|
||||
|
||||
// Bilinear resizing
|
||||
if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1")) {
|
||||
// Use the best available scale quality
|
||||
if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "2")) {
|
||||
LOGW("Could not enable bilinear filtering");
|
||||
}
|
||||
|
||||
@ -132,10 +132,26 @@ static inline struct size get_initial_optimal_size(struct size frame_size) {
|
||||
return get_optimal_size(frame_size, frame_size);
|
||||
}
|
||||
|
||||
// apply hidpi scaling and call SDL_RenderSetLogicalSize
|
||||
static inline SDL_bool render_set_scaled_logical_size(struct screen *screen, struct size size) {
|
||||
int w, h, dw, dh;
|
||||
SDL_GL_GetDrawableSize(screen->window, &w, &h);
|
||||
SDL_GetWindowSize(screen->window, &dw, &dh);
|
||||
// use 32 bits unsigned not to lose precision (width and height fit in 16 bits)
|
||||
int scaled_x = (Uint32) size.width * (Uint32) w / (Uint32) dw;
|
||||
int scaled_y = (Uint32) size.height * (Uint32) h / (Uint32) dh;
|
||||
return SDL_RenderSetLogicalSize(screen->renderer, scaled_x, scaled_y);
|
||||
}
|
||||
|
||||
void screen_init(struct screen *screen) {
|
||||
*screen = (struct screen) SCREEN_INITIALIZER;
|
||||
}
|
||||
|
||||
static inline SDL_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);
|
||||
}
|
||||
|
||||
SDL_bool screen_init_rendering(struct screen *screen, const char *device_name, struct size frame_size) {
|
||||
screen->frame_size = frame_size;
|
||||
|
||||
@ -158,7 +174,7 @@ SDL_bool screen_init_rendering(struct screen *screen, const char *device_name, s
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
if (SDL_RenderSetLogicalSize(screen->renderer, frame_size.width, frame_size.height)) {
|
||||
if (render_set_scaled_logical_size(screen, frame_size)) {
|
||||
LOGE("Could not set renderer logical size: %s", SDL_GetError());
|
||||
screen_destroy(screen);
|
||||
return SDL_FALSE;
|
||||
@ -174,8 +190,7 @@ SDL_bool screen_init_rendering(struct screen *screen, const char *device_name, s
|
||||
SDL_FreeSurface(icon);
|
||||
|
||||
LOGI("Initial texture: %" PRIu16 "x%" PRIu16, frame_size.width, frame_size.height);
|
||||
screen->texture = SDL_CreateTexture(screen->renderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING,
|
||||
frame_size.width, frame_size.height);
|
||||
screen->texture = create_texture(screen->renderer, frame_size);
|
||||
if (!screen->texture) {
|
||||
LOGC("Could not create texture: %s", SDL_GetError());
|
||||
screen_destroy(screen);
|
||||
@ -204,7 +219,7 @@ void screen_destroy(struct screen *screen) {
|
||||
// recreate the texture and resize the window if the frame size has changed
|
||||
static SDL_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) {
|
||||
if (SDL_RenderSetLogicalSize(screen->renderer, new_frame_size.width, new_frame_size.height)) {
|
||||
if (render_set_scaled_logical_size(screen, new_frame_size)) {
|
||||
LOGE("Could not set renderer logical size: %s", SDL_GetError());
|
||||
return SDL_FALSE;
|
||||
}
|
||||
@ -224,8 +239,7 @@ static SDL_bool prepare_for_frame(struct screen *screen, struct size new_frame_s
|
||||
|
||||
LOGD("New texture: %" PRIu16 "x%" PRIu16,
|
||||
screen->frame_size.width, screen->frame_size.height);
|
||||
screen->texture = SDL_CreateTexture(screen->renderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING,
|
||||
new_frame_size.width, new_frame_size.height);
|
||||
screen->texture = create_texture(screen->renderer, new_frame_size);
|
||||
if (!screen->texture) {
|
||||
LOGC("Could not create texture: %s", SDL_GetError());
|
||||
return SDL_FALSE;
|
||||
@ -299,3 +313,7 @@ void screen_resize_to_pixel_perfect(struct screen *screen) {
|
||||
LOGD("Resized to pixel-perfect");
|
||||
}
|
||||
}
|
||||
|
||||
void screen_update_scale(struct screen *screen) {
|
||||
render_set_scaled_logical_size(screen, screen->frame_size);
|
||||
}
|
||||
|
@ -66,4 +66,8 @@ void screen_resize_to_fit(struct screen *screen);
|
||||
// resize window to 1:1 (pixel-perfect)
|
||||
void screen_resize_to_pixel_perfect(struct screen *screen);
|
||||
|
||||
// recompute the scale in case the window moved from/to another screen with a
|
||||
// different HiDPI
|
||||
void screen_update_scale(struct screen *screen);
|
||||
|
||||
#endif
|
||||
|
157
app/src/server.c
157
app/src/server.c
@ -3,7 +3,9 @@
|
||||
#include <errno.h>
|
||||
#include <inttypes.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <SDL2/SDL_assert.h>
|
||||
#include <SDL2/SDL_timer.h>
|
||||
|
||||
#include "config.h"
|
||||
#include "log.h"
|
||||
@ -37,17 +39,46 @@ static SDL_bool remove_server(const char *serial) {
|
||||
return process_check_success(process, "adb shell rm");
|
||||
}
|
||||
|
||||
static SDL_bool enable_tunnel(const char *serial, Uint16 local_port) {
|
||||
static SDL_bool enable_tunnel_reverse(const char *serial, Uint16 local_port) {
|
||||
process_t process = adb_reverse(serial, SOCKET_NAME, local_port);
|
||||
return process_check_success(process, "adb reverse");
|
||||
}
|
||||
|
||||
static SDL_bool disable_tunnel(const char *serial) {
|
||||
static SDL_bool disable_tunnel_reverse(const char *serial) {
|
||||
process_t process = adb_reverse_remove(serial, SOCKET_NAME);
|
||||
return process_check_success(process, "adb reverse --remove");
|
||||
}
|
||||
|
||||
static process_t execute_server(const char *serial, Uint16 max_size, Uint32 bit_rate) {
|
||||
static SDL_bool enable_tunnel_forward(const char *serial, Uint16 local_port) {
|
||||
process_t process = adb_forward(serial, local_port, SOCKET_NAME);
|
||||
return process_check_success(process, "adb forward");
|
||||
}
|
||||
|
||||
static SDL_bool disable_tunnel_forward(const char *serial, Uint16 local_port) {
|
||||
process_t process = adb_forward_remove(serial, local_port);
|
||||
return process_check_success(process, "adb forward --remove");
|
||||
}
|
||||
|
||||
static SDL_bool enable_tunnel(struct server *server) {
|
||||
if (enable_tunnel_reverse(server->serial, server->local_port)) {
|
||||
return SDL_TRUE;
|
||||
}
|
||||
|
||||
LOGW("'adb reverse' failed, fallback to 'adb forward'");
|
||||
server->tunnel_forward = SDL_TRUE;
|
||||
return enable_tunnel_forward(server->serial, server->local_port);
|
||||
}
|
||||
|
||||
static SDL_bool disable_tunnel(struct server *server) {
|
||||
if (server->tunnel_forward) {
|
||||
return disable_tunnel_forward(server->serial, server->local_port);
|
||||
}
|
||||
return disable_tunnel_reverse(server->serial);
|
||||
}
|
||||
|
||||
static process_t execute_server(const char *serial,
|
||||
Uint16 max_size, Uint32 bit_rate,
|
||||
const char *crop, SDL_bool tunnel_forward) {
|
||||
char max_size_string[6];
|
||||
char bit_rate_string[11];
|
||||
sprintf(max_size_string, "%"PRIu16, max_size);
|
||||
@ -60,15 +91,49 @@ static process_t execute_server(const char *serial, Uint16 max_size, Uint32 bit_
|
||||
"com.genymobile.scrcpy.Server",
|
||||
max_size_string,
|
||||
bit_rate_string,
|
||||
tunnel_forward ? "true" : "false",
|
||||
crop ? crop : "",
|
||||
};
|
||||
return adb_execute(serial, cmd, sizeof(cmd) / sizeof(cmd[0]));
|
||||
}
|
||||
|
||||
static socket_t listen_on_port(Uint16 port) {
|
||||
#define IPV4_LOCALHOST 0x7F000001
|
||||
|
||||
static socket_t listen_on_port(Uint16 port) {
|
||||
return net_listen(IPV4_LOCALHOST, port, 1);
|
||||
}
|
||||
|
||||
static socket_t connect_and_read_byte(Uint16 port) {
|
||||
socket_t socket = net_connect(IPV4_LOCALHOST, port);
|
||||
if (socket == INVALID_SOCKET) {
|
||||
return INVALID_SOCKET;
|
||||
}
|
||||
|
||||
char byte;
|
||||
// the connection may succeed even if the server behind the "adb tunnel"
|
||||
// is not listening, so read one byte to detect a working connection
|
||||
if (net_recv_all(socket, &byte, 1) != 1) {
|
||||
// the server is not listening yet behind the adb tunnel
|
||||
return INVALID_SOCKET;
|
||||
}
|
||||
return socket;
|
||||
}
|
||||
|
||||
static socket_t connect_to_server(Uint16 port, Uint32 attempts, Uint32 delay) {
|
||||
do {
|
||||
LOGD("Remaining connection attempts: %d", (int) attempts);
|
||||
socket_t socket = connect_and_read_byte(port);
|
||||
if (socket != INVALID_SOCKET) {
|
||||
// it worked!
|
||||
return socket;
|
||||
}
|
||||
if (attempts) {
|
||||
SDL_Delay(delay);
|
||||
}
|
||||
} while (--attempts > 0);
|
||||
return INVALID_SOCKET;
|
||||
}
|
||||
|
||||
static void close_socket(socket_t *socket) {
|
||||
SDL_assert(*socket != INVALID_SOCKET);
|
||||
net_shutdown(*socket, SHUT_RDWR);
|
||||
@ -84,64 +149,93 @@ void server_init(struct server *server) {
|
||||
}
|
||||
|
||||
SDL_bool server_start(struct server *server, const char *serial, Uint16 local_port,
|
||||
Uint16 max_size, Uint32 bit_rate) {
|
||||
Uint16 max_size, Uint32 bit_rate, const char *crop) {
|
||||
server->local_port = local_port;
|
||||
|
||||
if (serial) {
|
||||
server->serial = SDL_strdup(serial);
|
||||
if (!server->serial) {
|
||||
return SDL_FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
if (!push_server(serial)) {
|
||||
SDL_free((void *) server->serial);
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
server->server_copied_to_device = SDL_TRUE;
|
||||
|
||||
if (!enable_tunnel(serial, local_port)) {
|
||||
if (!enable_tunnel(server)) {
|
||||
SDL_free((void *) server->serial);
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
// At the application level, the device part is "the server" because it
|
||||
// serves video stream and control. However, at the network level, the
|
||||
// client listens and the server connects to the client. That way, the
|
||||
// client can listen before starting the server app, so there is no need to
|
||||
// try to connect until the server socket is listening on the device.
|
||||
// if "adb reverse" does not work (e.g. over "adb connect"), it fallbacks to
|
||||
// "adb forward", so the app socket is the client
|
||||
if (!server->tunnel_forward) {
|
||||
// At the application level, the device part is "the server" because it
|
||||
// serves video stream and control. However, at the network level, the
|
||||
// client listens and the server connects to the client. That way, the
|
||||
// client can listen before starting the server app, so there is no need to
|
||||
// try to connect until the server socket is listening on the device.
|
||||
|
||||
server->server_socket = listen_on_port(local_port);
|
||||
if (server->server_socket == INVALID_SOCKET) {
|
||||
LOGE("Could not listen on port %" PRIu16, local_port);
|
||||
disable_tunnel(serial);
|
||||
return SDL_FALSE;
|
||||
server->server_socket = listen_on_port(local_port);
|
||||
if (server->server_socket == INVALID_SOCKET) {
|
||||
LOGE("Could not listen on port %" PRIu16, local_port);
|
||||
disable_tunnel(server);
|
||||
SDL_free((void *) server->serial);
|
||||
return SDL_FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
// server will connect to our server socket
|
||||
server->process = execute_server(serial, max_size, bit_rate);
|
||||
server->process = execute_server(serial, max_size, bit_rate, crop,
|
||||
server->tunnel_forward);
|
||||
if (server->process == PROCESS_NONE) {
|
||||
close_socket(&server->server_socket);
|
||||
disable_tunnel(serial);
|
||||
if (!server->tunnel_forward) {
|
||||
close_socket(&server->server_socket);
|
||||
}
|
||||
disable_tunnel(server);
|
||||
SDL_free((void *) server->serial);
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
server->adb_reverse_enabled = SDL_TRUE;
|
||||
server->tunnel_enabled = SDL_TRUE;
|
||||
|
||||
return SDL_TRUE;
|
||||
}
|
||||
|
||||
socket_t server_connect_to(struct server *server, const char *serial, Uint32 timeout_ms) {
|
||||
server->device_socket = net_accept(server->server_socket);
|
||||
socket_t server_connect_to(struct server *server) {
|
||||
if (!server->tunnel_forward) {
|
||||
server->device_socket = net_accept(server->server_socket);
|
||||
} else {
|
||||
Uint32 attempts = 100;
|
||||
Uint32 delay = 100; // ms
|
||||
server->device_socket = connect_to_server(server->local_port, attempts, delay);
|
||||
}
|
||||
|
||||
if (server->device_socket == INVALID_SOCKET) {
|
||||
return INVALID_SOCKET;
|
||||
}
|
||||
|
||||
// we don't need the server socket anymore
|
||||
close_socket(&server->server_socket);
|
||||
if (!server->tunnel_forward) {
|
||||
// we don't need the server socket anymore
|
||||
close_socket(&server->server_socket);
|
||||
}
|
||||
|
||||
// the server is started, we can clean up the jar from the temporary folder
|
||||
remove_server(serial); // ignore failure
|
||||
remove_server(server->serial); // ignore failure
|
||||
server->server_copied_to_device = SDL_FALSE;
|
||||
|
||||
// we don't need the adb tunnel anymore
|
||||
disable_tunnel(serial); // ignore failure
|
||||
server->adb_reverse_enabled = SDL_FALSE;
|
||||
disable_tunnel(server); // ignore failure
|
||||
server->tunnel_enabled = SDL_FALSE;
|
||||
|
||||
return server->device_socket;
|
||||
}
|
||||
|
||||
void server_stop(struct server *server, const char *serial) {
|
||||
void server_stop(struct server *server) {
|
||||
SDL_assert(server->process != PROCESS_NONE);
|
||||
|
||||
if (!cmd_terminate(server->process)) {
|
||||
@ -151,13 +245,13 @@ void server_stop(struct server *server, const char *serial) {
|
||||
cmd_simple_wait(server->process, NULL); // ignore exit code
|
||||
LOGD("Server terminated");
|
||||
|
||||
if (server->adb_reverse_enabled) {
|
||||
if (server->tunnel_enabled) {
|
||||
// ignore failure
|
||||
disable_tunnel(serial);
|
||||
disable_tunnel(server);
|
||||
}
|
||||
|
||||
if (server->server_copied_to_device) {
|
||||
remove_server(serial); // ignore failure
|
||||
remove_server(server->serial); // ignore failure
|
||||
}
|
||||
}
|
||||
|
||||
@ -168,4 +262,5 @@ void server_destroy(struct server *server) {
|
||||
if (server->device_socket != INVALID_SOCKET) {
|
||||
close_socket(&server->device_socket);
|
||||
}
|
||||
SDL_free((void *) server->serial);
|
||||
}
|
||||
|
@ -5,18 +5,24 @@
|
||||
#include "net.h"
|
||||
|
||||
struct server {
|
||||
const char *serial;
|
||||
process_t process;
|
||||
socket_t server_socket;
|
||||
socket_t server_socket; // only used if !tunnel_forward
|
||||
socket_t device_socket;
|
||||
SDL_bool adb_reverse_enabled;
|
||||
Uint16 local_port;
|
||||
SDL_bool tunnel_enabled;
|
||||
SDL_bool tunnel_forward; // use "adb forward" instead of "adb reverse"
|
||||
SDL_bool server_copied_to_device;
|
||||
};
|
||||
|
||||
#define SERVER_INITIALIZER { \
|
||||
.serial = NULL, \
|
||||
.process = PROCESS_NONE, \
|
||||
.server_socket = INVALID_SOCKET, \
|
||||
.device_socket = INVALID_SOCKET, \
|
||||
.adb_reverse_enabled = SDL_FALSE, \
|
||||
.local_port = 0, \
|
||||
.tunnel_enabled = SDL_FALSE, \
|
||||
.tunnel_forward = SDL_FALSE, \
|
||||
.server_copied_to_device = SDL_FALSE, \
|
||||
}
|
||||
|
||||
@ -25,13 +31,13 @@ void server_init(struct server *server);
|
||||
|
||||
// push, enable tunnel et start the server
|
||||
SDL_bool server_start(struct server *server, const char *serial, Uint16 local_port,
|
||||
Uint16 max_size, Uint32 bit_rate);
|
||||
Uint16 max_size, Uint32 bit_rate, const char *crop);
|
||||
|
||||
// block until the communication with the server is established
|
||||
socket_t server_connect_to(struct server *server, const char *serial, Uint32 timeout_ms);
|
||||
socket_t server_connect_to(struct server *server);
|
||||
|
||||
// disconnect and kill the server process
|
||||
void server_stop(struct server *server, const char *serial);
|
||||
void server_stop(struct server *server);
|
||||
|
||||
// close and release sockets
|
||||
void server_destroy(struct server *server);
|
||||
|
@ -1,4 +1,4 @@
|
||||
#include "strutil.h"
|
||||
#include "str_util.h"
|
||||
|
||||
size_t xstrncpy(char *dest, const char *src, size_t n) {
|
||||
size_t i;
|
@ -1,25 +1,80 @@
|
||||
#include "../../command.h"
|
||||
#include "command.h"
|
||||
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <signal.h>
|
||||
#include <stdlib.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/wait.h>
|
||||
#include <unistd.h>
|
||||
#include "log.h"
|
||||
|
||||
pid_t cmd_execute(const char *path, const char *const argv[]) {
|
||||
pid_t pid = fork();
|
||||
if (pid == -1) {
|
||||
perror("fork");
|
||||
return -1;
|
||||
enum process_result cmd_execute(const char *path, const char *const argv[], pid_t *pid) {
|
||||
int fd[2];
|
||||
|
||||
if (pipe(fd) == -1) {
|
||||
perror("pipe");
|
||||
return PROCESS_ERROR_GENERIC;
|
||||
}
|
||||
if (pid == 0) {
|
||||
execvp(path, (char *const *)argv);
|
||||
perror("exec");
|
||||
|
||||
enum process_result ret = PROCESS_SUCCESS;
|
||||
|
||||
*pid = fork();
|
||||
if (*pid == -1) {
|
||||
perror("fork");
|
||||
ret = PROCESS_ERROR_GENERIC;
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (*pid > 0) {
|
||||
// parent close write side
|
||||
close(fd[1]);
|
||||
fd[1] = -1;
|
||||
// wait for EOF or receive errno from child
|
||||
if (read(fd[0], &ret, sizeof(ret)) == -1) {
|
||||
perror("read");
|
||||
ret = PROCESS_ERROR_GENERIC;
|
||||
goto end;
|
||||
}
|
||||
} else if (*pid == 0) {
|
||||
// child close read side
|
||||
close(fd[0]);
|
||||
if (fcntl(fd[1], F_SETFD, FD_CLOEXEC) == 0) {
|
||||
execvp(path, (char *const *)argv);
|
||||
if (errno == ENOENT) {
|
||||
ret = PROCESS_ERROR_MISSING_BINARY;
|
||||
} else {
|
||||
ret = PROCESS_ERROR_GENERIC;
|
||||
}
|
||||
perror("exec");
|
||||
} else {
|
||||
perror("fcntl");
|
||||
ret = PROCESS_ERROR_GENERIC;
|
||||
}
|
||||
// send ret to the parent
|
||||
if (write(fd[1], &ret, sizeof(ret)) == -1) {
|
||||
perror("write");
|
||||
}
|
||||
// close write side before exiting
|
||||
close(fd[1]);
|
||||
_exit(1);
|
||||
}
|
||||
return pid;
|
||||
|
||||
end:
|
||||
if (fd[0] != -1) {
|
||||
close(fd[0]);
|
||||
}
|
||||
if (fd[1] != -1) {
|
||||
close(fd[1]);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
SDL_bool cmd_terminate(pid_t pid) {
|
||||
if (pid <= 0) {
|
||||
LOGC("Requested to kill %d, this is an error. Please report the bug.\n", (int) pid);
|
||||
abort();
|
||||
}
|
||||
return kill(pid, SIGTERM) != -1;
|
||||
}
|
||||
|
||||
|
@ -1,4 +1,4 @@
|
||||
#include "../../net.h"
|
||||
#include "net.h"
|
||||
|
||||
# include <unistd.h>
|
||||
|
||||
|
@ -1,9 +1,10 @@
|
||||
#include "../../command.h"
|
||||
#include "command.h"
|
||||
|
||||
#include "../../log.h"
|
||||
#include "../../strutil.h"
|
||||
#include "config.h"
|
||||
#include "log.h"
|
||||
#include "str_util.h"
|
||||
|
||||
HANDLE cmd_execute(const char *path, const char *const argv[]) {
|
||||
enum process_result cmd_execute(const char *path, const char *const argv[], HANDLE *handle) {
|
||||
STARTUPINFO si;
|
||||
PROCESS_INFORMATION pi;
|
||||
memset(&si, 0, sizeof(si));
|
||||
@ -17,14 +18,25 @@ HANDLE cmd_execute(const char *path, const char *const argv[]) {
|
||||
size_t ret = xstrjoin(cmd, argv, ' ', sizeof(cmd));
|
||||
if (ret >= sizeof(cmd)) {
|
||||
LOGE("Command too long (%" PRIsizet " chars)", sizeof(cmd) - 1);
|
||||
return NULL;
|
||||
*handle = NULL;
|
||||
return PROCESS_ERROR_GENERIC;
|
||||
}
|
||||
|
||||
if (!CreateProcess(NULL, cmd, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi)) {
|
||||
return NULL;
|
||||
#ifdef WINDOWS_NOCONSOLE
|
||||
int flags = CREATE_NO_WINDOW;
|
||||
#else
|
||||
int flags = 0;
|
||||
#endif
|
||||
if (!CreateProcess(NULL, cmd, NULL, NULL, FALSE, flags, NULL, NULL, &si, &pi)) {
|
||||
*handle = NULL;
|
||||
if (GetLastError() == ERROR_FILE_NOT_FOUND) {
|
||||
return PROCESS_ERROR_MISSING_BINARY;
|
||||
}
|
||||
return PROCESS_ERROR_GENERIC;
|
||||
}
|
||||
|
||||
return pi.hProcess;
|
||||
*handle = pi.hProcess;
|
||||
return PROCESS_SUCCESS;
|
||||
}
|
||||
|
||||
SDL_bool cmd_terminate(HANDLE handle) {
|
||||
|
@ -1,6 +1,6 @@
|
||||
#include "../../net.h"
|
||||
#include "net.h"
|
||||
|
||||
#include "../../log.h"
|
||||
#include "log.h"
|
||||
|
||||
SDL_bool net_init(void) {
|
||||
WSADATA wsa;
|
||||
|
@ -1,4 +1,4 @@
|
||||
#include "tinyxpm.h"
|
||||
#include "tiny_xpm.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
@ -40,15 +40,15 @@ SDL_Surface *read_xpm(char *xpm[]) {
|
||||
// *** No error handling, assume the XPM source is valid ***
|
||||
// (it's in our source repo)
|
||||
// Assertions are only checked in debug
|
||||
Uint32 width = strtol(xpm[0], &endptr, 10);
|
||||
Uint32 height = strtol(endptr + 1, &endptr, 10);
|
||||
Uint32 colors = strtol(endptr + 1, &endptr, 10);
|
||||
Uint32 chars = strtol(endptr + 1, &endptr, 10);
|
||||
int width = strtol(xpm[0], &endptr, 10);
|
||||
int height = strtol(endptr + 1, &endptr, 10);
|
||||
int colors = strtol(endptr + 1, &endptr, 10);
|
||||
int chars = strtol(endptr + 1, &endptr, 10);
|
||||
|
||||
// sanity checks
|
||||
SDL_assert(width < 256);
|
||||
SDL_assert(height < 256);
|
||||
SDL_assert(colors < 256);
|
||||
SDL_assert(0 <= width && width < 256);
|
||||
SDL_assert(0 <= height && height < 256);
|
||||
SDL_assert(0 <= colors && colors < 256);
|
||||
SDL_assert(chars == 1); // this implementation does not support more
|
||||
|
||||
// init index
|
@ -1,6 +1,7 @@
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "controlevent.h"
|
||||
#include "control_event.h"
|
||||
|
||||
static void test_control_event_queue_empty() {
|
||||
struct control_event_queue queue;
|
||||
|
@ -1,6 +1,7 @@
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "controlevent.h"
|
||||
#include "control_event.h"
|
||||
|
||||
static void test_serialize_keycode_event() {
|
||||
struct control_event event = {
|
||||
@ -35,16 +36,36 @@ static void test_serialize_text_event() {
|
||||
|
||||
unsigned char buf[SERIALIZED_EVENT_MAX_SIZE];
|
||||
int size = control_event_serialize(&event, buf);
|
||||
assert(size == 15);
|
||||
assert(size == 16);
|
||||
|
||||
const unsigned char expected[] = {
|
||||
0x01, // CONTROL_EVENT_TYPE_KEYCODE
|
||||
0x0d, // text length
|
||||
0x00, 0x0d, // text length
|
||||
'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', // text
|
||||
};
|
||||
assert(!memcmp(buf, expected, sizeof(expected)));
|
||||
}
|
||||
|
||||
static void test_serialize_long_text_event() {
|
||||
struct control_event event;
|
||||
event.type = CONTROL_EVENT_TYPE_TEXT;
|
||||
char text[TEXT_MAX_LENGTH];
|
||||
memset(text, 'a', sizeof(text));
|
||||
event.text_event.text = text;
|
||||
|
||||
unsigned char buf[SERIALIZED_EVENT_MAX_SIZE];
|
||||
int size = control_event_serialize(&event, buf);
|
||||
assert(size == 3 + sizeof(text));
|
||||
|
||||
unsigned char expected[3 + TEXT_MAX_LENGTH];
|
||||
expected[0] = 0x01; // CONTROL_EVENT_TYPE_KEYCODE
|
||||
expected[1] = 0x01;
|
||||
expected[2] = 0x2c; // text length (16 bits)
|
||||
memset(&expected[3], 'a', TEXT_MAX_LENGTH);
|
||||
|
||||
assert(!memcmp(buf, expected, sizeof(expected)));
|
||||
}
|
||||
|
||||
static void test_serialize_mouse_event() {
|
||||
struct control_event event = {
|
||||
.type = CONTROL_EVENT_TYPE_MOUSE,
|
||||
@ -114,6 +135,7 @@ static void test_serialize_scroll_event() {
|
||||
int main() {
|
||||
test_serialize_keycode_event();
|
||||
test_serialize_text_event();
|
||||
test_serialize_long_text_event();
|
||||
test_serialize_mouse_event();
|
||||
test_serialize_scroll_event();
|
||||
return 0;
|
||||
|
@ -1,7 +1,7 @@
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "strutil.h"
|
||||
#include "str_util.h"
|
||||
|
||||
static void test_xstrncpy_simple() {
|
||||
char s[] = "xxxxxxxxxx";
|
||||
|
@ -7,7 +7,7 @@ buildscript {
|
||||
jcenter()
|
||||
}
|
||||
dependencies {
|
||||
classpath 'com.android.tools.build:gradle:3.0.1'
|
||||
classpath 'com.android.tools.build:gradle:3.1.1'
|
||||
|
||||
// NOTE: Do not place your application dependencies here; they belong
|
||||
// in the individual module build.gradle files
|
||||
|
20
cross_win32.txt
Normal file
20
cross_win32.txt
Normal file
@ -0,0 +1,20 @@
|
||||
# apt install mingw-w64 mingw-w64-tools
|
||||
|
||||
[binaries]
|
||||
name = 'mingw'
|
||||
c = '/usr/bin/i686-w64-mingw32-gcc'
|
||||
cpp = '/usr/bin/i686-w64-mingw32-g++'
|
||||
ar = '/usr/bin/i686-w64-mingw32-ar'
|
||||
strip = '/usr/bin/i686-w64-mingw32-strip'
|
||||
pkgconfig = '/usr/bin/i686-w64-mingw32-pkg-config'
|
||||
|
||||
[host_machine]
|
||||
system = 'windows'
|
||||
cpu_family = 'x86'
|
||||
cpu = 'i686'
|
||||
endian = 'little'
|
||||
|
||||
[properties]
|
||||
prebuilt_ffmpeg_shared = 'ffmpeg-4.0.2-win32-shared'
|
||||
prebuilt_ffmpeg_dev = 'ffmpeg-4.0.2-win32-dev'
|
||||
prebuilt_sdl2 = 'SDL2-2.0.8/i686-w64-mingw32'
|
20
cross_win64.txt
Normal file
20
cross_win64.txt
Normal file
@ -0,0 +1,20 @@
|
||||
# apt install mingw-w64 mingw-w64-tools
|
||||
|
||||
[binaries]
|
||||
name = 'mingw'
|
||||
c = '/usr/bin/x86_64-w64-mingw32-gcc'
|
||||
cpp = '/usr/bin/x86_64-w64-mingw32-g++'
|
||||
ar = '/usr/bin/x86_64-w64-mingw32-ar'
|
||||
strip = '/usr/bin/x86_64-w64-mingw32-strip'
|
||||
pkgconfig = '/usr/bin/x86_64-w64-mingw32-pkg-config'
|
||||
|
||||
[host_machine]
|
||||
system = 'windows'
|
||||
cpu_family = 'x86'
|
||||
cpu = 'x86_64'
|
||||
endian = 'little'
|
||||
|
||||
[properties]
|
||||
prebuilt_ffmpeg_shared = 'ffmpeg-4.0.2-win64-shared'
|
||||
prebuilt_ffmpeg_dev = 'ffmpeg-4.0.2-win64-dev'
|
||||
prebuilt_sdl2 = 'SDL2-2.0.8/x86_64-w64-mingw32'
|
4
gradle/wrapper/gradle-wrapper.properties
vendored
4
gradle/wrapper/gradle-wrapper.properties
vendored
@ -1,6 +1,6 @@
|
||||
#Mon Jan 29 16:38:49 CET 2018
|
||||
#Mon Jun 04 11:48:32 CEST 2018
|
||||
distributionBase=GRADLE_USER_HOME
|
||||
distributionPath=wrapper/dists
|
||||
zipStoreBase=GRADLE_USER_HOME
|
||||
zipStorePath=wrapper/dists
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-4.1-all.zip
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-4.4-all.zip
|
||||
|
@ -1,4 +1,4 @@
|
||||
project('scrcpy', 'c', meson_version: '>= 0.37')
|
||||
project('scrcpy', 'c', meson_version: '>= 0.37', default_options : 'c_std=c11')
|
||||
|
||||
if get_option('build_app')
|
||||
subdir('app')
|
||||
|
@ -1,5 +1,7 @@
|
||||
option('build_app', type: 'boolean', value: true, description: 'Build the client')
|
||||
option('build_server', type: 'boolean', value: true, description: 'Build the server')
|
||||
option('crossbuild_windows', type: 'boolean', value: false, description: 'Build for Windows from Linux')
|
||||
option('windows_noconsole', type: 'boolean', value: false, description: 'Disable console on Windows (pass -mwindows flag)')
|
||||
option('prebuilt_server', type: 'string', description: 'Path of the prebuilt server')
|
||||
option('override_server_path', type: 'string', description: 'Hardcoded path to find the server at runtime')
|
||||
option('skip_frames', type: 'boolean', value: true, description: 'Always display the most recent frame')
|
||||
|
4
prebuilt-deps/.gitignore
vendored
Normal file
4
prebuilt-deps/.gitignore
vendored
Normal file
@ -0,0 +1,4 @@
|
||||
*
|
||||
!/.gitignore
|
||||
!/Makefile
|
||||
!/prepare-dep
|
40
prebuilt-deps/Makefile
Normal file
40
prebuilt-deps/Makefile
Normal file
@ -0,0 +1,40 @@
|
||||
.PHONY: prepare-win32 prepare-win64 \
|
||||
prepare-ffmpeg-shared-win32 \
|
||||
prepare-ffmpeg-dev-win32 \
|
||||
prepare-ffmpeg-shared-win64 \
|
||||
prepare-ffmpeg-dev-win64 \
|
||||
prepare-sdl2 \
|
||||
prepare-adb
|
||||
|
||||
prepare-win32: prepare-sdl2 prepare-ffmpeg-shared-win32 prepare-ffmpeg-dev-win32 prepare-adb
|
||||
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.0.2-win32-shared.zip \
|
||||
cc190a3a4cf7bfbd4fbaa92609c1501a1de458055e6cfea8b745c1d515013aa8 \
|
||||
ffmpeg-4.0.2-win32-shared
|
||||
|
||||
prepare-ffmpeg-dev-win32:
|
||||
@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/dev/ffmpeg-4.0.2-win32-dev.zip \
|
||||
c72c74bad74ac0541f1b43090c26a50017c49041c182a703abd2057bb8cdc238 \
|
||||
ffmpeg-4.0.2-win32-dev
|
||||
|
||||
prepare-ffmpeg-shared-win64:
|
||||
@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/shared/ffmpeg-4.0.2-win64-shared.zip \
|
||||
ede566aca8b5348dff85570f9638c6bad33209f9419f79db7bde7daa37599bff \
|
||||
ffmpeg-4.0.2-win64-shared
|
||||
|
||||
prepare-ffmpeg-dev-win64:
|
||||
@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/dev/ffmpeg-4.0.2-win64-dev.zip \
|
||||
23ee994161c51285cb956b98d3caa499d48083dae7b26c1fdf77f22e98df1c5f \
|
||||
ffmpeg-4.0.2-win64-dev
|
||||
|
||||
prepare-sdl2:
|
||||
@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.8-mingw.tar.gz \
|
||||
ffff7305d634aff5e1df5b7bb935435c3a02c8b03ad94a1a2be9169a558a7961 \
|
||||
SDL2-2.0.8
|
||||
|
||||
prepare-adb:
|
||||
@./prepare-dep https://dl.google.com/android/repository/platform-tools_r28.0.0-windows.zip \
|
||||
e2c1ec7c8e9b71cf1c8befd3bff91d06b26dd334c3f32b3817e9d46ba260b0e8 \
|
||||
platform-tools
|
58
prebuilt-deps/prepare-dep
Executable file
58
prebuilt-deps/prepare-dep
Executable file
@ -0,0 +1,58 @@
|
||||
#!/bin/bash
|
||||
set -e
|
||||
url="$1"
|
||||
sum="$2"
|
||||
dir="$3"
|
||||
|
||||
checksum() {
|
||||
local file="$1"
|
||||
local sum="$2"
|
||||
echo "$file: verifying checksum..."
|
||||
echo "$sum $file" | sha256sum -c
|
||||
}
|
||||
|
||||
get_file() {
|
||||
local url="$1"
|
||||
local file="$2"
|
||||
local sum="$3"
|
||||
if [[ -f "$file" ]]
|
||||
then
|
||||
echo "$file: found"
|
||||
else
|
||||
echo "$file: not found, downloading..."
|
||||
wget "$url" -O "$file"
|
||||
fi
|
||||
checksum "$file" "$sum"
|
||||
}
|
||||
|
||||
extract() {
|
||||
local file="$1"
|
||||
echo "Extracting $file..."
|
||||
if [[ "$file" == *.zip ]]
|
||||
then
|
||||
unzip -q "$file"
|
||||
elif [[ "$file" == *.tar.gz ]]
|
||||
then
|
||||
tar xf "$file"
|
||||
else
|
||||
echo "Unsupported file: $file"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
get_dep() {
|
||||
local url="$1"
|
||||
local sum="$2"
|
||||
local dir="$3"
|
||||
local file="${url##*/}"
|
||||
if [[ -d "$dir" ]]
|
||||
then
|
||||
echo "$dir: found"
|
||||
else
|
||||
echo "$dir: not found"
|
||||
get_file "$url" "$file" "$sum"
|
||||
extract "$file"
|
||||
fi
|
||||
}
|
||||
|
||||
get_dep "$1" "$2" "$3"
|
@ -6,8 +6,8 @@ android {
|
||||
applicationId "com.genymobile.scrcpy"
|
||||
minSdkVersion 21
|
||||
targetSdkVersion 27
|
||||
versionCode 1
|
||||
versionName "1.0"
|
||||
versionCode 4
|
||||
versionName "1.3"
|
||||
testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
|
||||
}
|
||||
buildTypes {
|
||||
|
@ -11,7 +11,7 @@ public final class ControlEvent {
|
||||
public static final int TYPE_SCROLL = 3;
|
||||
public static final int TYPE_COMMAND = 4;
|
||||
|
||||
public static final int COMMAND_SCREEN_ON = 0;
|
||||
public static final int COMMAND_BACK_OR_SCREEN_ON = 0;
|
||||
|
||||
private int type;
|
||||
private String text;
|
||||
|
@ -13,8 +13,8 @@ public class ControlEventReader {
|
||||
private static final int SCROLL_PAYLOAD_LENGTH = 16;
|
||||
private static final int COMMAND_PAYLOAD_LENGTH = 1;
|
||||
|
||||
private static final int TEXT_MAX_LENGTH = 256;
|
||||
private static final int RAW_BUFFER_SIZE = 128;
|
||||
public static final int TEXT_MAX_LENGTH = 300;
|
||||
private static final int RAW_BUFFER_SIZE = 1024;
|
||||
|
||||
private final byte[] rawBuffer = new byte[RAW_BUFFER_SIZE];
|
||||
private final ByteBuffer buffer = ByteBuffer.wrap(rawBuffer);
|
||||
@ -94,7 +94,7 @@ public class ControlEventReader {
|
||||
if (buffer.remaining() < 1) {
|
||||
return null;
|
||||
}
|
||||
int len = toUnsigned(buffer.get());
|
||||
int len = toUnsigned(buffer.getShort());
|
||||
if (buffer.remaining() < len) {
|
||||
return null;
|
||||
}
|
||||
|
@ -1,12 +1,13 @@
|
||||
package com.genymobile.scrcpy;
|
||||
|
||||
import android.net.LocalServerSocket;
|
||||
import android.net.LocalSocket;
|
||||
import android.net.LocalSocketAddress;
|
||||
|
||||
import java.io.Closeable;
|
||||
import java.io.FileDescriptor;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.io.OutputStream;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
|
||||
public final class DesktopConnection implements Closeable {
|
||||
@ -17,14 +18,14 @@ public final class DesktopConnection implements Closeable {
|
||||
|
||||
private final LocalSocket socket;
|
||||
private final InputStream inputStream;
|
||||
private final OutputStream outputStream;
|
||||
private final FileDescriptor fd;
|
||||
|
||||
private final ControlEventReader reader = new ControlEventReader();
|
||||
|
||||
private DesktopConnection(LocalSocket socket) throws IOException {
|
||||
this.socket = socket;
|
||||
inputStream = socket.getInputStream();
|
||||
outputStream = socket.getOutputStream();
|
||||
fd = socket.getFileDescriptor();
|
||||
}
|
||||
|
||||
private static LocalSocket connect(String abstractName) throws IOException {
|
||||
@ -33,8 +34,24 @@ public final class DesktopConnection implements Closeable {
|
||||
return localSocket;
|
||||
}
|
||||
|
||||
public static DesktopConnection open(Device device) throws IOException {
|
||||
LocalSocket socket = connect(SOCKET_NAME);
|
||||
private static LocalSocket listenAndAccept(String abstractName) throws IOException {
|
||||
LocalServerSocket localServerSocket = new LocalServerSocket(abstractName);
|
||||
try {
|
||||
return localServerSocket.accept();
|
||||
} finally {
|
||||
localServerSocket.close();
|
||||
}
|
||||
}
|
||||
|
||||
public static DesktopConnection open(Device device, boolean tunnelForward) throws IOException {
|
||||
LocalSocket socket;
|
||||
if (tunnelForward) {
|
||||
socket = listenAndAccept(SOCKET_NAME);
|
||||
// send one byte so the client may read() to detect a connection error
|
||||
socket.getOutputStream().write(0);
|
||||
} else {
|
||||
socket = connect(SOCKET_NAME);
|
||||
}
|
||||
|
||||
DesktopConnection connection = new DesktopConnection(socket);
|
||||
Size videoSize = device.getScreenInfo().getVideoSize();
|
||||
@ -61,11 +78,11 @@ public final class DesktopConnection implements Closeable {
|
||||
buffer[DEVICE_NAME_FIELD_LENGTH + 1] = (byte) width;
|
||||
buffer[DEVICE_NAME_FIELD_LENGTH + 2] = (byte) (height >> 8);
|
||||
buffer[DEVICE_NAME_FIELD_LENGTH + 3] = (byte) height;
|
||||
outputStream.write(buffer, 0, buffer.length);
|
||||
IO.writeFully(fd, buffer, 0, buffer.length);
|
||||
}
|
||||
|
||||
public OutputStream getOutputStream() {
|
||||
return outputStream;
|
||||
public FileDescriptor getFd() {
|
||||
return fd;
|
||||
}
|
||||
|
||||
public ControlEvent receiveControlEvent() throws IOException {
|
||||
|
@ -3,6 +3,7 @@ package com.genymobile.scrcpy;
|
||||
import com.genymobile.scrcpy.wrappers.ServiceManager;
|
||||
|
||||
import android.graphics.Point;
|
||||
import android.graphics.Rect;
|
||||
import android.os.Build;
|
||||
import android.os.RemoteException;
|
||||
import android.view.IRotationWatcher;
|
||||
@ -20,7 +21,7 @@ public final class Device {
|
||||
private RotationListener rotationListener;
|
||||
|
||||
public Device(Options options) {
|
||||
screenInfo = computeScreenInfo(options.getMaxSize());
|
||||
screenInfo = computeScreenInfo(options.getCrop(), options.getMaxSize());
|
||||
registerRotationWatcher(new IRotationWatcher.Stub() {
|
||||
@Override
|
||||
public void onRotationChanged(int rotation) throws RemoteException {
|
||||
@ -40,18 +41,40 @@ public final class Device {
|
||||
return screenInfo;
|
||||
}
|
||||
|
||||
private ScreenInfo computeScreenInfo(Rect crop, int maxSize) {
|
||||
DisplayInfo displayInfo = serviceManager.getDisplayManager().getDisplayInfo();
|
||||
boolean rotated = (displayInfo.getRotation() & 1) != 0;
|
||||
Size deviceSize = displayInfo.getSize();
|
||||
Rect contentRect = new Rect(0, 0, deviceSize.getWidth(), deviceSize.getHeight());
|
||||
if (crop != null) {
|
||||
if (rotated) {
|
||||
// the crop (provided by the user) is expressed in the natural orientation
|
||||
crop = flipRect(crop);
|
||||
}
|
||||
if (!contentRect.intersect(crop)) {
|
||||
// intersect() changes contentRect so that it is intersected with crop
|
||||
Ln.w("Crop rectangle (" + formatCrop(crop) + ") does not intersect device screen (" + formatCrop(deviceSize.toRect()) + ")");
|
||||
contentRect = new Rect(); // empty
|
||||
}
|
||||
}
|
||||
|
||||
Size videoSize = computeVideoSize(contentRect.width(), contentRect.height(), maxSize);
|
||||
return new ScreenInfo(contentRect, videoSize, rotated);
|
||||
}
|
||||
|
||||
private static String formatCrop(Rect rect) {
|
||||
return rect.width() + ":" + rect.height() + ":" + rect.left + ":" + rect.top;
|
||||
}
|
||||
|
||||
@SuppressWarnings("checkstyle:MagicNumber")
|
||||
private ScreenInfo computeScreenInfo(int maxSize) {
|
||||
private static Size computeVideoSize(int w, int h, int maxSize) {
|
||||
// Compute the video size and the padding of the content inside this video.
|
||||
// Principle:
|
||||
// - scale down the great side of the screen to maxSize (if necessary);
|
||||
// - scale down the other side so that the aspect ratio is preserved;
|
||||
// - round this value to the nearest multiple of 8 (H.264 only accepts multiples of 8)
|
||||
DisplayInfo displayInfo = serviceManager.getDisplayManager().getDisplayInfo();
|
||||
boolean rotated = (displayInfo.getRotation() & 1) != 0;
|
||||
Size deviceSize = displayInfo.getSize();
|
||||
int w = deviceSize.getWidth();
|
||||
int h = deviceSize.getHeight();
|
||||
w &= ~7; // in case it's not a multiple of 8
|
||||
h &= ~7;
|
||||
if (maxSize > 0) {
|
||||
if (BuildConfig.DEBUG && maxSize % 8 != 0) {
|
||||
throw new AssertionError("Max size must be a multiple of 8");
|
||||
@ -68,12 +91,12 @@ public final class Device {
|
||||
w = portrait ? minor : major;
|
||||
h = portrait ? major : minor;
|
||||
}
|
||||
Size videoSize = new Size(w, h);
|
||||
return new ScreenInfo(deviceSize, videoSize, rotated);
|
||||
return new Size(w, h);
|
||||
}
|
||||
|
||||
public Point getPhysicalPoint(Position position) {
|
||||
@SuppressWarnings("checkstyle:HiddenField") // it hides the field on purpose, to read it with a lock
|
||||
// it hides the field on purpose, to read it with a lock
|
||||
@SuppressWarnings("checkstyle:HiddenField")
|
||||
ScreenInfo screenInfo = getScreenInfo(); // read with synchronization
|
||||
Size videoSize = screenInfo.getVideoSize();
|
||||
Size clientVideoSize = position.getScreenSize();
|
||||
@ -82,10 +105,10 @@ public final class Device {
|
||||
// the device may have been rotated since the event was generated, so ignore the event
|
||||
return null;
|
||||
}
|
||||
Size deviceSize = screenInfo.getDeviceSize();
|
||||
Rect contentRect = screenInfo.getContentRect();
|
||||
Point point = position.getPoint();
|
||||
int scaledX = point.x * deviceSize.getWidth() / videoSize.getWidth();
|
||||
int scaledY = point.y * deviceSize.getHeight() / videoSize.getHeight();
|
||||
int scaledX = contentRect.left + point.x * contentRect.width() / videoSize.getWidth();
|
||||
int scaledY = contentRect.top + point.y * contentRect.height() / videoSize.getHeight();
|
||||
return new Point(scaledX, scaledY);
|
||||
}
|
||||
|
||||
@ -108,4 +131,8 @@ public final class Device {
|
||||
public synchronized void setRotationListener(RotationListener rotationListener) {
|
||||
this.rotationListener = rotationListener;
|
||||
}
|
||||
|
||||
static Rect flipRect(Rect crop) {
|
||||
return new Rect(crop.top, crop.left, crop.bottom, crop.right);
|
||||
}
|
||||
}
|
||||
|
@ -39,10 +39,6 @@ public class EventController {
|
||||
coords.orientation = 0;
|
||||
coords.pressure = 1;
|
||||
coords.size = 1;
|
||||
coords.toolMajor = 1;
|
||||
coords.toolMinor = 1;
|
||||
coords.touchMajor = 1;
|
||||
coords.touchMinor = 1;
|
||||
}
|
||||
|
||||
private void setPointerCoords(Point point) {
|
||||
@ -167,10 +163,15 @@ public class EventController {
|
||||
return device.isScreenOn() || injectKeycode(KeyEvent.KEYCODE_POWER);
|
||||
}
|
||||
|
||||
private boolean pressBackOrTurnScreenOn() {
|
||||
int keycode = device.isScreenOn() ? KeyEvent.KEYCODE_BACK : KeyEvent.KEYCODE_POWER;
|
||||
return injectKeycode(keycode);
|
||||
}
|
||||
|
||||
private boolean executeCommand(int action) {
|
||||
switch (action) {
|
||||
case ControlEvent.COMMAND_SCREEN_ON:
|
||||
return turnScreenOn();
|
||||
case ControlEvent.COMMAND_BACK_OR_SCREEN_ON:
|
||||
return pressBackOrTurnScreenOn();
|
||||
default:
|
||||
Ln.w("Unsupported command: " + action);
|
||||
}
|
||||
|
31
server/src/main/java/com/genymobile/scrcpy/IO.java
Normal file
31
server/src/main/java/com/genymobile/scrcpy/IO.java
Normal file
@ -0,0 +1,31 @@
|
||||
package com.genymobile.scrcpy;
|
||||
|
||||
import android.system.ErrnoException;
|
||||
import android.system.Os;
|
||||
import android.system.OsConstants;
|
||||
|
||||
import java.io.FileDescriptor;
|
||||
import java.io.IOException;
|
||||
import java.nio.ByteBuffer;
|
||||
|
||||
public class IO {
|
||||
private IO() {
|
||||
// not instantiable
|
||||
}
|
||||
|
||||
public static void writeFully(FileDescriptor fd, ByteBuffer from) throws IOException {
|
||||
while (from.hasRemaining()) {
|
||||
try {
|
||||
Os.write(fd, from);
|
||||
} catch (ErrnoException e) {
|
||||
if (e.errno != OsConstants.EINTR) {
|
||||
throw new IOException(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void writeFully(FileDescriptor fd, byte[] buffer, int offset, int len) throws IOException {
|
||||
writeFully(fd, ByteBuffer.wrap(buffer, offset, len));
|
||||
}
|
||||
}
|
@ -1,8 +1,12 @@
|
||||
package com.genymobile.scrcpy;
|
||||
|
||||
import android.graphics.Rect;
|
||||
|
||||
public class Options {
|
||||
private int maxSize;
|
||||
private int bitRate;
|
||||
private boolean tunnelForward;
|
||||
private Rect crop;
|
||||
|
||||
public int getMaxSize() {
|
||||
return maxSize;
|
||||
@ -19,4 +23,20 @@ public class Options {
|
||||
public void setBitRate(int bitRate) {
|
||||
this.bitRate = bitRate;
|
||||
}
|
||||
|
||||
public boolean isTunnelForward() {
|
||||
return tunnelForward;
|
||||
}
|
||||
|
||||
public void setTunnelForward(boolean tunnelForward) {
|
||||
this.tunnelForward = tunnelForward;
|
||||
}
|
||||
|
||||
public Rect getCrop() {
|
||||
return crop;
|
||||
}
|
||||
|
||||
public void setCrop(Rect crop) {
|
||||
this.crop = crop;
|
||||
}
|
||||
}
|
||||
|
@ -9,8 +9,8 @@ import android.media.MediaFormat;
|
||||
import android.os.IBinder;
|
||||
import android.view.Surface;
|
||||
|
||||
import java.io.FileDescriptor;
|
||||
import java.io.IOException;
|
||||
import java.io.OutputStream;
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.concurrent.atomic.AtomicBoolean;
|
||||
|
||||
@ -48,7 +48,7 @@ public class ScreenEncoder implements Device.RotationListener {
|
||||
return rotationChanged.getAndSet(false);
|
||||
}
|
||||
|
||||
public void streamScreen(Device device, OutputStream outputStream) throws IOException {
|
||||
public void streamScreen(Device device, FileDescriptor fd) throws IOException {
|
||||
MediaFormat format = createFormat(bitRate, frameRate, iFrameInterval);
|
||||
device.setRotationListener(this);
|
||||
boolean alive;
|
||||
@ -56,15 +56,15 @@ public class ScreenEncoder implements Device.RotationListener {
|
||||
do {
|
||||
MediaCodec codec = createCodec();
|
||||
IBinder display = createDisplay();
|
||||
Rect deviceRect = device.getScreenInfo().getDeviceSize().toRect();
|
||||
Rect contentRect = device.getScreenInfo().getContentRect();
|
||||
Rect videoRect = device.getScreenInfo().getVideoSize().toRect();
|
||||
setSize(format, videoRect.width(), videoRect.height());
|
||||
configure(codec, format);
|
||||
Surface surface = codec.createInputSurface();
|
||||
setDisplaySurface(display, surface, deviceRect, videoRect);
|
||||
setDisplaySurface(display, surface, contentRect, videoRect);
|
||||
codec.start();
|
||||
try {
|
||||
alive = encode(codec, outputStream);
|
||||
alive = encode(codec, fd);
|
||||
} finally {
|
||||
codec.stop();
|
||||
destroyDisplay(display);
|
||||
@ -77,9 +77,7 @@ public class ScreenEncoder implements Device.RotationListener {
|
||||
}
|
||||
}
|
||||
|
||||
private boolean encode(MediaCodec codec, OutputStream outputStream) throws IOException {
|
||||
@SuppressWarnings("checkstyle:MagicNumber")
|
||||
byte[] buf = new byte[bitRate / 8]; // may contain up to 1 second of video
|
||||
private boolean encode(MediaCodec codec, FileDescriptor fd) throws IOException {
|
||||
boolean eof = false;
|
||||
MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
|
||||
while (!consumeRotationChange() && !eof) {
|
||||
@ -91,15 +89,8 @@ public class ScreenEncoder implements Device.RotationListener {
|
||||
break;
|
||||
}
|
||||
if (outputBufferId >= 0) {
|
||||
ByteBuffer outputBuffer = codec.getOutputBuffer(outputBufferId);
|
||||
while (outputBuffer.hasRemaining()) {
|
||||
int remaining = outputBuffer.remaining();
|
||||
int len = Math.min(buf.length, remaining);
|
||||
// the outputBuffer is probably direct (it has no underlying array), and LocalSocket does not expose channels,
|
||||
// so we must copy the data locally to write them manually to the output stream
|
||||
outputBuffer.get(buf, 0, len);
|
||||
outputStream.write(buf, 0, len);
|
||||
}
|
||||
ByteBuffer codecBuffer = codec.getOutputBuffer(outputBufferId);
|
||||
IO.writeFully(fd, codecBuffer);
|
||||
}
|
||||
} finally {
|
||||
if (outputBufferId >= 0) {
|
||||
|
@ -1,18 +1,20 @@
|
||||
package com.genymobile.scrcpy;
|
||||
|
||||
import android.graphics.Rect;
|
||||
|
||||
public final class ScreenInfo {
|
||||
private final Size deviceSize;
|
||||
private final Rect contentRect; // device size, possibly cropped
|
||||
private final Size videoSize;
|
||||
private final boolean rotated;
|
||||
|
||||
public ScreenInfo(Size deviceSize, Size videoSize, boolean rotated) {
|
||||
this.deviceSize = deviceSize;
|
||||
public ScreenInfo(Rect contentRect, Size videoSize, boolean rotated) {
|
||||
this.contentRect = contentRect;
|
||||
this.videoSize = videoSize;
|
||||
this.rotated = rotated;
|
||||
}
|
||||
|
||||
public Size getDeviceSize() {
|
||||
return deviceSize;
|
||||
public Rect getContentRect() {
|
||||
return contentRect;
|
||||
}
|
||||
|
||||
public Size getVideoSize() {
|
||||
@ -24,6 +26,6 @@ public final class ScreenInfo {
|
||||
if (rotated == newRotated) {
|
||||
return this;
|
||||
}
|
||||
return new ScreenInfo(deviceSize.rotate(), videoSize.rotate(), newRotated);
|
||||
return new ScreenInfo(Device.flipRect(contentRect), videoSize.rotate(), newRotated);
|
||||
}
|
||||
}
|
||||
|
@ -1,5 +1,7 @@
|
||||
package com.genymobile.scrcpy;
|
||||
|
||||
import android.graphics.Rect;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
public final class Server {
|
||||
@ -10,7 +12,8 @@ public final class Server {
|
||||
|
||||
private static void scrcpy(Options options) throws IOException {
|
||||
final Device device = new Device(options);
|
||||
try (DesktopConnection connection = DesktopConnection.open(device)) {
|
||||
boolean tunnelForward = options.isTunnelForward();
|
||||
try (DesktopConnection connection = DesktopConnection.open(device, tunnelForward)) {
|
||||
ScreenEncoder screenEncoder = new ScreenEncoder(options.getBitRate());
|
||||
|
||||
// asynchronous
|
||||
@ -18,7 +21,7 @@ public final class Server {
|
||||
|
||||
try {
|
||||
// synchronous
|
||||
screenEncoder.streamScreen(device, connection.getOutputStream());
|
||||
screenEncoder.streamScreen(device, connection.getFd());
|
||||
} catch (IOException e) {
|
||||
// this is expected on close
|
||||
Ln.d("Screen streaming stopped");
|
||||
@ -55,9 +58,38 @@ public final class Server {
|
||||
int bitRate = Integer.parseInt(args[1]);
|
||||
options.setBitRate(bitRate);
|
||||
|
||||
if (args.length < 3) {
|
||||
return options;
|
||||
}
|
||||
// use "adb forward" instead of "adb tunnel"? (so the server must listen)
|
||||
boolean tunnelForward = Boolean.parseBoolean(args[2]);
|
||||
options.setTunnelForward(tunnelForward);
|
||||
|
||||
if (args.length < 4) {
|
||||
return options;
|
||||
}
|
||||
Rect crop = parseCrop(args[3]);
|
||||
options.setCrop(crop);
|
||||
|
||||
return options;
|
||||
}
|
||||
|
||||
private static Rect parseCrop(String crop) {
|
||||
if (crop.isEmpty()) {
|
||||
return null;
|
||||
}
|
||||
// input format: "width:height:x:y"
|
||||
String[] tokens = crop.split(":");
|
||||
if (tokens.length != 4) {
|
||||
throw new IllegalArgumentException("Crop must contains 4 values separated by colons: \"" + crop + "\"");
|
||||
}
|
||||
int width = Integer.parseInt(tokens[0]);
|
||||
int height = Integer.parseInt(tokens[1]);
|
||||
int x = Integer.parseInt(tokens[2]);
|
||||
int y = Integer.parseInt(tokens[3]);
|
||||
return new Rect(x, y, x + width, y + height);
|
||||
}
|
||||
|
||||
public static void main(String... args) throws Exception {
|
||||
Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
|
||||
@Override
|
||||
|
@ -11,6 +11,8 @@ import java.io.ByteArrayOutputStream;
|
||||
import java.io.DataOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.Arrays;
|
||||
|
||||
|
||||
public class ControlEventReaderTest {
|
||||
|
||||
@ -43,8 +45,8 @@ public class ControlEventReaderTest {
|
||||
DataOutputStream dos = new DataOutputStream(bos);
|
||||
dos.writeByte(ControlEvent.TYPE_TEXT);
|
||||
byte[] text = "testé".getBytes(StandardCharsets.UTF_8);
|
||||
dos.writeByte(text.length);
|
||||
dos.write("testé".getBytes(StandardCharsets.UTF_8));
|
||||
dos.writeShort(text.length);
|
||||
dos.write(text);
|
||||
byte[] packet = bos.toByteArray();
|
||||
|
||||
reader.readFrom(new ByteArrayInputStream(packet));
|
||||
@ -54,6 +56,26 @@ public class ControlEventReaderTest {
|
||||
Assert.assertEquals("testé", event.getText());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParseLongTextEvent() throws IOException {
|
||||
ControlEventReader reader = new ControlEventReader();
|
||||
|
||||
ByteArrayOutputStream bos = new ByteArrayOutputStream();
|
||||
DataOutputStream dos = new DataOutputStream(bos);
|
||||
dos.writeByte(ControlEvent.TYPE_TEXT);
|
||||
byte[] text = new byte[ControlEventReader.TEXT_MAX_LENGTH];
|
||||
Arrays.fill(text, (byte) 'a');
|
||||
dos.writeShort(text.length);
|
||||
dos.write(text);
|
||||
byte[] packet = bos.toByteArray();
|
||||
|
||||
reader.readFrom(new ByteArrayInputStream(packet));
|
||||
ControlEvent event = reader.next();
|
||||
|
||||
Assert.assertEquals(ControlEvent.TYPE_TEXT, event.getType());
|
||||
Assert.assertEquals(new String(text, StandardCharsets.US_ASCII), event.getText());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParseMouseEvent() throws IOException {
|
||||
ControlEventReader reader = new ControlEventReader();
|
||||
|
Reference in New Issue
Block a user