clean up

With --install, the server is installed only if the current version is
not already installed. Passing --reinstall force reinstallation is all
cases.

BUILD.md

@@ -46,7 +46,7 @@ sudo ninja -Cbuild-auto uninstall
 ### `master`
 
 The `master` branch concerns the latest release, and is the home page of the
-project on Github.
+project on GitHub.
 
 
 ### `dev`
@@ -272,10 +272,10 @@ install` must be run as root)._
 
 #### Option 2: Use prebuilt server
 
- - [`scrcpy-server-v1.22`][direct-scrcpy-server]  
-   _(SHA-256: c05d273eec7533c0e106282e0254cf04e7f5e8f0c2920ca39448865fab2a419b)_
+ - [`scrcpy-server-v1.24`][direct-scrcpy-server]  
+   <sub>SHA-256: `ae74a81ea79c0dc7250e586627c278c0a9a8c5de46c9fb5c38c167fb1a36f056`</sub>
 
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.22/scrcpy-server-v1.22
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.24/scrcpy-server-v1.24
 
 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
@@ -305,13 +305,16 @@ After a successful build, you can install _scrcpy_ on the system:
 sudo ninja -Cx install    # without sudo on Windows
 ```
 
-This installs three files:
+This installs several files:
 
- - `/usr/local/bin/scrcpy`
- - `/usr/local/share/scrcpy/scrcpy-server`
- - `/usr/local/share/man/man1/scrcpy.1`
+ - `/usr/local/bin/scrcpy` (main app)
+ - `/usr/local/share/scrcpy/scrcpy-server` (server to push to the device)
+ - `/usr/local/share/man/man1/scrcpy.1` (manpage)
+ - `/usr/local/share/icons/hicolor/256x256/apps/icon.png` (app icon)
+ - `/usr/local/share/zsh/site-functions/_scrcpy` (zsh completion)
+ - `/usr/local/share/bash-completion/completions/scrcpy` (bash completion)
 
-You can then [run](README.md#run) _scrcpy_.
+You can then [run](README.md#run) `scrcpy`.
 
 ### Uninstall
 

FAQ.md

@@ -158,22 +158,24 @@ screen, then you might get poor quality, especially visible on text (see [#40]).
 
 [#40]: https://github.com/Genymobile/scrcpy/issues/40
 
-To improve downscaling quality, trilinear filtering is enabled automatically
-if the renderer is OpenGL and if it supports mipmapping.
+This problem should be fixed in scrcpy v1.22: **update to the latest version**.
 
-On Windows, you might want to force OpenGL:
-
-```
-scrcpy --render-driver=opengl
-```
-
-You may also need to configure the [scaling behavior]:
+On older versions, you must configure the [scaling behavior]:
 
 > `scrcpy.exe` > Properties > Compatibility > Change high DPI settings >
 > Override high DPI scaling behavior > Scaling performed by: _Application_.
 
 [scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
 
+Also, to improve downscaling quality, trilinear filtering is enabled
+automatically if the renderer is OpenGL and if it supports mipmapping.
+
+On Windows, you might want to force OpenGL to enable mipmapping:
+
+```
+scrcpy --render-driver=opengl
+```
+
 
 ### Issue with Wayland
 

README.id.md

@@ -218,7 +218,7 @@ variation] does not impact the recorded file.
 
 #### Wireless
 
-_Scrcpy_ menggunakan `adb` untuk berkomunikasi dengan perangkat, dan` adb` dapat [terhubung] ke perangkat melalui TCP / IP:
+_Scrcpy_ menggunakan `adb` untuk berkomunikasi dengan perangkat, dan `adb` dapat [terhubung] ke perangkat melalui TCP / IP:
 
 1. Hubungkan perangkat ke Wi-Fi yang sama dengan komputer Anda.
 2. Dapatkan alamat IP perangkat Anda (dalam Pengaturan → Tentang ponsel → Status).
@@ -281,7 +281,7 @@ Dari terminal lain:
 scrcpy
 ```
 
-Untuk menghindari mengaktifkan penerusan port jarak jauh, Anda dapat memaksa sambungan maju sebagai gantinya (perhatikan `-L`, bukan` -R`):
+Untuk menghindari mengaktifkan penerusan port jarak jauh, Anda dapat memaksa sambungan maju sebagai gantinya (perhatikan `-L`, bukan `-R`):
 
 ```bash
 adb kill-server    # matikan server adb lokal di 5037
@@ -579,7 +579,7 @@ Lihat juga [Masalah #14].
 
 Dalam daftar berikut, <kbd>MOD</kbd> adalah pengubah pintasan. Secara default, ini (kiri) <kbd>Alt</kbd> atau (kiri) <kbd>Super</kbd>.
 
-Ini dapat diubah menggunakan `--shortcut-mod`. Kunci yang memungkinkan adalah `lctrl`,`rctrl`, `lalt`,` ralt`, `lsuper` dan` rsuper`. Sebagai contoh:
+Ini dapat diubah menggunakan `--shortcut-mod`. Kunci yang memungkinkan adalah `lctrl`, `rctrl`, `lalt`, `ralt`, `lsuper` dan `rsuper`. Sebagai contoh:
 
 ```bash
 # gunakan RCtrl untuk jalan pintas

README.it.md

@@ -1,23 +1,42 @@
-_Apri il [README](README.md) originale e sempre aggiornato._
+_Apri il [README](README.md) originale (in inglese) e sempre aggiornato._
 
-# scrcpy (v1.19)
+<img src="app/data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />
 
-Questa applicazione fornisce la visualizzazione e il controllo dei dispositivi Android collegati via USB (o [via TCP/IP][article-tcpip]). Non richiede alcun accesso _root_.
+# scrcpy (v1.23)
+
+_si pronuncia "**scr**een **c**o**py**"_
+
+[Leggi in altre lingue](#traduzioni)
+
+Questa applicazione fornisce la visualizzazione e il controllo di dispositivi Android collegati via USB (o [via TCP/IP](#tcpip-wireless)). Non richiede alcun accesso _root_.
 Funziona su _GNU/Linux_, _Windows_ e _macOS_.
 
 ![screenshot](assets/screenshot-debian-600.jpg)
 
 Si concentra su:
 
- - **leggerezza** (nativo, mostra solo lo schermo del dispositivo)
- - **prestazioni** (30~60fps)
- - **qualità** (1920×1080 o superiore)
- - **bassa latenza** ([35~70ms][lowlatency])
- - **tempo di avvio basso** (~ 1secondo per visualizzare la prima immagine)
- - **non invadenza** (nulla viene lasciato installato sul dispositivo)
+ - **leggerezza**: nativo, mostra solo lo schermo del dispositivo
+ - **prestazioni**: 30~120fps, in funzione del dispositivo
+ - **qualità**: 1920×1080 o superiore
+ - **bassa latenza**: [35~70ms][lowlatency]
+ - **tempo di avvio basso**: ~ 1secondo per visualizzare la prima immagine
+ - **non invadenza**: nulla rimane installato sul dispositivo
+ - **vantaggi per l'utente**: nessun account, nessuna pubblicità, non è richiesta alcuna connessione a internet
+ - **libertà**: software libero e a codice aperto (_free and open source_)
 
 [lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
 
+Le sue caratteristiche includono:
+ - [registrazione](#registrazione)
+ - mirroring con [schermo del dispositivo spento](#spegnere-lo-schermo)
+ - [copia-incolla](#copia-incolla) in entrambe le direzioni
+ - [qualità configurabile](#configurazione-di-acquisizione)
+ - schermo del dispositivo [come webcam (V4L2)](#v4l2loopback) (solo per Linux)
+ - [simulazione della tastiera fisica (HID)](#simulazione-della-tastiera-fisica-HID)
+ - [simulazione mouse fisico (HID)](#simulazione-del-mouse-fisico-HID)
+ - [modalità OTG](#otg)
+ - e altro ancora...
+
 
 ## Requisiti
 
@@ -49,12 +68,18 @@ Compila dai sorgenti: [BUILD] (in inglese) ([procedimento semplificato][BUILD_si
 
 ### Linux
 
-Su Debian (_testing_ e _sid_ per ora) e Ubuntu (20.04):
+Su Debian e Ubuntu:
 
 ```
 apt install scrcpy
 ```
 
+Su Arch Linux:
+
+```
+pacman -S scrcpy
+```
+
 È disponibile anche un pacchetto [Snap]: [`scrcpy`][snap-link].
 
 [snap-link]: https://snapstats.org/snaps/scrcpy
@@ -66,10 +91,6 @@ Per Fedora, è disponibile un pacchetto [COPR]: [`scrcpy`][copr-link].
 [COPR]: https://fedoraproject.org/wiki/Category:Copr
 [copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
 
-Per Arch Linux, è disponibile un pacchetto [AUR]: [`scrcpy`][aur-link].
-
-[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
-[aur-link]: https://aur.archlinux.org/packages/scrcpy/
 
 Per Gentoo, è disponibile una [Ebuild]: [`scrcpy/`][ebuild-link].
 
@@ -142,7 +163,7 @@ Collega un dispositivo Android ed esegui:
 scrcpy
 ```
 
-Scrcpy accetta argomenti da riga di comando, essi sono listati con:
+Scrcpy accetta argomenti da riga di comando, elencati con:
 
 ```bash
 scrcpy --help
@@ -186,6 +207,14 @@ scrcpy --max-fps 15
 
 Questo è supportato ufficialmente a partire da Android 10, ma potrebbe funzionare in versioni precedenti.
 
+L'attuale frame rate di acquisizione può essere stampato sulla console:
+
+```
+scrcpy --print-fps
+```
+
+Può anche essere abilitato o disabilitato in qualsiasi momento con <kbd>MOD</kbd>+<kbd>i</kbd>.
+
 #### Ritaglio
 
 Lo schermo del dispositivo può essere ritagliato per visualizzare solo parte di esso.
@@ -258,7 +287,7 @@ I "fotogrammi saltati" sono registrati nonostante non siano mostrati in tempo re
 
 #### v4l2loopback
 
-Su Linux è possibile inviare il flusso video ad un dispositivo v4l2 loopback, cosicchè un dispositivo Android possa essere aperto come una webcam da qualsiasi strumento compatibile con v4l2.
+Su Linux è possibile inviare il flusso video ad un dispositivo v4l2 loopback, cosicché un dispositivo Android possa essere aperto come una webcam da qualsiasi strumento compatibile con v4l2.
 
 Il modulo `v4l2loopback` deve essere installato:
 
@@ -321,42 +350,72 @@ scrcpy --display-buffer=50  # aggiungi 50 ms di buffer per la visualizzazione
 e per il V4L2 sink:
 
 ```bash
-scrcpy --v4l2-buffer=500    #  aggiungi 50 ms di buffer per il v4l2 sink
+scrcpy --v4l2-buffer=500    #  aggiungi 500 ms di buffer per il v4l2 sink
 ```
 
 
 ### Connessione
 
-#### Wireless
+#### TCP/IP (wireless)
 
+_Scrcpy_ usa `adb` per comunicare col dispositivo e `adb` può [connettersi][connect] a un dispositivo mediante TCP/IP. Il dispositivo deve essere collegato alla stessa rete del computer.
 
-_Scrcpy_ usa `adb` per comunicare col dispositivo e `adb` può [connettersi][connect] al dispositivo mediante TCP/IP:
+##### Automatico
 
-1. Connetti il dispositivo alla stessa rete Wi-Fi del tuo computer.
-2. Trova l'indirizzo IP del tuo dispositivo in Impostazioni → Informazioni sul telefono → Stato, oppure   eseguendo questo comando:
+Un'opzione `--tcpip` permette di configurare automaticamente la connessione. Ci sono due varianti.
+
+Se il dispositivo (accessibile a 192.168.1.1 in questo esempio) ascolta già su una porta (tipicamente 5555) per le connessioni adb in entrata, allora esegui:
+
+```bash
+scrcpy --tcpip=192.168.1.1       # la porta predefinita è 5555
+scrcpy --tcpip=192.168.1.1:5555
+```
+
+Se la modalità TCP/IP di adb è disabilitata sul dispositivo (o se non si conosce l'indirizzo IP indirizzo), collegare il dispositivo tramite USB, quindi eseguire:
+
+```bash
+scrcpy --tcpip # senza argomenti
+```
+
+Il comando troverà automaticamente l'indirizzo IP del dispositivo, abiliterà la modalità TCP/IP, quindi connettersi al dispositivo prima di iniziare.
+
+##### Manuale
+
+In alternativa, è possibile abilitare la connessione TCP/IP manualmente usando `adb`:
+
+1. Inserisci il dispositivo in una porta USB del tuo computer.
+2. Connetti il dispositivo alla stessa rete Wi-Fi del tuo computer.
+3. Ottieni l'indirizzo IP del tuo dispositivo, in Impostazioni → Informazioni sul telefono → Stato, o
+   eseguendo questo comando:
 
     ```bash
     adb shell ip route | awk '{print $9}'
     ```
 
-3. Abilita adb via TCP/IP sul tuo dispositivo: `adb tcpip 5555`.
-4. Scollega il tuo dispositivo.
-5. Connetti il tuo dispositivo: `adb connect IP_DISPOSITVO:5555` _(rimpiazza `IP_DISPOSITIVO`)_.
-6. Esegui `scrcpy` come al solito.
+4. Abilita adb via TCP/IP sul tuo dispositivo: `adb tcpip 5555`.
+5. Scollega il tuo dispositivo.
+6. Connettiti al tuo dispositivo: `adb connect DEVICE_IP:5555` _(sostituisci `DEVICE_IP`
+con l'indirizzo IP del dispositivo che hai trovato)_.
+7. Esegui `scrcpy` come al solito.
 
-Potrebbe essere utile diminuire il bit-rate e la definizione
+Da Android 11, una [opzione di debug wireless][adb-wireless] permette di evitare di dover collegare fisicamente il dispositivo direttamente al computer.
+
+[adb-wireless]: https://developer.android.com/studio/command-line/adb#connect-to-a-device-over-wi-fi-android-11+
+
+Se la connessione cade casualmente, esegui il comando `scrcpy` per riconnetterti. Se il comando dice che non ci sono dispositivi/emulatori trovati, prova ad eseguire `adb connect DEVICE_IP:5555` di nuovo, e poi `scrcpy` come al solito. Se dice ancora che non ne ha trovato nessuno, prova ad eseguire `adb disconnect` e poi esegui di nuovo questi due comandi.
+
+Potrebbe essere utile diminuire il bit-rate e la definizione:
 
 ```bash
 scrcpy --bit-rate 2M --max-size 800
-scrcpy -b2M -m800  # versione breve
+scrcpy -b2M -m800 # versione breve
 ```
 
 [connect]: https://developer.android.com/studio/command-line/adb.html#wireless
 
-
 #### Multi dispositivo
 
-Se in `adb devices` sono listati più dispositivi, è necessario specificare il _seriale_:
+Se in `adb devices` sono elencati più dispositivi, è necessario specificare il _seriale_:
 
 ```bash
 scrcpy --serial 0123456789abcdef
@@ -370,6 +429,18 @@ scrcpy --serial 192.168.0.1:5555
 scrcpy -s 192.168.0.1:5555  # versione breve
 ```
 
+Se solo un dispositivo è collegato via USB o TCP/IP, è possibile selezionarlo automaticamente:
+
+```bash
+# Select the only device connected via USB
+scrcpy -d             # like adb -d
+scrcpy --select-usb   # long version
+
+# Select the only device connected via TCP/IP
+scrcpy -e             # like adb -e
+scrcpy --select-tcpip # long version
+```
+
 Puoi avviare più istanze di _scrcpy_ per diversi dispositivi.
 
 
@@ -383,37 +454,77 @@ autoadb scrcpy -s '{}'
 
 [AutoAdb]: https://github.com/rom1v/autoadb
 
-#### Tunnel SSH
+#### Tunnels
 
-Per connettersi a un dispositivo remoto è possibile collegare un client `adb` locale ad un server `adb` remoto (assunto che entrambi stiano usando la stessa versione del protocollo _adb_):
+Per connettersi a un dispositivo remoto, è possibile collegare un client `adb` locale a un server remoto `adb` (purché usino la stessa versione del protocollo _adb_). ).
+
+##### Server ADB remoto
+
+Per connettersi a un server ADB remoto, fate ascoltare il server su tutte le interfacce:
 
 ```bash
-adb kill-server    # termina il server adb locale su 5037
-ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
-# tieni questo aperto
+adb kill-server
+adb -a nodaemon server start
+# tienilo aperto
 ```
 
-Da un altro terminale:
+**Attenzione: tutte le comunicazioni tra i client e il server ADB non sono criptate.**
+
+Supponi che questo server sia accessibile a 192.168.1.2. Poi, da un altro terminale, esegui scrcpy:
 
 ```bash
+export ADB_SERVER_SOCKET=tcp:192.168.1.2:5037
+scrcpy --tunnel-host=192.168.1.2
+```
+
+Per impostazione predefinita, scrcpy utilizza la porta locale utilizzata per il tunnel `adb forward` (tipicamente `27183`, vedi `--port`). È anche possibile forzare una diversa porta del tunnel (può essere utile in situazioni più complesse, quando sono coinvolti più reindirizzamenti):
+
+```
+scrcpy --tunnel-port=1234
+```
+
+##### SSH tunnel
+
+Per comunicare con un server ADB remoto in modo sicuro, è preferibile utilizzare un tunnel SSH.
+
+Per prima cosa, assicurati che il server ADB sia in esecuzione sul computer remoto:
+
+```bash
+adb start-server
+```
+
+Poi, crea un tunnel SSH:
+
+```bash
+# local  5038 --> remote  5037
+# local 27183 <-- remote 27183
+ssh -CN -L5038:localhost:5037 -R27183:localhost:27183 your_remote_computer
+# keep this open
+```
+
+Da un altro terminale, esegui scrcpy:
+
+```bash
+export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy
 ```
 
 Per evitare l'abilitazione dell'apertura porte remota potresti invece forzare una "forward connection" (notare il `-L` invece di `-R`)
 
 ```bash
-adb kill-server    # termina il server adb locale su 5037
-ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
+# local  5038 --> remote  5037
+# local 27183 --> remote 27183
+ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # tieni questo aperto
 ```
 
-Da un altro terminale:
+Da un altro terminale, esegui scrcpy:
 
 ```bash
+export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy --force-adb-forward
 ```
 
-
 Come per le connessioni wireless potrebbe essere utile ridurre la qualità:
 
 ```
@@ -551,6 +662,14 @@ scrcpy --turn-screen-off --stay-awake
 scrcpy -Sw
 ```
 
+#### Spegnimento alla chiusura
+
+Per spegnere lo schermo del dispositivo quando si chiude scrcpy:
+
+```bash
+scrcpy --power-off-on-close
+```
+
 
 #### Mostrare i tocchi
 
@@ -596,20 +715,22 @@ Qualsiasi scorciatoia <kbd>Ctrl</kbd> viene inoltrata al dispositivo. In partico
  - <kbd>Ctrl</kbd>+<kbd>x</kbd> taglia
  - <kbd>Ctrl</kbd>+<kbd>v</kbd> incolla (dopo la sincronizzazione degli appunti da computer a dispositivo)
 
-Questo solitamente funziona nella maniera più comune.
+Questo solitamente funziona come ci si aspetta.
 
 Il comportamento reale, però, dipende dall'applicazione attiva. Per esempio _Termux_ invia SIGINT con <kbd>Ctrl</kbd>+<kbd>c</kbd>, e _K-9 Mail_ compone un nuovo messaggio.
 
 Per copiare, tagliare e incollare in questi casi (ma è solo supportato in Android >= 7):
- - <kbd>MOD</kbd>+<kbd>c</kbd> inietta `COPY`
- - <kbd>MOD</kbd>+<kbd>x</kbd> inietta `CUT`
- - <kbd>MOD</kbd>+<kbd>v</kbd> inietta `PASTE` (dopo la sincronizzazione degli appunti da computer a dispositivo)
+ - <kbd>MOD</kbd>+<kbd>c</kbd> invia `COPY`
+ - <kbd>MOD</kbd>+<kbd>x</kbd> invia `CUT`
+ - <kbd>MOD</kbd>+<kbd>v</kbd> invia `PASTE` (dopo la sincronizzazione degli appunti da computer a dispositivo)
 
-In aggiunta, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> permette l'iniezione del testo degli appunti del computer come una sequenza di eventi pressione dei tasti. Questo è utile quando il componente non accetta l'incollaggio di testo (per esempio in _Termux_), ma questo può rompere il contenuto non ASCII.
+In aggiunta, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> permette l'invio del testo degli appunti del computer come una sequenza di eventi pressione dei tasti. Questo è utile quando il componente non accetta l'incollaggio di testo (per esempio in _Termux_), ma questo può compromettere il contenuto non ASCII.
 
 **AVVISO:** Incollare gli appunti del computer nel dispositivo (sia con <kbd>Ctrl</kbd>+<kbd>v</kbd> che con <kbd>MOD</kbd>+<kbd>v</kbd>) copia il contenuto negli appunti del dispositivo. Come conseguenza, qualsiasi applicazione Android potrebbe leggere il suo contenuto. Dovresti evitare di incollare contenuti sensibili (come password) in questa maniera.
 
-Alcuni dispositivi non si comportano come aspettato quando si modificano gli appunti del dispositivo a livello di codice. L'opzione `--legacy-paste` è fornita per cambiare il comportamento di <kbd>Ctrl</kbd>+<kbd>v</kbd> and <kbd>MOD</kbd>+<kbd>v</kbd> in modo tale che anch'essi iniettino il testo gli appunti del computer come una sequenza di eventi pressione dei tasti (nella stessa maniera di <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>).
+Alcuni dispositivi non si comportano come aspettato quando si modificano gli appunti del dispositivo a livello di codice. L'opzione `--legacy-paste` è fornita per cambiare il comportamento di <kbd>Ctrl</kbd>+<kbd>v</kbd> and <kbd>MOD</kbd>+<kbd>v</kbd> in modo tale che anch'essi inviino il testo degli appunti del computer come una sequenza di eventi di pressione dei tasti (nella stessa maniera di <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>).
+
+Per disabilitare la sincronizzazione automatica degli appunti, usa `--no-clipboard-autosync`.
 
 #### Pizzica per zoomare (pinch-to-zoom)
 
@@ -617,16 +738,98 @@ Per simulare il "pizzica per zoomare": <kbd>Ctrl</kbd>+_click e trascina_.
 
 Più precisamente, tieni premuto <kbd>Ctrl</kbd> mentre premi il pulsante sinistro. Finchè il pulsante non sarà rilasciato, tutti i movimenti del mouse ridimensioneranno e ruoteranno il contenuto (se supportato dall'applicazione) relativamente al centro dello schermo.
 
-Concretamente scrcpy genera degli eventi di tocco addizionali di un "dito virtuale" nella posizione simmetricamente opposta rispetto al centro dello schermo.
+Concretamente, scrcpy genera degli eventi di tocco addizionali di un "dito virtuale" nella posizione simmetricamente opposta rispetto al centro dello schermo.
+
+#### Simulazione della tastiera fisica (HID)
+
+Per impostazione predefinita, scrcpy utilizza l'invio dei tasti o del testo di Android: funziona ovunque, ma è limitato all'ASCII.
+
+In alternativa scrcpy può simulare una tastiera fisica USB su Android per fornire una migliore esperienza di input (utilizzando [USB HID over AOAv2][hid-aoav2]): la tastiera virtuale è disabilitata e funziona per tutti i caratteri e IME.
+
+[hid-aoav2]: https://source.android.com/devices/accessories/aoa2#hid-support
+
+Tuttavia, funziona solo se il dispositivo è collegato via USB.
+
+Nota: su Windows, può funzionare solo in [odalità OTG](#otg), non durante il mirroring (non è possibile aprire un dispositivo USB se è già aperto da un altro processo come il daemon adb).
+
+Per abilitare questa modalità:
+
+```bash
+scrcpy --hid-keyboard
+scrcpy -K # versione breve
+```
+
+Se fallisce per qualche motivo (per esempio perché il dispositivo non è connesso via USB), ritorna automaticamente alla modalità predefinita (con un log nella console). Questo permette di usare le stesse opzioni della linea di comando quando si è connessi via USB e TCP/IP.
+
+In questa modalità, gli eventi i pressione originali (scancodes) sono inviati al dispositivo, indipendentemente dalla mappatura dei tasti dell'host. Pertanto, se il layout della tua tastiera non corrisponde, deve essere configurato sul dispositivo Android, in Impostazioni → Sistema → Lingue e input → [Tastiera fisica] (in inglese).
+
+Questa pagina di impostazioni può essere avviata direttamente:
+
+```bash
+adb shell am start -a android.settings.HARD_KEYBOARD_SETTINGS
+```
+
+Tuttavia, l'opzione è disponibile solo quando la tastiera HID è abilitata (o quando una tastiera fisica è collegata).
+
+[Tastiera fisica]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915
+
+#### Simulazione del mouse fisico (HID)
+
+In modo simile alla simulazione della tastiera fisica, è possibile simulare un mouse fisico. Allo stesso modo funziona solo se il dispositivo è connesso via USB.
+
+Per impostazione predefinita, scrcpy utilizza l'invio degli eventi del mouse di Android, utilizzando coordinate assolute. Simulando un mouse fisico, un puntatore del mouse appare sul dispositivo Android e vengono inviati i movimenti relativi del mouse, i click e gli scorrimenti.
+
+Per abilitare questa modalità:
+
+```bash
+scrcpy --hid-mouse
+scrcpy -M # versione breve
+```
+
+Si potrebbe anche aggiungere `--forward-all-clicks` a [inoltra tutti i pulsanti del mouse][forward_all_clicks].
+
+[forward_all_clicks]: #click-destro-e-click-centrale
 
 
-#### Preferenze di iniezione del testo
+Quando questa modalità è attivata, il mouse del computer viene "catturato" (il puntatore del mouse scompare dal computer e appare invece sul dispositivo Android).
+
+I tasti speciali di cattura, <kbd>Alt</kbd> o <kbd>Super</kbd>, commutano (disabilitano o abilitano) la cattura del mouse. Usa uno di essi per ridare il controllo del mouse al computer.
+
+
+#### OTG
+
+È possibile eseguire _scrcpy_ con la sola simulazione della tastiera fisica e del mouse (HID), come se la tastiera e il mouse del computer fossero collegati direttamente al dispositivo tramite un cavo OTG.
+
+In questa modalità, _adb_ (debug USB) non è necessario e il mirroring è disabilitato.
+
+Per attivare la modallità OTG:
+
+```bash
+scrcpy --otg
+# Passa la seriale se sono disponibili diversi dispositivi USB
+scrcpy --otg -s 0123456789abcdef
+```
+
+È possibile abilitare solo la tastiera HID o il mouse HID:
+
+```bash
+scrcpy --otg --hid-keyboard # solo la tastiera
+scrcpy --otg --hid-mouse # solo mouse
+scrcpy --otg --hid-keyboard --hid-mouse # tastiera e mouse
+# per comodità, abilita entrambi per default
+scrcpy --otg # tastiera e mouse
+```
+
+Come `--hid-keyboard` e `--hid-mouse`, funziona solo se il dispositivo è collegato via USB.
+
+
+#### Preferenze di invio del testo
 
 Ci sono due tipi di [eventi][textevents] generati quando si scrive testo:
  - _eventi di pressione_, segnalano che tasto è stato premuto o rilasciato;
  - _eventi di testo_, segnalano che del testo è stato inserito.
 
-In maniera predefinita le lettere sono "iniettate" usando gli eventi di pressione, in maniera tale che la tastiera si comporti come aspettato nei giochi (come accade solitamente per i tasti WASD).
+In maniera predefinita le lettere sono inviate usando gli eventi di pressione, in maniera tale che la tastiera si comporti come aspettato nei giochi (come accade solitamente per i tasti WASD).
 
 Questo, però, può [causare problemi][prefertext]. Se incontri un problema del genere, puoi evitarlo con:
 
@@ -636,13 +839,21 @@ scrcpy --prefer-text
 
 (ma questo romperà il normale funzionamento della tastiera nei giochi)
 
+Al contrario, si potrebbe forzare per inviare sempre eventi di pressione grezzi:
+
+```bash
+scrcpy --raw-key-events
+```
+
+Queste opzioni non hanno effetto sulla tastiera HID (tutti gli eventi di pressione sono inviati come scancodes in questa modalità).
+
 [textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
 [prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
 
 
 #### Ripetizione di tasti
 
-In maniera predefinita tenere premuto un tasto genera una ripetizione degli eventi di pressione di tale tasto. Questo può creare problemi di performance in alcuni giochi, dove questi eventi sono inutilizzati.
+In maniera predefinita, tenere premuto un tasto genera una ripetizione degli eventi di pressione di tale tasto. Questo può creare problemi di performance in alcuni giochi, dove questi eventi sono inutilizzati.
 
 Per prevenire l'inoltro ripetuto degli eventi di pressione:
 
@@ -650,9 +861,12 @@ Per prevenire l'inoltro ripetuto degli eventi di pressione:
 scrcpy --no-key-repeat
 ```
 
+Questa opzione non ha effetto sulla tastiera HID (la ripetizione dei tasti è gestita da Android direttamente in questa modalità).
+
+
 #### Click destro e click centrale
 
-In maniera predefinita, click destro aziona BACK (indietro) e il click centrale aziona HOME. Per disabilitare queste scorciatoie e, invece, inviare i click al dispositivo:
+In maniera predefinita, click destro aziona BACK (indietro) o POWER on (accensione) e il click centrale aziona HOME. Per disabilitare queste scorciatoie e, invece, inviare i click al dispositivo:
 
 ```bash
 scrcpy --forward-all-clicks
@@ -705,7 +919,7 @@ scrcpy --shortcut-mod=rctrl
 scrcpy --shortcut-mod=lctrl+lalt,lsuper
 ```
 
-_<kbd>[Super]</kbd> è il pulsante <kbd>Windows</kbd> o <kbd>Cmd</kbd>._
+_<kbd>[Super]</kbd> è solitamente il pulsante <kbd>Windows</kbd> o <kbd>Cmd</kbd>._
 
 [Super]: https://it.wikipedia.org/wiki/Tasto_Windows
 <!-- https://en.wikipedia.org/wiki/Super_key_(keyboard_button) è la pagina originale di Wikipedia inglese, l'ho sostituita con una simile in quello italiano -->
@@ -720,7 +934,7 @@ _<kbd>[Super]</kbd> è il pulsante <kbd>Windows</kbd> o <kbd>Cmd</kbd>._
  | Premi il tasto `HOME`                             | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Click centrale_
  | Premi il tasto `BACK`                             | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Click destro²_
  | Premi il tasto `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4° click³_
- | Premi il tasto `MENU` (sblocca lo schermo)             | <kbd>MOD</kbd>+<kbd>m</kbd>
+ | Premi il tasto `MENU` (sblocca lo schermo)⁴           | <kbd>MOD</kbd>+<kbd>m</kbd>
  | Premi il tasto `VOLUME_UP`                        | <kbd>MOD</kbd>+<kbd>↑</kbd> _(su)_
  | Premi il tasto `VOLUME_DOWN`                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(giù)_
  | Premi il tasto `POWER`                            | <kbd>MOD</kbd>+<kbd>p</kbd>
@@ -731,17 +945,20 @@ _<kbd>[Super]</kbd> è il pulsante <kbd>Windows</kbd> o <kbd>Cmd</kbd>._
  | Espandi il pannello delle notifiche                   | <kbd>MOD</kbd>+<kbd>n</kbd> \| _5° click³_
  | Espandi il pannello delle impostazioni                   | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Doppio 5° click³_
  | Chiudi pannelli                 | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | Copia negli appunti⁴                          | <kbd>MOD</kbd>+<kbd>c</kbd>
- | Taglia negli appunti⁴                           | <kbd>MOD</kbd>+<kbd>x</kbd>
- | Sincronizza gli appunti e incolla⁴           | <kbd>MOD</kbd>+<kbd>v</kbd>
- | Inietta il testo degli appunti del computer              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
+ | Copia negli appunti⁵                          | <kbd>MOD</kbd>+<kbd>c</kbd>
+ | Taglia negli appunti⁵                           | <kbd>MOD</kbd>+<kbd>x</kbd>
+ | Sincronizza gli appunti e incolla⁵           | <kbd>MOD</kbd>+<kbd>v</kbd>
+ | Invia il testo degli appunti del computer              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
  | Abilita/Disabilita il contatore FPS (su stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
  | Pizzica per zoomare                               | <kbd>Ctrl</kbd>+_click e trascina_
+ | Trascina file APK                        | Installa APK dal computer
+ | Trascina file non-APK                    | [Trasferisci file verso il dispositivo](#push-file-to-device)
 
 _¹Doppio click sui bordi neri per rimuoverli._  
 _²Il tasto destro accende lo schermo se era spento, preme BACK in caso contrario._  
 _³4° e 5° pulsante del mouse, se il tuo mouse ne dispone._  
-_⁴Solo in Android >= 7._
+_⁴Per le app native react in sviluppo, `MENU` attiva il menu di sviluppo._  
+_⁵Solo in Android >= 7._
 
 Le scorciatoie con pulsanti ripetuti sono eseguite rilasciando e premendo il pulsante una seconda volta. Per esempio, per eseguire "Espandi il pannello delle impostazioni":
 
@@ -811,3 +1028,14 @@ Leggi la [pagina per sviluppatori].
 
 [article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
 [article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
+
+## Contatti
+
+Se incontri un bug, per favore leggi prima le [FAQ](FAQ.it.md), poi apri una [issue].
+
+[issue]: https://github.com/Genymobile/scrcpy/issues
+
+Per domande generali o discussioni, puoi anche usare:
+
+ - Reddit: [`r/scrcpy`](https://www.reddit.com/r/scrcpy)
+ - Twitter: [`@scrcpy_app`](https://twitter.com/scrcpy_app)

README.md

@@ -1,13 +1,13 @@
-# scrcpy (v1.22)
+# scrcpy (v1.24)
 
-<img src="data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />
+<img src="app/data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />
 
 _pronounced "**scr**een **c**o**py**"_
 
 [Read in another language](#translations)
 
 This application provides display and control of Android devices connected via
-USB (or [over TCP/IP](#tcpip-wireless)). It does not require any _root_ access.
+USB or [over TCP/IP](#tcpip-wireless). It does not require any _root_ access.
 It works on _GNU/Linux_, _Windows_ and _macOS_.
 
 ![screenshot](assets/screenshot-debian-600.jpg)
@@ -19,7 +19,7 @@ It focuses on:
  - **quality**: 1920×1080 or above
  - **low latency**: [35~70ms][lowlatency]
  - **low startup time**: ~1 second to display the first image
- - **non-intrusiveness**: nothing is left installed on the device
+ - **non-intrusiveness**: nothing is left installed on the Android device
  - **user benefits**: no account, no ads, no internet required
  - **freedom**: free and open source software
 
@@ -27,10 +27,10 @@ It focuses on:
 
 Its features include:
  - [recording](#recording)
- - mirroring with [device screen off](#turn-screen-off)
+ - mirroring with [Android device screen off](#turn-screen-off)
  - [copy-paste](#copy-paste) in both directions
  - [configurable quality](#capture-configuration)
- - device screen [as a webcam (V4L2)](#v4l2loopback) (Linux-only)
+ - Android device [as a webcam (V4L2)](#v4l2loopback) (Linux-only)
  - [physical keyboard simulation (HID)](#physical-keyboard-simulation-hid)
  - [physical mouse simulation (HID)](#physical-mouse-simulation-hid)
  - [OTG mode](#otg)
@@ -40,12 +40,12 @@ Its features include:
 
 The Android device requires at least API 21 (Android 5.0).
 
-Make sure you [enabled adb debugging][enable-adb] on your device(s).
+Make sure you [enable adb debugging][enable-adb] on your device(s).
 
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 
 On some devices, you also need to enable [an additional option][control] to
-control it using keyboard and mouse.
+control it using a keyboard and mouse.
 
 [control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
 
@@ -97,19 +97,19 @@ For Gentoo, an [Ebuild] is available: [`scrcpy/`][ebuild-link].
 [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
 
-You could also [build the app manually][BUILD] ([simplified
+You can also [build the app manually][BUILD] ([simplified
 process][BUILD_simple]).
 
 
 ### Windows
 
-For Windows, for simplicity, a prebuilt archive with all the dependencies
-(including `adb`) is available:
+For Windows, a prebuilt archive with all the dependencies (including `adb`) is
+available:
 
- - [`scrcpy-win64-v1.22.zip`][direct-win64]  
-   _(SHA-256: ce4d9b8cc761e29862c4a72d8ad6f538bdd1f1831d15fd1f36633cd3b403db82)_
+ - [`scrcpy-win64-v1.24.zip`][direct-win64]  
+   <sub>SHA-256: `6ccb64cba0a3e75715e85a188daeb4f306a1985f8ce123eba92ba74fc9b27367`</sub>
 
-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.22/scrcpy-win64-v1.22.zip
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.24/scrcpy-win64-v1.24.zip
 
 It is also available in [Chocolatey]:
 
@@ -148,7 +148,7 @@ You need `adb`, accessible from your `PATH`. If you don't have it yet:
 brew install android-platform-tools
 ```
 
-It's also available in [MacPorts], which sets up adb for you:
+It's also available in [MacPorts], which sets up `adb` for you:
 
 ```bash
 sudo port install scrcpy
@@ -162,7 +162,7 @@ You can also [build the app manually][BUILD].
 
 ## Run
 
-Plug an Android device, and execute:
+Plug an Android device into your computer, and execute:
 
 ```bash
 scrcpy
@@ -180,7 +180,7 @@ scrcpy --help
 
 #### Reduce size
 
-Sometimes, it is useful to mirror an Android device at a lower definition to
+Sometimes, it is useful to mirror an Android device at a lower resolution to
 increase performance.
 
 To limit both the width and height to some value (e.g. 1024):
@@ -190,8 +190,8 @@ scrcpy --max-size 1024
 scrcpy -m 1024  # short version
 ```
 
-The other dimension is computed to that the device aspect ratio is preserved.
-That way, a device in 1920×1080 will be mirrored at 1024×576.
+The other dimension is computed so that the Android device aspect ratio is
+preserved. That way, a device in 1920×1080 will be mirrored at 1024×576.
 
 
 #### Change bit-rate
@@ -226,7 +226,7 @@ It may also be enabled or disabled at any time with <kbd>MOD</kbd>+<kbd>i</kbd>.
 
 The device screen may be cropped to mirror only part of the screen.
 
-This is useful for example to mirror only one eye of the Oculus Go:
+This is useful, for example, to mirror only one eye of the Oculus Go:
 
 ```bash
 scrcpy --crop 1224:1440:0:0   # 1224x1440 at offset (0,0)
@@ -237,7 +237,6 @@ If `--max-size` is also specified, resizing is applied after cropping.
 
 #### Lock video orientation
 
-
 To lock the orientation of the mirroring:
 
 ```bash
@@ -262,7 +261,7 @@ crash. It is possible to select a different encoder:
 scrcpy --encoder OMX.qcom.video.encoder.avc
 ```
 
-To list the available encoders, you could pass an invalid encoder name, the
+To list the available encoders, you can pass an invalid encoder name; the
 error will give the available encoders:
 
 ```bash
@@ -326,7 +325,7 @@ v4l2-ctl --list-devices
 ls /dev/video*
 ```
 
-To start scrcpy using a v4l2 sink:
+To start `scrcpy` using a v4l2 sink:
 
 ```bash
 scrcpy --v4l2-sink=/dev/videoN
@@ -334,7 +333,7 @@ scrcpy --v4l2-sink=/dev/videoN --no-display  # disable mirroring window
 scrcpy --v4l2-sink=/dev/videoN -N            # short version
 ```
 
-(replace `N` by the device ID, check with `ls /dev/video*`)
+(replace `N` with the device ID, check with `ls /dev/video*`)
 
 Once enabled, you can open your video stream with a v4l2-capable tool:
 
@@ -350,7 +349,7 @@ For example, you could capture the video within [OBS].
 
 #### Buffering
 
-It is possible to add buffering. This increases latency but reduces jitter (see
+It is possible to add buffering. This increases latency, but reduces jitter (see
 [#2464]).
 
 [#2464]: https://github.com/Genymobile/scrcpy/issues/2464
@@ -382,14 +381,14 @@ An option `--tcpip` allows to configure the connection automatically. There are
 two variants.
 
 If the device (accessible at 192.168.1.1 in this example) already listens on a
-port (typically 5555) for incoming adb connections, then run:
+port (typically 5555) for incoming _adb_ connections, then run:
 
 ```bash
 scrcpy --tcpip=192.168.1.1       # default port is 5555
 scrcpy --tcpip=192.168.1.1:5555
 ```
 
-If adb TCP/IP mode is disabled on the device (or if you don't know the IP
+If _adb_ TCP/IP mode is disabled on the device (or if you don't know the IP
 address), connect the device over USB, then run:
 
 ```bash
@@ -413,7 +412,7 @@ Alternatively, it is possible to enable the TCP/IP connection manually using
     adb shell ip route | awk '{print $9}'
     ```
 
-4. Enable adb over TCP/IP on your device: `adb tcpip 5555`.
+4. Enable `adb` over TCP/IP on your device: `adb tcpip 5555`.
 5. Unplug your device.
 6. Connect to your device: `adb connect DEVICE_IP:5555` _(replace `DEVICE_IP`
 with the device IP address you found)_.
@@ -427,9 +426,9 @@ having to physically connect your device directly to your computer.
 If the connection randomly drops, run your `scrcpy` command to reconnect. If it
 says there are no devices/emulators found, try running `adb connect
 DEVICE_IP:5555` again, and then `scrcpy` as usual. If it still says there are
-none found, try running `adb disconnect` and then run those two commands again.
+none found, try running `adb disconnect`, and then run those two commands again.
 
-It may be useful to decrease the bit-rate and the definition:
+It may be useful to decrease the bit-rate and the resolution:
 
 ```bash
 scrcpy --bit-rate 2M --max-size 800
@@ -448,6 +447,9 @@ scrcpy --serial 0123456789abcdef
 scrcpy -s 0123456789abcdef  # short version
 ```
 
+The serial may also be provided via the environment variable `ANDROID_SERIAL`
+(also used by `adb`).
+
 If the device is connected over TCP/IP:
 
 ```bash
@@ -488,7 +490,7 @@ protocol).
 
 ##### Remote ADB server
 
-To connect to a remote ADB server, make the server listen on all interfaces:
+To connect to a remote _adb server_, make the server listen on all interfaces:
 
 ```bash
 adb kill-server
@@ -496,17 +498,18 @@ adb -a nodaemon server start
 # keep this open
 ```
 
-**Warning: all communications between clients and ADB server are unencrypted.**
+**Warning: all communications between clients and the _adb server_ are
+unencrypted.**
 
 Suppose that this server is accessible at 192.168.1.2. Then, from another
-terminal, run scrcpy:
+terminal, run `scrcpy`:
 
 ```bash
 export ADB_SERVER_SOCKET=tcp:192.168.1.2:5037
 scrcpy --tunnel-host=192.168.1.2
 ```
 
-By default, scrcpy uses the local port used for `adb forward` tunnel
+By default, `scrcpy` uses the local port used for `adb forward` tunnel
 establishment (typically `27183`, see `--port`). It is also possible to force a
 different tunnel port (it may be useful in more complex situations, when more
 redirections are involved):
@@ -518,16 +521,16 @@ scrcpy --tunnel-port=1234
 
 ##### SSH tunnel
 
-To communicate with a remote ADB server securely, it is preferable to use a SSH
-tunnel.
+To communicate with a remote _adb server_ securely, it is preferable to use an
+SSH tunnel.
 
-First, make sure the ADB server is running on the remote computer:
+First, make sure the _adb server_ is running on the remote computer:
 
 ```bash
 adb start-server
 ```
 
-Then, establish a SSH tunnel:
+Then, establish an SSH tunnel:
 
 ```bash
 # local  5038 --> remote  5037
@@ -536,7 +539,7 @@ ssh -CN -L5038:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # keep this open
 ```
 
-From another terminal, run scrcpy:
+From another terminal, run `scrcpy`:
 
 ```bash
 export ADB_SERVER_SOCKET=tcp:localhost:5038
@@ -553,7 +556,7 @@ ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # keep this open
 ```
 
-From another terminal, run scrcpy:
+From another terminal, run `scrcpy`:
 
 ```bash
 export ADB_SERVER_SOCKET=tcp:localhost:5038
@@ -595,7 +598,7 @@ scrcpy --window-borderless
 
 #### Always on top
 
-To keep the scrcpy window always on top:
+To keep the _scrcpy_ window always on top:
 
 ```bash
 scrcpy --always-on-top
@@ -620,7 +623,7 @@ The window may be rotated:
 scrcpy --rotation 1
 ```
 
-Possibles values are:
+Possible values:
  - `0`: no rotation
  - `1`: 90 degrees counterclockwise
  - `2`: 180 degrees
@@ -669,19 +672,19 @@ adb shell dumpsys display   # search "mDisplayId=" in the output
 ```
 
 The secondary display may only be controlled if the device runs at least Android
-10 (otherwise it is mirrored in read-only).
+10 (otherwise it is mirrored as read-only).
 
 
 #### Stay awake
 
-To prevent the device to sleep after some delay when the device is plugged in:
+To prevent the device from sleeping after a delay when the device is plugged in:
 
 ```bash
 scrcpy --stay-awake
 scrcpy -w
 ```
 
-The initial state is restored when scrcpy is closed.
+The initial state is restored when _scrcpy_ is closed.
 
 
 #### Turn screen off
@@ -699,9 +702,10 @@ Or by pressing <kbd>MOD</kbd>+<kbd>o</kbd> at any time.
 To turn it back on, press <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>.
 
 On Android, the `POWER` button always turns the screen on. For convenience, if
-`POWER` is sent via scrcpy (via right-click or <kbd>MOD</kbd>+<kbd>p</kbd>), it
-will force to turn the screen off after a small delay (on a best effort basis).
-The physical `POWER` button will still cause the screen to be turned on.
+`POWER` is sent via _scrcpy_ (via right-click or <kbd>MOD</kbd>+<kbd>p</kbd>),
+it will force to turn the screen off after a small delay (on a best effort
+basis).  The physical `POWER` button will still cause the screen to be turned
+on.
 
 It can also be useful to prevent the device from sleeping:
 
@@ -712,12 +716,22 @@ scrcpy -Sw
 
 #### Power off on close
 
-To turn the device screen off when closing scrcpy:
+To turn the device screen off when closing _scrcpy_:
 
 ```bash
 scrcpy --power-off-on-close
 ```
 
+#### Power on on start
+
+By default, on start, the device is powered on.
+
+To prevent this behavior:
+
+```bash
+scrcpy --no-power-on
+```
+
 
 #### Show touches
 
@@ -734,12 +748,13 @@ scrcpy --show-touches
 scrcpy -t
 ```
 
-Note that it only shows _physical_ touches (with the finger on the device).
+Note that it only shows _physical_ touches (by a finger on the device).
 
 
 #### Disable screensaver
 
-By default, scrcpy does not prevent the screensaver to run on the computer.
+By default, _scrcpy_ does not prevent the screensaver from running on the
+computer.
 
 To disable it:
 
@@ -781,18 +796,18 @@ To copy, cut and paste in such cases (but only supported on Android >= 7):
  - <kbd>MOD</kbd>+<kbd>v</kbd> injects `PASTE` (after computer-to-device
    clipboard synchronization)
 
-In addition, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> allows to inject the
-computer clipboard text as a sequence of key events. This is useful when the
-component does not accept text pasting (for example in _Termux_), but it can
-break non-ASCII content.
+In addition, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> injects the computer
+clipboard text as a sequence of key events. This is useful when the component
+does not accept text pasting (for example in _Termux_), but it can break
+non-ASCII content.
 
 **WARNING:** Pasting the computer clipboard to the device (either via
 <kbd>Ctrl</kbd>+<kbd>v</kbd> or <kbd>MOD</kbd>+<kbd>v</kbd>) copies the content
-into the device clipboard. As a consequence, any Android application could read
-its content. You should avoid to paste sensitive content (like passwords) that
+into the Android clipboard. As a consequence, any Android application could read
+its content. You should avoid pasting sensitive content (like passwords) that
 way.
 
-Some devices do not behave as expected when setting the device clipboard
+Some Android devices do not behave as expected when setting the device clipboard
 programmatically. An option `--legacy-paste` is provided to change the behavior
 of <kbd>Ctrl</kbd>+<kbd>v</kbd> and <kbd>MOD</kbd>+<kbd>v</kbd> so that they
 also inject the computer clipboard text as a sequence of key events (the same
@@ -805,29 +820,29 @@ To disable automatic clipboard synchronization, use
 
 To simulate "pinch-to-zoom": <kbd>Ctrl</kbd>+_click-and-move_.
 
-More precisely, hold <kbd>Ctrl</kbd> while pressing the left-click button. Until
-the left-click button is released, all mouse movements scale and rotate the
-content (if supported by the app) relative to the center of the screen.
+More precisely, hold down <kbd>Ctrl</kbd> while pressing the left-click button.
+Until the left-click button is released, all mouse movements scale and rotate
+the content (if supported by the app) relative to the center of the screen.
 
-Concretely, scrcpy generates additional touch events from a "virtual finger" at
-a location inverted through the center of the screen.
+Technically, _scrcpy_ generates additional touch events from a "virtual finger"
+at a location inverted through the center of the screen.
 
 #### Physical keyboard simulation (HID)
 
-By default, scrcpy uses Android key or text injection: it works everywhere, but
-is limited to ASCII.
+By default, _scrcpy_ uses Android key or text injection: it works everywhere,
+but is limited to ASCII.
 
-Alternatively, scrcpy can simulate a physical USB keyboard on Android to provide
-a better input experience (using [USB HID over AOAv2][hid-aoav2]): the virtual
-keyboard is disabled and it works for all characters and IME.
+Alternatively, `scrcpy` can simulate a physical USB keyboard on Android to
+provide a better input experience (using [USB HID over AOAv2][hid-aoav2]): the
+virtual keyboard is disabled and it works for all characters and IME.
 
 [hid-aoav2]: https://source.android.com/devices/accessories/aoa2#hid-support
 
-However, it only works if the device is connected by USB.
+However, it only works if the device is connected via USB.
 
 Note: On Windows, it may only work in [OTG mode](#otg), not while mirroring (it
 is not possible to open a USB device if it is already open by another process
-like the adb daemon).
+like the _adb daemon_).
 
 To enable this mode:
 
@@ -838,7 +853,7 @@ scrcpy -K  # short version
 
 If it fails for some reason (for example because the device is not connected via
 USB), it automatically fallbacks to the default mode (with a log in the
-console). This allows to use the same command line options when connected over
+console). This allows using the same command line options when connected over
 USB and TCP/IP.
 
 In this mode, raw key events (scancodes) are sent to the device, independently
@@ -862,7 +877,7 @@ a physical keyboard is connected).
 Similarly to the physical keyboard simulation, it is possible to simulate a
 physical mouse. Likewise, it only works if the device is connected by USB.
 
-By default, scrcpy uses Android mouse events injection, using absolute
+By default, _scrcpy_ uses Android mouse events injection with absolute
 coordinates. By simulating a physical mouse, a mouse pointer appears on the
 Android device, and relative mouse motion, clicks and scrolls are injected.
 
@@ -873,7 +888,7 @@ scrcpy --hid-mouse
 scrcpy -M  # short version
 ```
 
-You could also add `--forward-all-clicks` to [forward all mouse
+You can also add `--forward-all-clicks` to [forward all mouse
 buttons][forward_all_clicks].
 
 [forward_all_clicks]: #right-click-and-middle-click
@@ -892,7 +907,7 @@ It is possible to run _scrcpy_ with only physical keyboard and mouse simulation
 (HID), as if the computer keyboard and mouse were plugged directly to the device
 via an OTG cable.
 
-In this mode, _adb_ (USB debugging) is not necessary, and mirroring is disabled.
+In this mode, `adb` (USB debugging) is not necessary, and mirroring is disabled.
 
 To enable OTG mode:
 
@@ -918,7 +933,7 @@ connected by USB.
 
 #### Text injection preference
 
-There are two kinds of [events][textevents] generated when typing text:
+Two kinds of [events][textevents] are generated when typing text:
  - _key events_, signaling that a key is pressed or released;
  - _text events_, signaling that a text has been entered.
 
@@ -1062,7 +1077,7 @@ _³4th and 5th mouse buttons, if your mouse has them._
 _⁴For react-native apps in development, `MENU` triggers development menu._  
 _⁵Only on Android >= 7._
 
-Shortcuts with repeated keys are executted by releasing and pressing the key a
+Shortcuts with repeated keys are executed by releasing and pressing the key a
 second time. For example, to execute "Expand settings panel":
 
  1. Press and keep pressing <kbd>MOD</kbd>.
@@ -1075,7 +1090,7 @@ handled by the active application.
 
 ## Custom paths
 
-To use a specific _adb_ binary, configure its path in the environment variable
+To use a specific `adb` binary, configure its path in the environment variable
 `ADB`:
 
 ```bash
@@ -1088,7 +1103,7 @@ To override the path of the `scrcpy-server` file, configure its path in
 To override the icon, configure its path in `SCRCPY_ICON_PATH`.
 
 
-## Why _scrcpy_?
+## Why the name _scrcpy_?
 
 A colleague challenged me to find a name as unpronounceable as [gnirehtet].
 
@@ -1105,7 +1120,9 @@ See [BUILD].
 
 ## Common issues
 
-See the [FAQ](FAQ.md).
+See the [FAQ].
+
+[FAQ]: FAQ.md
 
 
 ## Developers
@@ -1140,12 +1157,24 @@ Read the [developers page].
 [article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
 [article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
 
+## Contact
+
+If you encounter a bug, please read the [FAQ] first, then open an [issue].
+
+[issue]: https://github.com/Genymobile/scrcpy/issues
+
+For general questions or discussions, you can also use:
+
+ - Reddit: [`r/scrcpy`](https://www.reddit.com/r/scrcpy)
+ - Twitter: [`@scrcpy_app`](https://twitter.com/scrcpy_app)
+
 ## Translations
 
 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)
+- [Italiano (Italiano, `it`) - v1.23](README.it.md)
 - [日本語 (Japanese, `jp`) - v1.19](README.jp.md)
 - [한국어 (Korean, `ko`) - v1.11](README.ko.md)
 - [Português Brasileiro (Brazilian Portuguese, `pt-BR`) - v1.19](README.pt-br.md)

README.zh-Hans.md

@@ -704,11 +704,11 @@ scrcpy --disable-screensaver
 
 #### 双指缩放
 
-模拟“双指缩放”：<kbd>Ctrl</kbd>+_按住并移动鼠标_。
+模拟“双指缩放”：<kbd>Ctrl</kbd>+_按下并拖动鼠标_。
 
-更准确的说，在按住鼠标左键时按住 <kbd>Ctrl</kbd>。直到松开鼠标左键，所有鼠标移动将以屏幕中心为原点，缩放或旋转内容 (如果应用支持)。
+在按住 <kbd>Ctrl</kbd> 时按下鼠标左键，直到松开鼠标左键前，移动鼠标会使屏幕内容相对于屏幕中心进行缩放或旋转 (如果应用支持)。
 
-实际上，_scrcpy_ 会在关于屏幕中心对称的位置上用“虚拟手指”发出触摸事件。
+具体来说，_scrcpy_ 会在鼠标位置，以及鼠标以屏幕中心镜像的位置分别生成触摸事件。
 
 #### 物理键盘模拟 (HID)
 

app/data/bash-completion/scrcpy

@@ -29,6 +29,7 @@ _scrcpy() {
         -N --no-display
         --no-key-repeat
         --no-mipmaps
+        --no-power-on
         --otg
         -p --port=
         --power-off-on-close

app/data/scrcpy-console.desktop

@@ -0,0 +1,13 @@
+[Desktop Entry]
+Name=scrcpy (console)
+GenericName=Android Remote Control
+Comment=Display and control your Android device
+# For some users, the PATH or ADB environment variables are set from the shell
+# startup file, like .bashrc or .zshrc… Run an interactive shell to get
+# environment correctly initialized.
+Exec=/bin/bash --norc --noprofile -i -c '"$SHELL" -i -c scrcpy || read -p "Press any key to quit..."'
+Icon=scrcpy
+Terminal=true
+Type=Application
+Categories=Utility;RemoteAccess;
+StartupNotify=false

app/data/scrcpy.desktop

@@ -0,0 +1,13 @@
+[Desktop Entry]
+Name=scrcpy
+GenericName=Android Remote Control
+Comment=Display and control your Android device
+# For some users, the PATH or ADB environment variables are set from the shell
+# startup file, like .bashrc or .zshrc… Run an interactive shell to get
+# environment correctly initialized.
+Exec=/bin/sh -c '"$SHELL" -i -c scrcpy'
+Icon=scrcpy
+Terminal=false
+Type=Application
+Categories=Utility;RemoteAccess;
+StartupNotify=false

app/data/zsh-completion/_scrcpy

@@ -35,6 +35,7 @@ arguments=(
     {-N,--no-display}'[Do not display device \(during screen recording or when V4L2 sink is enabled\)]'
     '--no-key-repeat[Do not forward repeated key events when a key is held down]'
     '--no-mipmaps[Disable the generation of mipmaps]'
+    '--no-power-on[Do not power on the device on start]'
     '--otg[Run in OTG mode \(simulating physical keyboard and mouse\)]'
     {-p,--port=}'[\[port\[\:port\]\] Set the TCP port \(range\) used by the client to listen]'
     '--power-off-on-close[Turn the device screen off when closing scrcpy]'

app/meson.build

@@ -143,12 +143,12 @@ else
 
     prebuilt_libusb = meson.get_cross_property('prebuilt_libusb')
     prebuilt_libusb_root = meson.get_cross_property('prebuilt_libusb_root')
-    libusb_bin_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_libusb + '/dll'
+    libusb_bin_dir = meson.current_source_dir() + '/prebuilt-deps/data/' + prebuilt_libusb
     libusb_include_dir = 'prebuilt-deps/data/' + prebuilt_libusb_root + '/include'
 
     libusb = declare_dependency(
         dependencies: [
-            cc.find_library('libusb-1.0', dirs: libusb_bin_dir),
+            cc.find_library('msys-usb-1.0', dirs: libusb_bin_dir),
         ],
         include_directories: include_directories(libusb_include_dir)
     )
@@ -188,7 +188,7 @@ conf.set_quoted('SCRCPY_VERSION', meson.project_version())
 # the prefix used during configuration (meson --prefix=PREFIX)
 conf.set_quoted('PREFIX', get_option('prefix'))
 
-# build a "portable" version (with scrcpy-server accessible from the same
+# build a "portable" version (with scrcpy-server.apk accessible from the same
 # directory as the executable)
 conf.set('PORTABLE', get_option('portable'))
 
@@ -223,14 +223,26 @@ executable('scrcpy', src,
            install: true,
            c_args: [])
 
+# <https://mesonbuild.com/Builtin-options.html#directories>
+datadir = get_option('datadir') # by default 'share'
+
 install_man('scrcpy.1')
 install_data('data/icon.png',
              rename: 'scrcpy.png',
-             install_dir: 'share/icons/hicolor/256x256/apps')
+             install_dir: join_paths(datadir, 'icons/hicolor/256x256/apps'))
 install_data('data/zsh-completion/_scrcpy',
-             install_dir: 'share/zsh/site-functions')
+             install_dir: join_paths(datadir, 'zsh/site-functions'))
 install_data('data/bash-completion/scrcpy',
-             install_dir: 'share/bash-completion/completions')
+             install_dir: join_paths(datadir, 'bash-completion/completions'))
+
+# Desktop entry file for application launchers
+if host_machine.system() == 'linux'
+    # Install a launcher (ex: /usr/local/share/applications/scrcpy.desktop)
+    install_data('data/scrcpy.desktop',
+                 install_dir: join_paths(datadir, 'applications'))
+    install_data('data/scrcpy-console.desktop',
+                 install_dir: join_paths(datadir, 'applications'))
+endif
 
 
 ### TESTS
@@ -245,8 +257,8 @@ if get_option('buildtype') == 'debug'
             'src/util/str.c',
             'src/util/strbuf.c',
         ]],
-        ['test_buffer_util', [
-            'tests/test_buffer_util.c',
+        ['test_binary', [
+            'tests/test_binary.c',
         ]],
         ['test_cbuf', [
             'tests/test_cbuf.c',

app/prebuilt-deps/prepare-adb.sh

@@ -6,10 +6,10 @@ cd "$DIR"
 mkdir -p "$PREBUILT_DATA_DIR"
 cd "$PREBUILT_DATA_DIR"
 
-DEP_DIR=platform-tools-31.0.3
+DEP_DIR=platform-tools-33.0.1
 
-FILENAME=platform-tools_r31.0.3-windows.zip
-SHA256SUM=0f4b8fdd26af2c3733539d6eebb3c2ed499ea1d4bb1f4e0ecc2d6016961a6e24
+FILENAME=platform-tools_r33.0.1-windows.zip
+SHA256SUM=c1f02d42ea24ef4ff2a405ae7370e764ef4546f9b3e4520f5571a00ed5012c42
 
 if [[ -d "$DEP_DIR" ]]
 then

app/prebuilt-deps/prepare-ffmpeg-win64.sh

@@ -6,10 +6,11 @@ cd "$DIR"
 mkdir -p "$PREBUILT_DATA_DIR"
 cd "$PREBUILT_DATA_DIR"
 
-DEP_DIR=ffmpeg-win64-5.0
+VERSION=5.0.1
+DEP_DIR=ffmpeg-win64-$VERSION
 
-FILENAME=ffmpeg-5.0-full_build-shared.7z
-SHA256SUM=e5900f6cecd4c438d398bd2fc308736c10b857cd8dd61c11bcfb05bff5d1211a
+FILENAME=ffmpeg-$VERSION-full_build-shared.7z
+SHA256SUM=ded28435b6f04b74f5ef5a6a13761233bce9e8e9f8ecb0eabe936fd36a778b0c
 
 if [[ -d "$DEP_DIR" ]]
 then
@@ -17,13 +18,13 @@ then
     exit 0
 fi
 
-get_file "https://github.com/GyanD/codexffmpeg/releases/download/5.0/$FILENAME" \
+get_file "https://github.com/GyanD/codexffmpeg/releases/download/$VERSION/$FILENAME" \
     "$FILENAME" "$SHA256SUM"
 
 mkdir "$DEP_DIR"
 cd "$DEP_DIR"
 
-ZIP_PREFIX=ffmpeg-5.0-full_build-shared
+ZIP_PREFIX=ffmpeg-$VERSION-full_build-shared
 7z x "../$FILENAME" \
     "$ZIP_PREFIX"/bin/avutil-57.dll \
     "$ZIP_PREFIX"/bin/avcodec-59.dll \

app/prebuilt-deps/prepare-libusb.sh

@@ -6,10 +6,10 @@ cd "$DIR"
 mkdir -p "$PREBUILT_DATA_DIR"
 cd "$PREBUILT_DATA_DIR"
 
-DEP_DIR=libusb-1.0.25
+DEP_DIR=libusb-1.0.26
 
-FILENAME=libusb-1.0.25.7z
-SHA256SUM=3d1c98416f454026034b2b5d67f8a294053898cb70a8b489874e75b136c6674d
+FILENAME=libusb-1.0.26-binaries.7z
+SHA256SUM=9c242696342dbde9cdc47239391f71833939bf9f7aa2bbb28cdaabe890465ec5
 
 if [[ -d "$DEP_DIR" ]]
 then
@@ -17,12 +17,18 @@ then
     exit 0
 fi
 
-get_file "https://github.com/libusb/libusb/releases/download/v1.0.25/$FILENAME" "$FILENAME" "$SHA256SUM"
+get_file "https://github.com/libusb/libusb/releases/download/v1.0.26/$FILENAME" "$FILENAME" "$SHA256SUM"
 
 mkdir "$DEP_DIR"
 cd "$DEP_DIR"
 
+# include/ is the same in all folders of the archive
 7z x "../$FILENAME" \
-    MinGW32/dll/libusb-1.0.dll \
-    MinGW64/dll/libusb-1.0.dll \
-    include /
+    libusb-1.0.26-binaries/libusb-MinGW-Win32/bin/msys-usb-1.0.dll \
+    libusb-1.0.26-binaries/libusb-MinGW-x64/bin/msys-usb-1.0.dll \
+    libusb-1.0.26-binaries/libusb-MinGW-x64/include/
+
+mv libusb-1.0.26-binaries/libusb-MinGW-Win32/bin MinGW-Win32
+mv libusb-1.0.26-binaries/libusb-MinGW-x64/bin MinGW-x64
+mv libusb-1.0.26-binaries/libusb-MinGW-x64/include .
+rm -rf libusb-1.0.26-binaries

app/prebuilt-deps/prepare-sdl.sh

@@ -6,10 +6,10 @@ cd "$DIR"
 mkdir -p "$PREBUILT_DATA_DIR"
 cd "$PREBUILT_DATA_DIR"
 
-DEP_DIR=SDL2-2.0.20
+DEP_DIR=SDL2-2.0.22
 
-FILENAME=SDL2-devel-2.0.20-mingw.tar.gz
-SHA256SUM=38094d82a857d6c62352e5c5cdec74948c5b4d25c59cbd298d6d233568976bd1
+FILENAME=SDL2-devel-2.0.22-mingw.tar.gz
+SHA256SUM=0e91e35973366aa1e6f81ee368924d9b4f93f9da4d2f2a89ec80b06eadcf23d1
 
 if [[ -d "$DEP_DIR" ]]
 then

app/scrcpy-windows.rc

@@ -13,7 +13,7 @@ BEGIN
       VALUE "LegalCopyright", "Romain Vimont, Genymobile"
       VALUE "OriginalFilename", "scrcpy.exe"
       VALUE "ProductName", "scrcpy"
-      VALUE "ProductVersion", "1.22"
+      VALUE "ProductVersion", "1.24"
     END
   END
   BLOCK "VarFileInfo"

app/scrcpy.1

@@ -110,6 +110,10 @@ However, the option is only available when the HID keyboard is enabled (or a phy
 
 Also see \fB\-\-hid\-mouse\fR.
 
+.TP
+.B \-\-install
+Install the server (via "adb install") rather than pushing it to /data/local/tmp (via "adb push").
+
 .TP
 .B \-\-legacy\-paste
 Inject computer clipboard text as a sequence of key events on Ctrl+v (like MOD+Shift+v).
@@ -180,6 +184,10 @@ Do not forward repeated key events when a key is held down.
 .B \-\-no\-mipmaps
 If the renderer is OpenGL 3.0+ or OpenGL ES 2.0+, then mipmaps are automatically generated to improve downscaling quality. This option disables the generation of mipmaps.
 
+.TP
+.B \-\-no\-power\-on
+Do not power on the device on start.
+
 .TP
 .B \-\-otg
 Run in OTG mode: simulate physical keyboard and mouse, as if the computer keyboard and mouse were plugged directly to the device via an OTG cable.
@@ -238,6 +246,10 @@ option if set, or by the file extension (.mp4 or .mkv).
 .BI "\-\-record\-format " format
 Force recording format (either mp4 or mkv).
 
+.TP
+.B \-\-reinstall
+Reinstall the server (via "adb install"), even if the correct version is already installed. Implies \fB\-\-install\fR.
+
 .TP
 .BI "\-\-render\-driver " name
 Request SDL to use the given render driver (this is just a hint).
@@ -355,6 +367,12 @@ Set the initial window height.
 
 Default is 0 (automatic).
 
+.SH EXIT STATUS
+.B scrcpy
+will exit with code 0 on normal program termination. If an initial
+connection cannot be established, the exit code 1 will be returned. If the
+device disconnects while a session is active, exit code 2 will be returned.
+
 .SH SHORTCUTS
 
 In the following list, MOD is the shortcut modifier. By default, it's (left)
@@ -471,6 +489,10 @@ Push file to device (see \fB\-\-push\-target\fR)
 .B ADB
 Path to adb.
 
+.TP
+.B ANDROID_SERIAL
+Device serial to use if no selector (-s, -d, -e or --tcpip=<addr>) is specified.
+
 .TP
 .B SCRCPY_ICON_PATH
 Path to the program icon.

app/src/adb/adb.c

@@ -329,6 +329,17 @@ sc_adb_install(struct sc_intr *intr, const char *serial, const char *local,
     return process_check_success_intr(intr, pid, "adb install", flags);
 }
 
+bool
+sc_adb_uninstall(struct sc_intr *intr, const char *serial, const char *pkg,
+                 unsigned flags) {
+    assert(serial);
+    const char *const argv[] =
+        SC_ADB_COMMAND("-s", serial, "uninstall", pkg);
+
+    sc_pid pid = sc_adb_execute(argv, flags);
+    return process_check_success_intr(intr, pid, "adb uninstall", flags);
+}
+
 bool
 sc_adb_tcpip(struct sc_intr *intr, const char *serial, uint16_t port,
              unsigned flags) {
@@ -401,6 +412,7 @@ sc_adb_list_devices(struct sc_intr *intr, unsigned flags,
 #define BUFSIZE 65536
     char *buf = malloc(BUFSIZE);
     if (!buf) {
+        LOG_OOM();
         return false;
     }
 
@@ -434,6 +446,7 @@ sc_adb_list_devices(struct sc_intr *intr, unsigned flags,
              "Please report an issue.");
         return false;
     }
+#undef BUFSIZE
 
     // It is parsed as a NUL-terminated string
     buf[r] = '\0';
@@ -473,9 +486,12 @@ sc_adb_accept_device(const struct sc_adb_device *device,
             }
             return !strcmp(selector->serial, device->serial);
         case SC_ADB_DEVICE_SELECT_USB:
-            return !sc_adb_is_serial_tcpip(device->serial);
+            return sc_adb_device_get_type(device->serial) ==
+                    SC_ADB_DEVICE_TYPE_USB;
         case SC_ADB_DEVICE_SELECT_TCPIP:
-            return sc_adb_is_serial_tcpip(device->serial);
+            // Both emulators and TCP/IP devices are selected via -e
+            return sc_adb_device_get_type(device->serial) !=
+                    SC_ADB_DEVICE_TYPE_USB;
         default:
             assert(!"Missing SC_ADB_DEVICE_SELECT_* handling");
             break;
@@ -509,8 +525,10 @@ sc_adb_devices_log(enum sc_log_level level, struct sc_adb_device *devices,
     for (size_t i = 0; i < count; ++i) {
         struct sc_adb_device *d = &devices[i];
         const char *selection = d->selected ? "-->" : "   ";
-        const char *type = sc_adb_is_serial_tcpip(d->serial) ? "(tcpip)"
-                                                             : "  (usb)";
+        bool is_usb =
+            sc_adb_device_get_type(d->serial) == SC_ADB_DEVICE_TYPE_USB;
+        const char *type = is_usb ? "  (usb)"
+                                  : "(tcpip)";
         LOG(level, "    %s %s  %-20s  %16s  %s",
              selection, type, d->serial, d->state, d->model ? d->model : "");
     }
@@ -531,6 +549,8 @@ sc_adb_device_check_state(struct sc_adb_device *device,
         LOGE("A popup should open on the device to request authorization.");
         LOGE("Check the FAQ: "
              "<https://github.com/Genymobile/scrcpy/blob/master/FAQ.md>");
+    } else {
+        LOGE("Device could not be connected (state=%s)", state);
     }
 
     return false;
@@ -703,10 +723,101 @@ sc_adb_get_device_ip(struct sc_intr *intr, const char *serial, unsigned flags) {
     // It is parsed as a NUL-terminated string
     buf[r] = '\0';
 
-    return sc_adb_parse_device_ip_from_output(buf);
+    return sc_adb_parse_device_ip(buf);
 }
 
-bool
-sc_adb_is_serial_tcpip(const char *serial) {
-    return strchr(serial, ':');
+char *
+sc_adb_get_installed_apk_path(struct sc_intr *intr, const char *serial,
+                              unsigned flags) {
+    assert(serial);
+    const char *const argv[] =
+        SC_ADB_COMMAND("-s", serial, "shell", "pm", "list", "package", "-f",
+                       SC_ANDROID_PACKAGE);
+
+    sc_pipe pout;
+    sc_pid pid = sc_adb_execute_p(argv, flags, &pout);
+    if (pid == SC_PROCESS_NONE) {
+        LOGD("Could not execute \"pm list packages\"");
+        return NULL;
+    }
+
+    // "pm list packages -f <package>" output should contain only one line, so
+    // the output should be short
+    char buf[1024];
+    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf) - 1);
+    sc_pipe_close(pout);
+
+    bool ok = process_check_success_intr(intr, pid, "pm list packages", flags);
+    if (!ok) {
+        return NULL;
+    }
+
+    if (r == -1) {
+        return NULL;
+    }
+
+    assert((size_t) r < sizeof(buf));
+    if (r == sizeof(buf) - 1)  {
+        // The implementation assumes that the output of "pm list packages"
+        // fits in the buffer in a single pass
+        LOGW("Result of \"pm list package\" does not fit in 1Kb. "
+             "Please report an issue.");
+        return NULL;
+    }
+
+    // It is parsed as a NUL-terminated string
+    buf[r] = '\0';
+
+    return sc_adb_parse_installed_apk_path(buf);
+}
+
+char *
+sc_adb_get_installed_apk_version(struct sc_intr *intr, const char *serial,
+                                 unsigned flags) {
+    assert(serial);
+    const char *const argv[] =
+        SC_ADB_COMMAND("-s", serial, "shell", "dumpsys", "package",
+                       SC_ANDROID_PACKAGE);
+
+    sc_pipe pout;
+    sc_pid pid = sc_adb_execute_p(argv, flags, &pout);
+    if (pid == SC_PROCESS_NONE) {
+        LOGD("Could not execute \"dumpsys package\"");
+        return NULL;
+    }
+
+    // "dumpsys package" output can be huge (e.g. 16k), but versionName is at
+    // the beginning, typically in the first 1024 bytes (64k should be enough
+    // for the whole output anyway)
+#define BUFSIZE 65536
+    char *buf = malloc(BUFSIZE);
+    if (!buf) {
+        return false;
+    }
+    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, BUFSIZE - 1);
+    sc_pipe_close(pout);
+
+    bool ok = process_check_success_intr(intr, pid, "dumpsys package", flags);
+    if (!ok) {
+        free(buf);
+        return NULL;
+    }
+
+    if (r == -1) {
+        free(buf);
+        return NULL;
+    }
+
+    assert((size_t) r < BUFSIZE);
+#undef BUFSIZE
+    // if r == sizeof(buf), then the output is truncated, but we don't care,
+    // versionName is at the beginning in practice, and is unlikely to be
+    // truncated at 64k
+
+    // It is parsed as a NUL-terminated string
+    buf[r] = '\0';
+
+    char *version = sc_adb_parse_installed_apk_version(buf);
+    free(buf);
+    return version;
 }

app/src/adb/adb.h

@@ -15,6 +15,8 @@
 
 #define SC_ADB_SILENT (SC_ADB_NO_STDOUT | SC_ADB_NO_STDERR | SC_ADB_NO_LOGERR)
 
+#define SC_ANDROID_PACKAGE "com.genymobile.scrcpy"
+
 const char *
 sc_adb_get_executable(void);
 
@@ -64,6 +66,10 @@ bool
 sc_adb_install(struct sc_intr *intr, const char *serial, const char *local,
                unsigned flags);
 
+bool
+sc_adb_uninstall(struct sc_intr *intr, const char *serial, const char *pkg,
+                 unsigned flags);
+
 /**
  * Execute `adb tcpip <port>`
  */
@@ -115,12 +121,17 @@ char *
 sc_adb_get_device_ip(struct sc_intr *intr, const char *serial, unsigned flags);
 
 /**
- * Indicate if the serial represents an IP address
- *
- * In practice, it just returns true if and only if it contains a ':', which is
- * sufficient to distinguish an ip:port from a real USB serial.
+ * Return the path of the installed APK for com.genymobile.scrcpy (if any)
  */
-bool
-sc_adb_is_serial_tcpip(const char *serial);
+char *
+sc_adb_get_installed_apk_path(struct sc_intr *intr, const char *serial,
+                              unsigned flags);
+
+/**
+ * Return the version of the installed APK for com.genymobile.scrcpy (if any)
+ */
+char *
+sc_adb_get_installed_apk_version(struct sc_intr *intr, const char *serial,
+                                 unsigned flags);
 
 #endif

app/src/adb/adb_device.c

@@ -1,6 +1,7 @@
 #include "adb_device.h"
 
 #include <stdlib.h>
+#include <string.h>
 
 void
 sc_adb_device_destroy(struct sc_adb_device *device) {
@@ -25,3 +26,18 @@ sc_adb_devices_destroy(struct sc_vec_adb_devices *devices) {
     sc_vector_destroy(devices);
 }
 
+enum sc_adb_device_type
+sc_adb_device_get_type(const char *serial) {
+    // Starts with "emulator-"
+    if (!strncmp(serial, "emulator-", sizeof("emulator-") - 1)) {
+        return SC_ADB_DEVICE_TYPE_EMULATOR;
+    }
+
+    // If the serial contains a ':', then it is a TCP/IP device (it is
+    // sufficient to distinguish an ip:port from a real USB serial)
+    if (strchr(serial, ':')) {
+        return SC_ADB_DEVICE_TYPE_TCPIP;
+    }
+
+    return SC_ADB_DEVICE_TYPE_USB;
+}

app/src/adb/adb_device.h

@@ -15,6 +15,12 @@ struct sc_adb_device {
     bool selected;
 };
 
+enum sc_adb_device_type {
+    SC_ADB_DEVICE_TYPE_USB,
+    SC_ADB_DEVICE_TYPE_TCPIP,
+    SC_ADB_DEVICE_TYPE_EMULATOR,
+};
+
 struct sc_vec_adb_devices SC_VECTOR(struct sc_adb_device);
 
 void
@@ -35,4 +41,10 @@ sc_adb_device_move(struct sc_adb_device *dst, struct sc_adb_device *src);
 void
 sc_adb_devices_destroy(struct sc_vec_adb_devices *devices);
 
+/**
+ * Deduce the device type from the serial
+ */
+enum sc_adb_device_type
+sc_adb_device_get_type(const char *serial);
+
 #endif

app/src/adb/adb_parser.c

@@ -199,7 +199,7 @@ sc_adb_parse_device_ip_from_line(char *line) {
 }
 
 char *
-sc_adb_parse_device_ip_from_output(char *str) {
+sc_adb_parse_device_ip(char *str) {
     size_t idx_line = 0;
     while (str[idx_line] != '\0') {
         char *line = &str[idx_line];
@@ -225,3 +225,62 @@ sc_adb_parse_device_ip_from_output(char *str) {
 
     return NULL;
 }
+
+char *
+sc_adb_parse_installed_apk_path(char *str) {
+    // str is expected to look like:
+    // "package:/data/app/.../base.apk=com.genymobile.scrcpy"
+    //          ^^^^^^^^^^^^^^^^^^^^^^
+    // We want to extract the path (which may contain '=', even in practice)
+
+    if (strncmp(str, "package:", 8)) {
+        // Does not start with "package:"
+        return NULL;
+    }
+
+    char *s = str + 8;
+    size_t len = strcspn(s, " \r\n");
+    s[len] = '\0';
+
+    char *p = strrchr(s, '=');
+    if (!p) {
+        // No '=' found
+        return NULL;
+    }
+
+    // Truncate at the last '='
+    *p = '\0';
+
+    return strdup(s);
+}
+
+char *
+sc_adb_parse_installed_apk_version(const char *str) {
+    // str is the (beginning of the) output of `dumpsys package`
+    // We want to extract the version string from a line starting with 4 spaces
+    // then `versionName=` then the version string.
+
+#define VERSION_NAME_PREFIX "\n    versionName="
+    char *s = strstr(str, VERSION_NAME_PREFIX);
+    if (!s) {
+        // Not found
+        return NULL;
+    }
+
+    s+= sizeof(VERSION_NAME_PREFIX) - 1;
+
+    size_t len = strspn(s, "0123456789.");
+    if (!len) {
+        LOGW("Unexpected version name with no value");
+        return NULL;
+    }
+
+    char *version = malloc(len + 1);
+    if (!version) {
+        return NULL;
+    }
+
+    memcpy(version, s, len);
+    version[len] = '\0';
+    return version;
+}

app/src/adb/adb_parser.h

@@ -25,6 +25,26 @@ sc_adb_parse_devices(char *str, struct sc_vec_adb_devices *out_vec);
  * Warning: this function modifies the buffer for optimization purposes.
  */
 char *
-sc_adb_parse_device_ip_from_output(char *str);
+sc_adb_parse_device_ip(char *str);
+
+/**
+ * Parse the package path from the output of
+ * `adb shell pm list packages -f <package>`
+ *
+ * The parameter must be a NUL-terminated string.
+ *
+ * Warning: this function modifies the buffer for optimization purposes.
+ */
+char *
+sc_adb_parse_installed_apk_path(char *str);
+
+/**
+ * Parse the package version from the output of
+ * `adb shell dumpsys package <package>`
+ *
+ * The parameter must be a NUL-terminated string.
+ */
+char *
+sc_adb_parse_installed_apk_version(const char *str);
 
 #endif

app/src/cli.c

@@ -56,6 +56,9 @@
 #define OPT_OTG                    1036
 #define OPT_NO_CLEANUP             1037
 #define OPT_PRINT_FPS              1038
+#define OPT_NO_POWER_ON            1039
+#define OPT_INSTALL                1040
+#define OPT_REINSTALL              1041
 
 struct sc_option {
     char shortopt;
@@ -80,6 +83,11 @@ struct sc_envvar {
     const char *text;
 };
 
+struct sc_exit_status {
+    unsigned value;
+    const char *text;
+};
+
 struct sc_getopt_adapter {
     char *optstring;
     struct option *longopts;
@@ -201,6 +209,12 @@ static const struct sc_option options[] = {
         .longopt = "help",
         .text = "Print this help.",
     },
+    {
+        .longopt_id = OPT_INSTALL,
+        .longopt = "install",
+        .text = "Install the server (via 'adb install') rather than pushing "
+                "it to /data/local/tmp (via 'adb push').",
+    },
     {
         .longopt_id = OPT_LEGACY_PASTE,
         .longopt = "legacy-paste",
@@ -297,6 +311,11 @@ static const struct sc_option options[] = {
                 "mipmaps are automatically generated to improve downscaling "
                 "quality. This option disables the generation of mipmaps.",
     },
+    {
+        .longopt_id = OPT_NO_POWER_ON,
+        .longopt = "no-power-on",
+        .text = "Do not power on the device on start.",
+    },
     {
         .longopt_id = OPT_OTG,
         .longopt = "otg",
@@ -367,6 +386,13 @@ static const struct sc_option options[] = {
         .argdesc = "format",
         .text = "Force recording format (either mp4 or mkv).",
     },
+    {
+        .longopt_id = OPT_REINSTALL,
+        .longopt = "reinstall",
+        .text = "Reinstall the server (via 'adb install'), even if the correct "
+                "version is already installed.\n"
+                "Implies --install.",
+    },
     {
         .longopt_id = OPT_RENDER_DRIVER,
         .longopt = "render-driver",
@@ -572,7 +598,7 @@ static const struct sc_shortcut shortcuts[] = {
         .text = "Click on BACK",
     },
     {
-        .shortcuts = { "MOD+s" },
+        .shortcuts = { "MOD+s", "4th-click" },
         .text = "Click on APP_SWITCH",
     },
     {
@@ -608,7 +634,7 @@ static const struct sc_shortcut shortcuts[] = {
         .text = "Rotate device screen",
     },
     {
-        .shortcuts = { "MOD+n" },
+        .shortcuts = { "MOD+n", "5th-click" },
         .text = "Expand notification panel",
     },
     {
@@ -655,6 +681,11 @@ static const struct sc_envvar envvars[] = {
         .name = "ADB",
         .text = "Path to adb executable",
     },
+    {
+        .name = "ANDROID_SERIAL",
+        .text = "Device serial to use if no selector (-s, -d, -e or "
+                "--tcpip=<addr>) is specified",
+    },
     {
         .name = "SCRCPY_ICON_PATH",
         .text = "Path to the program icon",
@@ -662,7 +693,22 @@ static const struct sc_envvar envvars[] = {
     {
         .name = "SCRCPY_SERVER_PATH",
         .text = "Path to the server binary",
-    }
+    },
+};
+
+static const struct sc_exit_status exit_statuses[] = {
+    {
+        .value = 0,
+        .text = "Normal program termination",
+    },
+    {
+        .value = 1,
+        .text = "Start failure",
+    },
+    {
+        .value = 2,
+        .text = "Device disconnected while running",
+    },
 };
 
 static char *
@@ -901,6 +947,25 @@ print_envvar(const struct sc_envvar *envvar, unsigned cols) {
     free(text);
 }
 
+static void
+print_exit_status(const struct sc_exit_status *status, unsigned cols) {
+    assert(cols > 8); // sc_str_wrap_lines() requires indent < columns
+    assert(status->text);
+
+    // The text starts at 9: 4 ident spaces, 3 chars for numeric value, 2 spaces
+    char *text = sc_str_wrap_lines(status->text, cols, 9);
+    if (!text) {
+        printf("<ERROR>\n");
+        return;
+    }
+
+    assert(strlen(text) >= 9); // Contains at least the initial identation
+
+    // text + 9 to remove the initial indentation
+    printf("    %3d  %s\n", status->value, text + 9);
+    free(text);
+}
+
 void
 scrcpy_print_usage(const char *arg0) {
 #define SC_TERM_COLS_DEFAULT 80
@@ -939,6 +1004,11 @@ scrcpy_print_usage(const char *arg0) {
     for (size_t i = 0; i < ARRAY_LEN(envvars); ++i) {
         print_envvar(&envvars[i], cols);
     }
+
+    printf("\nExit status:\n\n");
+    for (size_t i = 0; i < ARRAY_LEN(exit_statuses); ++i) {
+        print_exit_status(&exit_statuses[i], cols);
+    }
 }
 
 static bool
@@ -1549,9 +1619,19 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
             case OPT_NO_CLEANUP:
                 opts->cleanup = false;
                 break;
+            case OPT_NO_POWER_ON:
+                opts->power_on = false;
+                break;
             case OPT_PRINT_FPS:
                 opts->start_fps_counter = true;
                 break;
+            case OPT_INSTALL:
+                opts->install = true;
+                break;
+            case OPT_REINSTALL:
+                opts->install = true;
+                opts->reinstall = true;
+                break;
             case OPT_OTG:
 #ifdef HAVE_USB
                 opts->otg = true;

app/src/clock.c

@@ -98,7 +98,7 @@ sc_clock_update(struct sc_clock *clock, sc_tick system, sc_tick stream) {
         sc_clock_estimate(clock, &clock->slope, &clock->offset);
 
 #ifndef SC_CLOCK_NDEBUG
-        LOGD("Clock estimation: %g * pts + %" PRItick,
+        LOGD("Clock estimation: %f * pts + %" PRItick,
              clock->slope, clock->offset);
 #endif
     }

app/src/common.h

@@ -1,5 +1,5 @@
-#ifndef COMMON_H
-#define COMMON_H
+#ifndef SC_COMMON_H
+#define SC_COMMON_H
 
 #include "config.h"
 #include "compat.h"

app/src/compat.h

@@ -1,5 +1,5 @@
-#ifndef COMPAT_H
-#define COMPAT_H
+#ifndef SC_COMPAT_H
+#define SC_COMPAT_H
 
 #include "config.h"
 

app/src/control_msg.c

@@ -5,7 +5,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "util/buffer_util.h"
+#include "util/binary.h"
 #include "util/log.h"
 #include "util/str.h"
 
@@ -37,7 +37,7 @@ static const char *const android_motionevent_action_labels[] = {
     "move",
     "cancel",
     "outside",
-    "ponter-down",
+    "pointer-down",
     "pointer-up",
     "hover-move",
     "scroll",
@@ -78,16 +78,6 @@ write_string(const char *utf8, size_t max_len, unsigned char *buf) {
     return 4 + len;
 }
 
-static uint16_t
-to_fixed_point_16(float f) {
-    assert(f >= 0.0f && f <= 1.0f);
-    uint32_t u = f * 0x1p16f; // 2^16
-    if (u >= 0xffff) {
-        u = 0xffff;
-    }
-    return (uint16_t) u;
-}
-
 size_t
 sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) {
     buf[0] = msg->type;
@@ -109,18 +99,20 @@ sc_control_msg_serialize(const struct sc_control_msg *msg, unsigned char *buf) {
             sc_write64be(&buf[2], msg->inject_touch_event.pointer_id);
             write_position(&buf[10], &msg->inject_touch_event.position);
             uint16_t pressure =
-                to_fixed_point_16(msg->inject_touch_event.pressure);
+                sc_float_to_u16fp(msg->inject_touch_event.pressure);
             sc_write16be(&buf[22], pressure);
             sc_write32be(&buf[24], msg->inject_touch_event.buttons);
             return 28;
         case SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
             write_position(&buf[1], &msg->inject_scroll_event.position);
-            sc_write32be(&buf[13],
-                             (uint32_t) msg->inject_scroll_event.hscroll);
-            sc_write32be(&buf[17],
-                             (uint32_t) msg->inject_scroll_event.vscroll);
-            sc_write32be(&buf[21], msg->inject_scroll_event.buttons);
-            return 25;
+            int16_t hscroll =
+                sc_float_to_i16fp(msg->inject_scroll_event.hscroll);
+            int16_t vscroll =
+                sc_float_to_i16fp(msg->inject_scroll_event.vscroll);
+            sc_write16be(&buf[13], (uint16_t) hscroll);
+            sc_write16be(&buf[15], (uint16_t) vscroll);
+            sc_write32be(&buf[17], msg->inject_scroll_event.buttons);
+            return 21;
         case SC_CONTROL_MSG_TYPE_BACK_OR_SCREEN_ON:
             buf[1] = msg->inject_keycode.action;
             return 2;
@@ -170,7 +162,7 @@ sc_control_msg_log(const struct sc_control_msg *msg) {
             if (id == POINTER_ID_MOUSE || id == POINTER_ID_VIRTUAL_FINGER) {
                 // string pointer id
                 LOG_CMSG("touch [id=%s] %-4s position=%" PRIi32 ",%" PRIi32
-                             " pressure=%g buttons=%06lx",
+                             " pressure=%f buttons=%06lx",
                          id == POINTER_ID_MOUSE ? "mouse" : "vfinger",
                          MOTIONEVENT_ACTION_LABEL(action),
                          msg->inject_touch_event.position.point.x,
@@ -180,7 +172,7 @@ sc_control_msg_log(const struct sc_control_msg *msg) {
             } else {
                 // numeric pointer id
                 LOG_CMSG("touch [id=%" PRIu64_ "] %-4s position=%" PRIi32 ",%"
-                             PRIi32 " pressure=%g buttons=%06lx",
+                             PRIi32 " pressure=%f buttons=%06lx",
                          id,
                          MOTIONEVENT_ACTION_LABEL(action),
                          msg->inject_touch_event.position.point.x,
@@ -191,8 +183,8 @@ sc_control_msg_log(const struct sc_control_msg *msg) {
             break;
         }
         case SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT:
-            LOG_CMSG("scroll position=%" PRIi32 ",%" PRIi32 " hscroll=%" PRIi32
-                         " vscroll=%" PRIi32 " buttons=%06lx",
+            LOG_CMSG("scroll position=%" PRIi32 ",%" PRIi32 " hscroll=%f"
+                         " vscroll=%f buttons=%06lx",
                      msg->inject_scroll_event.position.point.x,
                      msg->inject_scroll_event.position.point.y,
                      msg->inject_scroll_event.hscroll,

app/src/control_msg.h

@@ -1,5 +1,5 @@
-#ifndef CONTROLMSG_H
-#define CONTROLMSG_H
+#ifndef SC_CONTROLMSG_H
+#define SC_CONTROLMSG_H
 
 #include "common.h"
 
@@ -68,8 +68,8 @@ struct sc_control_msg {
         } inject_touch_event;
         struct {
             struct sc_position position;
-            int32_t hscroll;
-            int32_t vscroll;
+            float hscroll;
+            float vscroll;
             enum android_motionevent_buttons buttons;
         } inject_scroll_event;
         struct {

app/src/controller.h

@@ -1,5 +1,5 @@
-#ifndef CONTROLLER_H
-#define CONTROLLER_H
+#ifndef SC_CONTROLLER_H
+#define SC_CONTROLLER_H
 
 #include "common.h"
 

app/src/demuxer.c

@@ -7,7 +7,7 @@
 #include "decoder.h"
 #include "events.h"
 #include "recorder.h"
-#include "util/buffer_util.h"
+#include "util/binary.h"
 #include "util/log.h"
 
 #define SC_PACKET_HEADER_SIZE 12
@@ -37,8 +37,8 @@ sc_demuxer_recv_packet(struct sc_demuxer *demuxer, AVPacket *packet) {
     // CK...... ........ ........ ........ ........ ........ ........ ........
     // ^^<------------------------------------------------------------------->
     // ||                                PTS
-    // | `- config packet
-    //  `-- key frame
+    // | `- key frame
+    //  `-- config packet
 
     uint8_t header[SC_PACKET_HEADER_SIZE];
     ssize_t r = net_recv_all(demuxer->socket, header, SC_PACKET_HEADER_SIZE);

app/src/device_msg.c

@@ -4,7 +4,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "util/buffer_util.h"
+#include "util/binary.h"
 #include "util/log.h"
 
 ssize_t

app/src/device_msg.h

@@ -1,5 +1,5 @@
-#ifndef DEVICEMSG_H
-#define DEVICEMSG_H
+#ifndef SC_DEVICEMSG_H
+#define SC_DEVICEMSG_H
 
 #include "common.h"
 

app/src/fps_counter.h

@@ -1,5 +1,5 @@
-#ifndef FPSCOUNTER_H
-#define FPSCOUNTER_H
+#ifndef SC_FPSCOUNTER_H
+#define SC_FPSCOUNTER_H
 
 #include "common.h"
 

app/src/icon.h

@@ -1,5 +1,5 @@
-#ifndef ICON_H
-#define ICON_H
+#ifndef SC_ICON_H
+#define SC_ICON_H
 
 #include "common.h"
 

app/src/input_events.h

@@ -358,8 +358,8 @@ struct sc_mouse_click_event {
 
 struct sc_mouse_scroll_event {
     struct sc_position position;
-    int32_t hscroll;
-    int32_t vscroll;
+    float hscroll;
+    float vscroll;
     uint8_t buttons_state; // bitwise-OR of sc_mouse_button values
 };
 

app/src/input_manager.c

@@ -747,8 +747,13 @@ sc_input_manager_process_mouse_wheel(struct sc_input_manager *im,
             .point = sc_screen_convert_window_to_frame_coords(im->screen,
                                                               mouse_x, mouse_y),
         },
-        .hscroll = event->x,
-        .vscroll = event->y,
+#if SDL_VERSION_ATLEAST(2, 0, 18)
+        .hscroll = CLAMP(event->preciseX, -1.0f, 1.0f),
+        .vscroll = CLAMP(event->preciseY, -1.0f, 1.0f),
+#else
+        .hscroll = CLAMP(event->x, -1, 1),
+        .vscroll = CLAMP(event->y, -1, 1),
+#endif
         .buttons_state =
             sc_mouse_buttons_state_from_sdl(buttons, im->forward_all_clicks),
     };

app/src/input_manager.h

@@ -1,5 +1,5 @@
-#ifndef INPUTMANAGER_H
-#define INPUTMANAGER_H
+#ifndef SC_INPUTMANAGER_H
+#define SC_INPUTMANAGER_H
 
 #include "common.h"
 

app/src/main.c

@@ -40,19 +40,19 @@ main(int argc, char *argv[]) {
 #endif
 
     if (!scrcpy_parse_args(&args, argc, argv)) {
-        return 1;
+        return SCRCPY_EXIT_FAILURE;
     }
 
     sc_set_log_level(args.opts.log_level);
 
     if (args.help) {
         scrcpy_print_usage(argv[0]);
-        return 0;
+        return SCRCPY_EXIT_SUCCESS;
     }
 
     if (args.version) {
         scrcpy_print_version();
-        return 0;
+        return SCRCPY_EXIT_SUCCESS;
     }
 
 #ifdef SCRCPY_LAVF_REQUIRES_REGISTER_ALL
@@ -66,17 +66,17 @@ main(int argc, char *argv[]) {
 #endif
 
     if (avformat_network_init()) {
-        return 1;
+        return SCRCPY_EXIT_FAILURE;
     }
 
 #ifdef HAVE_USB
-    bool ok = args.opts.otg ? scrcpy_otg(&args.opts)
-                            : scrcpy(&args.opts);
+    enum scrcpy_exit_code ret = args.opts.otg ? scrcpy_otg(&args.opts)
+                                              : scrcpy(&args.opts);
 #else
-    bool ok = scrcpy(&args.opts);
+    enum scrcpy_exit_code ret = scrcpy(&args.opts);
 #endif
 
     avformat_network_deinit(); // ignore failure
 
-    return ok ? 0 : 1;
+    return ret;
 }

app/src/opengl.c

@@ -28,7 +28,7 @@ sc_opengl_init(struct sc_opengl *gl) {
                                sizeof(OPENGL_ES_PREFIX) - 1);
     if (gl->is_opengles) {
         /* skip the prefix */
-        version += sizeof(PREFIX) - 1;
+        version += sizeof(OPENGL_ES_PREFIX) - 1;
     }
 
     int r = sscanf(version, "%d.%d", &gl->version_major, &gl->version_minor);

app/src/options.c

@@ -64,4 +64,7 @@ const struct scrcpy_options scrcpy_options_default = {
     .select_usb = false,
     .cleanup = true,
     .start_fps_counter = false,
+    .power_on = true,
+    .install = false,
+    .reinstall = false,
 };

app/src/options.h

@@ -139,6 +139,9 @@ struct scrcpy_options {
     bool select_tcpip;
     bool cleanup;
     bool start_fps_counter;
+    bool power_on;
+    bool install;
+    bool reinstall;
 };
 
 extern const struct scrcpy_options scrcpy_options_default;

app/src/receiver.h

@@ -1,5 +1,5 @@
-#ifndef RECEIVER_H
-#define RECEIVER_H
+#ifndef SC_RECEIVER_H
+#define SC_RECEIVER_H
 
 #include "common.h"
 

app/src/scrcpy.c

@@ -149,38 +149,41 @@ sdl_configure(bool display, bool disable_screensaver) {
     }
 }
 
-static bool
+static enum scrcpy_exit_code
 event_loop(struct scrcpy *s) {
     SDL_Event event;
     while (SDL_WaitEvent(&event)) {
         switch (event.type) {
             case EVENT_STREAM_STOPPED:
                 LOGW("Device disconnected");
-                return false;
+                return SCRCPY_EXIT_DISCONNECTED;
             case SDL_QUIT:
                 LOGD("User requested to quit");
-                return true;
+                return SCRCPY_EXIT_SUCCESS;
             default:
                 sc_screen_handle_event(&s->screen, &event);
                 break;
         }
     }
-    return false;
+    return SCRCPY_EXIT_FAILURE;
 }
 
+// Return true on success, false on error
 static bool
-await_for_server(void) {
+await_for_server(bool *connected) {
     SDL_Event event;
     while (SDL_WaitEvent(&event)) {
         switch (event.type) {
             case SDL_QUIT:
                 LOGD("User requested to quit");
-                return false;
+                *connected = false;
+                return true;
             case EVENT_SERVER_CONNECTION_FAILED:
                 LOGE("Server connection failed");
                 return false;
             case EVENT_SERVER_CONNECTED:
                 LOGD("Server connected");
+                *connected = true;
                 return true;
             default:
                 break;
@@ -262,7 +265,7 @@ sc_server_on_disconnected(struct sc_server *server, void *userdata) {
     // event
 }
 
-bool
+enum scrcpy_exit_code
 scrcpy(struct scrcpy_options *options) {
     static struct scrcpy scrcpy;
     struct scrcpy *s = &scrcpy;
@@ -270,12 +273,12 @@ scrcpy(struct scrcpy_options *options) {
     // Minimal SDL initialization
     if (SDL_Init(SDL_INIT_EVENTS)) {
         LOGE("Could not initialize SDL: %s", SDL_GetError());
-        return false;
+        return SCRCPY_EXIT_FAILURE;
     }
 
     atexit(SDL_Quit);
 
-    bool ret = false;
+    enum scrcpy_exit_code ret = SCRCPY_EXIT_FAILURE;
 
     bool server_started = false;
     bool file_pusher_initialized = false;
@@ -321,6 +324,9 @@ scrcpy(struct scrcpy_options *options) {
         .tcpip = options->tcpip,
         .tcpip_dst = options->tcpip_dst,
         .cleanup = options->cleanup,
+        .power_on = options->power_on,
+        .install = options->install,
+        .reinstall = options->reinstall,
     };
 
     static const struct sc_server_callbacks cbs = {
@@ -329,7 +335,7 @@ scrcpy(struct scrcpy_options *options) {
         .on_disconnected = sc_server_on_disconnected,
     };
     if (!sc_server_init(&s->server, &params, &cbs, NULL)) {
-        return false;
+        return SCRCPY_EXIT_FAILURE;
     }
 
     if (!sc_server_start(&s->server)) {
@@ -351,7 +357,14 @@ scrcpy(struct scrcpy_options *options) {
     sdl_configure(options->display, options->disable_screensaver);
 
     // Await for server without blocking Ctrl+C handling
-    if (!await_for_server()) {
+    bool connected;
+    if (!await_for_server(&connected)) {
+        goto end;
+    }
+
+    if (!connected) {
+        // This is not an error, user requested to quit
+        ret = SCRCPY_EXIT_SUCCESS;
         goto end;
     }
 

app/src/scrcpy.h

@@ -6,7 +6,18 @@
 #include <stdbool.h>
 #include "options.h"
 
-bool
+enum scrcpy_exit_code {
+    // Normal program termination
+    SCRCPY_EXIT_SUCCESS,
+
+    // No connection could be established
+    SCRCPY_EXIT_FAILURE,
+
+    // Device was disconnected while running
+    SCRCPY_EXIT_DISCONNECTED,
+};
+
+enum scrcpy_exit_code
 scrcpy(struct scrcpy_options *options);
 
 #endif

app/src/server.c

@@ -14,10 +14,11 @@
 #include "util/process_intr.h"
 #include "util/str.h"
 
-#define SC_SERVER_FILENAME "scrcpy-server"
+#define SC_SERVER_FILENAME "scrcpy-server.apk"
+#define SC_SERVER_PACKAGE "com.genymobile.scrcpy"
 
 #define SC_SERVER_PATH_DEFAULT PREFIX "/share/scrcpy/" SC_SERVER_FILENAME
-#define SC_DEVICE_SERVER_PATH "/data/local/tmp/scrcpy-server.jar"
+#define SC_DEVICE_SERVER_PATH "/data/local/tmp/scrcpy-server.apk"
 
 static char *
 get_server_path(void) {
@@ -104,7 +105,10 @@ error:
 }
 
 static bool
-push_server(struct sc_intr *intr, const char *serial) {
+push_server(struct sc_intr *intr, const char *serial, bool install,
+            bool reinstall) {
+    assert(install || !reinstall); // reinstall implies install
+
     char *server_path = get_server_path();
     if (!server_path) {
         return false;
@@ -114,7 +118,28 @@ push_server(struct sc_intr *intr, const char *serial) {
         free(server_path);
         return false;
     }
-    bool ok = sc_adb_push(intr, serial, server_path, SC_DEVICE_SERVER_PATH, 0);
+    bool ok;
+
+    if (install) {
+        char *version = sc_adb_get_installed_apk_version(intr, serial, 0);
+        bool same_version = version && !strcmp(version, SCRCPY_VERSION);
+        free(version);
+        if (!reinstall && same_version) {
+            LOGI("Server " SCRCPY_VERSION " already installed");
+            ok = true;
+        } else {
+            LOGI("Installing server " SCRCPY_VERSION);
+            // If a server with a different signature is installed, or if a
+            // newer server is already installed, we must uninstall it first.
+            ok = sc_adb_uninstall(intr, serial, SC_SERVER_PACKAGE,
+                                  SC_ADB_SILENT);
+            (void) ok; // expected to fail if it is not installed
+            ok = sc_adb_install(intr, serial, server_path, 0);
+        }
+    } else {
+        ok = sc_adb_push(intr, serial, server_path, SC_DEVICE_SERVER_PATH, 0);
+    }
+
     free(server_path);
     return ok;
 }
@@ -152,6 +177,38 @@ sc_server_sleep(struct sc_server *server, sc_tick deadline) {
     return !stopped;
 }
 
+static char *
+get_classpath_cmd(struct sc_intr *intr, const char *serial, bool install) {
+    if (!install) {
+        // In push mode, the path is known statically
+        char *cp = strdup("CLASSPATH=" SC_DEVICE_SERVER_PATH);
+        if (!cp) {
+            LOG_OOM();
+        }
+        return cp;
+    }
+
+    char *apk_path = sc_adb_get_installed_apk_path(intr, serial, 0);
+    if (!apk_path) {
+        LOGE("Could not get device apk path");
+        return NULL;
+    }
+
+#define PREFIX_SIZE (sizeof("CLASSPATH=") - 1)
+    size_t len = strlen(apk_path);
+    char *cp = malloc(PREFIX_SIZE + len + 1);
+    if (!cp) {
+        LOG_OOM();
+        free(apk_path);
+        return NULL;
+    }
+
+    memcpy(cp, "CLASSPATH=", PREFIX_SIZE);
+    memcpy(cp + PREFIX_SIZE, apk_path, len + 1);
+    free(apk_path);
+    return cp;
+}
+
 static sc_pid
 execute_server(struct sc_server *server,
                const struct sc_server_params *params) {
@@ -160,13 +217,20 @@ execute_server(struct sc_server *server,
     const char *serial = server->serial;
     assert(serial);
 
+    char *classpath = get_classpath_cmd(&server->intr, serial, params->install);
+    if (!classpath) {
+        return SC_PROCESS_NONE;
+    }
+
+    LOGD("Using %s", classpath);
+
     const char *cmd[128];
     unsigned count = 0;
     cmd[count++] = sc_adb_get_executable();
     cmd[count++] = "-s";
     cmd[count++] = serial;
     cmd[count++] = "shell";
-    cmd[count++] = "CLASSPATH=" SC_DEVICE_SERVER_PATH;
+    cmd[count++] = classpath;
     cmd[count++] = "app_process";
 
 #ifdef SERVER_DEBUGGER
@@ -248,6 +312,14 @@ execute_server(struct sc_server *server,
         // By default, cleanup is true
         ADD_PARAM("cleanup=false");
     }
+    if (!params->power_on) {
+        // By default, power_on is true
+        ADD_PARAM("power_on=false");
+    }
+    if (params->install) {
+        // By default, installed is false
+        ADD_PARAM("installed=true");
+    }
 
 #undef ADD_PARAM
 
@@ -268,6 +340,8 @@ execute_server(struct sc_server *server,
     pid = sc_adb_execute(cmd, 0);
 
 end:
+    free(classpath);
+
     for (unsigned i = dyn_idx; i < count; ++i) {
         free((char *) cmd[i]);
     }
@@ -649,7 +723,8 @@ sc_server_configure_tcpip_known_address(struct sc_server *server,
 static bool
 sc_server_configure_tcpip_unknown_address(struct sc_server *server,
                                           const char *serial) {
-    bool is_already_tcpip = sc_adb_is_serial_tcpip(serial);
+    bool is_already_tcpip =
+        sc_adb_device_get_type(serial) == SC_ADB_DEVICE_TYPE_TCPIP;
     if (is_already_tcpip) {
         // Nothing to do
         LOGI("Device already connected via TCP/IP: %s", serial);
@@ -707,7 +782,15 @@ run_server(void *data) {
         } else if (params->select_tcpip) {
             selector.type = SC_ADB_DEVICE_SELECT_TCPIP;
         } else {
-            selector.type = SC_ADB_DEVICE_SELECT_ALL;
+            // No explicit selection, check $ANDROID_SERIAL
+            const char *env_serial = getenv("ANDROID_SERIAL");
+            if (env_serial) {
+                LOGI("Using ANDROID_SERIAL: %s", env_serial);
+                selector.type = SC_ADB_DEVICE_SELECT_SERIAL;
+                selector.serial = env_serial;
+            } else {
+                selector.type = SC_ADB_DEVICE_SELECT_ALL;
+            }
         }
         struct sc_adb_device device;
         ok = sc_adb_select_device(&server->intr, &selector, 0, &device);
@@ -742,8 +825,9 @@ run_server(void *data) {
     assert(serial);
     LOGD("Device serial: %s", serial);
 
-    ok = push_server(&server->intr, serial);
+    ok = push_server(&server->intr, serial, params->install, params->reinstall);
     if (!ok) {
+        LOGE("Failed to push server");
         goto error_connection_failed;
     }
 

app/src/server.h

@@ -47,6 +47,9 @@ struct sc_server_params {
     bool select_usb;
     bool select_tcpip;
     bool cleanup;
+    bool power_on;
+    bool install;
+    bool reinstall;
 };
 
 struct sc_server {

app/src/stream.h

@@ -1,51 +0,0 @@
-#ifndef STREAM_H
-#define STREAM_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
-
-#include "trait/packet_sink.h"
-#include "util/net.h"
-#include "util/thread.h"
-
-#define STREAM_MAX_SINKS 2
-
-struct stream {
-    sc_socket socket;
-    sc_thread thread;
-
-    struct sc_packet_sink *sinks[STREAM_MAX_SINKS];
-    unsigned sink_count;
-
-    AVCodecContext *codec_ctx;
-    AVCodecParserContext *parser;
-    // successive packets may need to be concatenated, until a non-config
-    // packet is available
-    AVPacket *pending;
-
-    const struct stream_callbacks *cbs;
-    void *cbs_userdata;
-};
-
-struct stream_callbacks {
-    void (*on_eos)(struct stream *stream, void *userdata);
-};
-
-void
-stream_init(struct stream *stream, sc_socket socket,
-            const struct stream_callbacks *cbs, void *cbs_userdata);
-
-void
-stream_add_sink(struct stream *stream, struct sc_packet_sink *sink);
-
-bool
-stream_start(struct stream *stream);
-
-void
-stream_join(struct stream *stream);
-
-#endif

app/src/sys/unix/process.c

@@ -92,8 +92,14 @@ sc_process_execute_p(const char *const argv[], sc_pid *pid, unsigned flags,
                 close(in[0]);
             }
             close(in[1]);
+        } else {
+            int devnull = open("/dev/null", O_RDONLY | O_CREAT, 0666);
+            if (devnull != -1) {
+                dup2(devnull, STDIN_FILENO);
+            } else {
+                LOGE("Could not open /dev/null for stdin");
+            }
         }
-        // Do not close stdin in the child process, this makes adb fail on Linux
 
         if (pout) {
             if (out[1] != STDOUT_FILENO) {
@@ -102,8 +108,12 @@ sc_process_execute_p(const char *const argv[], sc_pid *pid, unsigned flags,
             }
             close(out[0]);
         } else if (!inherit_stdout) {
-            // Close stdout in the child process
-            close(STDOUT_FILENO);
+            int devnull = open("/dev/null", O_WRONLY | O_CREAT, 0666);
+            if (devnull != -1) {
+                dup2(devnull, STDOUT_FILENO);
+            } else {
+                LOGE("Could not open /dev/null for stdout");
+            }
         }
 
         if (perr) {
@@ -113,8 +123,12 @@ sc_process_execute_p(const char *const argv[], sc_pid *pid, unsigned flags,
             }
             close(err[0]);
         } else if (!inherit_stderr) {
-            // Close stderr in the child process
-            close(STDERR_FILENO);
+            int devnull = open("/dev/null", O_WRONLY | O_CREAT, 0666);
+            if (devnull != -1) {
+                dup2(devnull, STDERR_FILENO);
+            } else {
+                LOGE("Could not open /dev/null for stderr");
+            }
         }
 
         close(internal[0]);

app/src/usb/hid_keyboard.c

@@ -340,7 +340,7 @@ push_mod_lock_state(struct sc_hid_keyboard *kb, uint16_t mods_state) {
 
     if (!sc_aoa_push_hid_event(kb->aoa, &hid_event)) {
         sc_hid_event_destroy(&hid_event);
-        LOGW("Could request HID event");
+        LOGW("Could not request HID event (mod lock state)");
         return false;
     }
 
@@ -382,7 +382,7 @@ sc_key_processor_process_key(struct sc_key_processor *kp,
 
         if (!sc_aoa_push_hid_event(kb->aoa, &hid_event)) {
             sc_hid_event_destroy(&hid_event);
-            LOGW("Could request HID event");
+            LOGW("Could not request HID event (key)");
         }
     }
 }

app/src/usb/hid_mouse.c

@@ -181,7 +181,7 @@ sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
 
     if (!sc_aoa_push_hid_event(mouse->aoa, &hid_event)) {
         sc_hid_event_destroy(&hid_event);
-        LOGW("Could request HID event");
+        LOGW("Could not request HID event (mouse motion)");
     }
 }
 
@@ -203,7 +203,7 @@ sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
 
     if (!sc_aoa_push_hid_event(mouse->aoa, &hid_event)) {
         sc_hid_event_destroy(&hid_event);
-        LOGW("Could request HID event");
+        LOGW("Could not request HID event (mouse click)");
     }
 }
 
@@ -228,7 +228,7 @@ sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
 
     if (!sc_aoa_push_hid_event(mouse->aoa, &hid_event)) {
         sc_hid_event_destroy(&hid_event);
-        LOGW("Could request HID event");
+        LOGW("Could not request HID event (mouse scroll)");
     }
 }
 

app/src/usb/scrcpy_otg.c

@@ -29,32 +29,36 @@ sc_usb_on_disconnected(struct sc_usb *usb, void *userdata) {
     }
 }
 
-static bool
+static enum scrcpy_exit_code
 event_loop(struct scrcpy_otg *s) {
     SDL_Event event;
     while (SDL_WaitEvent(&event)) {
         switch (event.type) {
             case EVENT_USB_DEVICE_DISCONNECTED:
                 LOGW("Device disconnected");
-                return false;
+                return SCRCPY_EXIT_DISCONNECTED;
             case SDL_QUIT:
                 LOGD("User requested to quit");
-                return true;
+                return SCRCPY_EXIT_SUCCESS;
             default:
                 sc_screen_otg_handle_event(&s->screen_otg, &event);
                 break;
         }
     }
-    return false;
+    return SCRCPY_EXIT_FAILURE;
 }
 
-bool
+enum scrcpy_exit_code
 scrcpy_otg(struct scrcpy_options *options) {
     static struct scrcpy_otg scrcpy_otg;
     struct scrcpy_otg *s = &scrcpy_otg;
 
     const char *serial = options->serial;
 
+    if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1")) {
+        LOGW("Could not enable linear filtering");
+    }
+
     // Minimal SDL initialization
     if (SDL_Init(SDL_INIT_EVENTS)) {
         LOGE("Could not initialize SDL: %s", SDL_GetError());
@@ -67,7 +71,7 @@ scrcpy_otg(struct scrcpy_options *options) {
         LOGW("Could not enable mouse focus clickthrough");
     }
 
-    bool ret = false;
+    enum scrcpy_exit_code ret = SCRCPY_EXIT_FAILURE;
 
     struct sc_hid_keyboard *keyboard = NULL;
     struct sc_hid_mouse *mouse = NULL;
@@ -90,7 +94,7 @@ scrcpy_otg(struct scrcpy_options *options) {
     };
     bool ok = sc_usb_init(&s->usb);
     if (!ok) {
-        return false;
+        return SCRCPY_EXIT_FAILURE;
     }
 
     struct sc_usb_device usb_device;
@@ -162,6 +166,8 @@ scrcpy_otg(struct scrcpy_options *options) {
         .always_on_top = options->always_on_top,
         .window_x = options->window_x,
         .window_y = options->window_y,
+        .window_width = options->window_width,
+        .window_height = options->window_height,
         .window_borderless = options->window_borderless,
     };
 

app/src/usb/scrcpy_otg.h

@@ -3,10 +3,10 @@
 
 #include "common.h"
 
-#include <stdbool.h>
 #include "options.h"
+#include "scrcpy.h"
 
-bool
+enum scrcpy_exit_code
 scrcpy_otg(struct scrcpy_options *options);
 
 #endif

app/src/usb/screen_otg.c

@@ -69,10 +69,10 @@ sc_screen_otg_init(struct sc_screen_otg *screen,
           ? params->window_x : (int) SDL_WINDOWPOS_UNDEFINED;
     int y = params->window_y != SC_WINDOW_POSITION_UNDEFINED
           ? params->window_y : (int) SDL_WINDOWPOS_UNDEFINED;
-    int width = 256;
-    int height = 256;
+    int width = params->window_width ? params->window_width : 256;
+    int height = params->window_height ? params->window_height : 256;
 
-    uint32_t window_flags = 0;
+    uint32_t window_flags = SDL_WINDOW_ALLOW_HIGHDPI;
     if (params->always_on_top) {
         window_flags |= SDL_WINDOW_ALWAYS_ON_TOP;
     }
@@ -97,6 +97,11 @@ sc_screen_otg_init(struct sc_screen_otg *screen,
     if (icon) {
         SDL_SetWindowIcon(screen->window, icon);
 
+        if (SDL_RenderSetLogicalSize(screen->renderer, icon->w, icon->h)) {
+            LOGW("Could not set renderer logical size: %s", SDL_GetError());
+            // don't fail
+        }
+
         screen->texture = SDL_CreateTextureFromSurface(screen->renderer, icon);
         scrcpy_icon_destroy(icon);
         if (!screen->texture) {

app/src/usb/screen_otg.h

@@ -29,6 +29,8 @@ struct sc_screen_otg_params {
     bool always_on_top;
     int16_t window_x; // accepts SC_WINDOW_POSITION_UNDEFINED
     int16_t window_y; // accepts SC_WINDOW_POSITION_UNDEFINED
+    uint16_t window_width;
+    uint16_t window_height;
     bool window_borderless;
 };
 

app/src/usb/usb.c

@@ -15,6 +15,7 @@ read_string(libusb_device_handle *handle, uint8_t desc_index) {
                                            (unsigned char *) buffer,
                                            sizeof(buffer));
     if (result < 0) {
+        LOGD("Read string: libusb error: %s", libusb_strerror(result));
         return NULL;
     }
 
@@ -22,6 +23,11 @@ read_string(libusb_device_handle *handle, uint8_t desc_index) {
 
     // When non-negative, 'result' contains the number of bytes written
     char *s = malloc(result + 1);
+    if (!s) {
+        LOG_OOM();
+        return NULL;
+    }
+
     memcpy(s, buffer, result);
     s[result] = '\0';
     return s;

app/src/util/binary.h

@@ -1,8 +1,9 @@
-#ifndef SC_BUFFER_UTIL_H
-#define SC_BUFFER_UTIL_H
+#ifndef SC_BINARY_H
+#define SC_BINARY_H
 
 #include "common.h"
 
+#include <assert.h>
 #include <stdbool.h>
 #include <stdint.h>
 
@@ -43,4 +44,33 @@ sc_read64be(const uint8_t *buf) {
     return ((uint64_t) msb << 32) | lsb;
 }
 
+/**
+ * Convert a float between 0 and 1 to an unsigned 16-bit fixed-point value
+ */
+static inline uint16_t
+sc_float_to_u16fp(float f) {
+    assert(f >= 0.0f && f <= 1.0f);
+    uint32_t u = f * 0x1p16f; // 2^16
+    if (u >= 0xffff) {
+        assert(u == 0x10000); // for f == 1.0f
+        u = 0xffff;
+    }
+    return (uint16_t) u;
+}
+
+/**
+ * Convert a float between -1 and 1 to a signed 16-bit fixed-point value
+ */
+static inline int16_t
+sc_float_to_i16fp(float f) {
+    assert(f >= -1.0f && f <= 1.0f);
+    int32_t i = f * 0x1p15f; // 2^15
+    assert(i >= -0x8000);
+    if (i >= 0x7fff) {
+        assert(i == 0x8000); // for f == 1.0f
+        i = 0x7fff;
+    }
+    return (int16_t) i;
+}
+
 #endif

app/src/util/cbuf.h

@@ -1,6 +1,6 @@
 // generic circular buffer (bounded queue) implementation
-#ifndef CBUF_H
-#define CBUF_H
+#ifndef SC_CBUF_H
+#define SC_CBUF_H
 
 #include "common.h"
 

app/src/util/net.c

@@ -3,11 +3,10 @@
 #include <assert.h>
 #include <errno.h>
 #include <stdio.h>
-#include <SDL2/SDL_platform.h>
 
 #include "log.h"
 
-#ifdef __WINDOWS__
+#ifdef _WIN32
 # include <ws2tcpip.h>
   typedef int socklen_t;
   typedef SOCKET sc_raw_socket;
@@ -29,7 +28,7 @@
 
 bool
 net_init(void) {
-#ifdef __WINDOWS__
+#ifdef _WIN32
     WSADATA wsa;
     int res = WSAStartup(MAKEWORD(2, 2), &wsa) < 0;
     if (res < 0) {
@@ -42,14 +41,14 @@ net_init(void) {
 
 void
 net_cleanup(void) {
-#ifdef __WINDOWS__
+#ifdef _WIN32
     WSACleanup();
 #endif
 }
 
 static inline sc_socket
 wrap(sc_raw_socket sock) {
-#ifdef __WINDOWS__
+#ifdef _WIN32
     if (sock == INVALID_SOCKET) {
         return SC_SOCKET_NONE;
     }
@@ -72,7 +71,7 @@ wrap(sc_raw_socket sock) {
 
 static inline sc_raw_socket
 unwrap(sc_socket socket) {
-#ifdef __WINDOWS__
+#ifdef _WIN32
     if (socket == SC_SOCKET_NONE) {
         return INVALID_SOCKET;
     }
@@ -160,8 +159,8 @@ net_connect(sc_socket socket, uint32_t addr, uint16_t port) {
 }
 
 bool
-net_listen(sc_socket socket, uint32_t addr, uint16_t port, int backlog) {
-    sc_raw_socket raw_sock = unwrap(socket);
+net_listen(sc_socket server_socket, uint32_t addr, uint16_t port, int backlog) {
+    sc_raw_socket raw_sock = unwrap(server_socket);
 
     int reuse = 1;
     if (setsockopt(raw_sock, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuse,
@@ -248,7 +247,7 @@ net_interrupt(sc_socket socket) {
 
     sc_raw_socket raw_sock = unwrap(socket);
 
-#ifdef __WINDOWS__
+#ifdef _WIN32
     if (!atomic_flag_test_and_set(&socket->closed)) {
         return !closesocket(raw_sock);
     }
@@ -262,7 +261,7 @@ bool
 net_close(sc_socket socket) {
     sc_raw_socket raw_sock = unwrap(socket);
 
-#ifdef __WINDOWS__
+#ifdef _WIN32
     bool ret = true;
     if (!atomic_flag_test_and_set(&socket->closed)) {
         ret = !closesocket(raw_sock);

app/src/util/net.h

@@ -1,13 +1,12 @@
-#ifndef NET_H
-#define NET_H
+#ifndef SC_NET_H
+#define SC_NET_H
 
 #include "common.h"
 
 #include <stdbool.h>
 #include <stdint.h>
-#include <SDL2/SDL_platform.h>
 
-#ifdef __WINDOWS__
+#ifdef _WIN32
 
 # include <winsock2.h>
 # include <stdatomic.h>
@@ -17,7 +16,7 @@
       atomic_flag closed;
   } *sc_socket;
 
-#else // not __WINDOWS__
+#else // not _WIN32
 
 # include <sys/socket.h>
 # define SC_SOCKET_NONE -1
@@ -40,7 +39,7 @@ bool
 net_connect(sc_socket socket, uint32_t addr, uint16_t port);
 
 bool
-net_listen(sc_socket socket, uint32_t addr, uint16_t port, int backlog);
+net_listen(sc_socket server_socket, uint32_t addr, uint16_t port, int backlog);
 
 sc_socket
 net_accept(sc_socket server_socket);

app/src/util/net_intr.c

@@ -15,14 +15,14 @@ net_connect_intr(struct sc_intr *intr, sc_socket socket, uint32_t addr,
 }
 
 bool
-net_listen_intr(struct sc_intr *intr, sc_socket socket, uint32_t addr,
+net_listen_intr(struct sc_intr *intr, sc_socket server_socket, uint32_t addr,
                 uint16_t port, int backlog) {
-    if (!sc_intr_set_socket(intr, socket)) {
+    if (!sc_intr_set_socket(intr, server_socket)) {
         // Already interrupted
         return false;
     }
 
-    bool ret = net_listen(socket, addr, port, backlog);
+    bool ret = net_listen(server_socket, addr, port, backlog);
 
     sc_intr_set_socket(intr, SC_SOCKET_NONE);
     return ret;

app/src/util/net_intr.h

@@ -11,7 +11,7 @@ net_connect_intr(struct sc_intr *intr, sc_socket socket, uint32_t addr,
                  uint16_t port);
 
 bool
-net_listen_intr(struct sc_intr *intr, sc_socket socket, uint32_t addr,
+net_listen_intr(struct sc_intr *intr, sc_socket server_socket, uint32_t addr,
                 uint16_t port, int backlog);
 
 sc_socket

app/src/util/vector.h

@@ -5,6 +5,7 @@
 
 #include <stdbool.h>
 #include <stddef.h>
+#include <stdlib.h>
 
 // Adapted from vlc_vector:
 // <https://code.videolan.org/videolan/vlc/-/blob/0857947abaed9c89810cd96353aaa1b7e6ba3b0d/include/vlc_vector.h>

app/tests/test_adb_parser.c

@@ -5,7 +5,7 @@
 #include "adb/adb_device.h"
 #include "adb/adb_parser.h"
 
-static void test_adb_devices() {
+static void test_adb_devices(void) {
     char output[] =
         "List of devices attached\n"
         "0123456789abcdef	device usb:2-1 product:MyProduct model:MyModel "
@@ -31,7 +31,7 @@ static void test_adb_devices() {
     sc_adb_devices_destroy(&vec);
 }
 
-static void test_adb_devices_cr() {
+static void test_adb_devices_cr(void) {
     char output[] =
         "List of devices attached\r\n"
         "0123456789abcdef	device usb:2-1 product:MyProduct model:MyModel "
@@ -57,7 +57,7 @@ static void test_adb_devices_cr() {
     sc_adb_devices_destroy(&vec);
 }
 
-static void test_adb_devices_daemon_start() {
+static void test_adb_devices_daemon_start(void) {
     char output[] =
         "* daemon not running; starting now at tcp:5037\n"
         "* daemon started successfully\n"
@@ -78,7 +78,7 @@ static void test_adb_devices_daemon_start() {
     sc_adb_devices_destroy(&vec);
 }
 
-static void test_adb_devices_daemon_start_mixed() {
+static void test_adb_devices_daemon_start_mixed(void) {
     char output[] =
         "List of devices attached\n"
         "adb server version (41) doesn't match this client (39); killing...\n"
@@ -105,7 +105,7 @@ static void test_adb_devices_daemon_start_mixed() {
     sc_adb_devices_destroy(&vec);
 }
 
-static void test_adb_devices_without_eol() {
+static void test_adb_devices_without_eol(void) {
     char output[] =
         "List of devices attached\n"
         "0123456789abcdef	device usb:2-1 product:MyProduct model:MyModel "
@@ -124,7 +124,7 @@ static void test_adb_devices_without_eol() {
     sc_adb_devices_destroy(&vec);
 }
 
-static void test_adb_devices_without_header() {
+static void test_adb_devices_without_header(void) {
     char output[] =
         "0123456789abcdef	device usb:2-1 product:MyProduct model:MyModel "
             "device:MyDevice transport_id:1\n";
@@ -134,7 +134,7 @@ static void test_adb_devices_without_header() {
     assert(!ok);
 }
 
-static void test_adb_devices_corrupted() {
+static void test_adb_devices_corrupted(void) {
     char output[] =
         "List of devices attached\n"
         "corrupted_garbage\n";
@@ -145,7 +145,7 @@ static void test_adb_devices_corrupted() {
     assert(vec.size == 0);
 }
 
-static void test_adb_devices_spaces() {
+static void test_adb_devices_spaces(void) {
     char output[] =
         "List of devices attached\n"
         "0123456789abcdef       unauthorized usb:1-4 transport_id:3\n";
@@ -163,84 +163,132 @@ static void test_adb_devices_spaces() {
     sc_adb_devices_destroy(&vec);
 }
 
-static void test_get_ip_single_line() {
+static void test_get_ip_single_line(void) {
     char ip_route[] = "192.168.1.0/24 dev wlan0  proto kernel  scope link  src "
                       "192.168.12.34\r\r\n";
 
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route);
+    char *ip = sc_adb_parse_device_ip(ip_route);
     assert(ip);
     assert(!strcmp(ip, "192.168.12.34"));
     free(ip);
 }
 
-static void test_get_ip_single_line_without_eol() {
+static void test_get_ip_single_line_without_eol(void) {
     char ip_route[] = "192.168.1.0/24 dev wlan0  proto kernel  scope link  src "
                       "192.168.12.34";
 
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route);
+    char *ip = sc_adb_parse_device_ip(ip_route);
     assert(ip);
     assert(!strcmp(ip, "192.168.12.34"));
     free(ip);
 }
 
-static void test_get_ip_single_line_with_trailing_space() {
+static void test_get_ip_single_line_with_trailing_space(void) {
     char ip_route[] = "192.168.1.0/24 dev wlan0  proto kernel  scope link  src "
                       "192.168.12.34 \n";
 
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route);
+    char *ip = sc_adb_parse_device_ip(ip_route);
     assert(ip);
     assert(!strcmp(ip, "192.168.12.34"));
     free(ip);
 }
 
-static void test_get_ip_multiline_first_ok() {
+static void test_get_ip_multiline_first_ok(void) {
     char ip_route[] = "192.168.1.0/24 dev wlan0  proto kernel  scope link  src "
                       "192.168.1.2\r\n"
                       "10.0.0.0/24 dev rmnet  proto kernel  scope link  src "
                       "10.0.0.2\r\n";
 
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route);
+    char *ip = sc_adb_parse_device_ip(ip_route);
     assert(ip);
     assert(!strcmp(ip, "192.168.1.2"));
     free(ip);
 }
 
-static void test_get_ip_multiline_second_ok() {
+static void test_get_ip_multiline_second_ok(void) {
     char ip_route[] = "10.0.0.0/24 dev rmnet  proto kernel  scope link  src "
                       "10.0.0.3\r\n"
                       "192.168.1.0/24 dev wlan0  proto kernel  scope link  src "
                       "192.168.1.3\r\n";
 
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route);
+    char *ip = sc_adb_parse_device_ip(ip_route);
     assert(ip);
     assert(!strcmp(ip, "192.168.1.3"));
     free(ip);
 }
 
-static void test_get_ip_no_wlan() {
+static void test_get_ip_no_wlan(void) {
     char ip_route[] = "192.168.1.0/24 dev rmnet  proto kernel  scope link  src "
                       "192.168.12.34\r\r\n";
 
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route);
+    char *ip = sc_adb_parse_device_ip(ip_route);
     assert(!ip);
 }
 
-static void test_get_ip_no_wlan_without_eol() {
+static void test_get_ip_no_wlan_without_eol(void) {
     char ip_route[] = "192.168.1.0/24 dev rmnet  proto kernel  scope link  src "
                       "192.168.12.34";
 
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route);
+    char *ip = sc_adb_parse_device_ip(ip_route);
     assert(!ip);
 }
 
-static void test_get_ip_truncated() {
+static void test_get_ip_truncated(void) {
     char ip_route[] = "192.168.1.0/24 dev rmnet  proto kernel  scope link  src "
                       "\n";
 
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route);
+    char *ip = sc_adb_parse_device_ip(ip_route);
     assert(!ip);
 }
 
+static void test_apk_path(void) {
+    char str[] = "package:/data/app/~~71mguyc6p-kNjQdNaNkToA==/com.genymobile."
+                 "scrcpy-l6fiqqUSU7Ok7QLg-rIyJA==/base.apk=com.genymobile."
+                 "scrcpy\n";
+
+    const char *expected = "/data/app/~~71mguyc6p-kNjQdNaNkToA==/com.genymobile"
+                           ".scrcpy-l6fiqqUSU7Ok7QLg-rIyJA==/base.apk";
+    char *path = sc_adb_parse_installed_apk_path(str);
+    assert(!strcmp(path, expected));
+    free(path);
+}
+
+static void test_apk_path_invalid(void) {
+    // Does not start with "package:"
+    char str[] = "garbage:/data/app/~~71mguyc6p-kNjQdNaNkToA==/com.genymobile."
+                 "scrcpy-l6fiqqUSU7Ok7QLg-rIyJA==/base.apk=com.genymobile."
+                 "scrcpy\n";
+
+    char *path = sc_adb_parse_installed_apk_path(str);
+    assert(!path);
+}
+
+static void test_apk_version(void) {
+    char str[] =
+        "Key Set Manager:\n"
+        "  [com.genymobile.scrcpy]\n"
+        "      Signing KeySets: 128\n"
+        "\n"
+        "Packages:\n"
+        "  Package [com.genymobile.scrcpy] (89abcdef):\n"
+        "    userId=12345\n"
+        "    pkg=Package{012345 com.genymobile.scrcpy}\n"
+        "    codePath=/data/app/~~abcdef==/com.genymobile.scrcpy-012345==\n"
+        "    resourcePath=/data/app/~~abcdef==/com.genymobile.scrcpy-013245==\n"
+        "    primaryCpuAbi=null\n"
+        "    secondaryCpuAbi=null\n"
+        "    versionCode=12400 minSdk=21 targetSdk=31\n"
+        "    versionName=1.24\n"
+        "    splits=[base]\n"
+        "    apkSigningVersion=2\n"
+        "    applicationInfo=ApplicationInfo{012345 com.genymobile.scrcpy}\n";
+
+    const char *expected = "1.24";
+    char *version = sc_adb_parse_installed_apk_version(str);
+    assert(!strcmp(version, expected));
+    free(version);
+}
+
 int main(int argc, char *argv[]) {
     (void) argc;
     (void) argv;
@@ -262,4 +310,10 @@ int main(int argc, char *argv[]) {
     test_get_ip_no_wlan();
     test_get_ip_no_wlan_without_eol();
     test_get_ip_truncated();
+
+    test_apk_path();
+    test_apk_path_invalid();
+    test_apk_version();
+
+    return 0;
 }

app/tests/test_binary.c

@@ -0,0 +1,114 @@
+#include "common.h"
+
+#include <assert.h>
+
+#include "util/binary.h"
+
+static void test_write16be(void) {
+    uint16_t val = 0xABCD;
+    uint8_t buf[2];
+
+    sc_write16be(buf, val);
+
+    assert(buf[0] == 0xAB);
+    assert(buf[1] == 0xCD);
+}
+
+static void test_write32be(void) {
+    uint32_t val = 0xABCD1234;
+    uint8_t buf[4];
+
+    sc_write32be(buf, val);
+
+    assert(buf[0] == 0xAB);
+    assert(buf[1] == 0xCD);
+    assert(buf[2] == 0x12);
+    assert(buf[3] == 0x34);
+}
+
+static void test_write64be(void) {
+    uint64_t val = 0xABCD1234567890EF;
+    uint8_t buf[8];
+
+    sc_write64be(buf, val);
+
+    assert(buf[0] == 0xAB);
+    assert(buf[1] == 0xCD);
+    assert(buf[2] == 0x12);
+    assert(buf[3] == 0x34);
+    assert(buf[4] == 0x56);
+    assert(buf[5] == 0x78);
+    assert(buf[6] == 0x90);
+    assert(buf[7] == 0xEF);
+}
+
+static void test_read16be(void) {
+    uint8_t buf[2] = {0xAB, 0xCD};
+
+    uint16_t val = sc_read16be(buf);
+
+    assert(val == 0xABCD);
+}
+
+static void test_read32be(void) {
+    uint8_t buf[4] = {0xAB, 0xCD, 0x12, 0x34};
+
+    uint32_t val = sc_read32be(buf);
+
+    assert(val == 0xABCD1234);
+}
+
+static void test_read64be(void) {
+    uint8_t buf[8] = {0xAB, 0xCD, 0x12, 0x34,
+                      0x56, 0x78, 0x90, 0xEF};
+
+    uint64_t val = sc_read64be(buf);
+
+    assert(val == 0xABCD1234567890EF);
+}
+
+static void test_float_to_u16fp(void) {
+    assert(sc_float_to_u16fp(0.0f) == 0);
+    assert(sc_float_to_u16fp(0.03125f) == 0x800);
+    assert(sc_float_to_u16fp(0.0625f) == 0x1000);
+    assert(sc_float_to_u16fp(0.125f) == 0x2000);
+    assert(sc_float_to_u16fp(0.25f) == 0x4000);
+    assert(sc_float_to_u16fp(0.5f) == 0x8000);
+    assert(sc_float_to_u16fp(0.75f) == 0xc000);
+    assert(sc_float_to_u16fp(1.0f) == 0xffff);
+}
+
+static void test_float_to_i16fp(void) {
+    assert(sc_float_to_i16fp(0.0f) == 0);
+    assert(sc_float_to_i16fp(0.03125f) == 0x400);
+    assert(sc_float_to_i16fp(0.0625f) == 0x800);
+    assert(sc_float_to_i16fp(0.125f) == 0x1000);
+    assert(sc_float_to_i16fp(0.25f) == 0x2000);
+    assert(sc_float_to_i16fp(0.5f) == 0x4000);
+    assert(sc_float_to_i16fp(0.75f) == 0x6000);
+    assert(sc_float_to_i16fp(1.0f) == 0x7fff);
+
+    assert(sc_float_to_i16fp(-0.03125f) == -0x400);
+    assert(sc_float_to_i16fp(-0.0625f) == -0x800);
+    assert(sc_float_to_i16fp(-0.125f) == -0x1000);
+    assert(sc_float_to_i16fp(-0.25f) == -0x2000);
+    assert(sc_float_to_i16fp(-0.5f) == -0x4000);
+    assert(sc_float_to_i16fp(-0.75f) == -0x6000);
+    assert(sc_float_to_i16fp(-1.0f) == -0x8000);
+}
+
+int main(int argc, char *argv[]) {
+    (void) argc;
+    (void) argv;
+
+    test_write16be();
+    test_write32be();
+    test_write64be();
+    test_read16be();
+    test_read32be();
+    test_read64be();
+
+    test_float_to_u16fp();
+    test_float_to_i16fp();
+    return 0;
+}

app/tests/test_buffer_util.c

@@ -1,81 +0,0 @@
-#include "common.h"
-
-#include <assert.h>
-
-#include "util/buffer_util.h"
-
-static void test_buffer_write16be(void) {
-    uint16_t val = 0xABCD;
-    uint8_t buf[2];
-
-    sc_write16be(buf, val);
-
-    assert(buf[0] == 0xAB);
-    assert(buf[1] == 0xCD);
-}
-
-static void test_buffer_write32be(void) {
-    uint32_t val = 0xABCD1234;
-    uint8_t buf[4];
-
-    sc_write32be(buf, val);
-
-    assert(buf[0] == 0xAB);
-    assert(buf[1] == 0xCD);
-    assert(buf[2] == 0x12);
-    assert(buf[3] == 0x34);
-}
-
-static void test_buffer_write64be(void) {
-    uint64_t val = 0xABCD1234567890EF;
-    uint8_t buf[8];
-
-    sc_write64be(buf, val);
-
-    assert(buf[0] == 0xAB);
-    assert(buf[1] == 0xCD);
-    assert(buf[2] == 0x12);
-    assert(buf[3] == 0x34);
-    assert(buf[4] == 0x56);
-    assert(buf[5] == 0x78);
-    assert(buf[6] == 0x90);
-    assert(buf[7] == 0xEF);
-}
-
-static void test_buffer_read16be(void) {
-    uint8_t buf[2] = {0xAB, 0xCD};
-
-    uint16_t val = sc_read16be(buf);
-
-    assert(val == 0xABCD);
-}
-
-static void test_buffer_read32be(void) {
-    uint8_t buf[4] = {0xAB, 0xCD, 0x12, 0x34};
-
-    uint32_t val = sc_read32be(buf);
-
-    assert(val == 0xABCD1234);
-}
-
-static void test_buffer_read64be(void) {
-    uint8_t buf[8] = {0xAB, 0xCD, 0x12, 0x34,
-                      0x56, 0x78, 0x90, 0xEF};
-
-    uint64_t val = sc_read64be(buf);
-
-    assert(val == 0xABCD1234567890EF);
-}
-
-int main(int argc, char *argv[]) {
-    (void) argc;
-    (void) argv;
-
-    test_buffer_write16be();
-    test_buffer_write32be();
-    test_buffer_write64be();
-    test_buffer_read16be();
-    test_buffer_read32be();
-    test_buffer_read64be();
-    return 0;
-}

app/tests/test_control_msg_serialize.c

@@ -132,14 +132,14 @@ static void test_serialize_inject_scroll_event(void) {
 
     unsigned char buf[SC_CONTROL_MSG_MAX_SIZE];
     size_t size = sc_control_msg_serialize(&msg, buf);
-    assert(size == 25);
+    assert(size == 21);
 
     const unsigned char expected[] = {
         SC_CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT,
         0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x04, 0x02, // 260 1026
         0x04, 0x38, 0x07, 0x80, // 1080 1920
-        0x00, 0x00, 0x00, 0x01, // 1
-        0xFF, 0xFF, 0xFF, 0xFF, // -1
+        0x7F, 0xFF, // 1 (float encoded as i16)
+        0x80, 0x00, // -1 (float encoded as i16)
         0x00, 0x00, 0x00, 0x01, // 1
     };
     assert(!memcmp(buf, expected, sizeof(expected)));

build.gradle

@@ -4,10 +4,10 @@ buildscript {
 
     repositories {
         google()
-        jcenter()
+        mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:7.0.3'
+        classpath 'com.android.tools.build:gradle:7.2.2'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files
@@ -17,7 +17,7 @@ buildscript {
 allprojects {
     repositories {
         google()
-        jcenter()
+        mavenCentral()
     }
     tasks.withType(JavaCompile) {
         options.compilerArgs << "-Xlint:deprecation"

cross_win32.txt

@@ -20,6 +20,6 @@ ffmpeg_avcodec = 'avcodec-58'
 ffmpeg_avformat = 'avformat-58'
 ffmpeg_avutil = 'avutil-56'
 prebuilt_ffmpeg = 'ffmpeg-win32-4.3.1'
-prebuilt_sdl2 = 'SDL2-2.0.20/i686-w64-mingw32'
-prebuilt_libusb_root = 'libusb-1.0.25'
-prebuilt_libusb = prebuilt_libusb_root + '/MinGW32'
+prebuilt_sdl2 = 'SDL2-2.0.22/i686-w64-mingw32'
+prebuilt_libusb_root = 'libusb-1.0.26'
+prebuilt_libusb = prebuilt_libusb_root + '/MinGW-Win32'

cross_win64.txt

@@ -19,7 +19,7 @@ endian = 'little'
 ffmpeg_avcodec = 'avcodec-59'
 ffmpeg_avformat = 'avformat-59'
 ffmpeg_avutil = 'avutil-57'
-prebuilt_ffmpeg = 'ffmpeg-win64-5.0'
-prebuilt_sdl2 = 'SDL2-2.0.20/x86_64-w64-mingw32'
-prebuilt_libusb_root = 'libusb-1.0.25'
-prebuilt_libusb = prebuilt_libusb_root + '/MinGW64'
+prebuilt_ffmpeg = 'ffmpeg-win64-5.0.1'
+prebuilt_sdl2 = 'SDL2-2.0.22/x86_64-w64-mingw32'
+prebuilt_libusb_root = 'libusb-1.0.26'
+prebuilt_libusb = prebuilt_libusb_root + '/MinGW-x64'

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.0.2-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.3-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

install_release.sh

@@ -2,8 +2,8 @@
 set -e
 
 BUILDDIR=build-auto
-PREBUILT_SERVER_URL=https://github.com/Genymobile/scrcpy/releases/download/v1.22/scrcpy-server-v1.22
-PREBUILT_SERVER_SHA256=c05d273eec7533c0e106282e0254cf04e7f5e8f0c2920ca39448865fab2a419b
+PREBUILT_SERVER_URL=https://github.com/Genymobile/scrcpy/releases/download/v1.24/scrcpy-server-v1.24
+PREBUILT_SERVER_SHA256=ae74a81ea79c0dc7250e586627c278c0a9a8c5de46c9fb5c38c167fb1a36f056
 
 echo "[scrcpy] Downloading prebuilt server..."
 wget "$PREBUILT_SERVER_URL" -O scrcpy-server

meson.build

@@ -1,5 +1,5 @@
 project('scrcpy', 'c',
-        version: '1.22',
+        version: '1.24',
         meson_version: '>= 0.48',
         default_options: [
             'c_std=c11',

release.mk

@@ -75,12 +75,10 @@ prepare-deps-win64:
 	@app/prebuilt-deps/prepare-libusb.sh
 
 build-win32: prepare-deps-win32
-	# -Dusb=false because of libusb-win32 build issue, cf #3011
 	[ -d "$(WIN32_BUILD_DIR)" ] || ( mkdir "$(WIN32_BUILD_DIR)" && \
 		meson "$(WIN32_BUILD_DIR)" \
 			--cross-file cross_win32.txt \
 			--buildtype release --strip -Db_lto=true \
-			-Dusb=false \
 			-Dcompile_server=false \
 			-Dportable=true )
 	ninja -C "$(WIN32_BUILD_DIR)"
@@ -107,11 +105,11 @@ dist-win32: build-server build-win32
 	cp app/prebuilt-deps/data/ffmpeg-win32-4.3.1/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/ffmpeg-win32-4.3.1/bin/swresample-3.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp app/prebuilt-deps/data/ffmpeg-win32-4.3.1/bin/swscale-5.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-31.0.3/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-31.0.3/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-31.0.3/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/SDL2-2.0.20/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	#cp app/prebuilt-deps/data/libusb-1.0.25/MinGW32/dll/libusb-1.0.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-33.0.1/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-33.0.1/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-33.0.1/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/SDL2-2.0.22/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/libusb-1.0.26/MinGW-Win32/msys-usb-1.0.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 
 dist-win64: build-server build-win64
 	mkdir -p "$(DIST)/$(WIN64_TARGET_DIR)"
@@ -121,16 +119,16 @@ dist-win64: build-server build-win64
 	cp app/data/scrcpy-noconsole.vbs "$(DIST)/$(WIN64_TARGET_DIR)"
 	cp app/data/icon.png "$(DIST)/$(WIN64_TARGET_DIR)"
 	cp app/data/open_a_terminal_here.bat "$(DIST)/$(WIN64_TARGET_DIR)"
-	cp app/prebuilt-deps/data/ffmpeg-win64-5.0/bin/avutil-57.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/ffmpeg-win64-5.0/bin/avcodec-59.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/ffmpeg-win64-5.0/bin/avformat-59.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/ffmpeg-win64-5.0/bin/swresample-4.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/ffmpeg-win64-5.0/bin/swscale-6.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-31.0.3/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-31.0.3/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/platform-tools-31.0.3/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/SDL2-2.0.20/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp app/prebuilt-deps/data/libusb-1.0.25/MinGW64/dll/libusb-1.0.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win64-5.0.1/bin/avutil-57.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win64-5.0.1/bin/avcodec-59.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win64-5.0.1/bin/avformat-59.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win64-5.0.1/bin/swresample-4.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/ffmpeg-win64-5.0.1/bin/swscale-6.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-33.0.1/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-33.0.1/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/platform-tools-33.0.1/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/SDL2-2.0.22/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp app/prebuilt-deps/data/libusb-1.0.26/MinGW-x64/msys-usb-1.0.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 
 zip-win32: dist-win32
 	cd "$(DIST)/$(WIN32_TARGET_DIR)"; \

run

@@ -20,6 +20,6 @@ then
     exit 1
 fi
 
-SCRCPY_ICON_PATH="data/icon.png" \
-SCRCPY_SERVER_PATH="$BUILDDIR/server/scrcpy-server" \
+SCRCPY_ICON_PATH="app/data/icon.png" \
+SCRCPY_SERVER_PATH="$BUILDDIR/server/scrcpy-server.apk" \
 "$BUILDDIR/app/scrcpy" "$@"

server/.gitignore

@@ -6,3 +6,4 @@
 /build
 /captures
 .externalNativeBuild
+/keystore.properties

server/HOWTO_keystore.txt

@@ -0,0 +1,12 @@
+For an APK to be installable, it must be signed: <https://developer.android.com/training/articles/keystore>
+
+For that purpose, create a keystore by executing this command:
+
+    keytool -genkey -v -keystore ~/.android/scrcpy.keystore -keyalg RSA -keysize 2048 -validity 10000 -alias scrcpy -dname cn=scrcpy
+
+(Adapt ~/.android/scrcpy.keystore if you want to generate it to another location.)
+
+Then create server/keystore.properties and edit its properties:
+
+    cp keystore.properties.sample keystore.properties
+    vim keystore.properties  # fill the properties

server/build.gradle

@@ -1,25 +1,40 @@
 apply plugin: 'com.android.application'
 
 android {
-    compileSdkVersion 31
+    compileSdkVersion 33
     defaultConfig {
         applicationId "com.genymobile.scrcpy"
         minSdkVersion 21
-        targetSdkVersion 31
-        versionCode 12200
-        versionName "1.22"
+        targetSdkVersion 33
+        versionCode 12400
+        versionName "1.24"
         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
     }
+    signingConfigs {
+        release {
+            // to be defined in server/keystore.properties (see server/HOWTO_keystore.txt)
+            def keystorePropsFile = rootProject.file("server/keystore.properties")
+            if (keystorePropsFile.exists()) {
+                def props = new Properties()
+                props.load(new FileInputStream(keystorePropsFile))
+
+                storeFile rootProject.file(props['storeFile'])
+                storePassword props['storePassword']
+                keyAlias props['keyAlias']
+                keyPassword props['keyPassword']
+            }
+        }
+    }
     buildTypes {
         release {
             minifyEnabled false
             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+            signingConfig signingConfigs.release
         }
     }
 }
 
 dependencies {
-    implementation fileTree(dir: 'libs', include: ['*.jar'])
     testImplementation 'junit:junit:4.13.1'
 }
 

server/build_without_gradle.sh

@@ -12,15 +12,44 @@
 set -e
 
 SCRCPY_DEBUG=false
-SCRCPY_VERSION_NAME=1.22
+SCRCPY_VERSION_NAME=1.24
 
-PLATFORM=${ANDROID_PLATFORM:-31}
-BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-31.0.0}
+SERVER_DIR="$(realpath $(dirname "$0"))"
+KEYSTORE_PROPERTIES_FILE="$SERVER_DIR/keystore.properties"
+
+if [[ ! -f "$KEYSTORE_PROPERTIES_FILE" ]]
+then
+    echo "The file '$KEYSTORE_PROPERTIES_FILE' does not exist." >&2
+    echo "Please read '$SERVER_DIR/HOWTO_keystore.txt'." >&2
+    exit 1
+fi
+
+declare -A props
+while IFS='=' read -r key value
+do
+    props["$key"]="$value"
+done < "$KEYSTORE_PROPERTIES_FILE"
+
+KEYSTORE_FILE=${props['storeFile']}
+KEYSTORE_PASSWORD=${props['storePassword']}
+KEYSTORE_KEY_ALIAS=${props['keyAlias']}
+KEYSTORE_KEY_PASSWORD=${props['keyPassword']}
+
+if [[ ! -f "$KEYSTORE_FILE" ]]
+then
+    echo "Keystore '$KEYSTORE_FILE' (read from '$KEYSTORE_PROPERTIES_FILE')" \
+         "does not exist." >&2
+    echo "Please read '$SERVER_DIR/HOWTO_keystore.txt'." >&2
+    exit 2
+fi
+
+PLATFORM=${ANDROID_PLATFORM:-33}
+BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-33.0.0}
+BUILD_TOOLS_DIR="$ANDROID_HOME/build-tools/$BUILD_TOOLS"
 
 BUILD_DIR="$(realpath ${BUILD_DIR:-build_manual})"
 CLASSES_DIR="$BUILD_DIR/classes"
-SERVER_DIR=$(dirname "$0")
-SERVER_BINARY=scrcpy-server
+SERVER_BINARY=scrcpy-server.apk
 ANDROID_JAR="$ANDROID_HOME/platforms/android-$PLATFORM/android.jar"
 
 echo "Platform: android-$PLATFORM"
@@ -41,9 +70,8 @@ EOF
 
 echo "Generating java from aidl..."
 cd "$SERVER_DIR/src/main/aidl"
-"$ANDROID_HOME/build-tools/$BUILD_TOOLS/aidl" -o"$CLASSES_DIR" \
-    android/view/IRotationWatcher.aidl
-"$ANDROID_HOME/build-tools/$BUILD_TOOLS/aidl" -o"$CLASSES_DIR" \
+"$BUILD_TOOLS_DIR/aidl" -o"$CLASSES_DIR" android/view/IRotationWatcher.aidl
+"$BUILD_TOOLS_DIR/aidl" -o"$CLASSES_DIR" \
     android/content/IOnPrimaryClipChangedListener.aidl
 
 echo "Compiling java sources..."
@@ -59,20 +87,15 @@ cd "$CLASSES_DIR"
 if [[ $PLATFORM -lt 31 ]]
 then
     # use dx
-    "$ANDROID_HOME/build-tools/$BUILD_TOOLS/dx" --dex \
-        --output "$BUILD_DIR/classes.dex" \
+    "$BUILD_TOOLS_DIR/dx" --dex --output "$BUILD_DIR/classes.dex" \
         android/view/*.class \
         android/content/*.class \
         com/genymobile/scrcpy/*.class \
         com/genymobile/scrcpy/wrappers/*.class
-
-    echo "Archiving..."
     cd "$BUILD_DIR"
-    jar cvf "$SERVER_BINARY" classes.dex
-    rm -rf classes.dex classes
 else
     # use d8
-    "$ANDROID_HOME/build-tools/$BUILD_TOOLS/d8" --classpath "$ANDROID_JAR" \
+    "$BUILD_TOOLS_DIR/d8" --classpath "$ANDROID_JAR" \
         --output "$BUILD_DIR/classes.zip" \
         android/view/*.class \
         android/content/*.class \
@@ -80,8 +103,24 @@ else
         com/genymobile/scrcpy/wrappers/*.class
 
     cd "$BUILD_DIR"
-    mv classes.zip "$SERVER_BINARY"
-    rm -rf classes
+    unzip -o classes.zip classes.dex  # we need the inner classes.dex
 fi
 
+echo "Packaging..."
+# note: if a res directory exists, add: -S "$SERVER_DIR/src/main/res"
+"$BUILD_TOOLS_DIR/aapt" package -f \
+    -M "$SERVER_DIR/src/main/AndroidManifest.xml" \
+    -I "$ANDROID_JAR" \
+    -F "$SERVER_BINARY.unaligned"
+"$BUILD_TOOLS_DIR/aapt" add "$SERVER_BINARY.unaligned" classes.dex
+"$BUILD_TOOLS_DIR/zipalign" -p 4 "$SERVER_BINARY.unaligned" "$SERVER_BINARY"
+rm "$SERVER_BINARY.unaligned"
+
+"$BUILD_TOOLS_DIR/apksigner" sign \
+    --ks "$KEYSTORE_FILE" \
+    --ks-pass "pass:$KEYSTORE_PASSWORD" \
+    --ks-key-alias "$KEYSTORE_KEY_ALIAS" \
+    --key-pass "pass:$KEYSTORE_KEY_PASSWORD" \
+    "$SERVER_BINARY"
+
 echo "Server generated in $BUILD_DIR/$SERVER_BINARY"

server/keystore.properties.sample

@@ -0,0 +1,4 @@
+storeFile=/path/to/your/keystore
+storePassword=PASSWORD
+keyAlias=scrcpy
+keyPassword=PASSWORD

server/meson.build

@@ -6,19 +6,19 @@ if prebuilt_server == ''
                   # gradle is responsible for tracking source changes
                   build_by_default: true,
                   build_always_stale: true,
-                  output: 'scrcpy-server',
+                  output: 'scrcpy-server.apk',
                   command: [find_program('./scripts/build-wrapper.sh'), meson.current_source_dir(), '@OUTPUT@', get_option('buildtype')],
                   console: true,
                   install: true,
                   install_dir: 'share/scrcpy')
 else
     if not prebuilt_server.startswith('/')
-        # relative path needs some trick
-        prebuilt_server = meson.source_root() + '/' + prebuilt_server
+        # prebuilt server path is relative to the root scrcpy directory
+        prebuilt_server = '../' + prebuilt_server
     endif
     custom_target('scrcpy-server-prebuilt',
                   input: prebuilt_server,
-                  output: 'scrcpy-server',
+                  output: 'scrcpy-server.apk',
                   command: ['cp', '@INPUT@', '@OUTPUT@'],
                   install: true,
                   install_dir: 'share/scrcpy')

server/scripts/build-wrapper.sh

@@ -25,5 +25,5 @@ then
     cp "$PROJECT_ROOT/build/outputs/apk/debug/server-debug.apk" "$OUTPUT"
 else
     "$GRADLE" -p "$PROJECT_ROOT" assembleRelease
-    cp "$PROJECT_ROOT/build/outputs/apk/release/server-release-unsigned.apk" "$OUTPUT"
+    cp "$PROJECT_ROOT/build/outputs/apk/release/server-release.apk" "$OUTPUT"
 fi

server/src/main/java/com/genymobile/scrcpy/Binary.java

@@ -0,0 +1,38 @@
+package com.genymobile.scrcpy;
+
+public final class Binary {
+    private Binary() {
+        // not instantiable
+    }
+
+    public static int toUnsigned(short value) {
+        return value & 0xffff;
+    }
+
+    public static int toUnsigned(byte value) {
+        return value & 0xff;
+    }
+
+    /**
+     * Convert unsigned 16-bit fixed-point to a float between 0 and 1
+     *
+     * @param value encoded value
+     * @return Float value between 0 and 1
+     */
+    public static float u16FixedPointToFloat(short value) {
+        int unsignedShort = Binary.toUnsigned(value);
+        // 0x1p16f is 2^16 as float
+        return unsignedShort == 0xffff ? 1f : (unsignedShort / 0x1p16f);
+    }
+
+    /**
+     * Convert signed 16-bit fixed-point to a float between -1 and 1
+     *
+     * @param value encoded value
+     * @return Float value between -1 and 1
+     */
+    public static float i16FixedPointToFloat(short value) {
+        // 0x1p15f is 2^15 as float
+        return value == 0x7fff ? 1f : (value / 0x1p15f);
+    }
+}

server/src/main/java/com/genymobile/scrcpy/CleanUp.java

@@ -16,7 +16,7 @@ import java.io.IOException;
  */
 public final class CleanUp {
 
-    public static final String SERVER_PATH = "/data/local/tmp/scrcpy-server.jar";
+    public static final String SERVER_PATH = "/data/local/tmp/scrcpy-server.apk";
 
     // A simple struct to be passed from the main process to the cleanup process
     public static class Config implements Parcelable {
@@ -37,6 +37,8 @@ public final class CleanUp {
         private static final int FLAG_RESTORE_NORMAL_POWER_MODE = 2;
         private static final int FLAG_POWER_OFF_SCREEN = 4;
 
+        private boolean installed;
+
         private int displayId;
 
         // Restore the value (between 0 and 7), -1 to not restore
@@ -52,6 +54,7 @@ public final class CleanUp {
         }
 
         protected Config(Parcel in) {
+            installed = in.readInt() != 0;
             displayId = in.readInt();
             restoreStayOn = in.readInt();
             byte options = in.readByte();
@@ -62,6 +65,7 @@ public final class CleanUp {
 
         @Override
         public void writeToParcel(Parcel dest, int flags) {
+            dest.writeInt(installed ? 1 : 0);
             dest.writeInt(displayId);
             dest.writeInt(restoreStayOn);
             byte options = 0;
@@ -116,9 +120,10 @@ public final class CleanUp {
         // not instantiable
     }
 
-    public static void configure(int displayId, int restoreStayOn, boolean disableShowTouches, boolean restoreNormalPowerMode, boolean powerOffScreen)
+    public static void configure(boolean installed, int displayId, int restoreStayOn, boolean disableShowTouches, boolean restoreNormalPowerMode, boolean powerOffScreen)
             throws IOException {
         Config config = new Config();
+        config.installed = installed;
         config.displayId = displayId;
         config.disableShowTouches = disableShowTouches;
         config.restoreStayOn = restoreStayOn;
@@ -127,8 +132,9 @@ public final class CleanUp {
 
         if (config.hasWork()) {
             startProcess(config);
-        } else {
-            // There is no additional clean up to do when scrcpy dies
+        } else if (!installed) {
+            // There is no additional clean up to do when scrcpy dies.
+            // If the APK has been pushed to /data/local/tmp, remove it.
             unlinkSelf();
         }
     }
@@ -136,6 +142,7 @@ public final class CleanUp {
     private static void startProcess(Config config) throws IOException {
         String[] cmd = {"app_process", "/", CleanUp.class.getName(), config.toBase64()};
 
+        // TODO if scrcpy is "installed", then we must find the install path!
         ProcessBuilder builder = new ProcessBuilder(cmd);
         builder.environment().put("CLASSPATH", SERVER_PATH);
         builder.start();
@@ -150,7 +157,12 @@ public final class CleanUp {
     }
 
     public static void main(String... args) {
-        unlinkSelf();
+        Config config = Config.fromBase64(args[0]);
+
+        if (!config.installed) {
+            // If the APK has been pushed to /data/local/tmp, remove it.
+            unlinkSelf();
+        }
 
         try {
             // Wait for the server to die
@@ -161,8 +173,6 @@ public final class CleanUp {
 
         Ln.i("Cleaning up");
 
-        Config config = Config.fromBase64(args[0]);
-
         if (config.disableShowTouches || config.restoreStayOn != -1) {
             ServiceManager serviceManager = new ServiceManager();
             Settings settings = new Settings(serviceManager);

server/src/main/java/com/genymobile/scrcpy/Command.java

@@ -30,4 +30,14 @@ public final class Command {
         }
         return result;
     }
+
+    public static String execReadOutput(String... cmd) throws IOException, InterruptedException {
+        Process process = Runtime.getRuntime().exec(cmd);
+        String output = IO.toString(process.getInputStream());
+        int exitCode = process.waitFor();
+        if (exitCode != 0) {
+            throw new IOException("Command " + Arrays.toString(cmd) + " returned with value " + exitCode);
+        }
+        return output;
+    }
 }

server/src/main/java/com/genymobile/scrcpy/ControlMessage.java

@@ -33,8 +33,8 @@ public final class ControlMessage {
     private long pointerId;
     private float pressure;
     private Position position;
-    private int hScroll;
-    private int vScroll;
+    private float hScroll;
+    private float vScroll;
     private int copyKey;
     private boolean paste;
     private int repeat;
@@ -71,7 +71,7 @@ public final class ControlMessage {
         return msg;
     }
 
-    public static ControlMessage createInjectScrollEvent(Position position, int hScroll, int vScroll, int buttons) {
+    public static ControlMessage createInjectScrollEvent(Position position, float hScroll, float vScroll, int buttons) {
         ControlMessage msg = new ControlMessage();
         msg.type = TYPE_INJECT_SCROLL_EVENT;
         msg.position = position;
@@ -156,11 +156,11 @@ public final class ControlMessage {
         return position;
     }
 
-    public int getHScroll() {
+    public float getHScroll() {
         return hScroll;
     }
 
-    public int getVScroll() {
+    public float getVScroll() {
         return vScroll;
     }
 

server/src/main/java/com/genymobile/scrcpy/ControlMessageReader.java

@@ -10,7 +10,7 @@ public class ControlMessageReader {
 
     static final int INJECT_KEYCODE_PAYLOAD_LENGTH = 13;
     static final int INJECT_TOUCH_EVENT_PAYLOAD_LENGTH = 27;
-    static final int INJECT_SCROLL_EVENT_PAYLOAD_LENGTH = 24;
+    static final int INJECT_SCROLL_EVENT_PAYLOAD_LENGTH = 20;
     static final int BACK_OR_SCREEN_ON_LENGTH = 1;
     static final int SET_SCREEN_POWER_MODE_PAYLOAD_LENGTH = 1;
     static final int GET_CLIPBOARD_LENGTH = 1;
@@ -103,7 +103,7 @@ public class ControlMessageReader {
         if (buffer.remaining() < INJECT_KEYCODE_PAYLOAD_LENGTH) {
             return null;
         }
-        int action = toUnsigned(buffer.get());
+        int action = Binary.toUnsigned(buffer.get());
         int keycode = buffer.getInt();
         int repeat = buffer.getInt();
         int metaState = buffer.getInt();
@@ -136,13 +136,10 @@ public class ControlMessageReader {
         if (buffer.remaining() < INJECT_TOUCH_EVENT_PAYLOAD_LENGTH) {
             return null;
         }
-        int action = toUnsigned(buffer.get());
+        int action = Binary.toUnsigned(buffer.get());
         long pointerId = buffer.getLong();
         Position position = readPosition(buffer);
-        // 16 bits fixed-point
-        int pressureInt = toUnsigned(buffer.getShort());
-        // convert it to a float between 0 and 1 (0x1p16f is 2^16 as float)
-        float pressure = pressureInt == 0xffff ? 1f : (pressureInt / 0x1p16f);
+        float pressure = Binary.u16FixedPointToFloat(buffer.getShort());
         int buttons = buffer.getInt();
         return ControlMessage.createInjectTouchEvent(action, pointerId, position, pressure, buttons);
     }
@@ -152,8 +149,8 @@ public class ControlMessageReader {
             return null;
         }
         Position position = readPosition(buffer);
-        int hScroll = buffer.getInt();
-        int vScroll = buffer.getInt();
+        float hScroll = Binary.i16FixedPointToFloat(buffer.getShort());
+        float vScroll = Binary.i16FixedPointToFloat(buffer.getShort());
         int buttons = buffer.getInt();
         return ControlMessage.createInjectScrollEvent(position, hScroll, vScroll, buttons);
     }
@@ -162,7 +159,7 @@ public class ControlMessageReader {
         if (buffer.remaining() < BACK_OR_SCREEN_ON_LENGTH) {
             return null;
         }
-        int action = toUnsigned(buffer.get());
+        int action = Binary.toUnsigned(buffer.get());
         return ControlMessage.createBackOrScreenOn(action);
     }
 
@@ -170,7 +167,7 @@ public class ControlMessageReader {
         if (buffer.remaining() < GET_CLIPBOARD_LENGTH) {
             return null;
         }
-        int copyKey = toUnsigned(buffer.get());
+        int copyKey = Binary.toUnsigned(buffer.get());
         return ControlMessage.createGetClipboard(copyKey);
     }
 
@@ -198,16 +195,8 @@ public class ControlMessageReader {
     private static Position readPosition(ByteBuffer buffer) {
         int x = buffer.getInt();
         int y = buffer.getInt();
-        int screenWidth = toUnsigned(buffer.getShort());
-        int screenHeight = toUnsigned(buffer.getShort());
+        int screenWidth = Binary.toUnsigned(buffer.getShort());
+        int screenHeight = Binary.toUnsigned(buffer.getShort());
         return new Position(x, y, screenWidth, screenHeight);
     }
-
-    private static int toUnsigned(short value) {
-        return value & 0xffff;
-    }
-
-    private static int toUnsigned(byte value) {
-        return value & 0xff;
-    }
 }

server/src/main/java/com/genymobile/scrcpy/Controller.java

@@ -22,6 +22,7 @@ public class Controller {
     private final DesktopConnection connection;
     private final DeviceMessageSender sender;
     private final boolean clipboardAutosync;
+    private final boolean powerOn;
 
     private final KeyCharacterMap charMap = KeyCharacterMap.load(KeyCharacterMap.VIRTUAL_KEYBOARD);
 
@@ -32,10 +33,11 @@ public class Controller {
 
     private boolean keepPowerModeOff;
 
-    public Controller(Device device, DesktopConnection connection, boolean clipboardAutosync) {
+    public Controller(Device device, DesktopConnection connection, boolean clipboardAutosync, boolean powerOn) {
         this.device = device;
         this.connection = connection;
         this.clipboardAutosync = clipboardAutosync;
+        this.powerOn = powerOn;
         initPointers();
         sender = new DeviceMessageSender(connection);
     }
@@ -56,7 +58,7 @@ public class Controller {
 
     public void control() throws IOException {
         // on start, power on the device
-        if (!Device.isScreenOn()) {
+        if (powerOn && !Device.isScreenOn()) {
             device.pressReleaseKeycode(KeyEvent.KEYCODE_POWER, Device.INJECT_MODE_ASYNC);
 
             // dirty hack
@@ -221,7 +223,7 @@ public class Controller {
         return device.injectEvent(event, Device.INJECT_MODE_ASYNC);
     }
 
-    private boolean injectScroll(Position position, int hScroll, int vScroll, int buttons) {
+    private boolean injectScroll(Position position, float hScroll, float vScroll, int buttons) {
         long now = SystemClock.uptimeMillis();
         Point point = device.getPhysicalPoint(position);
         if (point == null) {

server/src/main/java/com/genymobile/scrcpy/Device.java

@@ -7,6 +7,7 @@ import com.genymobile.scrcpy.wrappers.SurfaceControl;
 import com.genymobile.scrcpy.wrappers.WindowManager;
 
 import android.content.IOnPrimaryClipChangedListener;
+import android.content.pm.ApplicationInfo;
 import android.graphics.Rect;
 import android.os.Build;
 import android.os.IBinder;
@@ -21,6 +22,8 @@ import java.util.concurrent.atomic.AtomicBoolean;
 
 public final class Device {
 
+    private static final String SCRCPY_PACKAGE_NAME = "com.genymobile.scrcpy";
+
     public static final int POWER_MODE_OFF = SurfaceControl.POWER_MODE_OFF;
     public static final int POWER_MODE_NORMAL = SurfaceControl.POWER_MODE_NORMAL;
 
@@ -319,4 +322,12 @@ public final class Device {
     public static Settings getSettings() {
         return SETTINGS;
     }
+
+    public static String getApkPath() {
+        ApplicationInfo info = SERVICE_MANAGER.getPackageManager().getApplicationInfo(SCRCPY_PACKAGE_NAME);
+        if (info == null) {
+            return null;
+        }
+        return info.sourceDir;
+    }
 }

server/src/main/java/com/genymobile/scrcpy/IO.java

@@ -6,7 +6,9 @@ import android.system.OsConstants;
 
 import java.io.FileDescriptor;
 import java.io.IOException;
+import java.io.InputStream;
 import java.nio.ByteBuffer;
+import java.util.Scanner;
 
 public final class IO {
     private IO() {
@@ -37,4 +39,13 @@ public final class IO {
     public static void writeFully(FileDescriptor fd, byte[] buffer, int offset, int len) throws IOException {
         writeFully(fd, ByteBuffer.wrap(buffer, offset, len));
     }
+
+    public static String toString(InputStream inputStream) {
+        StringBuilder builder = new StringBuilder();
+        Scanner scanner = new Scanner(inputStream);
+        while (scanner.hasNextLine()) {
+            builder.append(scanner.nextLine()).append('\n');
+        }
+        return builder.toString();
+    }
 }

server/src/main/java/com/genymobile/scrcpy/Options.java

@@ -22,6 +22,8 @@ public class Options {
     private boolean clipboardAutosync = true;
     private boolean downsizeOnError = true;
     private boolean cleanup = true;
+    private boolean powerOn = true;
+    private boolean installed = false;
 
     // Options not used by the scrcpy client, but useful to use scrcpy-server directly
     private boolean sendDeviceMeta = true; // send device name and size
@@ -164,6 +166,14 @@ public class Options {
         this.cleanup = cleanup;
     }
 
+    public boolean getPowerOn() {
+        return powerOn;
+    }
+
+    public void setPowerOn(boolean powerOn) {
+        this.powerOn = powerOn;
+    }
+
     public boolean getSendDeviceMeta() {
         return sendDeviceMeta;
     }
@@ -187,4 +197,12 @@ public class Options {
     public void setSendDummyByte(boolean sendDummyByte) {
         this.sendDummyByte = sendDummyByte;
     }
+
+    public boolean getInstalled() {
+        return installed;
+    }
+
+    public void setInstalled(boolean installed) {
+        this.installed = installed;
+    }
 }

server/src/main/java/com/genymobile/scrcpy/Server.java

@@ -52,8 +52,8 @@ public final class Server {
 
         if (options.getCleanup()) {
             try {
-                CleanUp.configure(options.getDisplayId(), restoreStayOn, mustDisableShowTouchesOnCleanUp, restoreNormalPowerMode,
-                        options.getPowerOffScreenOnClose());
+                CleanUp.configure(options.getInstalled(), options.getDisplayId(), restoreStayOn, mustDisableShowTouchesOnCleanUp,
+                        restoreNormalPowerMode, options.getPowerOffScreenOnClose());
             } catch (IOException e) {
                 Ln.e("Could not configure cleanup", e);
             }
@@ -82,7 +82,7 @@ public final class Server {
             Thread controllerThread = null;
             Thread deviceMessageSenderThread = null;
             if (control) {
-                final Controller controller = new Controller(device, connection, options.getClipboardAutosync());
+                final Controller controller = new Controller(device, connection, options.getClipboardAutosync(), options.getPowerOn());
 
                 // asynchronous
                 controllerThread = startController(controller);
@@ -248,6 +248,14 @@ public final class Server {
                     boolean cleanup = Boolean.parseBoolean(value);
                     options.setCleanup(cleanup);
                     break;
+                case "power_on":
+                    boolean powerOn = Boolean.parseBoolean(value);
+                    options.setPowerOn(powerOn);
+                    break;
+                case "installed":
+                    boolean installed = Boolean.parseBoolean(value);
+                    options.setInstalled(installed);
+                    break;
                 case "send_device_meta":
                     boolean sendDeviceMeta = Boolean.parseBoolean(value);
                     options.setSendDeviceMeta(sendDeviceMeta);

server/src/main/java/com/genymobile/scrcpy/wrappers/DisplayManager.java

@@ -1,22 +1,78 @@
 package com.genymobile.scrcpy.wrappers;
 
+import com.genymobile.scrcpy.Command;
 import com.genymobile.scrcpy.DisplayInfo;
+import com.genymobile.scrcpy.Ln;
 import com.genymobile.scrcpy.Size;
 
-import android.os.IInterface;
+import android.view.Display;
+
+import java.lang.reflect.Field;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 public final class DisplayManager {
-    private final IInterface manager;
+    private final Object manager; // instance of hidden class android.hardware.display.DisplayManagerGlobal
 
-    public DisplayManager(IInterface manager) {
+    public DisplayManager(Object manager) {
         this.manager = manager;
     }
 
+    // public to call it from unit tests
+    public static DisplayInfo parseDisplayInfo(String dumpsysDisplayOutput, int displayId) {
+        Pattern regex = Pattern.compile(
+                "^    mOverrideDisplayInfo=DisplayInfo\\{\".*?\", displayId " + displayId + ".*?(, FLAG_.*)?, real ([0-9]+) x ([0-9]+).*?, "
+                        + "rotation ([0-9]+).*?, layerStack ([0-9]+)",
+                Pattern.MULTILINE);
+        Matcher m = regex.matcher(dumpsysDisplayOutput);
+        if (!m.find()) {
+            return null;
+        }
+        int flags = parseDisplayFlags(m.group(1));
+        int width = Integer.parseInt(m.group(2));
+        int height = Integer.parseInt(m.group(3));
+        int rotation = Integer.parseInt(m.group(4));
+        int layerStack = Integer.parseInt(m.group(5));
+
+        return new DisplayInfo(displayId, new Size(width, height), rotation, layerStack, flags);
+    }
+
+    private static DisplayInfo getDisplayInfoFromDumpsysDisplay(int displayId) {
+        try {
+            String dumpsysDisplayOutput = Command.execReadOutput("dumpsys", "display");
+            return parseDisplayInfo(dumpsysDisplayOutput, displayId);
+        } catch (Exception e) {
+            Ln.e("Could not get display info from \"dumpsys display\" output", e);
+            return null;
+        }
+    }
+
+    private static int parseDisplayFlags(String text) {
+        Pattern regex = Pattern.compile("FLAG_[A-Z_]+");
+        if (text == null) {
+            return 0;
+        }
+
+        int flags = 0;
+        Matcher m = regex.matcher(text);
+        while (m.find()) {
+            String flagString = m.group();
+            try {
+                Field filed = Display.class.getDeclaredField(flagString);
+                flags |= filed.getInt(null);
+            } catch (NoSuchFieldException | IllegalAccessException e) {
+                // Silently ignore, some flags reported by "dumpsys display" are @TestApi
+            }
+        }
+        return flags;
+    }
+
     public DisplayInfo getDisplayInfo(int displayId) {
         try {
             Object displayInfo = manager.getClass().getMethod("getDisplayInfo", int.class).invoke(manager, displayId);
             if (displayInfo == null) {
-                return null;
+                // fallback when displayInfo is null
+                return getDisplayInfoFromDumpsysDisplay(displayId);
             }
             Class<?> cls = displayInfo.getClass();
             // width and height already take the rotation into account

server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java

@@ -2,7 +2,6 @@ package com.genymobile.scrcpy.wrappers;
 
 import com.genymobile.scrcpy.Ln;
 
-import android.os.IInterface;
 import android.view.InputEvent;
 
 import java.lang.reflect.InvocationTargetException;
@@ -14,24 +13,18 @@ public final class InputManager {
     public static final int INJECT_INPUT_EVENT_MODE_WAIT_FOR_RESULT = 1;
     public static final int INJECT_INPUT_EVENT_MODE_WAIT_FOR_FINISH = 2;
 
-    private final IInterface manager;
+    private final android.hardware.input.InputManager manager;
     private Method injectInputEventMethod;
-    private boolean alternativeInjectInputEventMethod;
 
     private static Method setDisplayIdMethod;
 
-    public InputManager(IInterface manager) {
+    public InputManager(android.hardware.input.InputManager manager) {
         this.manager = manager;
     }
 
     private Method getInjectInputEventMethod() throws NoSuchMethodException {
         if (injectInputEventMethod == null) {
-            try {
-                injectInputEventMethod = manager.getClass().getMethod("injectInputEvent", InputEvent.class, int.class);
-            } catch (NoSuchMethodException e) {
-                injectInputEventMethod = manager.getClass().getMethod("injectInputEvent", InputEvent.class, int.class, int.class);
-                alternativeInjectInputEventMethod = true;
-            }
+            injectInputEventMethod = manager.getClass().getMethod("injectInputEvent", InputEvent.class, int.class);
         }
         return injectInputEventMethod;
     }
@@ -39,10 +32,6 @@ public final class InputManager {
     public boolean injectInputEvent(InputEvent inputEvent, int mode) {
         try {
             Method method = getInjectInputEventMethod();
-            if (alternativeInjectInputEventMethod) {
-                // See <https://github.com/Genymobile/scrcpy/issues/2250>
-                return (boolean) method.invoke(manager, inputEvent, mode, 0);
-            }
             return (boolean) method.invoke(manager, inputEvent, mode);
         } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
             Ln.e("Could not invoke method", e);

server/src/main/java/com/genymobile/scrcpy/wrappers/PackageManager.java

@@ -0,0 +1,36 @@
+package com.genymobile.scrcpy.wrappers;
+
+import com.genymobile.scrcpy.Ln;
+
+import android.content.pm.ApplicationInfo;
+import android.os.IInterface;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class PackageManager {
+
+    private IInterface manager;
+    private Method getApplicationInfoMethod;
+
+    public PackageManager(IInterface manager) {
+        this.manager = manager;
+    }
+
+    private Method getGetApplicationInfoMethod() throws NoSuchMethodException {
+        if (getApplicationInfoMethod == null) {
+            getApplicationInfoMethod = manager.getClass().getDeclaredMethod("getApplicationInfo", String.class, int.class, int.class);
+        }
+        return getApplicationInfoMethod;
+    }
+
+    public ApplicationInfo getApplicationInfo(String packageName) {
+        try {
+            Method method = getGetApplicationInfoMethod();
+            return (ApplicationInfo) method.invoke(manager, packageName, 0, ServiceManager.USER_ID);
+        } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
+            Ln.e("Cannot get application info", e);
+            return null;
+        }
+    }
+}

server/src/main/java/com/genymobile/scrcpy/wrappers/ServiceManager.java

@@ -4,6 +4,7 @@ import android.annotation.SuppressLint;
 import android.os.IBinder;
 import android.os.IInterface;
 
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
 @SuppressLint("PrivateApi,DiscouragedPrivateApi")
@@ -21,6 +22,7 @@ public final class ServiceManager {
     private StatusBarManager statusBarManager;
     private ClipboardManager clipboardManager;
     private ActivityManager activityManager;
+    private PackageManager packageManager;
 
     public ServiceManager() {
         try {
@@ -49,14 +51,27 @@ public final class ServiceManager {
 
     public DisplayManager getDisplayManager() {
         if (displayManager == null) {
-            displayManager = new DisplayManager(getService("display", "android.hardware.display.IDisplayManager"));
+            try {
+                Class<?> clazz = Class.forName("android.hardware.display.DisplayManagerGlobal");
+                Method getInstanceMethod = clazz.getDeclaredMethod("getInstance");
+                Object dmg = getInstanceMethod.invoke(null);
+                displayManager = new DisplayManager(dmg);
+            } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+                throw new AssertionError(e);
+            }
         }
         return displayManager;
     }
 
     public InputManager getInputManager() {
         if (inputManager == null) {
-            inputManager = new InputManager(getService("input", "android.hardware.input.IInputManager"));
+            try {
+                Method getInstanceMethod = android.hardware.input.InputManager.class.getDeclaredMethod("getInstance");
+                android.hardware.input.InputManager im = (android.hardware.input.InputManager) getInstanceMethod.invoke(null);
+                inputManager = new InputManager(im);
+            } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+                throw new AssertionError(e);
+            }
         }
         return inputManager;
     }
@@ -105,4 +120,20 @@ public final class ServiceManager {
 
         return activityManager;
     }
+
+    public PackageManager getPackageManager() {
+        if (packageManager == null) {
+            try {
+                //IInterface manager = getService("package", "android.content.pm.IPackageManager");
+                Class<?> activityThreadClass = Class.forName("android.app.ActivityThread");
+                Method getPackageManager = activityThreadClass.getDeclaredMethod("getPackageManager");
+                IInterface manager = (IInterface) getPackageManager.invoke(null);
+                return new PackageManager(manager);
+            } catch (Exception e) {
+                throw new AssertionError(e);
+            }
+        }
+
+        return packageManager;
+    }
 }

server/src/test/java/com/genymobile/scrcpy/BinaryTest.java

@@ -0,0 +1,42 @@
+package com.genymobile.scrcpy;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class BinaryTest {
+
+    @Test
+    public void testU16FixedPointToFloat() {
+        final float delta = 0.0f; // on these values, there MUST be no rounding error
+        Assert.assertEquals(0.0f, Binary.u16FixedPointToFloat((short) 0), delta);
+        Assert.assertEquals(0.03125f, Binary.u16FixedPointToFloat((short) 0x800), delta);
+        Assert.assertEquals(0.0625f, Binary.u16FixedPointToFloat((short) 0x1000), delta);
+        Assert.assertEquals(0.125f, Binary.u16FixedPointToFloat((short) 0x2000), delta);
+        Assert.assertEquals(0.25f, Binary.u16FixedPointToFloat((short) 0x4000), delta);
+        Assert.assertEquals(0.5f, Binary.u16FixedPointToFloat((short) 0x8000), delta);
+        Assert.assertEquals(0.75f, Binary.u16FixedPointToFloat((short) 0xc000), delta);
+        Assert.assertEquals(1.0f, Binary.u16FixedPointToFloat((short) 0xffff), delta);
+    }
+
+    @Test
+    public void testI16FixedPointToFloat() {
+        final float delta = 0.0f; // on these values, there MUST be no rounding error
+
+        Assert.assertEquals(0.0f, Binary.i16FixedPointToFloat((short) 0), delta);
+        Assert.assertEquals(0.03125f, Binary.i16FixedPointToFloat((short) 0x400), delta);
+        Assert.assertEquals(0.0625f, Binary.i16FixedPointToFloat((short) 0x800), delta);
+        Assert.assertEquals(0.125f, Binary.i16FixedPointToFloat((short) 0x1000), delta);
+        Assert.assertEquals(0.25f, Binary.i16FixedPointToFloat((short) 0x2000), delta);
+        Assert.assertEquals(0.5f, Binary.i16FixedPointToFloat((short) 0x4000), delta);
+        Assert.assertEquals(0.75f, Binary.i16FixedPointToFloat((short) 0x6000), delta);
+        Assert.assertEquals(1.0f, Binary.i16FixedPointToFloat((short) 0x7fff), delta);
+
+        Assert.assertEquals(-0.03125f, Binary.i16FixedPointToFloat((short) -0x400), delta);
+        Assert.assertEquals(-0.0625f, Binary.i16FixedPointToFloat((short) -0x800), delta);
+        Assert.assertEquals(-0.125f, Binary.i16FixedPointToFloat((short) -0x1000), delta);
+        Assert.assertEquals(-0.25f, Binary.i16FixedPointToFloat((short) -0x2000), delta);
+        Assert.assertEquals(-0.5f, Binary.i16FixedPointToFloat((short) -0x4000), delta);
+        Assert.assertEquals(-0.75f, Binary.i16FixedPointToFloat((short) -0x6000), delta);
+        Assert.assertEquals(-1.0f, Binary.i16FixedPointToFloat((short) -0x8000), delta);
+    }
+}

server/src/test/java/com/genymobile/scrcpy/CommandParserTest.java

@@ -0,0 +1,186 @@
+package com.genymobile.scrcpy;
+
+import com.genymobile.scrcpy.wrappers.DisplayManager;
+
+import android.view.Display;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CommandParserTest {
+    @Test
+    public void testParseDisplayInfoFromDumpsysDisplay() {
+        /* @formatter:off */
+        String partialOutput = "Logical Displays: size=1\n"
+                + "  Display 0:\n"
+                + "mDisplayId=0\n"
+                + "    mLayerStack=0\n"
+                + "    mHasContent=true\n"
+                + "    mDesiredDisplayModeSpecs={baseModeId=2 primaryRefreshRateRange=[90 90] appRequestRefreshRateRange=[90 90]}\n"
+                + "    mRequestedColorMode=0\n"
+                + "    mDisplayOffset=(0, 0)\n"
+                + "    mDisplayScalingDisabled=false\n"
+                + "    mPrimaryDisplayDevice=Built-in Screen\n"
+                + "    mBaseDisplayInfo=DisplayInfo{\"Built-in Screen\", displayId 0, FLAG_SECURE, FLAG_SUPPORTS_PROTECTED_BUFFERS, FLAG_TRUSTED, "
+                + "real 1440 x 3120, largest app 1440 x 3120, smallest app 1440 x 3120, appVsyncOff 2000000, presDeadline 11111111, mode 2, "
+                + "defaultMode 1, modes [{id=1, width=1440, height=3120, fps=60.0}, {id=2, width=1440, height=3120, fps=90.0}, {id=3, width=1080, "
+                + "height=2340, fps=90.0}, {id=4, width=1080, height=2340, fps=60.0}], hdrCapabilities HdrCapabilities{mSupportedHdrTypes=[2, 3, 4], "
+                + "mMaxLuminance=540.0, mMaxAverageLuminance=270.1, mMinLuminance=0.2}, minimalPostProcessingSupported false, rotation 0, state OFF, "
+                + "type INTERNAL, uniqueId \"local:0\", app 1440 x 3120, density 600 (515.154 x 514.597) dpi, layerStack 0, colorMode 0, "
+                + "supportedColorModes [0, 7, 9], address {port=129, model=0}, deviceProductInfo DeviceProductInfo{name=, manufacturerPnpId=QCM, "
+                + "productId=1, modelYear=null, manufactureDate=ManufactureDate{week=27, year=2006}, relativeAddress=null}, removeMode 0}\n"
+                + "    mOverrideDisplayInfo=DisplayInfo{\"Built-in Screen\", displayId 0, FLAG_SECURE, FLAG_SUPPORTS_PROTECTED_BUFFERS, "
+                + "FLAG_TRUSTED, real 1440 x 3120, largest app 3120 x 2983, smallest app 1440 x 1303, appVsyncOff 2000000, presDeadline 11111111, "
+                + "mode 2, defaultMode 1, modes [{id=1, width=1440, height=3120, fps=60.0}, {id=2, width=1440, height=3120, fps=90.0}, {id=3, "
+                + "width=1080, height=2340, fps=90.0}, {id=4, width=1080, height=2340, fps=60.0}], hdrCapabilities "
+                + "HdrCapabilities{mSupportedHdrTypes=[2, 3, 4], mMaxLuminance=540.0, mMaxAverageLuminance=270.1, mMinLuminance=0.2}, "
+                + "minimalPostProcessingSupported false, rotation 0, state ON, type INTERNAL, uniqueId \"local:0\", app 1440 x 3120, density 600 "
+                + "(515.154 x 514.597) dpi, layerStack 0, colorMode 0, supportedColorModes [0, 7, 9], address {port=129, model=0}, deviceProductInfo "
+                + "DeviceProductInfo{name=, manufacturerPnpId=QCM, productId=1, modelYear=null, manufactureDate=ManufactureDate{week=27, year=2006}, "
+                + "relativeAddress=null}, removeMode 0}\n"
+                + "    mRequestedMinimalPostProcessing=false\n";
+        DisplayInfo displayInfo = DisplayManager.parseDisplayInfo(partialOutput, 0);
+        Assert.assertNotNull(displayInfo);
+        Assert.assertEquals(0, displayInfo.getDisplayId());
+        Assert.assertEquals(0, displayInfo.getRotation());
+        Assert.assertEquals(0, displayInfo.getLayerStack());
+        // FLAG_TRUSTED does not exist in Display (@TestApi), so it won't be reported
+        Assert.assertEquals(Display.FLAG_SECURE | Display.FLAG_SUPPORTS_PROTECTED_BUFFERS, displayInfo.getFlags());
+        Assert.assertEquals(1440, displayInfo.getSize().getWidth());
+        Assert.assertEquals(3120, displayInfo.getSize().getHeight());
+    }
+
+    @Test
+    public void testParseDisplayInfoFromDumpsysDisplayWithRotation() {
+        /* @formatter:off */
+        String partialOutput = "Logical Displays: size=1\n"
+                + "  Display 0:\n"
+                + "mDisplayId=0\n"
+                + "    mLayerStack=0\n"
+                + "    mHasContent=true\n"
+                + "    mDesiredDisplayModeSpecs={baseModeId=2 primaryRefreshRateRange=[90 90] appRequestRefreshRateRange=[90 90]}\n"
+                + "    mRequestedColorMode=0\n"
+                + "    mDisplayOffset=(0, 0)\n"
+                + "    mDisplayScalingDisabled=false\n"
+                + "    mPrimaryDisplayDevice=Built-in Screen\n"
+                + "    mBaseDisplayInfo=DisplayInfo{\"Built-in Screen\", displayId 0, FLAG_SECURE, FLAG_SUPPORTS_PROTECTED_BUFFERS, FLAG_TRUSTED, "
+                + "real 1440 x 3120, largest app 1440 x 3120, smallest app 1440 x 3120, appVsyncOff 2000000, presDeadline 11111111, mode 2, "
+                + "defaultMode 1, modes [{id=1, width=1440, height=3120, fps=60.0}, {id=2, width=1440, height=3120, fps=90.0}, {id=3, width=1080, "
+                + "height=2340, fps=90.0}, {id=4, width=1080, height=2340, fps=60.0}], hdrCapabilities HdrCapabilities{mSupportedHdrTypes=[2, 3, 4], "
+                + "mMaxLuminance=540.0, mMaxAverageLuminance=270.1, mMinLuminance=0.2}, minimalPostProcessingSupported false, rotation 0, state ON, "
+                + "type INTERNAL, uniqueId \"local:0\", app 1440 x 3120, density 600 (515.154 x 514.597) dpi, layerStack 0, colorMode 0, "
+                + "supportedColorModes [0, 7, 9], address {port=129, model=0}, deviceProductInfo DeviceProductInfo{name=, manufacturerPnpId=QCM, "
+                + "productId=1, modelYear=null, manufactureDate=ManufactureDate{week=27, year=2006}, relativeAddress=null}, removeMode 0}\n"
+                + "    mOverrideDisplayInfo=DisplayInfo{\"Built-in Screen\", displayId 0, FLAG_SECURE, FLAG_SUPPORTS_PROTECTED_BUFFERS, "
+                + "FLAG_TRUSTED, real 3120 x 1440, largest app 3120 x 2983, smallest app 1440 x 1303, appVsyncOff 2000000, presDeadline 11111111, "
+                + "mode 2, defaultMode 1, modes [{id=1, width=1440, height=3120, fps=60.0}, {id=2, width=1440, height=3120, fps=90.0}, {id=3, "
+                + "width=1080, height=2340, fps=90.0}, {id=4, width=1080, height=2340, fps=60.0}], hdrCapabilities "
+                + "HdrCapabilities{mSupportedHdrTypes=[2, 3, 4], mMaxLuminance=540.0, mMaxAverageLuminance=270.1, mMinLuminance=0.2}, "
+                + "minimalPostProcessingSupported false, rotation 3, state ON, type INTERNAL, uniqueId \"local:0\", app 3120 x 1440, density 600 "
+                + "(515.154 x 514.597) dpi, layerStack 0, colorMode 0, supportedColorModes [0, 7, 9], address {port=129, model=0}, deviceProductInfo "
+                + "DeviceProductInfo{name=, manufacturerPnpId=QCM, productId=1, modelYear=null, manufactureDate=ManufactureDate{week=27, year=2006}, "
+                + "relativeAddress=null}, removeMode 0}\n"
+                + "    mRequestedMinimalPostProcessing=false";
+        DisplayInfo displayInfo = DisplayManager.parseDisplayInfo(partialOutput, 0);
+        Assert.assertNotNull(displayInfo);
+        Assert.assertEquals(0, displayInfo.getDisplayId());
+        Assert.assertEquals(3, displayInfo.getRotation());
+        Assert.assertEquals(0, displayInfo.getLayerStack());
+        // FLAG_TRUSTED does not exist in Display (@TestApi), so it won't be reported
+        Assert.assertEquals(Display.FLAG_SECURE | Display.FLAG_SUPPORTS_PROTECTED_BUFFERS, displayInfo.getFlags());
+        Assert.assertEquals(3120, displayInfo.getSize().getWidth());
+        Assert.assertEquals(1440, displayInfo.getSize().getHeight());
+    }
+
+    @Test
+    public void testParseDisplayInfoFromDumpsysDisplayAPI31() {
+        /* @formatter:off */
+        String partialOutput = "Logical Displays: size=1\n"
+                + "  Display 0:\n"
+                + "    mDisplayId=0\n"
+                + "    mPhase=1\n"
+                + "    mLayerStack=0\n"
+                + "    mHasContent=true\n"
+                + "    mDesiredDisplayModeSpecs={baseModeId=1 allowGroupSwitching=false primaryRefreshRateRange=[0 60] appRequestRefreshRateRange=[0 "
+                + "Infinity]}\n"
+                + "    mRequestedColorMode=0\n"
+                + "    mDisplayOffset=(0, 0)\n"
+                + "    mDisplayScalingDisabled=false\n"
+                + "    mPrimaryDisplayDevice=Built-in Screen\n"
+                + "    mBaseDisplayInfo=DisplayInfo{\"Built-in Screen\", displayId 0\", displayGroupId 0, FLAG_SECURE, "
+                + "FLAG_SUPPORTS_PROTECTED_BUFFERS, FLAG_TRUSTED, real 1080 x 2280, largest app 1080 x 2280, smallest app 1080 x 2280, appVsyncOff "
+                + "1000000, presDeadline 16666666, mode 1, defaultMode 1, modes [{id=1, width=1080, height=2280, fps=60.000004, "
+                + "alternativeRefreshRates=[]}], hdrCapabilities HdrCapabilities{mSupportedHdrTypes=[], mMaxLuminance=500.0, "
+                + "mMaxAverageLuminance=500.0, mMinLuminance=0.0}, userDisabledHdrTypes [], minimalPostProcessingSupported false, rotation 0, state "
+                + "ON, type INTERNAL, uniqueId \"local:0\", app 1080 x 2280, density 440 (440.0 x 440.0) dpi, layerStack 0, colorMode 0, "
+                + "supportedColorModes [0], address {port=0, model=0}, deviceProductInfo DeviceProductInfo{name=EMU_display_0, "
+                + "manufacturerPnpId=GGL, productId=1, modelYear=null, manufactureDate=ManufactureDate{week=27, year=2006}, connectionToSinkType=0}, "
+                + "removeMode 0, refreshRateOverride 0.0, brightnessMinimum 0.0, brightnessMaximum 1.0, brightnessDefault 0.39763778}\n"
+                + "    mOverrideDisplayInfo=DisplayInfo{\"Built-in Screen\", displayId 0\", displayGroupId 0, FLAG_SECURE, "
+                + "FLAG_SUPPORTS_PROTECTED_BUFFERS, FLAG_TRUSTED, real 1080 x 2280, largest app 2148 x 2065, smallest app 1080 x 997, appVsyncOff "
+                + "1000000, presDeadline 16666666, mode 1, defaultMode 1, modes [{id=1, width=1080, height=2280, fps=60.000004, "
+                + "alternativeRefreshRates=[]}], hdrCapabilities HdrCapabilities{mSupportedHdrTypes=[], mMaxLuminance=500.0, "
+                + "mMaxAverageLuminance=500.0, mMinLuminance=0.0}, userDisabledHdrTypes [], minimalPostProcessingSupported false, rotation 0, state "
+                + "ON, type INTERNAL, uniqueId \"local:0\", app 1080 x 2148, density 440 (440.0 x 440.0) dpi, layerStack 0, colorMode 0, "
+                + "supportedColorModes [0], address {port=0, model=0}, deviceProductInfo DeviceProductInfo{name=EMU_display_0, "
+                + "manufacturerPnpId=GGL, productId=1, modelYear=null, manufactureDate=ManufactureDate{week=27, year=2006}, connectionToSinkType=0}, "
+                + "removeMode 0, refreshRateOverride 0.0, brightnessMinimum 0.0, brightnessMaximum 1.0, brightnessDefault 0.39763778}\n"
+                + "    mRequestedMinimalPostProcessing=false\n"
+                + "    mFrameRateOverrides=[]\n"
+                + "    mPendingFrameRateOverrideUids={}\n";
+        DisplayInfo displayInfo = DisplayManager.parseDisplayInfo(partialOutput, 0);
+        Assert.assertNotNull(displayInfo);
+        Assert.assertEquals(0, displayInfo.getDisplayId());
+        Assert.assertEquals(0, displayInfo.getRotation());
+        Assert.assertEquals(0, displayInfo.getLayerStack());
+        // FLAG_TRUSTED does not exist in Display (@TestApi), so it won't be reported
+        Assert.assertEquals(Display.FLAG_SECURE | Display.FLAG_SUPPORTS_PROTECTED_BUFFERS, displayInfo.getFlags());
+        Assert.assertEquals(1080, displayInfo.getSize().getWidth());
+        Assert.assertEquals(2280, displayInfo.getSize().getHeight());
+    }
+
+    @Test
+    public void testParseDisplayInfoFromDumpsysDisplayAPI31NoFlags() {
+        /* @formatter:off */
+        String partialOutput = "Logical Displays: size=1\n"
+                + "  Display 0:\n"
+                + "    mDisplayId=0\n"
+                + "    mPhase=1\n"
+                + "    mLayerStack=0\n"
+                + "    mHasContent=true\n"
+                + "    mDesiredDisplayModeSpecs={baseModeId=1 allowGroupSwitching=false primaryRefreshRateRange=[0 60] appRequestRefreshRateRange=[0 "
+                + "Infinity]}\n"
+                + "    mRequestedColorMode=0\n"
+                + "    mDisplayOffset=(0, 0)\n"
+                + "    mDisplayScalingDisabled=false\n"
+                + "    mPrimaryDisplayDevice=Built-in Screen\n"
+                + "    mBaseDisplayInfo=DisplayInfo{\"Built-in Screen\", displayId 0\", displayGroupId 0, "
+                + "real 1080 x 2280, largest app 1080 x 2280, smallest app 1080 x 2280, appVsyncOff "
+                + "1000000, presDeadline 16666666, mode 1, defaultMode 1, modes [{id=1, width=1080, height=2280, fps=60.000004, "
+                + "alternativeRefreshRates=[]}], hdrCapabilities HdrCapabilities{mSupportedHdrTypes=[], mMaxLuminance=500.0, "
+                + "mMaxAverageLuminance=500.0, mMinLuminance=0.0}, userDisabledHdrTypes [], minimalPostProcessingSupported false, rotation 0, state "
+                + "ON, type INTERNAL, uniqueId \"local:0\", app 1080 x 2280, density 440 (440.0 x 440.0) dpi, layerStack 0, colorMode 0, "
+                + "supportedColorModes [0], address {port=0, model=0}, deviceProductInfo DeviceProductInfo{name=EMU_display_0, "
+                + "manufacturerPnpId=GGL, productId=1, modelYear=null, manufactureDate=ManufactureDate{week=27, year=2006}, connectionToSinkType=0}, "
+                + "removeMode 0, refreshRateOverride 0.0, brightnessMinimum 0.0, brightnessMaximum 1.0, brightnessDefault 0.39763778}\n"
+                + "    mOverrideDisplayInfo=DisplayInfo{\"Built-in Screen\", displayId 0\", displayGroupId 0, "
+                + "real 1080 x 2280, largest app 2148 x 2065, smallest app 1080 x 997, appVsyncOff "
+                + "1000000, presDeadline 16666666, mode 1, defaultMode 1, modes [{id=1, width=1080, height=2280, fps=60.000004, "
+                + "alternativeRefreshRates=[]}], hdrCapabilities HdrCapabilities{mSupportedHdrTypes=[], mMaxLuminance=500.0, "
+                + "mMaxAverageLuminance=500.0, mMinLuminance=0.0}, userDisabledHdrTypes [], minimalPostProcessingSupported false, rotation 0, state "
+                + "ON, type INTERNAL, uniqueId \"local:0\", app 1080 x 2148, density 440 (440.0 x 440.0) dpi, layerStack 0, colorMode 0, "
+                + "supportedColorModes [0], address {port=0, model=0}, deviceProductInfo DeviceProductInfo{name=EMU_display_0, "
+                + "manufacturerPnpId=GGL, productId=1, modelYear=null, manufactureDate=ManufactureDate{week=27, year=2006}, connectionToSinkType=0}, "
+                + "removeMode 0, refreshRateOverride 0.0, brightnessMinimum 0.0, brightnessMaximum 1.0, brightnessDefault 0.39763778}\n"
+                + "    mRequestedMinimalPostProcessing=false\n"
+                + "    mFrameRateOverrides=[]\n"
+                + "    mPendingFrameRateOverrideUids={}\n";
+        DisplayInfo displayInfo = DisplayManager.parseDisplayInfo(partialOutput, 0);
+        Assert.assertNotNull(displayInfo);
+        Assert.assertEquals(0, displayInfo.getDisplayId());
+        Assert.assertEquals(0, displayInfo.getRotation());
+        Assert.assertEquals(0, displayInfo.getLayerStack());
+        Assert.assertEquals(0, displayInfo.getFlags());
+        Assert.assertEquals(1080, displayInfo.getSize().getWidth());
+        Assert.assertEquals(2280, displayInfo.getSize().getHeight());
+    }
+}

server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java

@@ -126,8 +126,8 @@ public class ControlMessageReaderTest {
         dos.writeInt(1026);
         dos.writeShort(1080);
         dos.writeShort(1920);
-        dos.writeInt(1);
-        dos.writeInt(-1);
+        dos.writeShort(0); // 0.0f encoded as i16
+        dos.writeShort(0x8000); // -1.0f encoded as i16
         dos.writeInt(1);
 
         byte[] packet = bos.toByteArray();
@@ -143,8 +143,8 @@ public class ControlMessageReaderTest {
         Assert.assertEquals(1026, event.getPosition().getPoint().getY());
         Assert.assertEquals(1080, event.getPosition().getScreenSize().getWidth());
         Assert.assertEquals(1920, event.getPosition().getScreenSize().getHeight());
-        Assert.assertEquals(1, event.getHScroll());
-        Assert.assertEquals(-1, event.getVScroll());
+        Assert.assertEquals(0f, event.getHScroll(), 0f);
+        Assert.assertEquals(-1f, event.getVScroll(), 0f);
         Assert.assertEquals(1, event.getButtons());
     }