Display and control your Android device
Add German translation of README.md
Firqb58b566fa5c1
diff --git a/README.de.md b/README.de.mdnew file mode 100644index 00000000..ca080cd3--- /dev/null+++ b/README.de.md@@ -0,0 +1,1016 @@+_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][direct-win64]+ - 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ögerungs-Variation]: 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 Wifi 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+```++[connect]: 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/diff --git a/README.md b/README.mdindex e8ddf907..3d935e73 100644--- a/README.md+++ b/README.md@@ -1110,6 +1110,7 @@ Read the [developers page].This README is available in other languages:+- [Deutsch (German, `de`) - v1.22](README.de.md)- [Indonesian (Indonesia, `id`) - v1.16](README.id.md)- [Italiano (Italiano, `it`) - v1.19](README.it.md)- [日本語 (Japanese, `jp`) - v1.19](README.jp.md)