Compare commits
7 Commits
pr3151
...
hw_dec_poc
| Author | SHA1 | Date | |
|---|---|---|---|
|
be6c6325d9 | ||
|
|
b1dbc30072 | ||
|
b3f5dfe1de | ||
|
|
1f4c801f3c | ||
|
|
8d91cda4f6 | ||
|
|
59656fe649 | ||
|
|
e4bb2b8728 |
342
README.it.md
342
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_.
|
||||
|
||||
|
||||
|
||||
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)
|
||||
|
||||
@@ -1105,7 +1105,7 @@ See [BUILD].
|
||||
|
||||
## Common issues
|
||||
|
||||
See the [FAQ].
|
||||
See the [FAQ].md).
|
||||
|
||||
[FAQ]: FAQ.md
|
||||
|
||||
|
||||
@@ -704,11 +704,11 @@ scrcpy --disable-screensaver
|
||||
|
||||
#### 双指缩放
|
||||
|
||||
模拟“双指缩放”：<kbd>Ctrl</kbd>+_按下并拖动鼠标_。
|
||||
模拟“双指缩放”：<kbd>Ctrl</kbd>+_按住并移动鼠标_。
|
||||
|
||||
在按住 <kbd>Ctrl</kbd> 时按下鼠标左键，直到松开鼠标左键前，移动鼠标会使屏幕内容相对于屏幕中心进行缩放或旋转 (如果应用支持)。
|
||||
更准确的说，在按住鼠标左键时按住 <kbd>Ctrl</kbd>。直到松开鼠标左键，所有鼠标移动将以屏幕中心为原点，缩放或旋转内容 (如果应用支持)。
|
||||
|
||||
具体来说，_scrcpy_ 会在鼠标位置，以及鼠标以屏幕中心镜像的位置分别生成触摸事件。
|
||||
实际上，_scrcpy_ 会在关于屏幕中心对称的位置上用“虚拟手指”发出触摸事件。
|
||||
|
||||
#### 物理键盘模拟 (HID)
|
||||
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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;
|
||||
@@ -662,7 +667,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 +921,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 +978,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
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
|
||||
#include <libavcodec/avcodec.h>
|
||||
#include <libavformat/avformat.h>
|
||||
#include <libavutil/pixdesc.h>
|
||||
|
||||
#include "events.h"
|
||||
#include "video_buffer.h"
|
||||
@@ -11,6 +12,39 @@
|
||||
/** Downcast packet_sink to decoder */
|
||||
#define DOWNCAST(SINK) container_of(SINK, struct sc_decoder, packet_sink)
|
||||
|
||||
static int hw_decoder_init(struct sc_decoder *decoder, const enum AVHWDeviceType type)
|
||||
{
|
||||
int err = 0;
|
||||
|
||||
AVBufferRef *hw_device_ctx;
|
||||
if ((err = av_hwdevice_ctx_create(&hw_device_ctx, type,
|
||||
NULL, NULL, 0)) < 0) {
|
||||
LOGE("Failed to create specified HW device.");
|
||||
return err;
|
||||
}
|
||||
decoder->codec_ctx->hw_device_ctx = av_buffer_ref(hw_device_ctx);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static enum AVPixelFormat get_hw_format(AVCodecContext *ctx,
|
||||
const enum AVPixelFormat *pix_fmts)
|
||||
{
|
||||
(void) ctx;
|
||||
const enum AVPixelFormat *p;
|
||||
|
||||
LOGD("== get_hw_format ==");
|
||||
|
||||
for (p = pix_fmts; *p != AV_PIX_FMT_NONE; p++) {
|
||||
LOGD("==== %s (%d)", av_get_pix_fmt_name(*p), *p);
|
||||
if (*p == AV_PIX_FMT_VAAPI)
|
||||
return *p;
|
||||
}
|
||||
|
||||
LOGE("Failed to get HW surface format.");
|
||||
return AV_PIX_FMT_NONE;
|
||||
}
|
||||
|
||||
static void
|
||||
sc_decoder_close_first_sinks(struct sc_decoder *decoder, unsigned count) {
|
||||
while (count) {
|
||||
@@ -48,6 +82,10 @@ sc_decoder_open(struct sc_decoder *decoder, const AVCodec *codec) {
|
||||
|
||||
decoder->codec_ctx->flags |= AV_CODEC_FLAG_LOW_DELAY;
|
||||
|
||||
int r = hw_decoder_init(decoder, AV_HWDEVICE_TYPE_VAAPI);
|
||||
assert(!r);
|
||||
decoder->codec_ctx->get_format = get_hw_format;
|
||||
|
||||
if (avcodec_open2(decoder->codec_ctx, codec, NULL) < 0) {
|
||||
LOGE("Could not open codec");
|
||||
avcodec_free_context(&decoder->codec_ctx);
|
||||
@@ -62,6 +100,9 @@ sc_decoder_open(struct sc_decoder *decoder, const AVCodec *codec) {
|
||||
return false;
|
||||
}
|
||||
|
||||
decoder->hw_frame = av_frame_alloc();
|
||||
assert(decoder->hw_frame);
|
||||
|
||||
if (!sc_decoder_open_sinks(decoder)) {
|
||||
LOGE("Could not open decoder sinks");
|
||||
av_frame_free(&decoder->frame);
|
||||
@@ -76,6 +117,7 @@ sc_decoder_open(struct sc_decoder *decoder, const AVCodec *codec) {
|
||||
static void
|
||||
sc_decoder_close(struct sc_decoder *decoder) {
|
||||
sc_decoder_close_sinks(decoder);
|
||||
av_frame_free(&decoder->hw_frame);
|
||||
av_frame_free(&decoder->frame);
|
||||
avcodec_close(decoder->codec_ctx);
|
||||
avcodec_free_context(&decoder->codec_ctx);
|
||||
@@ -107,15 +149,26 @@ sc_decoder_push(struct sc_decoder *decoder, const AVPacket *packet) {
|
||||
LOGE("Could not send video packet: %d", ret);
|
||||
return false;
|
||||
}
|
||||
ret = avcodec_receive_frame(decoder->codec_ctx, decoder->frame);
|
||||
ret = avcodec_receive_frame(decoder->codec_ctx, decoder->hw_frame);
|
||||
if (!ret) {
|
||||
// a frame was received
|
||||
|
||||
sc_tick t = sc_tick_now();
|
||||
ret = av_hwframe_transfer_data(decoder->frame, decoder->hw_frame, 0);
|
||||
if (ret < 0) {
|
||||
LOGE("HWFRAME transfer fail");
|
||||
return false;
|
||||
}
|
||||
|
||||
LOGD("av_hwframe_transfer_data: %ld", sc_tick_now() - t);
|
||||
|
||||
bool ok = push_frame_to_sinks(decoder, decoder->frame);
|
||||
// A frame lost should not make the whole pipeline fail. The error, if
|
||||
// any, is already logged.
|
||||
(void) ok;
|
||||
|
||||
av_frame_unref(decoder->frame);
|
||||
av_frame_unref(decoder->hw_frame);
|
||||
} else if (ret != AVERROR(EAGAIN)) {
|
||||
LOGE("Could not receive video frame: %d", ret);
|
||||
return false;
|
||||
|
||||
@@ -19,6 +19,7 @@ struct sc_decoder {
|
||||
|
||||
AVCodecContext *codec_ctx;
|
||||
AVFrame *frame;
|
||||
AVFrame *hw_frame;
|
||||
};
|
||||
|
||||
void
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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, ¶ms, &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;
|
||||
}
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -244,7 +244,7 @@ static inline SDL_Texture *
|
||||
create_texture(struct sc_screen *screen) {
|
||||
SDL_Renderer *renderer = screen->renderer;
|
||||
struct sc_size size = screen->frame_size;
|
||||
SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
|
||||
SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_NV12,
|
||||
SDL_TEXTUREACCESS_STREAMING,
|
||||
size.width, size.height);
|
||||
if (!texture) {
|
||||
@@ -711,10 +711,11 @@ prepare_for_frame(struct sc_screen *screen, struct sc_size new_frame_size) {
|
||||
// write the frame into the texture
|
||||
static void
|
||||
update_texture(struct sc_screen *screen, const AVFrame *frame) {
|
||||
SDL_UpdateYUVTexture(screen->texture, NULL,
|
||||
frame->data[0], frame->linesize[0],
|
||||
frame->data[1], frame->linesize[1],
|
||||
frame->data[2], frame->linesize[2]);
|
||||
// SDL_UpdateYUVTexture(screen->texture, NULL,
|
||||
// frame->data[0], frame->linesize[0],
|
||||
// frame->data[1], frame->linesize[1],
|
||||
// frame->data[2], frame->linesize[2]);
|
||||
SDL_UpdateTexture(screen->texture, NULL, frame->data[0], frame->linesize[0]);
|
||||
|
||||
if (screen->mipmaps) {
|
||||
SDL_GL_BindTexture(screen->texture, NULL, NULL);
|
||||
|
||||
@@ -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)");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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)");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user