Remove obsolete alternative injection method

The previous commit replaced the IInterface instance (the "input" service) by the InputManager instance (retrieved by InputManager.getInstance()). Both define an "injectInputEvent" method, but the alternate version (probably) does not concern the InputManager. This reverts commit b7a06278fe.
Adapt event injection to Android 13
2026-03-01 09:44:27 +01:00 · 2022-04-16 09:28:24 +02:00 · 2022-04-16 09:25:06 +02:00 · 2022-04-12 23:59:01 +02:00 · 2022-04-12 23:51:05 +02:00 · 2022-03-30 14:00:05 +02:00
33 changed files with 265 additions and 382 deletions
--- a/README.it.md
+++ b/README.it.md
@@ -1,42 +1,23 @@
-_Apri il [README](README.md) originale (in inglese) e sempre aggiornato._
+_Apri il [README](README.md) originale e sempre aggiornato._

-<img src="app/data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />
+# scrcpy (v1.19)

-# 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_.
+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_.
 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~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_)
+ - **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)

 [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

@@ -68,18 +49,12 @@ Compila dai sorgenti: [BUILD] (in inglese) ([procedimento semplificato][BUILD_si

 ### Linux

-Su Debian e Ubuntu:
+Su Debian (_testing_ e _sid_ per ora) e Ubuntu (20.04):

 ```
 apt install scrcpy
 ```

-Su Arch Linux:
-
-```
-pacman -S scrcpy
-```
-
 È disponibile anche un pacchetto [Snap]: [`scrcpy`][snap-link].

 [snap-link]: https://snapstats.org/snaps/scrcpy
@@ -91,6 +66,10 @@ 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].

@@ -163,7 +142,7 @@ Collega un dispositivo Android ed esegui:
 scrcpy
 ```

-Scrcpy accetta argomenti da riga di comando, elencati con:
+Scrcpy accetta argomenti da riga di comando, essi sono listati con:

 ```bash
 scrcpy --help
@@ -207,14 +186,6 @@ 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.
@@ -287,7 +258,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:

@@ -350,72 +321,42 @@ scrcpy --display-buffer=50  # aggiungi 50 ms di buffer per la visualizzazione
 e per il V4L2 sink:

 ```bash
-scrcpy --v4l2-buffer=500    #  aggiungi 500 ms di buffer per il v4l2 sink
+scrcpy --v4l2-buffer=500    #  aggiungi 50 ms di buffer per il v4l2 sink
 ```


 ### Connessione

-#### TCP/IP (wireless)
+#### 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.

-##### Automatico
+_Scrcpy_ usa `adb` per comunicare col dispositivo e `adb` può [connettersi][connect] al dispositivo mediante TCP/IP:

-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:
+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:

    ```bash
    adb shell ip route | awk '{print $9}'
    ```

-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.
+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.

-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:
+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 elencati più dispositivi, è necessario specificare il _seriale_:
+Se in `adb devices` sono listati più dispositivi, è necessario specificare il _seriale_:

 ```bash
 scrcpy --serial 0123456789abcdef
@@ -429,18 +370,6 @@ 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.


@@ -454,77 +383,37 @@ autoadb scrcpy -s '{}'

 [AutoAdb]: https://github.com/rom1v/autoadb

-#### Tunnels
+#### Tunnel SSH

-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:
+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_):

 ```bash
-adb kill-server
-adb -a nodaemon server start
-# tienilo aperto
+adb kill-server    # termina il server adb locale su 5037
+ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
+# tieni questo aperto
 ```

-**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:
+Da un altro terminale:

 ```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
-# local  5038 --> remote  5037
-# local 27183 --> remote 27183
-ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer
+adb kill-server    # termina il server adb locale su 5037
+ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # tieni questo aperto
 ```

-Da un altro terminale, esegui scrcpy:
+Da un altro terminale:

 ```bash
-export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy --force-adb-forward
 ```

+
 Come per le connessioni wireless potrebbe essere utile ridurre la qualità:

 ```
@@ -662,14 +551,6 @@ 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

@@ -715,22 +596,20 @@ 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 come ci si aspetta.
+Questo solitamente funziona nella maniera più comune.

 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> 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)
+ - <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)

-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.
+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.

 **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 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`.
+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>).

 #### Pizzica per zoomare (pinch-to-zoom)

@@ -738,98 +617,16 @@ 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.
-
-#### 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
+Concretamente scrcpy genera degli eventi di tocco addizionali di un "dito virtuale" nella posizione simmetricamente opposta rispetto al centro dello schermo.


-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
+#### Preferenze di iniezione 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 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).
+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).

 Questo, però, può [causare problemi][prefertext]. Se incontri un problema del genere, puoi evitarlo con:

@@ -839,21 +636,13 @@ 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:

@@ -861,12 +650,9 @@ 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) o POWER on (accensione) 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) e il click centrale aziona HOME. Per disabilitare queste scorciatoie e, invece, inviare i click al dispositivo:

 ```bash
 scrcpy --forward-all-clicks
@@ -919,7 +705,7 @@ scrcpy --shortcut-mod=rctrl
 scrcpy --shortcut-mod=lctrl+lalt,lsuper
 ```

-_<kbd>[Super]</kbd> è solitamente il pulsante <kbd>Windows</kbd> o <kbd>Cmd</kbd>._
+_<kbd>[Super]</kbd> è 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 -->
@@ -934,7 +720,7 @@ _<kbd>[Super]</kbd> è solitamente il pulsante <kbd>Windows</kbd> o <kbd>Cmd</kb
 | 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>
@@ -945,20 +731,17 @@ _<kbd>[Super]</kbd> è solitamente il pulsante <kbd>Windows</kbd> o <kbd>Cmd</kb
 | 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>
- | Invia 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>
+ | Inietta 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._  
-_⁴Per le app native react in sviluppo, `MENU` attiva il menu di sviluppo._  
-_⁵Solo in Android >= 7._
+_⁴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":

@@ -1028,14 +811,3 @@ 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)
--- a/README.md
+++ b/README.md
@@ -448,6 +448,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
@@ -1105,7 +1108,7 @@ See [BUILD].

 ## Common issues

-See the [FAQ].
+See the [FAQ].md).

 [FAQ]: FAQ.md

--- a/README.zh-Hans.md
+++ b/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)

--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@@ -355,6 +355,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 +477,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.
--- a/app/src/adb/adb.c
+++ b/app/src/adb/adb.c
@@ -473,9 +473,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 +512,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 +536,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;
@@ -705,8 +712,3 @@ sc_adb_get_device_ip(struct sc_intr *intr, const char *serial, unsigned flags) {

    return sc_adb_parse_device_ip_from_output(buf);
 }
-
-bool
-sc_adb_is_serial_tcpip(const char *serial) {
-    return strchr(serial, ':');
-}
--- a/app/src/adb/adb.h
+++ b/app/src/adb/adb.h
@@ -114,13 +114,4 @@ sc_adb_getprop(struct sc_intr *intr, const char *serial, const char *prop,
 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.
- */
-bool
-sc_adb_is_serial_tcpip(const char *serial);
-
 #endif
--- a/app/src/adb/adb_device.c
+++ b/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;
+}
--- a/app/src/adb/adb_device.h
+++ b/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
--- a/app/src/cli.c
+++ b/app/src/cli.c
@@ -80,6 +80,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;
@@ -655,6 +660,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 +672,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 +926,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 +983,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
--- a/app/src/common.h
+++ b/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"
--- a/app/src/compat.h
+++ b/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"

--- a/app/src/control_msg.h
+++ b/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"

--- a/app/src/controller.h
+++ b/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"

--- a/app/src/device_msg.h
+++ b/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"

--- a/app/src/fps_counter.h
+++ b/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"

--- a/app/src/icon.h
+++ b/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"

--- a/app/src/input_manager.h
+++ b/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"

--- a/app/src/main.c
+++ b/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;
 }
--- a/app/src/opengl.c
+++ b/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);
--- a/app/src/receiver.h
+++ b/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"

--- a/app/src/scrcpy.c
+++ b/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;
@@ -329,7 +332,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 +354,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;
    }

--- a/app/src/scrcpy.h
+++ b/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
--- a/app/src/server.c
+++ b/app/src/server.c
@@ -649,7 +649,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 +708,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);
--- a/app/src/usb/hid_keyboard.c
+++ b/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)");
        }
    }
 }
--- a/app/src/usb/hid_mouse.c
+++ b/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)");
    }
 }

--- a/app/src/usb/scrcpy_otg.c
+++ b/app/src/usb/scrcpy_otg.c
@@ -29,26 +29,26 @@ 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;
@@ -67,7 +67,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 +90,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;
--- a/app/src/usb/scrcpy_otg.h
+++ b/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
--- a/app/src/usb/usb.c
+++ b/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;
    }

--- a/app/src/util/cbuf.h
+++ b/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"

--- a/app/src/util/net.h
+++ b/app/src/util/net.h
@@ -1,5 +1,5 @@
-#ifndef NET_H
-#define NET_H
+#ifndef SC_NET_H
+#define SC_NET_H

 #include "common.h"

--- a/2
+++ b/2
@@ -20,6 +20,6 @@ then
    exit 1
 fi

-SCRCPY_ICON_PATH="data/icon.png" \
+SCRCPY_ICON_PATH="app/data/icon.png" \
 SCRCPY_SERVER_PATH="$BUILDDIR/server/scrcpy-server" \
 "$BUILDDIR/app/scrcpy" "$@"
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java
@@ -14,24 +14,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 +33,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);
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/ServiceManager.java
+++ b/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")
@@ -56,7 +57,13 @@ public final class ServiceManager {

    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;
    }
Author	SHA1	Message	Date
Romain Vimont	6cac0c32a2	Remove obsolete alternative injection method The previous commit replaced the IInterface instance (the "input" service) by the InputManager instance (retrieved by InputManager.getInstance()). Both define an "injectInputEvent" method, but the alternate version (probably) does not concern the InputManager. This reverts commit `b7a06278fe`.	2022-04-16 09:28:24 +02:00
Romain Vimont	2d84737f41	Adapt event injection to Android 13 Using the "input" service results in a permission error in Android 13. Use the InputManager instance (retrieved by InputManager.getInstance()) instead. Fixes #3186 <https://github.com/Genymobile/scrcpy/issues/3186>	2022-04-16 09:25:06 +02:00
Romain Vimont	fa5b2a29e9	Add missing SC_ prefix to header guards	2022-04-12 23:59:01 +02:00
Romain Vimont	0c94887075	Add missing include Refs `c3d45c8397`	2022-04-12 23:51:05 +02:00
Romain Vimont	88543cb545	Fix icon path in ./run The data/ directory has been moved to app/data/. Refs `36c75e15b8`	2022-03-30 14:00:05 +02:00
Romain Vimont	aaf3869a54	Fix OpenGL ES prefix skip	2022-03-30 12:01:01 +02:00
Romain Vimont	c3d45c8397	Consider emulators as TCP/IP devices Emulators were wrongly considered as USB devices, so they were selected using -d instead of -e (which was inconsistent with the adb behavior). Refs #3005 <https://github.com/Genymobile/scrcpy/issues/3005> Refs #3137 <https://github.com/Genymobile/scrcpy/issues/3137>	2022-03-22 21:08:08 +01:00
Romain Vimont	e56f2ac7a9	Log an error on unexpected device state Refs #3129 <https://github.com/Genymobile/scrcpy/issues/3129>	2022-03-20 14:56:52 +01:00
Romain Vimont	4ce7af42c6	Use $ANDROID_SERIAL if no selector is specified Like adb, read the ANDROID_SERIAL environment variable to select a device by serial if no explicit selection (-s, -d, -e or --tcpip=<addr>) is provided via the command line. Fixes #3111 <https://github.com/Genymobile/scrcpy/issues/3111> PR #3113 <https://github.com/Genymobile/scrcpy/pull/3113>	2022-03-15 08:32:34 +01:00
Romain Vimont	b1dbc30072	Document exit status in --help Refs #3085 <https://github.com/Genymobile/scrcpy/pull/3085>	2022-03-10 09:13:21 +01:00
martin f. krafft	b3f5dfe1de	Add specific exit code for device disconnection Modify the return logic such that exit code 1 is used when the initial connection fails, but if a session is established, and then the device disconnects, exit code 2 is emitted. Fixes #3083 <https://github.com/Genymobile/scrcpy/issues/3083> PR #3085 <https://github.com/Genymobile/scrcpy/pull/3085> Signed-off-by: martin f. krafft <madduck@madduck.net> Signed-off-by: Romain Vimont <rom@rom1v.com>	2022-03-06 22:19:46 +01:00
Romain Vimont	1f4c801f3c	Report server connection state We must distinguish 3 cases for await_for_server(): - an error occurred - no error occurred, the device is connected - no error occurred, the device is not connected (user requested to quit) For this purpose, use an additional output parameter to indicate if the device is connected (only set when no error occurs). Refs #3085 <https://github.com/Genymobile/scrcpy/pull/3085>	2022-03-06 22:16:13 +01:00
Romain Vimont	8d91cda4f6	Improve HID event push error message On HID event push failure, add the event type in the error message.	2022-02-24 23:28:20 +01:00
Romain Vimont	59656fe649	Fix typo in error message	2022-02-24 23:26:12 +01:00
Romain Vimont	e4bb2b8728	Add libusb error log Log libusb_get_string_descriptor_ascii() errors. Refs #3050 <https://github.com/Genymobile/scrcpy/issues/3050>	2022-02-24 23:25:02 +01:00