diff --git a/BUILD.md b/BUILD.md index d5aead0f..87078b71 100644 --- a/BUILD.md +++ b/BUILD.md @@ -268,10 +268,10 @@ install` must be run as root)._ #### Option 2: Use prebuilt server - - [`scrcpy-server-v1.17`][direct-scrcpy-server] - _(SHA-256: 11b5ad2d1bc9b9730fb7254a78efd71a8ff46b1938ff468e47a21b653a1b6725)_ + - [`scrcpy-server-v1.18`][direct-scrcpy-server] + _(SHA-256: 641c5c6beda9399dfae72d116f5ff43b5ed1059d871c9ebc3f47610fd33c51a3)_ -[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.17/scrcpy-server-v1.17 +[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.18/scrcpy-server-v1.18 Download the prebuilt server somewhere, and specify its path during the Meson configuration: diff --git a/FAQ.it.md b/FAQ.it.md new file mode 100644 index 00000000..5c5830ce --- /dev/null +++ b/FAQ.it.md @@ -0,0 +1,217 @@ +_Apri le [FAQ](FAQ.md) originali e sempre aggiornate._ + +# Domande Frequenti (FAQ) + +Questi sono i problemi più comuni riportati e i loro stati. + + +## Problemi di `adb` + +`scrcpy` esegue comandi `adb` per inizializzare la connessione con il dispositivo. Se `adb` fallisce, scrcpy non funzionerà. + +In questo caso sarà stampato questo errore: + +> ERROR: "adb push" returned with value 1 + +Questo solitamente non è un bug di _scrcpy_, ma un problema del tuo ambiente. + +Per trovare la causa, esegui: + +```bash +adb devices +``` + +### `adb` not found (`adb` non trovato) + +È necessario che `adb` sia accessibile dal tuo `PATH`. + +In Windows, la cartella corrente è nel tuo `PATH` e `adb.exe` è incluso nella release, perciò dovrebbe già essere pronto all'uso. + + +### Device unauthorized (Dispositivo non autorizzato) + +Controlla [stackoverflow][device-unauthorized] (in inglese). + +[device-unauthorized]: https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized + + +### Device not detected (Dispositivo non rilevato) + +> adb: error: failed to get feature set: no devices/emulators found + +Controlla di aver abilitato correttamente il [debug con adb][enable-adb] (link in inglese). + +Se il tuo dispositivo non è rilevato, potresti avere bisogno dei [driver][drivers] (link in inglese) (in Windows). + +[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling +[drivers]: https://developer.android.com/studio/run/oem-usb.html + + +### Più dispositivi connessi + +Se più dispositivi sono connessi, riscontrerai questo errore: + +> adb: error: failed to get feature set: more than one device/emulator + +l'identificatore del tuo dispositivo deve essere fornito: + +```bash +scrcpy -s 01234567890abcdef +``` + +Notare che se il tuo dispositivo è connesso mediante TCP/IP, riscontrerai questo messaggio: + +> adb: error: more than one device/emulator +> ERROR: "adb reverse" returned with value 1 +> WARN: 'adb reverse' failed, fallback to 'adb forward' + +Questo è un problema atteso (a causa di un bug di una vecchia versione di Android, vedi [#5] (link in inglese)), ma in quel caso scrcpy ripiega su un metodo differente, il quale dovrebbe funzionare. + +[#5]: https://github.com/Genymobile/scrcpy/issues/5 + + +### Conflitti tra versioni di adb + +> adb server version (41) doesn't match this client (39); killing... + +L'errore compare quando usi più versioni di `adb` simultaneamente. Devi trovare il programma che sta utilizzando una versione differente di `adb` e utilizzare la stessa versione dappertutto. + +Puoi sovrascrivere i binari di `adb` nell'altro programma, oppure chiedere a _scrcpy_ di usare un binario specifico di `adb`, impostando la variabile d'ambiente `ADB`: + +```bash +set ADB=/path/to/your/adb +scrcpy +``` + + +### Device disconnected (Dispositivo disconnesso) + +Se _scrcpy_ si interrompe con l'avviso "Device disconnected", allora la connessione `adb` è stata chiusa. + +Prova con un altro cavo USB o inseriscilo in un'altra porta USB. Vedi [#281] (in inglese) e [#283] (in inglese). + +[#281]: https://github.com/Genymobile/scrcpy/issues/281 +[#283]: https://github.com/Genymobile/scrcpy/issues/283 + + + +## Problemi di controllo + +### Mouse e tastiera non funzionano + +Su alcuni dispositivi potresti dover abilitare un opzione che permette l'[input simulato][simulating input] (link in inglese). Nelle opzioni sviluppatore, abilita: + +> **Debug USB (Impostazioni di sicurezza)** +> _Permetti la concessione dei permessi e la simulazione degli input mediante il debug USB_ + + +[simulating input]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323 + + +### I caratteri speciali non funzionano + +Iniettare del testo in input è [limitato ai caratteri ASCII][text-input] (link in inglese). Un trucco permette di iniettare dei [caratteri accentati][accented-characters] (link in inglese), ma questo è tutto. Vedi [#37] (link in inglese). + +[text-input]: https://github.com/Genymobile/scrcpy/issues?q=is%3Aopen+is%3Aissue+label%3Aunicode +[accented-characters]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-accented-characters +[#37]: https://github.com/Genymobile/scrcpy/issues/37 + + +## Problemi del client + +### La qualità è bassa + +Se la definizione della finestra del tuo client è minore di quella del tuo dispositivo, allora potresti avere una bassa qualità di visualizzazione, specialmente individuabile nei testi (vedi [#40] (link in inglese)). + +[#40]: https://github.com/Genymobile/scrcpy/issues/40 + +Per migliorare la qualità di ridimensionamento (downscaling), il filtro trilineare è applicato automaticamente se il renderizzatore è OpenGL e se supporta la creazione di mipmap. + +In Windows, potresti voler forzare OpenGL: + +``` +scrcpy --render-driver=opengl +``` + +Potresti anche dover configurare il [comportamento di ridimensionamento][scaling behavior] (link in inglese): + +> `scrcpy.exe` > Propietà > Compatibilità > Modifica impostazioni DPI elevati > Esegui l'override del comportamento di ridimensionamento DPI elevati > Ridimensionamento eseguito per: _Applicazione_. + +[scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723 + + + +### Crash del compositore KWin + +In Plasma Desktop, il compositore è disabilitato mentre _scrcpy_ è in esecuzione. + +Come soluzione alternativa, [disattiva la "composizione dei blocchi"][kwin] (link in inglese). + + +[kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613 + + +## Crash + +### Eccezione + +Ci potrebbero essere molte ragioni. Una causa comune è che il codificatore hardware del tuo dispositivo non riesce a codificare alla definizione selezionata: + +> ``` +> ERROR: Exception on thread Thread[main,5,main] +> android.media.MediaCodec$CodecException: Error 0xfffffc0e +> ... +> Exit due to uncaughtException in main thread: +> ERROR: Could not open video stream +> INFO: Initial texture: 1080x2336 +> ``` + +o + +> ``` +> ERROR: Exception on thread Thread[main,5,main] +> java.lang.IllegalStateException +> at android.media.MediaCodec.native_dequeueOutputBuffer(Native Method) +> ``` + +Prova con una definizione inferiore: + +``` +scrcpy -m 1920 +scrcpy -m 1024 +scrcpy -m 800 +``` + +Potresti anche provare un altro [codificatore](README.it.md#codificatore). + + +## Linea di comando in Windows + +Alcuni utenti Windows non sono familiari con la riga di comando. Qui è descritto come aprire un terminale ed eseguire `scrcpy` con gli argomenti: + + 1. Premi Windows+r, questo apre una finestra di dialogo. + 2. Scrivi `cmd` e premi Enter, questo apre un terminale. + 3. Vai nella tua cartella di _scrcpy_ scrivendo (adatta il percorso): + + ```bat + cd C:\Users\user\Downloads\scrcpy-win64-xxx + ``` + + e premi Enter + 4. Scrivi il tuo comando. Per esempio: + + ```bat + scrcpy --record file.mkv + ``` + +Se pianifichi di utilizzare sempre gli stessi argomenti, crea un file `myscrcpy.bat` (abilita mostra [estensioni nomi file][show file extensions] per evitare di far confusione) contenente il tuo comando nella cartella di `scrcpy`. Per esempio: + +```bat +scrcpy --prefer-text --turn-screen-off --stay-awake +``` + +Poi fai doppio click su quel file. + +Potresti anche modificare (una copia di) `scrcpy-console.bat` o `scrcpy-noconsole.vbs` per aggiungere alcuni argomenti. + +[show file extensions]: https://www.techpedia.it/14-windows/windows-10/171-visualizzare-le-estensioni-nomi-file-con-windows-10 diff --git a/FAQ.md b/FAQ.md index a84aade8..c1e39a39 100644 --- a/FAQ.md +++ b/FAQ.md @@ -1,5 +1,7 @@ # Frequently Asked Questions +[Read in another language](#translations) + Here are the common reported problems and their status. @@ -230,3 +232,11 @@ You could also edit (a copy of) `scrcpy-console.bat` or `scrcpy-noconsole.vbs` to add some arguments. [show file extensions]: https://www.howtogeek.com/205086/beginner-how-to-make-windows-show-file-extensions/ + + +## Translations + +This FAQ is available in other languages: + + - [Italiano (Italiano, `it`) - v1.17](FAQ.it.md) + - [한국어 (Korean, `ko`) - v1.11](FAQ.ko.md) diff --git a/README.it.md b/README.it.md new file mode 100644 index 00000000..37416f1d --- /dev/null +++ b/README.it.md @@ -0,0 +1,742 @@ +_Apri il [README](README.md) originale e sempre aggiornato._ + +# scrcpy (v1.17) + +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~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 + + +## Requisiti + +Il dispositivo Android richiede almeno le API 21 (Android 5.0). + +Assiucurati di aver [attivato il debug usb][enable-adb] sul(/i) tuo(i) dispositivo(/i). + +[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling + +In alcuni dispositivi, devi anche abilitare [un'opzione aggiuntiva][control] per controllarli con tastiera e mouse. + +[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323 + +## Ottieni l'app + +Packaging status + +### Sommario + + - Linux: `apt install scrcpy` + - Windows: [download](README.md#windows) + - macOS: `brew install scrcpy` + +Compila dai sorgenti: [BUILD] (in inglese) ([procedimento semplificato][BUILD_simple] (in inglese)) + +[BUILD]: BUILD.md +[BUILD_simple]: BUILD.md#simple + + +### Linux + +Su Debian (_testing_ e _sid_ per ora) e Ubuntu (20.04): + +``` +apt install scrcpy +``` + +È disponibile anche un pacchetto [Snap]: [`scrcpy`][snap-link]. + +[snap-link]: https://snapstats.org/snaps/scrcpy + +[snap]: https://it.wikipedia.org/wiki/Snappy_(gestore_pacchetti) + +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]. + +[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild +[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy + +Puoi anche [compilare l'app manualmente][BUILD] (in inglese) ([procedimento semplificato][BUILD_simple] (in inglese)). + + +### Windows + +Per Windows, per semplicità è disponibile un archivio precompilato con tutte le dipendenze (incluso `adb`): + + - [README](README.md#windows) (Link al README originale per l'ultima versione) + +È anche disponibile in [Chocolatey]: + +[Chocolatey]: https://chocolatey.org/ + +```bash +choco install scrcpy +choco install adb # se non lo hai già +``` + +E in [Scoop]: + +```bash +scoop install scrcpy +scoop install adb # se non lo hai già +``` + +[Scoop]: https://scoop.sh + +Puoi anche [compilare l'app manualmente][BUILD] (in inglese). + + +### macOS + +L'applicazione è disponibile in [Homebrew]. Basta installarlo: + +[Homebrew]: https://brew.sh/ + +```bash +brew install scrcpy +``` + +Serve che `adb` sia accessibile dal tuo `PATH`. Se non lo hai già: + +```bash +brew install android-platform-tools +``` + +È anche disponibile in [MacPorts], che imposta adb per te: + +```bash +sudo port install scrcpy +``` + +[MacPorts]: https://www.macports.org/ + + +Puoi anche [compilare l'app manualmente][BUILD] (in inglese). + + +## Esecuzione + +Collega un dispositivo Android ed esegui: + +```bash +scrcpy +``` + +Scrcpy accetta argomenti da riga di comando, essi sono listati con: + +```bash +scrcpy --help +``` + +## Funzionalità + +### Configurazione di acquisizione + +#### Riduci dimensione + +Qualche volta è utile trasmettere un dispositvo Android ad una definizione inferiore per aumentare le prestazioni. + +Per limitare sia larghezza che altezza ad un certo valore (ad es. 1024): + +```bash +scrcpy --max-size 1024 +scrcpy -m 1024 # versione breve +``` + +L'altra dimensione è calcolata in modo tale che il rapporto di forma del dispositivo sia preservato. +In questo esempio un dispositivo in 1920x1080 viene trasmesso a 1024x576. + + +#### Cambia bit-rate (velocità di trasmissione) + +Il bit-rate predefinito è 8 Mbps. Per cambiare il bitrate video (ad es. a 2 Mbps): + +```bash +scrcpy --bit-rate 2M +scrcpy -b 2M # versione breve +``` + +#### Limitare il frame rate (frequenza di fotogrammi) + +Il frame rate di acquisizione può essere limitato: + +```bash +scrcpy --max-fps 15 +``` + +Questo è supportato ufficialmente a partire da Android 10, ma potrebbe funzionare in versioni precedenti. + +#### Ritaglio + +Lo schermo del dispositivo può essere ritagliato per visualizzare solo parte di esso. + +Questo può essere utile, per esempio, per trasmettere solo un occhio dell'Oculus Go: + +```bash +scrcpy --crop 1224:1440:0:0 # 1224x1440 at offset (0,0) +``` + +Se anche `--max-size` è specificata, il ridimensionamento è applicato dopo il ritaglio. + + +#### Blocca orientamento del video + + +Per bloccare l'orientamento della trasmissione: + +```bash +scrcpy --lock-video-orientation 0 # orientamento naturale +scrcpy --lock-video-orientation 1 # 90° antiorario +scrcpy --lock-video-orientation 2 # 180° +scrcpy --lock-video-orientation 3 # 90° orario +``` + +Questo influisce sull'orientamento della registrazione. + + +La [finestra può anche essere ruotata](#rotazione) indipendentemente. + + +#### Codificatore + +Alcuni dispositivi hanno più di un codificatore e alcuni di questi possono provocare problemi o crash. È possibile selezionare un encoder diverso: + +```bash +scrcpy --encoder OMX.qcom.video.encoder.avc +``` + +Per elencare i codificatori disponibili puoi immettere un nome di codificatore non valido e l'errore mostrerà i codificatori disponibili: + +```bash +scrcpy --encoder _ +``` + +### Registrazione + +È possibile registrare lo schermo durante la trasmissione: + +```bash +scrcpy --record file.mp4 +scrcpy -r file.mkv +``` + +Per disabilitare la trasmissione durante la registrazione: + +```bash +scrcpy --no-display --record file.mp4 +scrcpy -Nr file.mkv +# interrompere la registrazione con Ctrl+C +``` + +I "fotogrammi saltati" sono registrati nonostante non siano mostrati in tempo reale (per motivi di prestazioni). I fotogrammi sono _datati_ sul dispositivo, così una [variazione di latenza dei pacchetti][packet delay variation] non impatta il file registrato. + +[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation + + +### Connessione + +#### Wireless + + +_Scrcpy_ usa `adb` per comunicare col dispositivo e `adb` può [connettersi][connect] al dispositivo mediante TCP/IP: + +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}' + ``` + +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. + +Potrebbe essere utile diminuire il bit-rate e la definizione + +```bash +scrcpy --bit-rate 2M --max-size 800 +scrcpy -b2M -m800 # versione breve +``` + +[connect]: https://developer.android.com/studio/command-line/adb.html#wireless + + +#### Multi dispositivo + +Se in `adb devices` sono listati più dispositivi, è necessario specificare il _seriale_: + +```bash +scrcpy --serial 0123456789abcdef +scrcpy -s 0123456789abcdef # versione breve +``` + +Se il dispositivo è collegato mediante TCP/IP: + +```bash +scrcpy --serial 192.168.0.1:5555 +scrcpy -s 192.168.0.1:5555 # versione breve +``` + +Puoi avviare più istanze di _scrcpy_ per diversi dispositivi. + + +#### Avvio automativo alla connessione del dispositivo + +Potresti usare [AutoAdb]: + +```bash +autoadb scrcpy -s '{}' +``` + +[AutoAdb]: https://github.com/rom1v/autoadb + +#### Tunnel SSH + +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 # termina il server adb locale su 5037 +ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer +# tieni questo aperto +``` + +Da un altro terminale: + +```bash +scrcpy +``` + +Per evitare l'abilitazione dell'apertura porte remota potresti invece forzare una "forward connection" (notare il `-L` invece di `-R`) + +```bash +adb kill-server # termina il server adb locale su 5037 +ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer +# tieni questo aperto +``` + +Da un altro terminale: + +```bash +scrcpy --force-adb-forward +``` + + +Come per le connessioni wireless potrebbe essere utile ridurre la qualità: + +``` +scrcpy -b2M -m800 --max-fps 15 +``` + +### Configurazione della finestra + +#### Titolo + +Il titolo della finestra è il modello del dispositivo per impostazione predefinita. Esso può essere cambiato: + +```bash +scrcpy --window-title 'My device' +``` + +#### Posizione e dimensione + +La posizione e la dimensione iniziale della finestra può essere specificata: + +```bash +scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600 +``` + +#### Senza bordi + +Per disabilitare le decorazioni della finestra: + +```bash +scrcpy --window-borderless +``` + +#### Sempre in primo piano + +Per tenere scrcpy sempre in primo piano: + +```bash +scrcpy --always-on-top +``` + +#### Schermo intero + +L'app può essere avviata direttamente a schermo intero: + +```bash +scrcpy --fullscreen +scrcpy -f # versione breve +``` + +Lo schermo intero può anche essere attivato/disattivato con MOD+f. + +#### Rotazione + +La finestra può essere ruotata: + +```bash +scrcpy --rotation 1 +``` + +I valori possibili sono: + - `0`: nessuna rotazione + - `1`: 90 gradi antiorari + - `2`: 180 gradi + - `3`: 90 gradi orari + +La rotazione può anche essere cambiata dinamicamente con MOD+← +_(sinistra)_ e MOD+→ _(destra)_. + +Notare che _scrcpy_ gestisce 3 diversi tipi di rotazione: + - MOD+r richiede al dispositvo di cambiare tra orientamento verticale (portrait) e orizzontale (landscape) (l'app in uso potrebbe rifiutarsi se non supporta l'orientamento richiesto). + - [`--lock-video-orientation`](#blocca-orientamento-del-video) cambia l'orientamento della trasmissione (l'orientamento del video inviato dal dispositivo al computer). Questo influenza la registrazione. + - `--rotation` (o MOD+←/MOD+→) ruota solo il contenuto della finestra. Questo influenza solo la visualizzazione, non la registrazione. + + +### Altre opzioni di trasmissione + +#### "Sola lettura" + +Per disabilitare i controlli (tutto ciò che può interagire col dispositivo: tasti di input, eventi del mouse, trascina e rilascia (drag&drop) file): + +```bash +scrcpy --no-control +scrcpy -n +``` + +#### Schermo + +Se sono disponibili più schermi, è possibile selezionare lo schermo da trasmettere: + +```bash +scrcpy --display 1 +``` + +La lista degli id schermo può essere ricavata da: + +```bash +adb shell dumpsys display # cerca "mDisplayId=" nell'output +``` + +Lo schermo secondario potrebbe essere possibile controllarlo solo se il dispositivo esegue almeno Android 10 (in caso contrario è trasmesso in modalità sola lettura). + + +#### Mantenere sbloccato + +Per evitare che il dispositivo si blocchi dopo un po' che il dispositivo è collegato: + +```bash +scrcpy --stay-awake +scrcpy -w +``` + +Lo stato iniziale è ripristinato quando scrcpy viene chiuso. + + +#### Spegnere lo schermo + +È possibile spegnere lo schermo del dispositivo durante la trasmissione con un'opzione da riga di comando: + +```bash +scrcpy --turn-screen-off +scrcpy -S +``` + +Oppure premendo MOD+o in qualsiasi momento. + +Per riaccenderlo premere MOD+Shift+o. + +In Android il pulsante `POWER` (tasto di accensione) accende sempre lo schermo. Per comodità, se `POWER` è inviato via scrcpy (con click destro o con MOD+p), si forza il dispositivo a spegnere lo schermo dopo un piccolo ritardo (appena possibile). +Il pulsante fisico `POWER` continuerà ad accendere lo schermo normalmente. + +Può anche essere utile evitare il blocco del dispositivo: + +```bash +scrcpy --turn-screen-off --stay-awake +scrcpy -Sw +``` + +#### Renderizzare i fotogrammi scaduti + +Per minimizzare la latenza _scrcpy_ renderizza sempre l'ultimo fotogramma decodificato disponibile in maniera predefinita e tralascia quelli precedenti. + +Per forzare la renderizzazione di tutti i fotogrammi (a costo di una possibile latenza superiore), utilizzare: + +```bash +scrcpy --render-expired-frames +``` + +#### Mostrare i tocchi + +Per le presentazioni può essere utile mostrare i tocchi fisici (sul dispositivo fisico). + +Android fornisce questa funzionalità nelle _Opzioni sviluppatore_. + +_Scrcpy_ fornisce un'opzione per abilitare questa funzionalità all'avvio e ripristinare il valore iniziale alla chiusura: + +```bash +scrcpy --show-touches +scrcpy -t +``` + +Notare che mostra solo i tocchi _fisici_ (con le dita sul dispositivo). + + +#### Disabilitare il salvaschermo + +In maniera predefinita scrcpy non previene l'attivazione del salvaschermo del computer. + +Per disabilitarlo: + +```bash +scrcpy --disable-screensaver +``` + + +### Input di controlli + +#### Rotazione dello schermo del dispostivo + +Premere MOD+r per cambiare tra le modalità verticale (portrait) e orizzontale (landscape). + +Notare che la rotazione avviene solo se l'applicazione in primo piano supporta l'orientamento richiesto. + +#### Copia-incolla + +Quando gli appunti di Android cambiano, essi vengono automaticamente sincronizzati con gli appunti del computer. + +Qualsiasi scorciatoia Ctrl viene inoltrata al dispositivo. In particolare: + - Ctrl+c copia + - Ctrl+x taglia + - Ctrl+v incolla (dopo la sincronizzazione degli appunti da computer a dispositivo) + +Questo solitamente funziona nella maniera più comune. + +Il comportamento reale, però, dipende dall'applicazione attiva. Per esempio _Termux_ invia SIGINT con Ctrl+c, e _K-9 Mail_ compone un nuovo messaggio. + +Per copiare, tagliare e incollare in questi casi (ma è solo supportato in Android >= 7): + - MOD+c inietta `COPY` + - MOD+x inietta `CUT` + - MOD+v inietta `PASTE` (dopo la sincronizzazione degli appunti da computer a dispositivo) + +In aggiunta, MOD+Shift+v 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 Ctrl+v che con MOD+v) 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 Ctrl+v and MOD+v 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 MOD+Shift+v). + +#### Pizzica per zoomare (pinch-to-zoom) + +Per simulare il "pizzica per zoomare": Ctrl+_click e trascina_. + +Più precisamente, tieni premuto Ctrl 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. + + +#### 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 "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: + +```bash +scrcpy --prefer-text +``` + +(ma questo romperà il normale funzionamento della tastiera nei giochi) + +[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. + +Per prevenire l'inoltro ripetuto degli eventi di pressione: + +```bash +scrcpy --no-key-repeat +``` + +#### Click destro e click centrale + +In maniera predefinita, click destro aziona BACK (indietro) e il click centrale aziona HOME. Per disabilitare queste scorciatoie e, invece, inviare i click al dispositivo: + +```bash +scrcpy --forward-all-clicks +``` + + +### Rilascio di file + +#### Installare APK + +Per installare un APK, trascina e rilascia un file APK (finisce con `.apk`) nella finestra di _scrcpy_. + +Non c'è alcuna risposta visiva, un log è stampato nella console. + + +#### Trasferimento di file verso il dispositivo + +Per trasferire un file in `/sdcard/` del dispositivo trascina e rilascia un file (non APK) nella finestra di _scrcpy_. + +Non c'è alcuna risposta visiva, un log è stampato nella console. + +La cartella di destinazione può essere cambiata all'avvio: + +```bash +scrcpy --push-target=/sdcard/Download/ +``` + + +### Inoltro dell'audio + +L'audio non è inoltrato da _scrcpy_. Usa [sndcpy]. + +Vedi anche la [issue #14]. + +[sndcpy]: https://github.com/rom1v/sndcpy +[issue #14]: https://github.com/Genymobile/scrcpy/issues/14 + + +## Scociatoie + +Nella lista seguente, MOD è il modificatore delle scorciatoie. In maniera predefinita è Alt (sinistro) o Super (sinistro). + +Può essere cambiato usando `--shortcut-mod`. I tasti possibili sono `lctrl`, `rctrl`, `lalt`, `ralt`, `lsuper` and `rsuper` (`l` significa sinistro e `r` significa destro). Per esempio: + +```bash +# usa ctrl destro per le scorciatoie +scrcpy --shortcut-mod=rctrl + +# use sia "ctrl sinistro"+"alt sinistro" che "super sinistro" per le scorciatoie +scrcpy --shortcut-mod=lctrl+lalt,lsuper +``` + +_[Super] è il pulsante Windows o Cmd._ + +[Super]: https://it.wikipedia.org/wiki/Tasto_Windows + + + | Azione | Scorciatoia + | ------------------------------------------- |:----------------------------- + | Schermo intero | MOD+f + | Rotazione schermo a sinistra | MOD+← _(sinistra)_ + | Rotazione schermo a destra | MOD+→ _(destra)_ + | Ridimensiona finestra a 1:1 (pixel-perfect) | MOD+g + | Ridimensiona la finestra per rimuovere i bordi neri | MOD+w \| _Doppio click¹_ + | Premi il tasto `HOME` | MOD+h \| _Click centrale_ + | Premi il tasto `BACK` | MOD+b \| _Click destro²_ + | Premi il tasto `APP_SWITCH` | MOD+s + | Premi il tasto `MENU` (sblocca lo schermo) | MOD+m + | Premi il tasto `VOLUME_UP` | MOD+↑ _(su)_ + | Premi il tasto `VOLUME_DOWN` | MOD+↓ _(giù)_ + | Premi il tasto `POWER` | MOD+p + | Accendi | _Click destro²_ + | Spegni lo schermo del dispositivo (continua a trasmettere) | MOD+o + | Accendi lo schermo del dispositivo | MOD+Shift+o + | Ruota lo schermo del dispositivo | MOD+r + | Espandi il pannello delle notifiche | MOD+n + | Chiudi il pannello delle notifiche | MOD+Shift+n + | Copia negli appunti³ | MOD+c + | Taglia negli appunti³ | MOD+x + | Sincronizza gli appunti e incolla³ | MOD+v + | Inietta il testo degli appunti del computer | MOD+Shift+v + | Abilita/Disabilita il contatore FPS (su stdout) | MOD+i + | Pizzica per zoomare | Ctrl+_click e trascina_ + +_¹Doppio click sui bordi neri per rimuoverli._ +_²Il tasto destro accende lo schermo se era spento, preme BACK in caso contrario._ +_³Solo in Android >= 7._ + +Tutte le scorciatoie Ctrl+_tasto_ sono inoltrate al dispositivo, così sono gestite dall'applicazione attiva. + +## Path personalizzati + +Per utilizzare dei binari _adb_ specifici, configura il suo path nella variabile d'ambente `ADB`: + +```bash +ADB=/percorso/per/adb scrcpy +``` + +Per sovrascrivere il percorso del file `scrcpy-server`, configura il percorso in `SCRCPY_SERVER_PATH`. + +## Perchè _scrcpy_? + +Un collega mi ha sfidato a trovare un nome tanto impronunciabile quanto [gnirehtet]. + +[`strcpy`] copia una **str**ing (stringa); `scrcpy` copia uno **scr**een (schermo). + +[gnirehtet]: https://github.com/Genymobile/gnirehtet +[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html + +## Come compilare? + +Vedi [BUILD] (in inglese). + + +## Problemi comuni + +Vedi le [FAQ](FAQ.it.md). + + +## Sviluppatori + +Leggi la [pagina per sviluppatori]. + +[pagina per sviluppatori]: DEVELOP.md + + +## Licenza (in inglese) + + Copyright (C) 2018 Genymobile + Copyright (C) 2018-2021 Romain Vimont + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + +## Articoli (in inglese) + +- [Introducendo scrcpy][article-intro] +- [Scrcpy ora funziona wireless][article-tcpip] + +[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/ +[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/ diff --git a/README.ko.md b/README.ko.md index 2da50562..31e38c6f 100644 --- a/README.ko.md +++ b/README.ko.md @@ -112,7 +112,7 @@ scrcpy --help ### 캡쳐 환경 설정 -###사이즈 재정의 +### 사이즈 재정의 가끔씩 성능을 향상시키기위해 안드로이드 디바이스를 낮은 해상도에서 미러링하는 것이 유용할 때도 있습니다. @@ -136,7 +136,7 @@ scrcpy --bit-rate 2M scrcpy -b 2M # 축약 버전 ``` -###프레임 비율 제한 +### 프레임 비율 제한 안드로이드 버전 10이상의 디바이스에서는, 다음의 명령어로 캡쳐 화면의 프레임 비율을 제한할 수 있습니다: diff --git a/README.md b/README.md index 150319d2..cf41756b 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# scrcpy (v1.17) +# scrcpy (v1.18) [Read in another language](#translations) @@ -88,10 +88,10 @@ process][BUILD_simple]). For Windows, for simplicity, a prebuilt archive with all the dependencies (including `adb`) is available: - - [`scrcpy-win64-v1.17.zip`][direct-win64] - _(SHA-256: 8b9e57993c707367ed10ebfe0e1ef563c7a29d9af4a355cd8b6a52a317c73eea)_ + - [`scrcpy-win64-v1.18.zip`][direct-win64] + _(SHA-256: 37212f5087fe6f3e258f1d44fa5c02207496b30e1d7ec442cbcf8358910a5c63)_ -[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.17/scrcpy-win64-v1.17.zip +[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.18/scrcpy-win64-v1.18.zip It is also available in [Chocolatey]: @@ -516,7 +516,7 @@ scrcpy --display 1 The list of display ids can be retrieved by: -``` +```bash adb shell dumpsys display # search "mDisplayId=" in the output ``` @@ -801,7 +801,9 @@ handled by the active application. To use a specific _adb_ binary, configure its path in the environment variable `ADB`: - ADB=/path/to/adb scrcpy +```bash +ADB=/path/to/adb scrcpy +``` To override the path of the `scrcpy-server` file, configure its path in `SCRCPY_SERVER_PATH`. @@ -865,10 +867,13 @@ Read the [developers page]. This README is available in other languages: +- [Русский (Russian, `ru`) - v1.18](README.ru.md) - [Indonesian (Indonesia, `id`) - v1.16](README.id.md) +- [Italiano (Italiano, `it`) - v1.17](README.it.md) - [日本語 (Japanese, `jp`) - v1.17](README.jp.md) - [한국어 (Korean, `ko`) - v1.11](README.ko.md) - [português brasileiro (Brazilian Portuguese, `pt-BR`) - v1.17](README.pt-br.md) +- [Español (Spanish, `sp`) - v1.17](README.sp.md) - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.17](README.zh-Hans.md) - [繁體中文 (Traditional Chinese, `zh-Hant`) - v1.15](README.zh-Hant.md) diff --git a/README.ru.md b/README.ru.md new file mode 100644 index 00000000..12e6edbd --- /dev/null +++ b/README.ru.md @@ -0,0 +1,1000 @@ +# scrcpy (v1.18) + +[Информация по переводу](#перевод-и-оригинальная-документация) +[Оригинальная документация 🇬🇧](README.md) +[Документация на других языках 🇬🇧](README.md#translations) + +Приложение транслирует экран Android устройств на ваш ПК или в иной источник, +например в [виртуальное v4l2 устройство](#перенаправление-на-виртуальное-v4l2-устройство) +(виртуальная веб-камера) и позволяет управлять устройством [через клавиатуру и мышь](#управление-через-окно-трансляции) +(в том числе операции [масштабирования пальцами](#масштабирование-пальцами), копирования, +вставки и синхронизация буферов обмена). + +Поддерживаются Android устройства подключенные через USB кабель, +[по WiFi сети 🇬🇧][article-tcpip] или удалённый ADB клиент [через SSH](#ssh-тунель). + +_Root_ доступ на устройстве **не** требуется. + +Приложение доступно под [_Linux_](#linux), [_Windows_](#windows) и [_macOS_](#macos). + +![screenshot](assets/screenshot-debian-600.jpg) + +Цели проекта: + + - **легковесность** (нативно, отображает только экран устройства) + - **производительность** (30~60fps) + - **качество** (1920×1080 или выше) + - **низкая задержка** ([35~70ms 🇬🇧][lowlatency]) + - **быстрое время запуска** (~1 секунда до отображения первого кадра) + - **ненавязчивость** (ничего не устанавливается на устройство) + +[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646 + + +# Содержание + - [ℹ️ Кратко о возможностях](#scrcpy-(v1.18)) + - [📑 Содержание](#содержание) + - [📱 Требования к устройству](#требования-к-устройству) + - [📦 Установка](#установка) + - [▶️ Linux](#linux) + - [▶️ Windows](#windows) + - [▶️ macOS](#macos) + - [🚀 Запуск](#запуск) + - [⭐️ Дополнительные возможности](#дополнительные-возможности) + - [🔧 Конфигурация запуска](#конфигурация-запуска) + - [🖼️ Ограничение разрешения трансляции](#ограничение-разрешения-трансляции) + - [🎚️ Изменение битрейта](#изменение-битрейта) + - [🎞️ Ограничение частоты кадров](#ограничение-частоты-кадров) + - [🔠 Трансляция области экрана](#трансляция-области-экрана) + - [🔄 Фиксация ориентации видеопотока](#фиксация-ориентации-видеопотока) + - [🗜️ Изменение кодировки трансляции](#изменение-кодировки-трансляции) + - [💻 Захват экрана](#захват-экрана) + - [🔴 Запись трансляции](#запись-трансляции) + - [🎥 Перенаправление на виртуальное v4l2 устройство](#перенаправление-на-виртуальное-v4l2-устройство) + - [🔌 Подключение устройства](#подключение-устройства) + - [📡 Беспроводной способ](#беспроводной-способ) + - [📱 Трансляция с нескольких устройств](#трансляция-с-нескольких-устройств) + - [🤖 Автоматическая трансляция при подключении устройства](#автоматическая-трансляция-при-подключении-устройства) + - [🛡️ SSH тунель](#ssh-тунель) + - [📌 Настройки окна](#настройки-окна) + - [🖥️ Заголовок](#заголовок) + - [📍 Позиционирование и размер](#позиционирование-и-размер) + - [🖥️ Безрамочность](#безрамочность) + - [🔝 Поверх всех окон](#поверх-всех-окон) + - [🖥️ Полный экран](#полный-экран) + - [🔄 Поворот трансляции в окне](#поворот-трансляции-в-окне) + - [🛠️ Прочие настройки](#прочие-настройки) + - [🎮 Запретить управление с окна](#запретить-управление-с-окна) + - [🖥️ Трансляция с конкретного дисплея](#трансляция-с-конкретного-дисплея) + - [📴 Не позволять экрану гаснуть](#не-позволять-экрану-гаснуть) + - [📴 Принудительно погасить или включить экран](#принудительно-погасить-или-включить-экран) + - [👆 Отображать касания](#отображать-касания) + - [🖼️ Отключить заставку на ПК](#отключить-заставку-на-пк) + - [🎮 Управление через окно трансляции](#управление-через-окно-трансляции) + - [🔄 Вращение экрана устройства](#вращение-экрана-устройства) + - [✂️ Копирование и вставка](#копирование-и-вставка) + - [✌️ Масштабирование пальцами](#масштабирование-пальцами) + - [⌨️ Настройка ввода клавиатуры](#настройка-ввода-клавиатуры) + - [🔳 Зажатие клавиш](#зажатие-клавиш) + - [🖱️ Правый и средний клик](#правый-и-средний-клик) + - [🗃️ Копирование файлов и установка приложений](#копирование-файлов-и-установка-приложений) + - [📦 Установка приложений](#установка-приложений) + - [📄 Копирование файла на устройство](#копирование-файла-на-устройство) + - [📢 Трансляция звука](#трансляция-звука) + - [🔥 Горячие клавиши](#горячие-клавиши) + - [🔧 Произвольный путь до ADB и сервера scrcpy](#произвольный-путь-до-adb-и-сервера-scrcpy) + - [❓️ Почему называется _scrcpy_?](#почему-называется-scrcpy) + - [🛠️ Как сделать собственную сборку](#как-сделать-собственную-сборку) + - [✔️ Часто задаваемые вопросы](#часто-задаваемые-вопросы) + - [👨‍💻 Для разработчиков](#для-разработчиков) + - [©️ Лицензия](#лицензия) + - [©️ Перевод](#перевод) + - [©️ Оригинал](#оригинал) + - [📑 Статьи](#статьи) + - [ℹ️ Перевод и оригинальная документация](#перевод-и-оригинальная-документация) + + ----- + +## Требования к устройству + +Устройство должно работать на Android 5.0 или выше (API 21). + +Необходимо [включить отладку по USB 🇬🇧][enable-adb] на подключаемых устройствах. + +[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling + +На некоторых устройствах необходимо [включить дополнительные опции 🇬🇧][control], +чтобы использовать управление клавиатурой и мышью. + +[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323 + + +## Установка + +Packaging status + +### Общий способ + + - Linux: `apt install scrcpy` + - Windows: [скачать приложение 🇬🇧][direct-win64] + - macOS: `brew install scrcpy` + +Компиляция из исходников: [Компиляция 🇬🇧][BUILD] ([упрощённый процесс 🇬🇧][BUILD_simple]) + +[BUILD]: BUILD.md +[BUILD_simple]: BUILD.md#simple + + +### Linux + +Для Debian (версия уточняется) и Ubuntu (20.04): + +```bash +apt install scrcpy +``` + +Дополнительно, приложение доступно [в виде Snap][Snap] пакета: [`scrcpy` 🇬🇧][snap-link]. + +[snap-link]: https://snapstats.org/snaps/scrcpy + +[snap]: https://ru.wikipedia.org/wiki/Snappy_(%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BF%D0%B0%D0%BA%D0%B5%D1%82%D0%B0%D0%BC%D0%B8) + +Установка в Fedora возможна [через COPR 🇬🇧][COPR] пакет: [`scrcpy` 🇬🇧][copr-link]. + +[COPR]: https://fedoraproject.org/wiki/Category:Copr +[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/ + +Для Arch Linux, [доступен AUR 🇬🇧][AUR] пакет: [`scrcpy` 🇬🇧][aur-link]. + +[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository +[aur-link]: https://aur.archlinux.org/packages/scrcpy/ + +В Gentoo установка возможна через [Ebuild 🇬🇧][Ebuild]: [`scrcpy` 🇬🇧][ebuild-link]. + +[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild +[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy + +Кроме прочего, вы всегда можете [собрать приложение вручную 🇬🇧][BUILD] ([упрощённый процесс 🇬🇧][BUILD_simple]). + + +### Windows + +Для Windows подготовлен архив со всеми зависимостями (включая `adb`): + + - [`scrcpy-win64-v1.18.zip`][direct-win64] + _(SHA-256: 37212f5087fe6f3e258f1d44fa5c02207496b30e1d7ec442cbcf8358910a5c63)_ + +[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.18/scrcpy-win64-v1.18.zip + +Если вы используете [Chocolatey 🇬🇧][Chocolatey]: + +[Chocolatey]: https://chocolatey.org/ + +```bash +choco install scrcpy +choco install adb # если не установлен ADB +``` + +Если вы используете [Scoop 🇬🇧][Scoop]: + +```bash +scoop install scrcpy +scoop install adb # если не установлен ADB +``` + +[Scoop]: https://scoop.sh + +Если ни один из источников не подходит, попробуйте [собрать приложение вручную 🇬🇧][BUILD]. + + +### macOS + +Приложение доступно через [Homebrew 🇬🇧][Homebrew]. Просто выполните в терминале: + +[Homebrew]: https://brew.sh/ + +```bash +brew install scrcpy +``` + +Дополнительно потребуется `adb`, который должен быть прописан в `PATH`. Если не установлен: + +```bash +brew install android-platform-tools +``` + +В качестве альтернативы возможно использовать [MacPorts 🇬🇧][MacPorts], который автоматически установит и ADB: + +```bash +sudo port install scrcpy +``` + +[MacPorts]: https://www.macports.org/ + + +Дополнительно, всегда доступен вариант с [ручной сборкой проекта 🇬🇧][BUILD]. + + +## Запуск + +Подключите Android устройство и выполните: + +```bash +scrcpy +``` + +Возможно указание дополнительных аргументов. +Получить справку по ним можно следующим образом: + +```bash +scrcpy --help +``` + +## Дополнительные возможности + +### Конфигурация запсука + +#### Ограничение разрешения трансляции + +Иногда может быть полезным отображать экран устройства в более низком разрешении +для увеличения производительности. + +Чтобы ограничить разрешение трансляции (например, до 1024 по большей стороне), +запустите _scrspy_ с аргументом: + +```bash +scrcpy --max-size 1024 +scrcpy -m 1024 # краткая версия +``` + +Таким образом, если разрешение экрана устройства 1920*1080, то трансляция будет +вестись в разрешении 1024*576. + + +#### Изменение битрейта + +Изменение битрейта может быть полезно в некоторых случаях. +Например, при подключении [нескольких устройств](#трансляция-с-нескольких-устройств) +или при использовании [SSH тунеля](#ssh-тунель), когда недостаточная ширина канала +не позволяет корректно передавать данные. + +Стандартный битрейт 8Мб/с. Способ установить битрейт в 2Мб/с: + +```bash +scrcpy --bit-rate 2M +scrcpy -b 2M # краткая версия +``` + +#### Ограничение частоты кадров + +Ограничить частоту можно следующим параметром: + +```bash +scrcpy --max-fps 15 +``` + +Официальная поддержка появилась начиная с Android 10, но более +старые устройства также могут поддерживать эту функцию. + +#### Трансляция области экрана + +Возможно настроить трансляцию только конкретной области экрана. + +Может быть полезно, например, для трансляции изображения +только для одного глаза из Oculus Go: + +```bash +scrcpy --crop 1224:1440:0:0 # область 1224x1440 со сдвигом (0,0) +``` + +Если указан `--max-size`, масштабирование будет применено после обрезания. + + +#### Фиксация ориентации видеопотока + +Влияет на ориентацию видепотока передаваемого с устройства на компьютер: + +```bash +scrcpy --lock-video-orientation # исходная ориентация (определяется устройством) +scrcpy --lock-video-orientation=0 # 0° (стандартная ориентация) +scrcpy --lock-video-orientation=1 # 270° / -90° (поворот влево) +scrcpy --lock-video-orientation=2 # 180° (разворот) +scrcpy --lock-video-orientation=3 # 90° (поворот вправо) +``` + +Эти параметры влияют на весь видеопоток, в том числе и на то, что отображается +в окне приложения и на то, что записывается, если ведётся запись. + +Отображаемая трансляция в окне приложения может [вращаться отдельно](#поворот-трансляции-в-окне). + + +#### Изменение кодировки трансляции + +Некоторые устройства умеют кодировать видео несколькими способами и некоторые +из них могут вызывать проблемы. Указать конкретную кодировку можно параметром: + +```bash +scrcpy --encoder OMX.qcom.video.encoder.avc +``` + +Для просмотра всех возможных вариантов кодировок укажите неверный параметр, +тогда в тексте ошибки можно будет увидеть все доступные варианты: + +```bash +scrcpy --encoder _ +``` + +### Захват экрана + +#### Запись трансляции + +Вы можете вести параллельную запись трансляции: + +```bash +scrcpy --record file.mp4 +scrcpy -r file.mkv +``` + +Либо вести только запись, без трансляции в окне приложения: + +```bash +scrcpy --no-display --record file.mp4 +scrcpy -Nr file.mkv +# для прекращения записи зажмите Ctrl+C +``` + +Во время трансляции приложение может [пропускать кадры 🇬🇧][packet delay variation] +для снижения нагрузки. Например, если на экране ничего не менется или изображение +не успевает передаваться. Тем не менее, если ведётся запись, то все +пропущенные кадры будут записаны в любом случае. + +[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation + + +#### Перенаправление на виртуальное v4l2 устройство + +На Linux возможно перенаправлять видеопоток на виртуальное v4l2 устройство. +Таким образом, видеопоток с устройства возможно использовать, например, +в качестве видеопотока веб-камеры. + +Для работы установите модуль `v4l2loopback`: + +```bash +sudo apt install v4l2loopback-dkms +``` + +И создайте новое виртуальное v4l2 устройство: + +```bash +sudo modprobe v4l2loopback +``` + +После, созданное устройство будет доступно по пути `/dev/videoN`, где +`N` - номер устройства. Возможно создание нескольких виртуальных устройств. +Более подробную информацию по виртуальным v4l2 устройствам +[можно найти здесь](https://github.com/umlaeute/v4l2loopback#options). + +Все доступные v4l2 устройства можно увидеть при помощи одной из команд: + +```bash +# требуется пакет v4l-utils +v4l2-ctl --list-devices + +# способ не требующий дополнительных пакетов +ls /dev/video* +``` + +Примеры перенаправления трансляции на виртуальное v4l2 устройство: + +```bash +scrcpy --v4l2-sink=/dev/videoN # отображать в окне и писать в v4l2 устройство +scrcpy --v4l2-sink=/dev/videoN --no-display # не отображать окно приложения +scrcpy --v4l2-sink=/dev/videoN -N # краткая версия +``` + +(замените `N` на идентификатор виртуального устройства, представленного в `ls /dev/video*`) + +Перенаправленную трансляцию можно открыть любым v4l2 совместимым инструментом: + +```bash +ffplay -i /dev/videoN +vlc v4l2:///dev/videoN # VLC плеер может добавлять незначительную задержку из-за буфериации +``` + +Перенаправление может быть полезно для прямой работы с трансляцией через [OBS студию][OBS]. + +[OBS]: https://obsproject.com/fr + + +### Подключение устройства + +#### Беспроводной способ + +_Scrcpy_ для общения с устройством использует `adb`, который поддерживает [удалённое подключение через WiFi][connect]: + +1. Подключите смартфон к одной WiFi сети с вашим ПК. +2. Узнайте IP адрес смартфона, для этого перейдите в **Настройки** -> **О телефоне** -> **Состояние**. + Или воспользуйтесь командой на вашем ПК, когда смартфон подключён по проводу: + + ```bash + adb shell ip route | awk '{print $9}' + ``` + +3. Переведите ADB в беспроводной режим: `adb tcpip 5555`. +4. Подключите ADB через WiFi к смартфону: `adb connect IP_УСТРОЙСТВА:5555` _(замените `IP_УСТРОЙСТВА`)_. +5. Запустите `scrcpy` как обычно. + +При таком способе подключения может быть полезным снизить битрейт: + +```bash +scrcpy --bit-rate 2M --max-size 800 +scrcpy -b2M -m800 # краткая версия +``` + +[connect]: https://developer.android.com/studio/command-line/adb.html#wireless + + +#### Трансляция с нескольких устройств + +Если несколько устройств подключены и отображаются в `adb devices`, вам необходимо +указать идентификатор конкретного устройства: + +```bash +scrcpy --serial 0123456789abcdef +scrcpy -s 0123456789abcdef # краткая версия +``` + +Если требуемое устройство подключено через WiFi: + +```bash +scrcpy --serial 192.168.0.1:5555 +scrcpy -s 192.168.0.1:5555 # краткая версия +``` + +Таким образом, возможен запуск нескольких экземпляров _scrcpy_ для трансляции разных устройств. + +#### Автоматическая трансляция при подключении устройства + +Это возможно при помощи [AutoAdb 🇬🇧][AutoAdb]: + +```bash +autoadb scrcpy -s '{}' +``` + +[AutoAdb]: https://github.com/rom1v/autoadb + +#### SSH тунель + +Можно подключаться к устройствам, подключённым к удалённым сессиям ADB. +Например, если устройство подключено к вашему серверу, вы можете использовать SSH тунель, +чтобы получить доступ к удалённой ADB сессии и прокинуть её на ваш компьютер. + +```bash +adb kill-server # остановка локального ADB сервера +ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 ваш_удалённый_сервер +# оставьте терминал открытым +``` + +С другого терминала: + +```bash +scrcpy +``` + +Чтобы предотвратить удалённый проброс портов, необходимо пробросить соединение принудительно. +(используйте `-L` вместо `-R`): + +```bash +adb kill-server # остановка локального ADB сервера +ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer +# оставьте терминал открытым +``` + +С другого терминала: + +```bash +scrcpy --force-adb-forward +``` + + +Как и в случае с беспроводным соединением, может быть полезным снизить качество: + +``` bash +scrcpy -b2M -m800 --max-fps 15 # битрейт 2Мб/с, разрешение 800 пикселей и 15 кадров в секунду +``` + +### Настройка окна + +#### Заголовок + +По умолчанию, в названии окна отображается модель смартфона. +Можно изменить заголовок на любой другой: + +```bash +scrcpy --window-title 'Презентация новой фичи' +``` + +#### Позиционирование и размер + +Позиция и размер окна тоже могут быть утсановлены вами: + +```bash +scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600 +``` + +#### Безрамочность + +Рамка окна и стандартные кнопки управления окном могут быть скрыты: + +```bash +scrcpy --window-borderless +``` + +#### Поверх всех окон + +Scrcpy может отображаться в приоритетном режиме поверх других окон: + +```bash +scrcpy --always-on-top +``` + +#### Полный экран + +Приложение может быть развёрнуто на весь экран: + +```bash +scrcpy --fullscreen +scrcpy -f # краткая версия +``` + +Полноэкранный режим может быть переключён во время трансляции комбинацией MOD+f. + +#### Поворот трансляции в окне + +Изображение трансляции в окне приложения можно вращать независимо +от ориентации исходного и записываемого видеопотока: + +```bash +scrcpy --rotation 1 +``` + +Возможные значения: + - `0`: без поворота + - `1`: 270 / -90 градусов (поворот влево) + - `2`: 180 градусов (разворот) + - `3`: 90 градусов (поворот вправо) + +Поворот может быть изменён во время трансляции используя комбинацию MOD+← _(влево)_ +и MOD+→ _(вправо)_. + +В _scrcpy_ есть 3 разных режима поворота: + - MOD+r заставляет устройство принудительно повернуть экран между горизонтальным + и вертикальным режимами (запущенное приложение может закрыться, если оно не поддерживает + требуемый режим). + - [`--lock-video-orientation`](#фиксация-ориентации-видеопотока) влияет на трансляцию и запись + (видеопоток, передаваемый с устройства). Если включена запись, то она будет повёрнута тоже. + - `--rotation` (or MOD+←/MOD+→) + Поворот только трансляции отображаемой в окне приложения. Это не повлияет на запись. + + +### Прочие настройки + +#### Запретить управление с окна + +Возможно запретить управление устройством через трансляцию. +Таким образом станет невозможным использовать клавиатуру и мышь при взаимодействии +с трансляцией. Перетаскивание файлов и копирование с буфера обмена тоже станут недоступны: + +```bash +scrcpy --no-control +scrcpy -n +``` + +#### Трансляция с конкретного дисплея + +Если устройство поддерживает несколько дисплеев или к нему подключены дополнительные +мониторы, возможно указать источник для трансляции: + +```bash +scrcpy --display 1 +``` + +Список всех источников можно посмотреть командой ниже: + +```bash +adb shell dumpsys display # ищите "mDisplayId=" в результатах выполнения команды +``` + +Управление на не стандартном дисплее поддерживается только на устройствах с Android 10 и выше. + + +#### Не позволять экрану гаснуть + +Если устройство долго не используется, оно, как правило, гасит экран. +Если это неприемлимо во время вашей трансляции или записи, то такое +поведение может быть предотвращено: + +```bash +scrcpy --stay-awake +scrcpy -w # краткая версия +``` + +После отключения _scrcpy_, устройство снова сможет гасить экран. + + +#### Принудительно погасить или включить экран + +Перед началом трансляции можно погасить экран. +Для этого укажите следующий аргумент: + +```bash +scrcpy --turn-screen-off +scrcpy -S # краткая версия +``` + +Или воспользуйтесь комбинацией MOD+o во время трансляции. + +Чтоб обратно включить экран воспользуйтесь MOD+Shift+o. + +На Android, кнопка `ПИТАНИЯ` всегда включает экран. Если +`ПИТАНИЕ` эмулируется через _scrcpy_ (через правый клик или MOD+p), +оно произойдёт с небольшой задержкой. +Физическое нажатие кнопки `ПИТАНИЯ` продолжит работать как обычно и будет управлять экраном. + +Если устройство способно переходить в режим сна при погашеном экране, это можно предотвратить: + +```bash +scrcpy --turn-screen-off --stay-awake +scrcpy -Sw # краткая версия +``` + +Таким образом устройство погасит экран, но не будет переходить в режим сна, а трансляция продолжиться +как если бы экран был включён. + + +#### Отображать касания + +Может быть полезно включить отображение касаний во время различных презентаций. +Android позволяет включить эту опцию вручную в _Настройках разработчика_. +Либо _scrcpy_ может сделать это за вас на время трансляции: + +```bash +scrcpy --show-touches +scrcpy -t # краткая версия +``` + +Касания будут работать только для _физических нажатий_ на экран устройства. +Вы не увидите точки касания если будете управлять устройством при помощи мыши +через _scrcpy_. + + +#### Отключить заставку на ПК + +По умолчанию _scrcpy_ не запрещает вашему ПК включать заставку во время трансляции. +Будет неудобно, если во время презентации ваш ноутбук вместо трансляции покажет всем заставку. +Это можно предотвратить: + +```bash +scrcpy --disable-screensaver +``` + + +### Управление через окно трансляции + +#### Вращение экрана устройства + +Нажмите MOD+r чтобы переключиться между горизонтальной и вертикальной раскладкой. +Эта функция будет работать только если приложение на устройстве поддерживает нужную раскладку. + + +#### Копирование и вставка + +Буфер обмена автоматически будет синхронизирован с буфером обмена устройства. + +Любая Ctrl комбинация транслируется на устройство. В частности: + - Ctrl+c обычно копирует + - Ctrl+x обычно вырезает + - Ctrl+v обычно вставляет (после синхронизации буферов обмена) + +Обычно это работает так, как вы ожидаете. + +Но, всё зависит и от приложения, которое запущено на устройстве. +Например, _Termux_ выполняет SIGINT при нажатии Ctrl+c, вместо копирования. +_K-9 Mail_ при этой комбинации создаёт новое сообщение. + +Чтобы копировать, вырезать и вставить в таких случаях используйте следующие комбинации +(поддерживается только на устройствах с Android 7 и выше): + - MOD+c имитирует копирование + - MOD+x имитирует вырезание + - MOD+v имитирует вставку (после синхронизации буферов обмена) + +В дополнение, MOD+Shift+v позволяет имитировать +вставку текста через нажатие клавиш клавиатуры. Может быть полезным в приложениях, +которые не поддерживают вставку совсем. Например _Termux_ или приложения ограничивающие +вставку стандартным способом, скажем, интернет банкинг и различные формы ввода паролей. + +Но такой метод работает только для ASCII текста и вставить русский текст не выйдет. + +**ВНИМАНИЕ:** Операции вставки будут копировать данные буфера обмена вашего ПК +в буфер устройства, который, доступен для чтения приложениям на устройстве. +Будтье осторожны и не вставляйте приватные данные (например, пароли). +Для безопасной вставки можно воспользоваться способом выше, через эмуляцию клавиш. + +Некоторые устройства ведут себя не корректно при попытке установить данные в буфер +обмена через _scrcpy_. В таких случаях используйте `--legacy-paste`, что заставит +Ctrl+v и MOD+v вставлять текст посимвольно, +аналогично комбинации MOD+Shift+v. + +#### Масштабирование пальцами + +"Масштабирования пальцами" можно эмулировать комбинацией: Ctrl+_click-and-move_. + +Удерживайте Ctrl и одновременно зажмите левую кнопку мыши. +Пока удерживается левая кнопка, операции масштабирования и поворота +(если поддерживается приложением) будут работать относительно центра экрана. + +_Scrcpy_ генерирует дополнительное событие касания в центре экрана. + + +#### Настройка ввода клавиатуры + +Существует 2 способа эмулировать [события ввода][textevents] с клавиатуры: + - _события клавиши (key event)_, указывает на нажатие клавиши; + - _события текста (text event)_, указывает на ввод символа. + +По умолчанию, символы вводятся через эмуляцию нажатия клавиш. +Таким образом, вы можете ожидать корректное поведение клавиатуры, например, в играх (WASD клавиши). + +Но такой способ [вызывает проблемы][prefertext] в других ситуациях. +Например, невозможность ввести русские символы или несоответствие раскладки +клавиатуры компьютера раскладке устройства. + +Проблема может быть решена переключением режима: + +```bash +scrcpy --prefer-text +``` + +(но это сломает управление в играх) + +[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input +[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343 + + +#### Зажатие клавиш + +По умолчанию, зажатие клавиши будет генерировать повторяющиеся нажатия. +Это может вызвать проблемы в некоторых играх. + +Способ исключить эту проблему: + +```bash +scrcpy --no-key-repeat +``` + + +#### Правый и средний клик + +По умолчанию, правый клик эмулирует кнопку `НАЗАД` (или `ПИТАНИЕ`), а средний +эмулирует `ДОМОЙ`. Чтобы отключить такое поведение и передавать клавиши +мыши напрямую, воспользуйтесь флагом ниже: + +```bash +scrcpy --forward-all-clicks +``` + + +### Копирование файлов и установка приложений + +#### Установка приложений + +Для установки приложения (файла с расширением `.apk`) перетащите его на экран трансляции. + +Это вызовет тихую установку без уведомлений на экране смартфона. +Но вы сможете видеть результат в консоли. + + +#### Копирование файла на устройство + +Перетащите файл (без расширения `.apk`) на экран трансляции и он будет +скопирован в `/sdcard/Download/` на устройстве. + +Файл копируется тихо, без информации на эране устройства. +Но вы сможете видеть результат в консоли. + +Директорию копирования можно изменить: + +```bash +scrcpy --push-target=/sdcard/Movies/ +``` + +Копировать файл с устройства на ПК средствами _scrcpy_ невозможно. +Но вы можете воспользоваться функционалом ADB: + +```bash +adb pull путь/на/устройстве путь/на/вашем/ПК +``` + + +### Трансляция звука + +_Scrcpy_ не умеет транслировать звук, для этих целей используйте [sndcpy 🇬🇧][sndcpy]. + +Обратите внимание на [эту ветку обсуждений 🇬🇧][issue #14]. + +[sndcpy]: https://github.com/rom1v/sndcpy +[issue #14]: https://github.com/Genymobile/scrcpy/issues/14 + + +## Горячие клавиши + +В списке далее MOD - модификатор для горячих клавиш. +По умолчанию это Alt (левый) или Super (левый). + +Клавиша модификатора может быть изменена при помощи `--shortcut-mod`. +Возможные значения: `lctrl`, `rctrl`, `lalt`, `ralt`, `lsuper` and `rsuper`. +Например: + +```bash +# используется правый Ctrl +scrcpy --shortcut-mod=rctrl + +# используются левые Ctrl+Alt или левый Super +scrcpy --shortcut-mod=lctrl+lalt,lsuper +``` + +_[Super] - это Win для Windows или Cmd для macOS._ + +[Super]: https://ru.wikipedia.org/wiki/Super_(%D0%BA%D0%BB%D0%B0%D0%B2%D0%B8%D1%88%D0%B0) + + | Действие | Горячие клавиши + | ------------------------------------------- |:----------------------------- + | Переключить полноэкранный режим | MOD+f + | Повернуть экран влево | MOD+← _(влево)_ + | Повернуть экран вправо | MOD+→ _(вправо)_ + | Масштабировать окно 1:1 (pixel-perfect) | MOD+g + | Масштабировать окно до скрытия чёрных полос | MOD+w \| _Двойной левый клик¹_ + | Эмулировать `ДОМОЙ` | MOD+h \| _Средний клик_ + | Эмулировать `НАЗАД` | MOD+b \| _Правый клик²_ + | Эмулировать `ПЕРЕКЛЮЧИТЬ_ПРИЛОЖЕНИЕ` | MOD+s \| _Четвёртая кнопка мыши³_ + | Эмулировать `МЕНЮ` (разблокировать экран) | MOD+m + | Эмулировать `ГРОМКОСТЬ_ВВЕРХ` | MOD+↑ _(вверх)_ + | Эмулировать `ГРОМКОСТЬ_ВНИЗ` | MOD+↓ _(вниз)_ + | Эмулировать `ПИТАНИЕ` | MOD+p + | Включить экран | _Правый клик²_ + | Выключить экран (оставить трансляцию) | MOD+o + | Включить экран | MOD+Shift+o + | Повернуть экран устройства | MOD+r + | Раскрыть панель уведомлений | MOD+n \| _Пятая кнопка мыши³_ + | Раскрыть панель управления | MOD+n+n \| _Двойной клик пятой кнопки мыши³_ + | Скрыть панели | MOD+Shift+n + | Копировать в буфер обмена⁴ | MOD+c + | Вырезать в буфер обмена⁴ | MOD+x + | Синхронизировать буфера и вставить⁴ | MOD+v + | Эмулировать вставку текста клавиатурой | MOD+Shift+v + | Вкл/Выкл счётчик кадров (в консоль) | MOD+i + | Масштабирование двумя пальцами | Ctrl+_Кликнуть и удерживать_ + +_¹Двойной клик по чёрной рамке скроет её._ +_²Правый клик включит экран если он выключен, либо эмулирует `НАЗАД` если включён._ +_³4 и 5 кнопки мыши если они у вас есть._ +_⁴Только Android 7 и выше._ + +Горячие клавиши, где присутствует повтор кнопки, сработают если нажать её дважды. +Например, чтобы выполнить "Раскрыть панель управления": + + 1. Нажмите и удерживайте MOD. + 2. Дважды нажмите n. + 3. Отпустите MOD. + +Все Ctrl+_клавиша_ комбинации передаются напрямую в устройство, поэтому они +могут обрабатываться конкретным приложением, которое может не позволить выполнять +какие-то действия или обрабатывать их по особому. + + +## Произвольный путь до ADB и сервера scrcpy + +Чтобы использовать файл конкретного _adb_ сервера, укажите путь к нему в переменной окружения `ADB`: + +```bash +ADB=/путь/к/adb/серверу scrcpy +``` + +Чтобы переопределить путь до `scrcpy-server`, настройте его в `SCRCPY_SERVER_PATH` окружениия. +Обратите внимание, `SCRCPY_SERVER_PATH` должен содержать полный путь до `scrcpy-server.jar`. + +[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345 + + +## Почему называется _scrcpy_? + +Я поспорил с коллегой, что смогу придумать непроизносимое название, вроде [gnirehtet 🇬🇧][gnirehtet]. + +[`strcpy` 🇬🇧][`strcpy`] копирует **стр**оку; `scrcpy` копирует **scr**een (прим: Экран). + +[gnirehtet]: https://github.com/Genymobile/gnirehtet +[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html + + +## Как сделать собственную сборку? + +Смотрите [инструкцию по сборке 🇬🇧][BUILD]. + + +## Часто задаваемые вопросы + +Смотрите [Вопрос-Ответ 🇬🇧](FAQ.md). + + +## Для разработчиков + +Прочтите [страницу разработчика 🇬🇧][developers page]. + +[developers page]: DEVELOP.md + + +## Лицензия + +### Перевод + +> Перевод не является официальной Лицензией и предназначен для ознакомительных целей. +> Для получения официального текста Лицензии воспользуйтесь оригиналом. + + Авторское право 2018 "Дженимобайл" (Genymobile) + Авторское право 2018-2021 Ромен Вимонт (Romain Vimont) + + Лицензировано Apache 2.0 лицензией ("Лицензия"); + Вы можете использовать этот файл только в соответствии Лицензии. + Вы можете получить копию оригинальной Лицензии по адресу + + http://www.apache.org/licenses/LICENSE-2.0 + + Если иное не требуется действующим законодательством или не + согласовано в письменной форме, программное обеспечение предоставляется + на условиях "КАК ЕСТЬ", БЕЗ ПРОЧИХ ГАРАНТИЙ ИЛИ УСЛОВИЙ, явных и + подразумевающихся. + Смотрите Лицензию для получения информации о правах и ограничениях + на конкретных языках, регулируемых действующей Лицензией. + +### Оригинал + + Copyright (C) 2018 Genymobile + Copyright (C) 2018-2021 Romain Vimont + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + +## Статьи + +- [Введение в scrcpy 🇬🇧][article-intro] +- [Работа с scrcpy через WiFi 🇬🇧][article-tcpip] + +[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/ +[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/ + +## Перевод и оригинальная документация + +1. Авторское право на оригинальное программное обеспечение сохраняется за автором + оригинального программного обеспечения в соответствии с оригинальной Лицензией. +2. Русскоязычная документация может не соответствовать актуальной версии программы. +3. Перевод не является прямым цитированием автора и не может быть использован для + регулирования любых юридических вопросов. +4. Перевод может содержать неточности и предназначен для ознакомления. +5. Перевод содержит пометки переводчика и перефразированный текст для облегченного + понимания носителями русского языка. + +Для получения актуальной информации обратитесь к [оригинальной англоязычной документации 🇬🇧](README.md). + +Для поддержания перевода в актуальном состоянии и исправления ошибок просьба создавать issue с упоминанием автора перевода. + +Перевод на русский выполнил @jkulvich (Кулагин Юрий / Kulagin Yuri) + diff --git a/README.sp.md b/README.sp.md new file mode 100644 index 00000000..6f76a7be --- /dev/null +++ b/README.sp.md @@ -0,0 +1,743 @@ +Solo se garantiza que el archivo [README](README.md) original esté actualizado. + +# scrcpy (v1.17) + +Esta aplicación proporciona imagen y control de un dispositivo Android conectado +por USB (o [por TCP/IP][article-tcpip]). No requiere acceso _root_. +Compatible con _GNU/Linux_, _Windows_ y _macOS_. + +![screenshot](assets/screenshot-debian-600.jpg) + +Sus características principales son: + + - **ligero** (nativo, solo muestra la imagen del dispositivo) + - **desempeño** (30~60fps) + - **calidad** (1920×1080 o superior) + - **baja latencia** ([35~70ms][lowlatency]) + - **corto tiempo de inicio** (~1 segundo para mostrar la primera imagen) + - **no intrusivo** (no se deja nada instalado en el dispositivo) + +[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646 + + +## Requisitos + +El dispositivo Android requiere como mínimo API 21 (Android 5.0). + +Asegurate de [habilitar el adb debugging][enable-adb] en tu(s) dispositivo(s). + +[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling + +En algunos dispositivos, también necesitas habilitar [una opción adicional][control] para controlarlo con el teclado y ratón. + +[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323 + + +## Consigue la app + +Packaging status + +### Resumen + + - Linux: `apt install scrcpy` + - Windows: [download](README.md#windows) + - macOS: `brew install scrcpy` + +Construir desde la fuente: [BUILD] ([proceso simplificado][BUILD_simple]) + +[BUILD]: BUILD.md +[BUILD_simple]: BUILD.md#simple + + +### Linux + +En Debian (_test_ y _sid_ por ahora) y Ubuntu (20.04): + +``` +apt install scrcpy +``` + +Hay un paquete [Snap]: [`scrcpy`][snap-link]. + +[snap-link]: https://snapstats.org/snaps/scrcpy + +[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager) + +Para Fedora, hay un paquete [COPR]: [`scrcpy`][copr-link]. + +[COPR]: https://fedoraproject.org/wiki/Category:Copr +[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/ + +Para Arch Linux, hay un paquete [AUR]: [`scrcpy`][aur-link]. + +[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository +[aur-link]: https://aur.archlinux.org/packages/scrcpy/ + +Para Gentoo, hay un paquete [Ebuild]: [`scrcpy/`][ebuild-link]. + +[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild +[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy + +También puedes [construir la aplicación manualmente][BUILD] ([proceso simplificado][BUILD_simple]). + + +### Windows + +Para Windows, por simplicidad, hay un pre-compilado con todas las dependencias +(incluyendo `adb`): + + - [README](README.md#windows) + +También está disponible en [Chocolatey]: + +[Chocolatey]: https://chocolatey.org/ + +```bash +choco install scrcpy +choco install adb # si aún no está instalado +``` + +Y en [Scoop]: + +```bash +scoop install scrcpy +scoop install adb # si aún no está instalado +``` + +[Scoop]: https://scoop.sh + +También puedes [construir la aplicación manualmente][BUILD]. + + +### macOS + +La aplicación está disponible en [Homebrew]. Solo instalala: + +[Homebrew]: https://brew.sh/ + +```bash +brew install scrcpy +``` + +Necesitarás `adb`, accesible desde `PATH`. Si aún no lo tienes: + +```bash +brew install android-platform-tools +``` + +También está disponible en [MacPorts], que configurará el adb automáticamente: + +```bash +sudo port install scrcpy +``` + +[MacPorts]: https://www.macports.org/ + + +También puedes [construir la aplicación manualmente][BUILD]. + + +## Ejecutar + +Enchufa el dispositivo Android, y ejecuta: + +```bash +scrcpy +``` + +Acepta argumentos desde la línea de comandos, listados en: + +```bash +scrcpy --help +``` + +## Características + +### Capturar configuración + +#### Reducir la definición + +A veces es útil reducir la definición de la imagen del dispositivo Android para aumentar el desempeño. + +Para limitar el ancho y la altura a un valor específico (ej. 1024): + +```bash +scrcpy --max-size 1024 +scrcpy -m 1024 # versión breve +``` + +La otra dimensión es calculada para conservar el aspect ratio del dispositivo. +De esta forma, un dispositivo en 1920×1080 será transmitido a 1024×576. + + +#### Cambiar el bit-rate + +El bit-rate por defecto es 8 Mbps. Para cambiar el bit-rate del video (ej. a 2 Mbps): + +```bash +scrcpy --bit-rate 2M +scrcpy -b 2M # versión breve +``` + +#### Limitar los fps + +El fps puede ser limitado: + +```bash +scrcpy --max-fps 15 +``` + +Es oficialmente soportado desde Android 10, pero puede funcionar en versiones anteriores. + +#### Recortar + +La imagen del dispositivo puede ser recortada para transmitir solo una parte de la pantalla. + +Por ejemplo, puede ser útil para transmitir la imagen de un solo ojo del Oculus Go: + +```bash +scrcpy --crop 1224:1440:0:0 # 1224x1440 con coordenadas de origen en (0,0) +``` + +Si `--max-size` también está especificado, el cambio de tamaño es aplicado después de cortar. + + +#### Fijar la rotación del video + + +Para fijar la rotación de la transmisión: + +```bash +scrcpy --lock-video-orientation 0 # orientación normal +scrcpy --lock-video-orientation 1 # 90° contrarreloj +scrcpy --lock-video-orientation 2 # 180° +scrcpy --lock-video-orientation 3 # 90° sentido de las agujas del reloj +``` + +Esto afecta la rotación de la grabación. + +La [ventana también puede ser rotada](#rotación) independientemente. + + +#### Codificador + +Algunos dispositivos pueden tener más de una rotación, y algunos pueden causar problemas o errores. Es posible seleccionar un codificador diferente: + +```bash +scrcpy --encoder OMX.qcom.video.encoder.avc +``` + +Para listar los codificadores disponibles, puedes pasar un nombre de codificador inválido, el error te dará los codificadores disponibles: + +```bash +scrcpy --encoder _ +``` + +### Grabación + +Es posible grabar la pantalla mientras se transmite: + +```bash +scrcpy --record file.mp4 +scrcpy -r file.mkv +``` + +Para grabar sin transmitir la pantalla: + +```bash +scrcpy --no-display --record file.mp4 +scrcpy -Nr file.mkv +# interrumpe la grabación con Ctrl+C +``` + +"Skipped frames" son grabados, incluso si no son mostrados en tiempo real (por razones de desempeño). Los frames tienen _marcas de tiempo_ en el dispositivo, por lo que el "[packet delay +variation]" no impacta el archivo grabado. + +[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation + + +### Conexión + +#### Inalámbrica + +_Scrcpy_ usa `adb` para comunicarse con el dispositivo, y `adb` puede [conectarse] vía TCP/IP: + +1. Conecta el dispositivo al mismo Wi-Fi que tu computadora. +2. Obtén la dirección IP del dispositivo, en Ajustes → Acerca del dispositivo → Estado, o ejecutando este comando: + + ```bash + adb shell ip route | awk '{print $9}' + ``` + +3. Habilita adb vía TCP/IP en el dispositivo: `adb tcpip 5555`. +4. Desenchufa el dispositivo. +5. Conéctate a tu dispositivo: `adb connect IP_DEL_DISPOSITIVO:5555` _(reemplaza `IP_DEL_DISPOSITIVO`)_. +6. Ejecuta `scrcpy` con normalidad. + +Podría resultar útil reducir el bit-rate y la definición: + +```bash +scrcpy --bit-rate 2M --max-size 800 +scrcpy -b2M -m800 # versión breve +``` + +[conectarse]: https://developer.android.com/studio/command-line/adb.html#wireless + + +#### Múltiples dispositivos + +Si hay muchos dispositivos listados en `adb devices`, será necesario especificar el _número de serie_: + +```bash +scrcpy --serial 0123456789abcdef +scrcpy -s 0123456789abcdef # versión breve +``` + +Si el dispositivo está conectado por TCP/IP: + +```bash +scrcpy --serial 192.168.0.1:5555 +scrcpy -s 192.168.0.1:5555 # versión breve +``` + +Puedes iniciar múltiples instancias de _scrcpy_ para múltiples dispositivos. + +#### Autoiniciar al detectar dispositivo + +Puedes utilizar [AutoAdb]: + +```bash +autoadb scrcpy -s '{}' +``` + +[AutoAdb]: https://github.com/rom1v/autoadb + +#### Túnel SSH + +Para conectarse a un dispositivo remoto, es posible conectar un cliente local de `adb` a un servidor remoto `adb` (siempre y cuando utilicen la misma versión de protocolos _adb_): + +```bash +adb kill-server # cierra el servidor local adb en 5037 +ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer +# conserva este servidor abierto +``` + +Desde otra terminal: + +```bash +scrcpy +``` + +Para evitar habilitar "remote port forwarding", puedes forzar una "forward connection" (nótese el argumento `-L` en vez de `-R`): + +```bash +adb kill-server # cierra el servidor local adb en 5037 +ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer +# conserva este servidor abierto +``` + +Desde otra terminal: + +```bash +scrcpy --force-adb-forward +``` + + +Al igual que las conexiones inalámbricas, puede resultar útil reducir la calidad: + +``` +scrcpy -b2M -m800 --max-fps 15 +``` + +### Configuración de la ventana + +#### Título + +Por defecto, el título de la ventana es el modelo del dispositivo. Puede ser modificado: + +```bash +scrcpy --window-title 'My device' +``` + +#### Posición y tamaño + +La posición y tamaño inicial de la ventana puede ser especificado: + +```bash +scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600 +``` + +#### Sin bordes + +Para deshabilitar el diseño de la ventana: + +```bash +scrcpy --window-borderless +``` + +#### Siempre adelante + +Para mantener la ventana de scrcpy siempre adelante: + +```bash +scrcpy --always-on-top +``` + +#### Pantalla completa + +La aplicación puede ser iniciada en pantalla completa: + +```bash +scrcpy --fullscreen +scrcpy -f # versión breve +``` + +Puede entrar y salir de la pantalla completa con la combinación MOD+f. + +#### Rotación + +Se puede rotar la ventana: + +```bash +scrcpy --rotation 1 +``` + +Los valores posibles son: + - `0`: sin rotación + - `1`: 90 grados contrarreloj + - `2`: 180 grados + - `3`: 90 grados en sentido de las agujas del reloj + +La rotación también puede ser modificada con la combinación de teclas MOD+← _(izquierda)_ y MOD+→ _(derecha)_. + +Nótese que _scrcpy_ maneja 3 diferentes rotaciones: + - MOD+r solicita al dispositivo cambiar entre vertical y horizontal (la aplicación en uso puede rechazarlo si no soporta la orientación solicitada). + - [`--lock-video-orientation`](#fijar-la-rotación-del-video) cambia la rotación de la transmisión (la orientación del video enviado a la PC). Esto afecta a la grabación. + - `--rotation` (o MOD+←/MOD+→) rota solo el contenido de la imagen. Esto solo afecta a la imagen mostrada, no a la grabación. + + +### Otras opciones menores + +#### Solo lectura ("Read-only") + +Para deshabilitar los controles (todo lo que interactúe con el dispositivo: eventos del teclado, eventos del mouse, arrastrar y soltar archivos): + +```bash +scrcpy --no-control +scrcpy -n # versión breve +``` + +#### Pantalla + +Si múltiples pantallas están disponibles, es posible elegir cual transmitir: + +```bash +scrcpy --display 1 +``` + +Los ids de las pantallas se pueden obtener con el siguiente comando: + +```bash +adb shell dumpsys display # busque "mDisplayId=" en la respuesta +``` + +La segunda pantalla solo puede ser manejada si el dispositivo cuenta con Android 10 (en caso contrario será transmitida en el modo solo lectura). + + +#### Permanecer activo + +Para evitar que el dispositivo descanse después de un tiempo mientras está conectado: + +```bash +scrcpy --stay-awake +scrcpy -w # versión breve +``` + +La configuración original se restaura al cerrar scrcpy. + + +#### Apagar la pantalla + +Es posible apagar la pantalla mientras se transmite al iniciar con el siguiente comando: + +```bash +scrcpy --turn-screen-off +scrcpy -S # versión breve +``` + +O presionando MOD+o en cualquier momento. + +Para volver a prenderla, presione MOD+Shift+o. + +En Android, el botón de `POWER` siempre prende la pantalla. Por conveniencia, si `POWER` es enviado vía scrcpy (con click-derecho o MOD+p), esto forzará a apagar la pantalla con un poco de atraso (en la mejor de las situaciones). El botón físico `POWER` seguirá prendiendo la pantalla. + +También puede resultar útil para evitar que el dispositivo entre en inactividad: + +```bash +scrcpy --turn-screen-off --stay-awake +scrcpy -Sw # versión breve +``` + + +#### Renderizar frames vencidos + +Por defecto, para minimizar la latencia, _scrcpy_ siempre renderiza el último frame disponible decodificado, e ignora cualquier frame anterior. + +Para forzar el renderizado de todos los frames (a costo de posible aumento de latencia), use: + +```bash +scrcpy --render-expired-frames +``` + +#### Mostrar clicks + +Para presentaciones, puede resultar útil mostrar los clicks físicos (en el dispositivo físicamente). + +Android provee esta opción en _Opciones para desarrolladores_. + +_Scrcpy_ provee una opción para habilitar esta función al iniciar la aplicación y restaurar el valor original al salir: + +```bash +scrcpy --show-touches +scrcpy -t # versión breve +``` + +Nótese que solo muestra los clicks _físicos_ (con el dedo en el dispositivo). + + +#### Desactivar protector de pantalla + +Por defecto, scrcpy no evita que el protector de pantalla se active en la computadora. + +Para deshabilitarlo: + +```bash +scrcpy --disable-screensaver +``` + + +### Control + +#### Rotar pantalla del dispositivo + +Presione MOD+r para cambiar entre posición vertical y horizontal. + +Nótese que solo rotará si la aplicación activa soporta la orientación solicitada. + +#### Copiar y pegar + +Cuando que el portapapeles de Android cambia, automáticamente se sincroniza al portapapeles de la computadora. + +Cualquier shortcut con Ctrl es enviado al dispositivo. En particular: + - Ctrl+c normalmente copia + - Ctrl+x normalmente corta + - Ctrl+v normalmente pega (después de la sincronización de portapapeles entre la computadora y el dispositivo) + +Esto normalmente funciona como es esperado. + +Sin embargo, este comportamiento depende de la aplicación en uso. Por ejemplo, _Termux_ envía SIGINT con Ctrl+c, y _K-9 Mail_ crea un nuevo mensaje. + +Para copiar, cortar y pegar, en tales casos (solo soportado en Android >= 7): + - MOD+c inyecta `COPY` + - MOD+x inyecta `CUT` + - MOD+v inyecta `PASTE` (después de la sincronización de portapapeles entre la computadora y el dispositivo) + +Además, MOD+Shift+v permite inyectar el texto en el portapapeles de la computadora como una secuencia de teclas. Esto es útil cuando el componente no acepta pegado de texto (por ejemplo en _Termux_), pero puede romper caracteres no pertenecientes a ASCII. + +**AVISO:** Pegar de la computadora al dispositivo (tanto con Ctrl+v o MOD+v) copia el contenido al portapapeles del dispositivo. Como consecuencia, cualquier aplicación de Android puede leer su contenido. Debería evitar pegar contenido sensible (como contraseñas) de esta forma. + +Algunos dispositivos no se comportan como es esperado al establecer el portapapeles programáticamente. La opción `--legacy-paste` está disponible para cambiar el comportamiento de Ctrl+v y MOD+v para que también inyecten el texto del portapapeles de la computadora como una secuencia de teclas (de la misma forma que MOD+Shift+v). + +#### Pellizcar para zoom + +Para simular "pinch-to-zoom": Ctrl+_click-y-mover_. + +Más precisamente, mantén Ctrl mientras presionas botón izquierdo. Hasta que no se suelte el botón, todos los movimientos del mouse cambiarán el tamaño y rotación del contenido (si es soportado por la app en uso) respecto al centro de la pantalla. + +Concretamente, scrcpy genera clicks adicionales con un "dedo virtual" en la posición invertida respecto al centro de la pantalla. + + +#### Preferencias de inyección de texto + +Existen dos tipos de [eventos][textevents] generados al escribir texto: + - _key events_, marcando si la tecla es presionada o soltada; + - _text events_, marcando si un texto fue introducido. + +Por defecto, las letras son inyectadas usando _key events_, para que el teclado funcione como es esperado en juegos (típicamente las teclas WASD). + +Pero esto puede [causar problemas][prefertext]. Si encuentras tales problemas, los puedes evitar con: + +```bash +scrcpy --prefer-text +``` + +(Pero esto romperá el comportamiento del teclado en los juegos) + +[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input +[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343 + + +#### Repetir tecla + +Por defecto, mantener una tecla presionada genera múltiples _key events_. Esto puede causar problemas de desempeño en algunos juegos, donde estos eventos no tienen sentido de todos modos. + +Para evitar enviar _key events_ repetidos: + +```bash +scrcpy --no-key-repeat +``` + + +#### Botón derecho y botón del medio + +Por defecto, botón derecho ejecuta RETROCEDER (o ENCENDIDO) y botón del medio INICIO. Para inhabilitar estos atajos y enviar los clicks al dispositivo: + +```bash +scrcpy --forward-all-clicks +``` + + +### Arrastrar y soltar archivos + +#### Instalar APKs + +Para instalar un APK, arrastre y suelte el archivo APK (terminado en `.apk`) a la ventana de _scrcpy_. + +No hay respuesta visual, un mensaje se escribirá en la consola. + + +#### Enviar archivos al dispositivo + +Para enviar un archivo a `/sdcard/` en el dispositivo, arrastre y suelte un archivo (no APK) a la ventana de _scrcpy_. + +No hay respuesta visual, un mensaje se escribirá en la consola. + +El directorio de destino puede ser modificado al iniciar: + +```bash +scrcpy --push-target=/sdcard/Download/ +``` + + +### Envío de Audio + +_Scrcpy_ no envía el audio. Use [sndcpy]. + +También lea [issue #14]. + +[sndcpy]: https://github.com/rom1v/sndcpy +[issue #14]: https://github.com/Genymobile/scrcpy/issues/14 + + +## Atajos + +En la siguiente lista, MOD es el atajo modificador. Por defecto es Alt (izquierdo) o Super (izquierdo). + +Se puede modificar usando `--shortcut-mod`. Las posibles teclas son `lctrl` (izquierdo), `rctrl` (derecho), `lalt` (izquierdo), `ralt` (derecho), `lsuper` (izquierdo) y `rsuper` (derecho). Por ejemplo: + +```bash +# use RCtrl para los atajos +scrcpy --shortcut-mod=rctrl + +# use tanto LCtrl+LAlt o LSuper para los atajos +scrcpy --shortcut-mod=lctrl+lalt,lsuper +``` + +_[Super] es generalmente la tecla Windows o Cmd._ + +[Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button) + + | Acción | Atajo + | ------------------------------------------- |:----------------------------- + | Alterne entre pantalla compelta | MOD+f + | Rotar pantalla hacia la izquierda | MOD+← _(izquierda)_ + | Rotar pantalla hacia la derecha | MOD+→ _(derecha)_ + | Ajustar ventana a 1:1 ("pixel-perfect") | MOD+g + | Ajustar ventana para quitar los bordes negros| MOD+w \| _Doble click¹_ + | Click en `INICIO` | MOD+h \| _Botón del medio_ + | Click en `RETROCEDER` | MOD+b \| _Botón derecho²_ + | Click en `CAMBIAR APLICACIÓN` | MOD+s + | Click en `MENÚ` (desbloquear pantalla) | MOD+m + | Click en `SUBIR VOLUMEN` | MOD+↑ _(arriba)_ + | Click en `BAJAR VOLUME` | MOD+↓ _(abajo)_ + | Click en `ENCENDIDO` | MOD+p + | Encendido | _Botón derecho²_ + | Apagar pantalla (manteniendo la transmisión)| MOD+o + | Encender pantalla | MOD+Shift+o + | Rotar pantalla del dispositivo | MOD+r + | Abrir panel de notificaciones | MOD+n + | Cerrar panel de notificaciones | MOD+Shift+n + | Copiar al portapapeles³ | MOD+c + | Cortar al portapapeles³ | MOD+x + | Synchronizar portapapeles y pegar³ | MOD+v + | inyectar texto del portapapeles de la PC | MOD+Shift+v + | Habilitar/Deshabilitar contador de FPS (en stdout) | MOD+i + | Pellizcar para zoom | Ctrl+_click-y-mover_ + +_¹Doble click en los bordes negros para eliminarlos._ +_²Botón derecho enciende la pantalla si estaba apagada, sino ejecuta RETROCEDER._ +_³Solo en Android >= 7._ + +Todos los atajos Ctrl+_tecla_ son enviados al dispositivo para que sean manejados por la aplicación activa. + + +## Path personalizado + +Para usar un binario de _adb_ en particular, configure el path `ADB` en las variables de entorno: + +```bash +ADB=/path/to/adb scrcpy +``` + +Para sobreescribir el path del archivo `scrcpy-server`, configure el path en `SCRCPY_SERVER_PATH`. + + +## ¿Por qué _scrcpy_? + +Un colega me retó a encontrar un nombre tan impronunciable como [gnirehtet]. + +[`strcpy`] copia un **str**ing; `scrcpy` copia un **scr**een. + +[gnirehtet]: https://github.com/Genymobile/gnirehtet +[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html + + +## ¿Cómo construir (BUILD)? + +Véase [BUILD] (en inglés). + + +## Problemas generales + +Vea las [preguntas frecuentes (en inglés)](FAQ.md). + + +## Desarrolladores + +Lea la [hoja de desarrolladores (en inglés)](DEVELOP.md). + + +## Licencia + + Copyright (C) 2018 Genymobile + Copyright (C) 2018-2021 Romain Vimont + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + +## Artículos + +- [Introducing scrcpy][article-intro] (en inglés) +- [Scrcpy now works wirelessly][article-tcpip] (en inglés) + +[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/ +[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/ diff --git a/app/src/adb.c b/app/src/adb.c index be973c41..5bb9df30 100644 --- a/app/src/adb.c +++ b/app/src/adb.c @@ -81,14 +81,20 @@ show_adb_installation_msg() { static void show_adb_err_msg(enum process_result err, const char *const argv[]) { - char buf[512]; +#define MAX_COMMAND_STRING_LEN 1024 + char *buf = malloc(MAX_COMMAND_STRING_LEN); + if (!buf) { + LOGE("Failed to execute (could not allocate error message)"); + return; + } + switch (err) { case PROCESS_ERROR_GENERIC: - argv_to_string(argv, buf, sizeof(buf)); + argv_to_string(argv, buf, MAX_COMMAND_STRING_LEN); LOGE("Failed to execute: %s", buf); break; case PROCESS_ERROR_MISSING_BINARY: - argv_to_string(argv, buf, sizeof(buf)); + argv_to_string(argv, buf, MAX_COMMAND_STRING_LEN); LOGE("Command not found: %s", buf); LOGE("(make 'adb' accessible from your PATH or define its full" "path in the ADB environment variable)"); @@ -98,29 +104,38 @@ show_adb_err_msg(enum process_result err, const char *const argv[]) { // do nothing break; } + + free(buf); } process_t adb_execute(const char *serial, const char *const adb_cmd[], size_t len) { - const char *cmd[len + 4]; int i; process_t process; - cmd[0] = get_adb_command(); + + const char **argv = malloc((len + 4) * sizeof(*argv)); + if (!argv) { + return PROCESS_NONE; + } + + argv[0] = get_adb_command(); if (serial) { - cmd[1] = "-s"; - cmd[2] = serial; + argv[1] = "-s"; + argv[2] = serial; i = 3; } else { i = 1; } - memcpy(&cmd[i], adb_cmd, len * sizeof(const char *)); - cmd[len + i] = NULL; - enum process_result r = process_execute(cmd, &process); + memcpy(&argv[i], adb_cmd, len * sizeof(const char *)); + argv[len + i] = NULL; + enum process_result r = process_execute(argv, &process); if (r != PROCESS_SUCCESS) { - show_adb_err_msg(r, cmd); - return PROCESS_NONE; + show_adb_err_msg(r, argv); + process = PROCESS_NONE; } + + free(argv); return process; } diff --git a/app/src/sys/win/process.c b/app/src/sys/win/process.c index f170e40d..aafd5d34 100644 --- a/app/src/sys/win/process.c +++ b/app/src/sys/win/process.c @@ -6,7 +6,9 @@ #include "util/log.h" #include "util/str_util.h" -static int +#define CMD_MAX_LEN 8192 + +static bool build_cmd(char *cmd, size_t len, const char *const argv[]) { // Windows command-line parsing is WTF: // @@ -15,9 +17,9 @@ build_cmd(char *cmd, size_t len, const char *const argv[]) { size_t ret = xstrjoin(cmd, argv, ' ', len); if (ret >= len) { LOGE("Command too long (%" PRIsizet " chars)", len - 1); - return -1; + return false; } - return 0; + return true; } enum process_result @@ -27,13 +29,14 @@ process_execute(const char *const argv[], HANDLE *handle) { memset(&si, 0, sizeof(si)); si.cb = sizeof(si); - char cmd[256]; - if (build_cmd(cmd, sizeof(cmd), argv)) { + char *cmd = malloc(CMD_MAX_LEN); + if (!cmd || !build_cmd(cmd, CMD_MAX_LEN, argv)) { *handle = NULL; return PROCESS_ERROR_GENERIC; } wchar_t *wide = utf8_to_wide_char(cmd); + free(cmd); if (!wide) { LOGC("Could not allocate wide char string"); return PROCESS_ERROR_GENERIC; diff --git a/install_release.sh b/install_release.sh index 5179c447..9158bdd4 100755 --- a/install_release.sh +++ b/install_release.sh @@ -2,8 +2,8 @@ set -e BUILDDIR=build-auto -PREBUILT_SERVER_URL=https://github.com/Genymobile/scrcpy/releases/download/v1.17/scrcpy-server-v1.17 -PREBUILT_SERVER_SHA256=11b5ad2d1bc9b9730fb7254a78efd71a8ff46b1938ff468e47a21b653a1b6725 +PREBUILT_SERVER_URL=https://github.com/Genymobile/scrcpy/releases/download/v1.18/scrcpy-server-v1.18 +PREBUILT_SERVER_SHA256=641c5c6beda9399dfae72d116f5ff43b5ed1059d871c9ebc3f47610fd33c51a3 echo "[scrcpy] Downloading prebuilt server..." wget "$PREBUILT_SERVER_URL" -O scrcpy-server diff --git a/meson.build b/meson.build index c2989ec7..2d76f1e9 100644 --- a/meson.build +++ b/meson.build @@ -1,5 +1,5 @@ project('scrcpy', 'c', - version: '1.17', + version: '1.18', meson_version: '>= 0.48', default_options: [ 'c_std=c11', diff --git a/prebuilt-deps/Makefile b/prebuilt-deps/Makefile index 356a944e..d75d0a5c 100644 --- a/prebuilt-deps/Makefile +++ b/prebuilt-deps/Makefile @@ -35,6 +35,6 @@ prepare-sdl2: SDL2-2.0.14 prepare-adb: - @./prepare-dep https://dl.google.com/android/repository/platform-tools_r30.0.5-windows.zip \ - 549ba2bdc31f335eb8a504f005f77606a479cc216d6b64a3e8b64c780003661f \ + @./prepare-dep https://dl.google.com/android/repository/platform-tools_r31.0.2-windows.zip \ + d560cb8ded83ae04763b94632673481f14843a5969256569623cfeac82db4ba5 \ platform-tools diff --git a/server/build.gradle b/server/build.gradle index 08ce2d27..f088ba9d 100644 --- a/server/build.gradle +++ b/server/build.gradle @@ -6,8 +6,8 @@ android { applicationId "com.genymobile.scrcpy" minSdkVersion 21 targetSdkVersion 30 - versionCode 20 - versionName "1.17" + versionCode 11800 + versionName "1.18" testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" } buildTypes { diff --git a/server/build_without_gradle.sh b/server/build_without_gradle.sh index 9afc5ba7..302d3aaa 100755 --- a/server/build_without_gradle.sh +++ b/server/build_without_gradle.sh @@ -12,7 +12,7 @@ set -e SCRCPY_DEBUG=false -SCRCPY_VERSION_NAME=1.17 +SCRCPY_VERSION_NAME=1.18 PLATFORM=${ANDROID_PLATFORM:-30} BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-30.0.0}