mirror of https://github.com/Genymobile/scrcpy
1017 lines
34 KiB
Markdown
1017 lines
34 KiB
Markdown
_Only the original [README](README.md) is guaranteed to be up-to-date._
|
||
|
||
# scrcpy (v1.22)
|
||
|
||
<img src="data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />
|
||
|
||
_ausgesprochen "**scr**een **c**o**py**"_
|
||
|
||
Diese Anwendung liefert sowohl Anzeige als auch Steuerung eines Android-Gerätes über USB (oder [über TCP/IP](#tcpip-kabellos)). Dabei wird kein _root_ Zugriff benötigt.
|
||
Die Anwendung funktioniert unter _GNU/Linux_, _Windows_ und _macOS_.
|
||
|
||
|
||
|
||
Dabei liegt der Fokus auf:
|
||
|
||
- **Leichtigkeit**: native, nur Anzeige des Gerätedisplays
|
||
- **Leistung**: 30~120fps, abhängig vom Gerät
|
||
- **Qualität**: 1920×1080 oder mehr
|
||
- **Geringe Latenz**: [35~70ms][lowlatency]
|
||
- **Kurze Startzeit**: ~1 Sekunde um das erste Bild anzuzeigen
|
||
- **Keine Aufdringlichkeit**: Es wird keine installierte Software auf dem Gerät zurückgelassen
|
||
- **Nutzervorteile**: kein Account, keine Werbung, kein Internetzugriff notwendig
|
||
- **Freiheit**: gratis und open-source
|
||
|
||
[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
|
||
|
||
Die Features beinhalten:
|
||
- [Aufnahme](#Aufnahme)
|
||
- Spiegeln mit [ausgeschaltetem Bildschirm](#bildschirm-ausschalten)
|
||
- [Copy&Paste](#copy-paste) in beide Richtungen
|
||
- [Einstellbare Qualität](#Aufnahmekonfiguration)
|
||
- Gerätebildschirm [als Webcam (V4L2)](#v4l2loopback) (nur Linux)
|
||
- [Simulation einer physischen Tastatur (HID)](#simulation-einer-physischen-tastatur-mit-hid)
|
||
(nur Linux)
|
||
- [Simulation einer physischen Maus (HID)](#simulation-einer-physischen-maus-mit-hid)
|
||
(nur Linux)
|
||
- [OTG Modus](#otg) (nur Linux)
|
||
- und mehr…
|
||
|
||
## Voraussetzungen
|
||
|
||
Das Android-Gerät benötigt mindestens API 21 (Android 5.0).
|
||
|
||
Es muss sichergestellt sein, dass [adb debugging][enable-adb] auf dem Gerät aktiv ist.
|
||
|
||
[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
|
||
|
||
Auf manchen Geräten müssen zudem [weitere Optionen][control] aktiv sein um das Gerät mit Maus und Tastatur steuern zu können.
|
||
|
||
[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
|
||
|
||
|
||
## Installation der App
|
||
|
||
<a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>
|
||
|
||
### Zusammenfassung
|
||
|
||
- Linux: `apt install scrcpy`
|
||
- Windows: [download (siehe README)](README.md#windows)
|
||
- macOS: `brew install scrcpy`
|
||
|
||
Direkt von der Source bauen: [BUILD] ([vereinfachter Prozess (englisch)][BUILD_simple])
|
||
|
||
[BUILD]: BUILD.md
|
||
[BUILD_simple]: BUILD.md#simple
|
||
|
||
|
||
### Linux
|
||
|
||
Auf Debian und Ubuntu:
|
||
|
||
```
|
||
apt install scrcpy
|
||
```
|
||
|
||
Auf Arch Linux:
|
||
|
||
```
|
||
pacman -S scrcpy
|
||
```
|
||
|
||
Ein [Snap] package ist verfügbar: [`scrcpy`][snap-link].
|
||
|
||
[snap-link]: https://snapstats.org/snaps/scrcpy
|
||
|
||
[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
|
||
|
||
Für Fedora ist ein [COPR] package verfügbar: [`scrcpy`][copr-link].
|
||
|
||
[COPR]: https://fedoraproject.org/wiki/Category:Copr
|
||
[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
|
||
|
||
|
||
Für Gentoo ist ein [Ebuild] verfügbar: [`scrcpy/`][ebuild-link].
|
||
|
||
[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
|
||
[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
|
||
|
||
Die App kann zudem [manuell gebaut werden][BUILD] ([vereinfachter Prozess (englisch)][BUILD_simple]).
|
||
|
||
|
||
### Windows
|
||
|
||
Für Windows ist der Einfachheit halber ein vorgebautes Archiv mit allen Abhängigkeiten (inklusive `adb`) vorhanden.
|
||
|
||
- [README](README.md#windows)
|
||
|
||
Es ist zudem in [Chocolatey] vorhanden:
|
||
|
||
[Chocolatey]: https://chocolatey.org/
|
||
|
||
```bash
|
||
choco install scrcpy
|
||
choco install adb # falls noch nicht vorhanden
|
||
```
|
||
|
||
Und in [Scoop]:
|
||
|
||
```bash
|
||
scoop install scrcpy
|
||
scoop install adb # falls noch nicht vorhanden
|
||
```
|
||
|
||
[Scoop]: https://scoop.sh
|
||
|
||
Die App kann zudem [manuell gebaut werden][BUILD].
|
||
|
||
|
||
### macOS
|
||
|
||
Die Anwendung ist in [Homebrew] verfügbar. Installation:
|
||
|
||
[Homebrew]: https://brew.sh/
|
||
|
||
```bash
|
||
brew install scrcpy
|
||
```
|
||
|
||
Es wird `adb` benötigt, auf welches über `PATH` zugegriffen werden kann. Falls noch nicht vorhanden:
|
||
|
||
```bash
|
||
brew install android-platform-tools
|
||
```
|
||
|
||
Es ist außerdem in [MacPorts] vorhanden, welches adb bereits aufsetzt:
|
||
|
||
```bash
|
||
sudo port install scrcpy
|
||
```
|
||
|
||
[MacPorts]: https://www.macports.org/
|
||
|
||
|
||
Die Anwendung kann zudem [manuell gebaut werden][BUILD].
|
||
|
||
|
||
## Ausführen
|
||
|
||
Ein Android-Gerät anschließen und diese Befehle ausführen:
|
||
|
||
```bash
|
||
scrcpy
|
||
```
|
||
|
||
Dabei werden Kommandozeilenargumente akzeptiert, aufgelistet per:
|
||
|
||
```bash
|
||
scrcpy --help
|
||
```
|
||
|
||
## Funktionalitäten
|
||
|
||
### Aufnahmekonfiguration
|
||
|
||
#### Größe reduzieren
|
||
|
||
Manchmal ist es sinnvoll, das Android-Gerät mit einer geringeren Auflösung zu spiegeln, um die Leistung zu erhöhen.
|
||
|
||
Um die Höhe und Breite auf einen Wert zu limitieren (z.B. 1024):
|
||
|
||
```bash
|
||
scrcpy --max-size 1024
|
||
scrcpy -m 1024 # short version
|
||
```
|
||
|
||
Die andere Größe wird dabei so berechnet, dass das Seitenverhältnis des Gerätes erhalten bleibt.
|
||
In diesem Fall wird ein Gerät mit einer 1920×1080-Auflösung mit 1024×576 gespiegelt.
|
||
|
||
|
||
#### Ändern der Bit-Rate
|
||
|
||
Die Standard-Bitrate ist 8 Mbps. Um die Bitrate zu ändern (z.B. zu 2 Mbps):
|
||
|
||
```bash
|
||
scrcpy --bit-rate 2M
|
||
scrcpy -b 2M # Kurzversion
|
||
```
|
||
|
||
#### Limitieren der Bildwiederholrate
|
||
|
||
Die Aufnahme-Bildwiederholrate kann begrenzt werden:
|
||
|
||
```bash
|
||
scrcpy --max-fps 15
|
||
```
|
||
|
||
Dies wird offiziell seit Android 10 unterstützt, kann jedoch bereits auf früheren Versionen funktionieren.
|
||
|
||
#### Zuschneiden
|
||
|
||
Der Geräte-Bildschirm kann zugeschnitten werden, sodass nur ein Teil gespiegelt wird.
|
||
|
||
Dies ist beispielsweise nützlich, um nur ein Auge der Oculus Go zu spiegeln:
|
||
|
||
```bash
|
||
scrcpy --crop 1224:1440:0:0 # 1224x1440 am Versatz (0,0)
|
||
```
|
||
|
||
Falls `--max-size` auch festgelegt ist, wird das Ändern der Größe nach dem Zuschneiden angewandt.
|
||
|
||
|
||
#### Feststellen der Videoorientierung
|
||
|
||
|
||
Um die Orientierung während dem Spiegeln festzustellen:
|
||
|
||
```bash
|
||
scrcpy --lock-video-orientation # ursprüngliche (momentane) Orientierung
|
||
scrcpy --lock-video-orientation=0 # normale Orientierung
|
||
scrcpy --lock-video-orientation=1 # 90° gegen den Uhrzeigersinn
|
||
scrcpy --lock-video-orientation=2 # 180°
|
||
scrcpy --lock-video-orientation=3 # 90° mit dem Uhrzeigersinn
|
||
```
|
||
|
||
Dies beeinflusst die Aufnahmeausrichtung.
|
||
|
||
Das [Fenster kann auch unabhängig rotiert](#Rotation) werden.
|
||
|
||
|
||
#### Encoder
|
||
|
||
Manche Geräte besitzen mehr als einen Encoder. Manche dieser Encoder können dabei sogar zu Problemen oder Abstürzen führen.
|
||
Die Auswahl eines anderen Encoders ist möglich:
|
||
|
||
```bash
|
||
scrcpy --encoder OMX.qcom.video.encoder.avc
|
||
```
|
||
|
||
Um eine Liste aller verfügbaren Encoder zu erhalten (eine Fehlermeldung gibt alle verfügbaren Encoder aus):
|
||
|
||
```bash
|
||
scrcpy --encoder _
|
||
```
|
||
|
||
### Aufnahme
|
||
|
||
#### Aufnehmen von Videos
|
||
|
||
Es ist möglich, das Display während des Spiegelns aufzunehmen:
|
||
|
||
```bash
|
||
scrcpy --record file.mp4
|
||
scrcpy -r file.mkv
|
||
```
|
||
|
||
Um das Spiegeln während des Aufnehmens zu deaktivieren:
|
||
|
||
```bash
|
||
scrcpy --no-display --record file.mp4
|
||
scrcpy -Nr file.mkv
|
||
# Unterbrechen der Aufnahme mit Strg+C
|
||
```
|
||
|
||
"Übersprungene Bilder" werden aufgenommen, selbst wenn sie in Echtzeit (aufgrund von Performancegründen) nicht dargestellt werden. Die Einzelbilder sind mit _Zeitstempeln_ des Gerätes versehen are, sodass eine [Paketverzögerungsvariation] nicht die Aufnahmedatei beeinträchtigt.
|
||
|
||
[Paketverzögerungsvariation]: https://www.wikide.wiki/wiki/en/Packet_delay_variation
|
||
|
||
|
||
#### v4l2loopback
|
||
|
||
Auf Linux ist es möglich, den Video-Stream zu einem v4l2 loopback Gerät zu senden, sodass das Android-Gerät von jedem v4l2-fähigen Tool wie eine Webcam verwendet werden kann.
|
||
|
||
Das Modul `v4l2loopback` muss dazu installiert werden:
|
||
|
||
```bash
|
||
sudo apt install v4l2loopback-dkms
|
||
```
|
||
|
||
Um ein v4l2 Gerät zu erzeugen:
|
||
|
||
```bash
|
||
sudo modprobe v4l2loopback
|
||
```
|
||
|
||
Dies erzeugt ein neues Video-Gerät in `/dev/videoN`, wobei `N` ein Integer ist (mehr [Optionen](https://github.com/umlaeute/v4l2loopback#options) sind verfügbar um mehrere Geräte oder Geräte mit spezifischen Nummern zu erzeugen).
|
||
|
||
Um die aktivierten Geräte aufzulisten:
|
||
|
||
```bash
|
||
# benötigt das v4l-utils package
|
||
v4l2-ctl --list-devices
|
||
|
||
# simpel, kann aber ausreichend
|
||
ls /dev/video*
|
||
```
|
||
|
||
Um scrcpy mithilfe eines v4l2 sink zu starten:
|
||
|
||
```bash
|
||
scrcpy --v4l2-sink=/dev/videoN
|
||
scrcpy --v4l2-sink=/dev/videoN --no-display # Fenster mit Spiegelung ausschalten
|
||
scrcpy --v4l2-sink=/dev/videoN -N # kurze Version
|
||
```
|
||
|
||
(`N` muss mit der Geräte-ID ersetzt werden, welche mit `ls /dev/video*` überprüft werden kann)
|
||
|
||
Einmal aktiv, kann der Stream mit einem v4l2-fähigen Tool verwendet werden:
|
||
|
||
```bash
|
||
ffplay -i /dev/videoN
|
||
vlc v4l2:///dev/videoN # VLC kann eine gewisse Bufferverzögerung herbeiführen
|
||
```
|
||
|
||
Beispielsweise kann das Video mithilfe von [OBS] aufgenommen werden.
|
||
|
||
[OBS]: https://obsproject.com/
|
||
|
||
|
||
#### Buffering
|
||
|
||
Es ist möglich, Buffering hinzuzufügen. Dies erhöht die Latenz, reduziert aber etwaigen Jitter (see [#2464]).
|
||
|
||
[#2464]: https://github.com/Genymobile/scrcpy/issues/2464
|
||
|
||
Diese Option ist sowohl für Video-Buffering:
|
||
|
||
```bash
|
||
scrcpy --display-buffer=50 # fügt 50ms Buffering zum Display hinzu
|
||
```
|
||
|
||
als auch V4L2 sink verfügbar:
|
||
|
||
```bash
|
||
scrcpy --v4l2-buffer=500 # fügt 500ms Buffering für v4l2 sink hinzu
|
||
```
|
||
|
||
|
||
### Verbindung
|
||
|
||
#### TCP/IP Kabellos
|
||
|
||
_Scrcpy_ verwendet `adb`, um mit dem Gerät zu kommunizieren. `adb` kann sich per TCP/IP mit einem Gerät [verbinden]. Das Gerät muss dabei mit demselben Netzwerk wie der Computer verbunden sein.
|
||
|
||
##### Automatisch
|
||
|
||
Die Option `--tcpip` erlaubt es, die Verbindung automatisch zu konfigurieren. Dabei gibt es zwei Varianten.
|
||
|
||
Falls das Gerät (verfügbar unter 192.168.1.1 in diesem Beispiel) bereit an einem Port (typically 5555) nach einkommenden adb-Verbindungen hört, dann führe diesen Befehl aus:
|
||
|
||
```bash
|
||
scrcpy --tcpip=192.168.1.1 # Standard-Port ist 5555
|
||
scrcpy --tcpip=192.168.1.1:5555
|
||
```
|
||
|
||
Falls adb TCP/IP auf dem Gerät deaktiviert ist (oder falls die IP-Adresse des Gerätes nicht bekannt ist): Gerät per USB verbinden, anschließend diesen Befehl ausführen:
|
||
|
||
```bash
|
||
scrcpy --tcpip # ohne weitere Argumente
|
||
```
|
||
|
||
Dies finden automatisch das Gerät und aktiviert den TCP/IP-Modus. Anschließend verbindet sich der Befehl mit dem Gerät bevor die Verbindung startet.
|
||
|
||
##### Manuell
|
||
|
||
Alternativ kann die TCP/IP-Verbindung auch manuell per `adb` aktiviert werden:
|
||
|
||
1. Gerät mit demselben Wi-Fi wie den Computer verbinden.
|
||
2. IP-Adresse des Gerätes herausfinden, entweder über Einstellungen → Über das Telefon → Status, oder indem dieser Befehl ausgeführt wird:
|
||
|
||
```bash
|
||
adb shell ip route | awk '{print $9}'
|
||
```
|
||
|
||
3. Aktivieren von adb über TCP/IP auf dem Gerät: `adb tcpip 5555`.
|
||
4. Ausstecken des Geräts.
|
||
5. Verbinden zum Gerät: `adb connect DEVICE_IP:5555` _(`DEVICE_IP` ersetzen)_.
|
||
6. `scrcpy` wie normal ausführen.
|
||
|
||
Es kann sinnvoll sein, die Bit-Rate sowie dei Auflösung zu reduzieren:
|
||
|
||
```bash
|
||
scrcpy --bit-rate 2M --max-size 800
|
||
scrcpy -b2M -m800 # kurze Version
|
||
```
|
||
|
||
[verbinden]: https://developer.android.com/studio/command-line/adb.html#wireless
|
||
|
||
|
||
#### Mehrere Geräte
|
||
|
||
Falls mehrere Geräte unter `adb devices` aufgelistet werden, muss die _Seriennummer_ angegeben werden:
|
||
|
||
```bash
|
||
scrcpy --serial 0123456789abcdef
|
||
scrcpy -s 0123456789abcdef # kurze Version
|
||
```
|
||
|
||
Falls das Gerät über TCP/IP verbunden ist:
|
||
|
||
```bash
|
||
scrcpy --serial 192.168.0.1:5555
|
||
scrcpy -s 192.168.0.1:5555 # kurze Version
|
||
```
|
||
|
||
Es können mehrere Instanzen von _scrcpy_ für mehrere Geräte gestartet werden.
|
||
|
||
#### Autostart beim Verbinden eines Gerätes
|
||
|
||
Hierfür kann [AutoAdb] verwendet werden:
|
||
|
||
```bash
|
||
autoadb scrcpy -s '{}'
|
||
```
|
||
|
||
[AutoAdb]: https://github.com/rom1v/autoadb
|
||
|
||
#### Tunnel
|
||
|
||
Um sich zu einem entfernten Gerät zu verbinden, kann der `adb` Client mit einem remote-`adb`-Server verbunden werden (Voraussetzung: Gleiche Version des `adb`-Protokolls).
|
||
|
||
##### Remote ADB Server
|
||
|
||
Um sich zu einem Remote-`adb`-Server zu verbinden: Der Server muss auf allen Ports hören
|
||
|
||
```bash
|
||
adb kill-server
|
||
adb -a nodaemon server start
|
||
# Diesen Dialog offen halten
|
||
```
|
||
|
||
**Warnung: Die gesamte Kommunikation zwischen adb und den Geräten ist unverschlüsselt.**
|
||
|
||
Angenommen, der Server ist unter 192.168.1.2 verfügbar. Dann kann von einer anderen Kommandozeile scrcpy aufgeführt werden:
|
||
|
||
```bash
|
||
export ADB_SERVER_SOCKET=tcp:192.168.1.2:5037
|
||
scrcpy --tunnel-host=192.168.1.2
|
||
```
|
||
|
||
Standardmäßig verwendet scrcpy den lokalen Port für die Einrichtung des `adb forward`-Tunnels (typischerweise `27183`, siehe `--port`).
|
||
Es ist zudem möglich, einen anderen Tunnel-Port zuzuweisen (sinnvoll in Situationen, bei welchen viele Weiterleitungen erfolgen):
|
||
|
||
```
|
||
scrcpy --tunnel-port=1234
|
||
```
|
||
|
||
|
||
##### SSH Tunnel
|
||
|
||
Um mit einem Remote-`adb`-Server sicher zu kommunizieren, wird ein SSH-Tunnel empfohlen.
|
||
|
||
Sicherstellen, dass der Remote-`adb`-Server läuft:
|
||
|
||
```bash
|
||
adb start-server
|
||
```
|
||
|
||
Erzeugung eines SSH-Tunnels:
|
||
|
||
```bash
|
||
# local 5038 --> remote 5037
|
||
# local 27183 <-- remote 27183
|
||
ssh -CN -L5038:localhost:5037 -R27183:localhost:27183 your_remote_computer
|
||
# Diesen Dialog geöffnet halten
|
||
```
|
||
|
||
Von einer anderen Kommandozeile aus scrcpy ausführen:
|
||
|
||
```bash
|
||
export ADB_SERVER_SOCKET=tcp:localhost:5038
|
||
scrcpy
|
||
```
|
||
|
||
Um das Aktivieren von Remote-Weiterleitung zu verhindern, kann eine Vorwärts-Verbindung verwendet werden (`-L` anstatt von `-R`):
|
||
|
||
```bash
|
||
# local 5038 --> remote 5037
|
||
# local 27183 --> remote 27183
|
||
ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer
|
||
# Diesen Dialog geöffnet halten
|
||
```
|
||
|
||
Von einer anderen Kommandozeile aus scrcpy ausführen:
|
||
|
||
```bash
|
||
export ADB_SERVER_SOCKET=tcp:localhost:5038
|
||
scrcpy --force-adb-forward
|
||
```
|
||
|
||
|
||
Wie für kabellose Verbindungen kann es sinnvoll sein, die Qualität zu reduzieren:
|
||
|
||
```
|
||
scrcpy -b2M -m800 --max-fps 15
|
||
```
|
||
|
||
### Fensterkonfiguration
|
||
|
||
#### Titel
|
||
|
||
Standardmäßig ist der Fenstertitel das Gerätemodell. Der Titel kann jedoch geändert werden:
|
||
|
||
```bash
|
||
scrcpy --window-title 'Mein Gerät'
|
||
```
|
||
|
||
#### Position und Größe
|
||
|
||
Die anfängliche Fensterposition und Größe können festgelegt werden:
|
||
|
||
```bash
|
||
scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
|
||
```
|
||
|
||
#### Rahmenlos
|
||
|
||
Um den Rahmen des Fensters zu deaktivieren:
|
||
|
||
```bash
|
||
scrcpy --window-borderless
|
||
```
|
||
|
||
#### Immer im Vordergrund
|
||
|
||
Um das Fenster immer im Vordergrund zu halten:
|
||
|
||
```bash
|
||
scrcpy --always-on-top
|
||
```
|
||
|
||
#### Vollbild
|
||
|
||
Die Anwendung kann direkt im Vollbildmodus gestartet werden:
|
||
|
||
```bash
|
||
scrcpy --fullscreen
|
||
scrcpy -f # kurze Version
|
||
```
|
||
|
||
Das Vollbild kann dynamisch mit <kbd>MOD</kbd>+<kbd>f</kbd> gewechselt werden.
|
||
|
||
#### Rotation
|
||
|
||
Das Fenster kann rotiert werden:
|
||
|
||
```bash
|
||
scrcpy --rotation 1
|
||
```
|
||
|
||
Mögliche Werte sind:
|
||
- `0`: keine Rotation
|
||
- `1`: 90 grad gegen den Uhrzeigersinn
|
||
- `2`: 180 grad
|
||
- `3`: 90 grad mit dem Uhrzeigersinn
|
||
|
||
die Rotation kann zudem dynamisch mit <kbd>MOD</kbd>+<kbd>←</kbd>
|
||
_(links)_ and <kbd>MOD</kbd>+<kbd>→</kbd> _(rechts)_ angepasst werden.
|
||
|
||
_scrcpy_ schafft 3 verschiedene Rotationen:
|
||
- <kbd>MOD</kbd>+<kbd>r</kbd> erfordert von Gerät den Wechsel zwischen Hochformat und Querformat (die momentane App kann dies verweigern, wenn die geforderte Ausrichtung nicht unterstützt wird).
|
||
- [`--lock-video-orientation`](#feststellen-der-videoorientierung) ändert die Ausrichtung der Spiegelung (die Ausrichtung des an den Computer gesendeten Videos). Dies beeinflusst eventuelle Aufnahmen.
|
||
- `--rotation` (or <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>) rotiert nur das Fenster, eventuelle Aufnahmen sind hiervon nicht beeinflusst.
|
||
|
||
|
||
### Andere Spiegel-Optionen
|
||
|
||
#### Lesezugriff
|
||
|
||
Um die Steuerung (alles, was mit dem Gerät interagieren kann: Tasten, Mausklicks, Drag-and-drop von Dateien) zu deaktivieren:
|
||
|
||
```bash
|
||
scrcpy --no-control
|
||
scrcpy -n
|
||
```
|
||
|
||
#### Anzeige
|
||
|
||
Falls mehrere Displays vorhanden sind, kann das zu spiegelnde Display gewählt werden:
|
||
|
||
```bash
|
||
scrcpy --display 1
|
||
```
|
||
|
||
Die Liste an verfügbaren Displays kann mit diesem Befehl ausgegeben werden:
|
||
|
||
```bash
|
||
adb shell dumpsys display # Nach "mDisplayId=" in der Ausgabe suchen
|
||
```
|
||
|
||
Das zweite Display kann nur gesteuert werden, wenn das Gerät Android 10 oder höher besitzt. Ansonsten wird das Display nur mit Lesezugriff gespiegelt.
|
||
|
||
|
||
#### Wach bleiben
|
||
|
||
Um zu verhindern, dass das Gerät nach einer Weile in den Ruhezustand übergeht (solange es eingesteckt ist):
|
||
|
||
```bash
|
||
scrcpy --stay-awake
|
||
scrcpy -w
|
||
```
|
||
|
||
Der ursprüngliche Zustand wird beim Schließen von scrcpy wiederhergestellt.
|
||
|
||
|
||
#### Bildschirm ausschalten
|
||
|
||
Es ist möglich, beim Starten des Spiegelns mithilfe eines Kommandozeilenarguments den Bildschirm des Gerätes auszuschalten:
|
||
|
||
```bash
|
||
scrcpy --turn-screen-off
|
||
scrcpy -S
|
||
```
|
||
|
||
Oder durch das Drücken von <kbd>MOD</kbd>+<kbd>o</kbd> jederzeit.
|
||
|
||
Um das Display wieder einzuschalten muss <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd> gedrückt werden.
|
||
|
||
Auf Android aktiviert der `POWER` Knopf das Display immer.
|
||
Für den Komfort wird, wenn `POWER` via scrcpy gesendet wird (über Rechtsklick oder <kbd>MOD</kbd>+<kbd>p</kbd>), wird versucht, das Display nach einer kurzen Zeit wieder auszuschalten (falls es möglich ist).
|
||
Der physische `POWER` Button aktiviert das Display jedoch immer.
|
||
|
||
Dies kann zudem nützlich sein, um das Gerät vom Ruhezustand abzuhalten:
|
||
|
||
```bash
|
||
scrcpy --turn-screen-off --stay-awake
|
||
scrcpy -Sw
|
||
```
|
||
|
||
#### Ausschalten beim Schließen
|
||
|
||
Um den Gerätebildschirm abzuschalten, wenn scrcpy geschlossen wird:
|
||
|
||
```bash
|
||
scrcpy --power-off-on-close
|
||
```
|
||
|
||
|
||
#### Anzeigen von Berührungen
|
||
|
||
Für Präsentationen kann es sinnvoll sein, die physischen Berührungen anzuzeigen (auf dem physischen Gerät).
|
||
|
||
Android stellt dieses Feature in den _Entwickleroptionen_ zur Verfügung.
|
||
|
||
_Scrcpy_ stellt die Option zur Verfügung, dies beim Start zu aktivieren und beim Schließen auf den Ursprungszustand zurückzusetzen:
|
||
|
||
```bash
|
||
scrcpy --show-touches
|
||
scrcpy -t
|
||
```
|
||
|
||
Anmerkung: Nur _physische Berührungen_ werden angezeigt (mit dem Finger auf dem Gerät).
|
||
|
||
|
||
#### Bildschirmschoner deaktivieren
|
||
|
||
Standardmäßig unterbindet scrcpy nicht den Bildschirmschoner des Computers.
|
||
|
||
Um den Bildschirmschoner zu unterbinden:
|
||
|
||
```bash
|
||
scrcpy --disable-screensaver
|
||
```
|
||
|
||
|
||
### Eingabesteuerung
|
||
|
||
#### Geräte-Bildschirm drehen
|
||
|
||
<kbd>MOD</kbd>+<kbd>r</kbd> drücken, um zwischen Hoch- und Querformat zu wechseln.
|
||
|
||
Anmerkung: Dis funktioniert nur, wenn die momentan geöffnete App beide Rotationen unterstützt.
|
||
|
||
#### Copy-paste
|
||
|
||
Immer, wenn sich die Zwischenablage von Android ändert wird dies mit dem Computer synchronisiert.
|
||
|
||
Jedes <kbd>Strg</kbd> wird an das Gerät weitergegeben. Insbesonders:
|
||
- <kbd>Strg</kbd>+<kbd>c</kbd> kopiert typischerweise
|
||
- <kbd>Strg</kbd>+<kbd>x</kbd> schneidet typischerweise aus
|
||
- <kbd>Strg</kbd>+<kbd>v</kbd> fügt typischerweise ein (nach der Computer-zu-Gerät-Synchronisation)
|
||
|
||
Dies funktioniert typischerweise wie erwartet.
|
||
|
||
Die wirkliche Funktionsweise hängt jedoch von der jeweiligen Anwendung ab. Beispielhaft sendet _Termux_ SIGINT bei <kbd>Strg</kbd>+<kbd>c</kbd>, und _K-9 Mail_ erzeugt eine neue Nachricht.
|
||
|
||
Um kopieren, ausschneiden und einfügen in diesen Fällen zu verwenden (nur bei Android >= 7 unterstützt):
|
||
- <kbd>MOD</kbd>+<kbd>c</kbd> gibt `COPY` ein
|
||
- <kbd>MOD</kbd>+<kbd>x</kbd> gibt `CUT` ein
|
||
- <kbd>MOD</kbd>+<kbd>v</kbd> gibt `PASTE` ein (nach der Computer-zu-Gerät-Synchronisation)
|
||
|
||
Zusätzlich erlaubt es <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> den momentanen Inhalt der Zwischenablage als eine Serie von Tastenevents einzugeben.
|
||
Dies ist nützlich, fall die Applikation kein Einfügen unterstützt (z.B. _Termux_). Jedoch kann nicht-ASCII-Inhalt dabei zerstört werden.
|
||
|
||
**WARNUNG:** Das Einfügen der Computer-Zwischenablage in das Gerät (entweder mit <kbd>Strg</kbd>+<kbd>v</kbd> oder <kbd>MOD</kbd>+<kbd>v</kbd>) kopiert den Inhalt in die Zwischenablage des Gerätes.
|
||
Als Konsequenz kann somit jede Android-Applikation diesen Inhalt lesen. Das Einfügen von sensiblen Informationen wie Passwörtern sollte aus diesem Grund vermieden werden.
|
||
|
||
Mache Geräte verhalten sich nicht wie erwartet, wenn die Zwischenablage per Programm verändert wird.
|
||
Die Option `--legacy-paste` wird bereitgestellt, welche das Verhalten von <kbd>Strg</kbd>+<kbd>v</kbd> und <kbd>MOD</kbd>+<kbd>v</kbd> so ändert, dass die Zwischenablage wie bei <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> als eine Serie von Tastenevents ausgeführt wird.
|
||
|
||
Um die automatische Synchronisierung der Zwischenablage zu deaktivieren:
|
||
`--no-clipboard-autosync`.
|
||
|
||
#### Ziehen zum Zoomen
|
||
|
||
Um "Ziehen-zum-Zoomen" zu simulieren: <kbd>Strg</kbd>+_klicken-und-bewegen_.
|
||
|
||
Genauer: <kbd>Strg</kbd> halten, während Linksklick gehalten wird. Solange Linksklick gehalten wird, skalieren und rotieren die Mausbewegungen den Inhalt (soweit von der jeweiligen App unterstützt).
|
||
|
||
Konkret erzeugt scrcpy einen am Mittelpunkt des Displays gespiegelten, "virtuellen" Finger.
|
||
|
||
#### Simulation einer physischen Tastatur mit HID
|
||
|
||
Standardmäßig verwendet scrcpy Android-Tasten oder Textinjektion. Dies funktioniert zwar immer, jedoch nur mit ASCII.
|
||
|
||
Auf Linux kann scrcpy mithilfe von HID eine physische Tastatur simulieren, um eine bessere Eingabeerfahrung zu gewährleisten (dies nutzt [USB HID over AOAv2][hid-aoav2]): Die virtuelle Tastatur wird deaktiviert, es funktioniert für alle Zeichen und mit IME.
|
||
|
||
[hid-aoav2]: https://source.android.com/devices/accessories/aoa2#hid-support
|
||
|
||
Dies funktioniert jedoch nur, wenn das Gerät über USB verbunden ist. Zudem wird dies momentan nur unter Linux unterstützt.
|
||
|
||
Um diesen Modus zu aktivieren:
|
||
|
||
```bash
|
||
scrcpy --hid-keyboard
|
||
scrcpy -K # kurze Version
|
||
```
|
||
|
||
Falls dies auf gewissen Gründen fehlschlägt (z.B. Gerät ist nicht über USB verbunden), so fällt scrcpy auf den Standardmodus zurück (mit einer Ausgabe in der Konsole).
|
||
Dies erlaubt es, dieselben Kommandozeilenargumente zu verwenden, egal ob das Gerät per USB oder TCP/IP verbunden ist.
|
||
|
||
In diesem Modus werden rohe Tastenevents (scancodes) an das Gerät gesendet.
|
||
Aus diesem Grund muss ein nicht passenden Tastaturformat in den Einstellungen des Android-Gerätes unter Einstellungen → System → Sprache und Eingabe → [Physical keyboard] konfiguriert werden.
|
||
|
||
Diese Einstellungsseite kann direkt mit diesem Befehl geöffnet werden:
|
||
|
||
```bash
|
||
adb shell am start -a android.settings.HARD_KEYBOARD_SETTINGS
|
||
```
|
||
|
||
Diese Option ist jedoch nur verfügbar, wenn eine HID-Tastatur oder eine physische Tastatur verbunden sind.
|
||
|
||
[Physical keyboard]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915
|
||
|
||
#### Simulation einer physischen Maus mit HID
|
||
|
||
Ähnlich zu einer Tastatur kann auch eine Maus mithilfe von HID simuliert werden.
|
||
Wie zuvor funktioniert dies jedoch nur, wenn das Gerät über USB verbunden ist. Zudem wird dies momentan nur unter Linux unterstützt.
|
||
|
||
Standardmäßig verwendet scrcpy Android Maus Injektionen mit absoluten Koordinaten.
|
||
Durch die Simulation einer physischen Maus erscheint auf dem Display des Geräts ein Mauszeiger, zu welchem die Bewegungen, Klicks und Scrollbewegungen relativ eingegeben werden.
|
||
|
||
Um diesen Modus zu aktivieren:
|
||
|
||
```bash
|
||
scrcpy --hid-mouse
|
||
scrcpy -M # kurze Version
|
||
```
|
||
|
||
Es kann zudem`--forward-all-clicks` übergeben werden, um [alle Mausklicks an das Gerät weiterzugeben](#rechtsklick-und-mittelklick).
|
||
|
||
Wenn dieser Modus aktiv ist, ist der Mauszeiger des Computers auf dem Fenster gefangen (Zeiger verschwindet von Computer und erscheint auf dem Android-Gerät).
|
||
|
||
Spezielle Tasteneingaben wie <kbd>Alt</kbd> oder <kbd>Super</kbd> ändern den Zustand des Mauszeigers (geben diesen wieder frei/fangen ihn wieder ein).
|
||
Eine dieser Tasten kann verwendet werden, um die Kontrolle der Maus wieder zurück an den Computer zu geben.
|
||
|
||
|
||
#### OTG
|
||
|
||
Es ist möglich, _scrcpy_ so auszuführen, dass nur Maus und Tastatur, wie wenn diese direkt über ein OTG-Kabel verbunden wären, simuliert werden.
|
||
|
||
In diesem Modus ist _adb_ nicht nötig, ebenso ist das Spiegeln der Anzeige deaktiviert.
|
||
|
||
Um den OTG-Modus zu aktivieren:
|
||
|
||
```bash
|
||
scrcpy --otg
|
||
# Seriennummer übergeben, falls mehrere Geräte vorhanden sind
|
||
scrcpy --otg -s 0123456789abcdef
|
||
```
|
||
|
||
Es ist möglich, nur HID-Tastatur oder HID-Maus zu aktivieren:
|
||
|
||
```bash
|
||
scrcpy --otg --hid-keyboard # nur Tastatur
|
||
scrcpy --otg --hid-mouse # nur Maus
|
||
scrcpy --otg --hid-keyboard --hid-mouse # Tastatur und Maus
|
||
# Der Einfachheit halber sind standardmäßig beide aktiv
|
||
scrcpy --otg # Tastatur und Maus
|
||
```
|
||
|
||
Wie `--hid-keyboard` und `--hid-mouse` funktioniert dies nur, wenn das Gerät per USB verbunden ist.
|
||
Zudem wird dies momentan nur unter Linux unterstützt.
|
||
|
||
|
||
#### Textinjektions-Vorliebe
|
||
|
||
Beim Tippen von Text werden zwei verschiedene [Events][textevents] generiert:
|
||
- _key events_, welche signalisieren, ob eine Taste gedrückt oder losgelassen wurde;
|
||
- _text events_, welche signalisieren, dass Text eingegeben wurde.
|
||
|
||
Standardmäßig werden key events verwendet, da sich bei diesen die Tastatur in Spielen wie erwartet verhält (typischerweise für WASD).
|
||
|
||
Dies kann jedoch [Probleme verursachen][prefertext]. Trifft man auf ein solches Problem, so kann dies mit diesem Befehl umgangen werden:
|
||
|
||
```bash
|
||
scrcpy --prefer-text
|
||
```
|
||
|
||
Dies kann jedoch das Tastaturverhalten in Spielen beeinträchtigen/zerstören.
|
||
|
||
Auf der anderen Seite kann jedoch auch die Nutzung von key events erzwungen werden:
|
||
|
||
```bash
|
||
scrcpy --raw-key-events
|
||
```
|
||
|
||
Diese Optionen haben jedoch keinen Einfluss auf eine etwaige HID-Tastatur, da in diesem modus alle key events als scancodes gesendet werden.
|
||
|
||
[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
|
||
[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
|
||
|
||
|
||
#### Wiederholen von Tasten
|
||
|
||
Standardmäßig löst das gedrückt halten einer Taste das jeweilige Event mehrfach aus. Dies kann jedoch zu Performanceproblemen in manchen Spielen führen.
|
||
|
||
Um das Weitergeben von sich wiederholenden Tasteneingaben zu verhindern:
|
||
|
||
```bash
|
||
scrcpy --no-key-repeat
|
||
```
|
||
|
||
This option has no effect on HID keyboard (key repeat is handled by Android
|
||
directly in this mode).
|
||
|
||
|
||
#### Rechtsklick und Mittelklick
|
||
|
||
Standardmäßig löst Rechtsklick BACK (wenn Bildschirm aus: POWER) und Mittelklick BACK aus. Um diese Kürzel abzuschalten und stattdessen die Eingaben direkt an das Gerät weiterzugeben:
|
||
|
||
```bash
|
||
scrcpy --forward-all-clicks
|
||
```
|
||
|
||
|
||
### Dateien ablegen
|
||
|
||
#### APK installieren
|
||
|
||
Um eine AKP zu installieren, kann diese per Drag-and-drop auf das _scrcpy_-Fenster gezogen werden.
|
||
|
||
Dabei erfolgt kein visuelles Feedback, ein Log wird in die Konsole ausgegeben.
|
||
|
||
|
||
#### Datei auf Gerät schieben
|
||
|
||
Um eine Datei nach `/sdcard/Download/` auf dem Gerät zu schieben, Drag-and-drop die (nicht-APK)-Datei auf das _scrcpy_-Fenster.
|
||
|
||
Dabei erfolgt kein visuelles Feedback, ein Log wird in die Konsole ausgegeben.
|
||
|
||
Das Zielverzeichnis kann beim Start geändert werden:
|
||
|
||
```bash
|
||
scrcpy --push-target=/sdcard/Movies/
|
||
```
|
||
|
||
|
||
### Audioweitergabe
|
||
|
||
Audio wird von _scrcpy_ nicht übertragen. Hierfür kann [sndcpy] verwendet werden.
|
||
|
||
Siehe zudem [issue #14].
|
||
|
||
[sndcpy]: https://github.com/rom1v/sndcpy
|
||
[issue #14]: https://github.com/Genymobile/scrcpy/issues/14
|
||
|
||
|
||
## Tastenkürzel
|
||
|
||
In der folgenden Liste ist <kbd>MOD</kbd> der Kürzel-Auslöser. Standardmäßig ist dies (links) <kbd>Alt</kbd> oder (links) <kbd>Super</kbd>.
|
||
|
||
Dies kann mithilfe von `--shortcut-mod` geändert werden. Mögliche Tasten sind `lstrg`, `rstrg`,
|
||
`lalt`, `ralt`, `lsuper` und `rsuper`. Beispielhaft:
|
||
|
||
```bash
|
||
# Nutze rStrg als Auslöser
|
||
scrcpy --shortcut-mod=rctrl
|
||
|
||
# Nutze entweder LStrg+LAlt oder LSuper für Tastenkürzel
|
||
scrcpy --shortcut-mod=lctrl+lalt,lsuper
|
||
```
|
||
|
||
_<kbd>[Super]</kbd> ist typischerweise die <kbd>Windows</kbd> oder <kbd>Cmd</kbd> Taste._
|
||
|
||
[Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
|
||
|
||
| Aktion | Tastenkürzel | |
|
||
|--------------------------------------------------------|-----------------------------------------------------------|:-------------------------|
|
||
| Vollbild wechseln | <kbd>MOD</kbd>+<kbd>f</kbd> | |
|
||
| Display nach links rotieren | <kbd>MOD</kbd>+<kbd>←</kbd> _(links)_ | |
|
||
| Display nach links rotieren | <kbd>MOD</kbd>+<kbd>→</kbd> _(rechts)_ | |
|
||
| Fenstergröße 1:1 replizieren (pixel-perfect) | <kbd>MOD</kbd>+<kbd>g</kbd> | |
|
||
| Fenstergröße zum entfernen der schwarzen Balken ändern | <kbd>MOD</kbd>+<kbd>w</kbd> | _Doppel-Linksklick¹_ |
|
||
| Klick auf `HOME` | <kbd>MOD</kbd>+<kbd>h</kbd> | _Mittelklick_ |
|
||
| Klick auf `BACK` | <kbd>MOD</kbd>+<kbd>b</kbd> | _Rechtsklick²_ |
|
||
| Klick auf `APP_SWITCH` | <kbd>MOD</kbd>+<kbd>s</kbd> | _4.-Taste-Klick³_ |
|
||
| Klick auf `MENU` (Bildschirm entsperren)⁴ | <kbd>MOD</kbd>+<kbd>m</kbd> | |
|
||
| Klick auf `VOLUME_UP` | <kbd>MOD</kbd>+<kbd>↑</kbd> _(hoch)_ | |
|
||
| CKlick auf `VOLUME_DOWN` | <kbd>MOD</kbd>+<kbd>↓</kbd> _(runter)_ | |
|
||
| Klick auf `POWER` | <kbd>MOD</kbd>+<kbd>p</kbd> | |
|
||
| Power an | _Rechtsklick²_ | |
|
||
| Gerätebildschirm ausschalten (weiterhin spiegeln) | <kbd>MOD</kbd>+<kbd>o</kbd> | |
|
||
| Gerätebildschirm einschalten | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd> | |
|
||
| Gerätebildschirm drehen | <kbd>MOD</kbd>+<kbd>r</kbd> | |
|
||
| Benachrichtigungs-Bereich anzeigen | <kbd>MOD</kbd>+<kbd>n</kbd> | _5.-Taste-Klick³_ |
|
||
| Erweitertes Einstellungs-Menü anzeigen | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> | _Doppel-5.-Taste-Klick³_ |
|
||
| Bedienfelder einklappen | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd> | |
|
||
| In die Zwischenablage kopieren⁵ | <kbd>MOD</kbd>+<kbd>c</kbd> | |
|
||
| In die Zwischenablage kopieren⁵ | <kbd>MOD</kbd>+<kbd>x</kbd> | |
|
||
| Zwischenablage synchronisieren und einfügen⁵ | <kbd>MOD</kbd>+<kbd>v</kbd> | |
|
||
| Computer-Zwischenablage einfügen (per Tastenevents) | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> | |
|
||
| FPS-Zähler aktivieren/deaktivieren (ing stdout) | <kbd>MOD</kbd>+<kbd>i</kbd> | |
|
||
| Ziehen zum Zoomen | <kbd>Strg</kbd>+_Klicken-und-Bewegen_ | |
|
||
| Drag-and-drop mit APK-Datei | APK von Computer installieren | |
|
||
| Drag-and-drop mit Nicht-APK Datei | [Datei auf das Gerät schieben](#datei-auf-gerät-schieben) | |
|
||
|
||
|
||
_¹Doppelklick auf die schwarzen Balken, um diese zu entfernen._
|
||
_²Rechtsklick aktiviert den Bildschirm, falls dieser aus war, ansonsten ZURÜCK._
|
||
_³4. und 5. Maustasten, wenn diese an der jeweiligen Maus vorhanden sind._
|
||
_⁴Für react-native Applikationen in Entwicklung, `MENU` öffnet das Entwickler-Menü._
|
||
_⁵Nur für Android >= 7._
|
||
|
||
Abkürzungen mit mehreren Tastenanschlägen werden durch das Loslassen und erneute Drücken der Taste erreicht.
|
||
Beispielhaft, um "Erweitere das Einstellungs-Menü" auszuführen:
|
||
|
||
1. Drücke und halte <kbd>MOD</kbd>.
|
||
2. Doppelklicke <kbd>n</kbd>.
|
||
3. Lasse <kbd>MOD</kbd> los.
|
||
|
||
Alle <kbd>Strg</kbd>+_Taste_ Tastenkürzel werden an das Gerät übergeben, sodass sie von der jeweiligen Applikation ausgeführt werden können.
|
||
|
||
|
||
## Personalisierte Pfade
|
||
|
||
Um eine spezifische _adb_ Binary zu verwenden, muss deren Pfad als Umgebungsvariable `ADB` deklariert werden:
|
||
|
||
```bash
|
||
ADB=/path/to/adb scrcpy
|
||
```
|
||
|
||
Um den Pfad der `scrcpy-server` Datei zu bearbeiten, muss deren Pfad in `SCRCPY_SERVER_PATH` bearbeitet werden.
|
||
|
||
Um das Icon von scrcpy zu ändern, muss `SCRCPY_ICON_PATH` geändert werden.
|
||
|
||
|
||
## Warum _scrcpy_?
|
||
|
||
Ein Kollege hat mich dazu herausgefordert, einen Namen so unaussprechbar wie [gnirehtet] zu finden.
|
||
|
||
[`strcpy`] kopiert einen **str**ing; `scrcpy` kopiert einen **scr**een.
|
||
|
||
[gnirehtet]: https://github.com/Genymobile/gnirehtet
|
||
[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
|
||
|
||
|
||
## Selbst bauen?
|
||
|
||
Siehe [BUILD].
|
||
|
||
|
||
## Typische Fehler
|
||
|
||
Siehe [FAQ](FAQ.md).
|
||
|
||
|
||
## Entwickler
|
||
|
||
[Entwicklerseite](DEVELOP.md).
|
||
|
||
|
||
## Licence
|
||
|
||
Copyright (C) 2018 Genymobile
|
||
Copyright (C) 2018-2022 Romain Vimont
|
||
|
||
Licensed under the Apache License, Version 2.0 (the "License");
|
||
you may not use this file except in compliance with the License.
|
||
You may obtain a copy of the License at
|
||
|
||
http://www.apache.org/licenses/LICENSE-2.0
|
||
|
||
Unless required by applicable law or agreed to in writing, software
|
||
distributed under the License is distributed on an "AS IS" BASIS,
|
||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
See the License for the specific language governing permissions and
|
||
limitations under the License.
|
||
|
||
## Artikel (auf Englisch)
|
||
|
||
- [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/
|