diff --git a/FAQ.it.md b/FAQ.it.md new file mode 100644 index 0000000..0da656c --- /dev/null +++ b/FAQ.it.md @@ -0,0 +1,235 @@ +_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 + + +### Problema con Wayland + +Per impostazione predefinita, SDL utilizza x11 su Linux. Il [video driver] può essere cambiato attraversio la variabile d'ambiente `SDL_VIDEODRIVER`: + +[video driver]: https://wiki.libsdl.org/FAQUsingSDL#how_do_i_choose_a_specific_video_driver + +```bash +export SDL_VIDEODRIVER=wayland +scrcpy +``` + +Su alcune distribuzioni (almeno Fedora), il pacchetto `libdecor` deve essere installato manualmente. + +Vedi le issues [#2554] e [#2559]. + +[#2554]: https://github.com/Genymobile/scrcpy/issues/2554 +[#2559]: https://github.com/Genymobile/scrcpy/issues/2559 + + +### 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.ko.md b/FAQ.ko.md new file mode 100644 index 0000000..c9e06e2 --- /dev/null +++ b/FAQ.ko.md @@ -0,0 +1,84 @@ +# 자주하는 질문 (FAQ) + +다음은 자주 제보되는 문제들과 그들의 현황입니다. + + +### Windows 운영체제에서, 디바이스가 발견되지 않습니다. + +가장 흔한 제보는 `adb`에 발견되지 않는 디바이스 혹은 권한 관련 문제입니다. +다음 명령어를 호출하여 모든 것들에 이상이 없는지 확인하세요: + + adb devices + +Windows는 당신의 디바이스를 감지하기 위해 [드라이버]가 필요할 수도 있습니다. + +[드라이버]: https://developer.android.com/studio/run/oem-usb.html + + +### 내 디바이스의 미러링만 가능하고, 디바이스와 상호작용을 할 수 없습니다. + +일부 디바이스에서는, [simulating input]을 허용하기 위해서 한가지 옵션을 활성화해야 할 수도 있습니다. +개발자 옵션에서 (developer options) 다음을 활성화 하세요: + +> **USB debugging (Security settings)** +> _권한 부여와 USB 디버깅을 통한 simulating input을 허용한다_ + +[simulating input]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323 + + +### 마우스 클릭이 다른 곳에 적용됩니다. + +Mac 운영체제에서, HiDPI support 와 여러 스크린 창이 있는 경우, 입력 위치가 잘못 파악될 수 있습니다. +[issue 15]를 참고하세요. + +[issue 15]: https://github.com/Genymobile/scrcpy/issues/15 + +차선책은 HiDPI support을 비활성화 하고 build하는 방법입니다: + +```bash +meson x --buildtype release -Dhidpi_support=false +``` + +하지만, 동영상은 낮은 해상도로 재생될 것 입니다. + + +### HiDPI display의 화질이 낮습니다. + +Windows에서는, [scaling behavior] 환경을 설정해야 할 수도 있습니다. + +> `scrcpy.exe` > Properties > Compatibility > Change high DPI settings > +> Override high DPI scaling behavior > Scaling performed by: _Application_. + +[scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723 + + +### KWin compositor가 실행되지 않습니다 + +Plasma Desktop에서는,_scrcpy_ 가 실행중에는 compositor가 비활성화 됩니다. + +차석책으로는, ["Block compositing"를 비활성화하세요][kwin]. + +[kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613 + + +###비디오 스트림을 열 수 없는 에러가 발생합니다.(Could not open video stream). + +여러가지 원인이 있을 수 있습니다. 가장 흔한 원인은 디바이스의 하드웨어 인코더(hardware encoder)가 +주어진 해상도를 인코딩할 수 없는 경우입니다. + +``` +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 +``` + +더 낮은 해상도로 시도 해보세요: + +``` +scrcpy -m 1920 +scrcpy -m 1024 +scrcpy -m 800 +``` diff --git a/FAQ.zh-Hans.md b/FAQ.zh-Hans.md new file mode 100644 index 0000000..23674ee --- /dev/null +++ b/FAQ.zh-Hans.md @@ -0,0 +1,284 @@ +_Only the original [FAQ.md](FAQ.md) is guaranteed to be up-to-date._ + +_只有原版的 [FAQ.md](FAQ.md)是保证最新的。_ + +Current version is based on [28054cd] + +本文根据[28054cd]进行翻译。 + +[28054cd]: https://github.com/Genymobile/scrcpy/blob/28054cd471f848733e11372c9d745cd5d71e6ce7/FAQ.md + +# 常见问题 + +这里是一些常见的问题以及他们的状态。 + +## `adb` 相关问题 + +`scrcpy` 执行 `adb` 命令来初始化和设备之间的连接。如果 `adb` 执行失败了， scrcpy 就无法工作。 + +在这种情况中，将会输出这个错误: + +> ERROR: "adb get-serialno" returned with value 1 + +这通常不是 _scrcpy_ 的bug，而是你的环境的问题。 + +要找出原因，请执行以下操作： + +```bash +adb devices +``` + +### 找不到`adb` + + +你的`PATH`中需要能访问到`adb`。 + +在Windows上，当前目录会包含在`PATH`中，并且`adb.exe`也包含在发行版中，因此它应该是开箱即用（直接解压就可以）的。 + + +### 设备未授权 + + +> error: device unauthorized. +> This adb server's $ADB_VENDOR_KEYS is not set +> Try 'adb kill-server' if that seems wrong. +> Otherwise check for a confirmation dialog on your device. + +连接时，在设备上应该会打开一个弹出窗口。 您必须授权 USB 调试。 + +如果没有打开，参见[stackoverflow][device-unauthorized]. + +[device-unauthorized]: https://stackoverflow.com/questions/23081263/adb-android-device-unauthorized + + +### 未检测到设备 + +> error: no devices/emulators found + +确认已经正确启用 [adb debugging][enable-adb]. + +如果你的设备没有被检测到，你可能需要一些[驱动][drivers] (在 Windows上)。这里有一个单独的 [适用于Google设备的USB驱动][google-usb-driver]. + +[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling +[drivers]: https://developer.android.com/studio/run/oem-usb.html +[google-usb-driver]: https://developer.android.com/studio/run/win-usb + + +### 已连接多个设备 + +如果连接了多个设备，您将遇到以下错误： + +> error: more than one device/emulator + +必须提供要镜像的设备的标识符： + +```bash +scrcpy -s 01234567890abcdef +``` + +注意，如果你的设备是通过 TCP/IP 连接的， 你将会收到以下消息： + +> adb: error: more than one device/emulator +> ERROR: "adb reverse" returned with value 1 +> WARN: 'adb reverse' failed, fallback to 'adb forward' + +这是意料之中的 (由于旧版安卓的一个bug, 请参见 [#5])，但是在这种情况下，scrcpy会退回到另一种方法，这种方法应该可以起作用。 + +[#5]: https://github.com/Genymobile/scrcpy/issues/5 + + +### adb版本之间冲突 + +> adb server version (41) doesn't match this client (39); killing... + +同时使用多个版本的`adb`时会发生此错误。你必须查找使用不同`adb`版本的程序，并在所有地方使用相同版本的`adb`。 + +你可以覆盖另一个程序中的`adb`二进制文件，或者通过设置`ADB`环境变量来让 _scrcpy_ 使用特定的`adb`二进制文件。 + +```bash +set ADB=/path/to/your/adb +scrcpy +``` + + +### 设备断开连接 + +如果 _scrcpy_ 在警告“设备连接断开”的情况下自动中止，那就意味着`adb`连接已经断开了。 + +请尝试使用另一条USB线或者电脑上的另一个USB接口。请参看 [#281] 和 [#283]。 + +[#281]: https://github.com/Genymobile/scrcpy/issues/281 +[#283]: https://github.com/Genymobile/scrcpy/issues/283 + + +## 控制相关问题 + +### 鼠标和键盘不起作用 + + +在某些设备上，您可能需要启用一个选项以允许 [模拟输入][simulating input]。 +在开发者选项中，打开： + +> **USB调试 (安全设置)** +> _允许通过USB调试修改权限或模拟点击_ + +[simulating input]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323 + + +### 特殊字符不起作用 + +可输入的文本[被限制为ASCII字符][text-input]。也可以用一些小技巧输入一些[带重音符号的字符][accented-characters]，但是仅此而已。参见[#37]。 + +自 Linux 上的 scrcpy v1.20 之后，可以模拟[物理键盘][hid] (HID)。 + +[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 +[hid]: README.md#physical-keyboard-simulation-hid + + +## 客户端相关问题 + +### 效果很差 + +如果你的客户端窗口分辨率比你的设备屏幕小，则可能出现效果差的问题，尤其是在文本上（参见 [#40]）。 + +[#40]: https://github.com/Genymobile/scrcpy/issues/40 + +为了提升降尺度的质量，如果渲染器是OpenGL并且支持mip映射，就会自动开启三线性过滤。 + +在Windows上，你可能希望强制使用OpenGL： + +``` +scrcpy --render-driver=opengl +``` + +你可能还需要配置[缩放行为][scaling behavior]： + +> `scrcpy.exe` > Properties > Compatibility > Change high DPI settings > +> Override high DPI scaling behavior > Scaling performed by: _Application_. + +[scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723 + + +### Wayland相关的问题 + +在Linux上，SDL默认使用x11。可以通过`SDL_VIDEODRIVER`环境变量来更改[视频驱动][video driver]： + +[video driver]: https://wiki.libsdl.org/FAQUsingSDL#how_do_i_choose_a_specific_video_driver + +```bash +export SDL_VIDEODRIVER=wayland +scrcpy +``` + +在一些发行版上 (至少包括 Fedora)， `libdecor` 包必须手动安装。 + +参见 [#2554] 和 [#2559]。 + +[#2554]: https://github.com/Genymobile/scrcpy/issues/2554 +[#2559]: https://github.com/Genymobile/scrcpy/issues/2559 + + +### KWin compositor 崩溃 + +在Plasma桌面中，当 _scrcpy_ 运行时，会禁用compositor。 + +一种解决方法是， [禁用 "Block compositing"][kwin]. + +[kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613 + + +## 崩溃 + +### 异常 + +可能有很多原因。一个常见的原因是您的设备无法按给定清晰度进行编码： + +> ``` +> 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 +> ``` + +或者 + +> ``` +> ERROR: Exception on thread Thread[main,5,main] +> java.lang.IllegalStateException +> at android.media.MediaCodec.native_dequeueOutputBuffer(Native Method) +> ``` + +请尝试使用更低的清晰度： + +``` +scrcpy -m 1920 +scrcpy -m 1024 +scrcpy -m 800 +``` + +自 scrcpy v1.22以来，scrcpy 会自动在失败前以更低的分辨率重试。这种行为可以用`--no-downsize-on-error`关闭。 + +你也可以尝试另一种 [编码器](README.md#encoder)。 + + +如果您在 Android 12 上遇到此异常，则只需升级到 scrcpy >= 1.18 (见 [#2129])： + +``` +> ERROR: Exception on thread Thread[main,5,main] +java.lang.AssertionError: java.lang.reflect.InvocationTargetException + at com.genymobile.scrcpy.wrappers.SurfaceControl.setDisplaySurface(SurfaceControl.java:75) + ... +Caused by: java.lang.reflect.InvocationTargetException + at java.lang.reflect.Method.invoke(Native Method) + at com.genymobile.scrcpy.wrappers.SurfaceControl.setDisplaySurface(SurfaceControl.java:73) + ... 7 more +Caused by: java.lang.IllegalArgumentException: displayToken must not be null + at android.view.SurfaceControl$Transaction.setDisplaySurface(SurfaceControl.java:3067) + at android.view.SurfaceControl.setDisplaySurface(SurfaceControl.java:2147) + ... 9 more +``` + +[#2129]: https://github.com/Genymobile/scrcpy/issues/2129 + + +## Windows命令行 + +从 v1.22 开始，增加了一个“快捷方式”，可以直接在 scrcpy 目录打开一个终端。双击`open_a_terminal_here.bat`，然后输入你的命令。 例如： + +``` +scrcpy --record file.mkv +``` + +您也可以打开终端并手动转到 scrcpy 文件夹： + + 1. 按下 Windows+r，打开一个对话框。 + 2. 输入 `cmd` 并按 Enter，这样就打开了一个终端。 + 3. 通过输入以下命令，切换到你的 _scrcpy_ 所在的目录 （根据你的实际位置修改路径）: + + ```bat + cd C:\Users\user\Downloads\scrcpy-win64-xxx + ``` + + 然后按 Enter + 4. 输入你的命令。比如: + + ```bat + scrcpy --record file.mkv + ``` + +如果你打算总是使用相同的参数，在`scrcpy`目录创建一个文件 `myscrcpy.bat` +（启用 [显示文件拓展名][show file extensions] 避免混淆），文件中包含你的命令。例如： + +```bat +scrcpy --prefer-text --turn-screen-off --stay-awake +``` + +然后只需双击刚刚创建的文件。 + +你也可以编辑 `scrcpy-console.bat` 或者 `scrcpy-noconsole.vbs`（的副本）来添加参数。 + +[show file extensions]: https://www.howtogeek.com/205086/beginner-how-to-make-windows-show-file-extensions/ diff --git a/Home.md b/Home.md index 7d50401..32b4874 100644 --- a/Home.md +++ b/Home.md @@ -1 +1,30 @@ Welcome to the scrcpy wiki! + +## Translations + +### README + +The [README] is available in the following languages: + +[README]: https://github.com/Genymobile/scrcpy/blob/master/README.md + +- [Deutsch (German, `de`) - v1.22](README.de) +- [Indonesian (Indonesia, `id`) - v1.16](README.id) +- [Italiano (Italiano, `it`) - v1.23](README.it) +- [日本語 (Japanese, `jp`) - v1.19](README.jp) +- [한국어 (Korean, `ko`) - v1.11](README.ko) +- [Português Brasileiro (Brazilian Portuguese, `pt-BR`) - v1.19](README.pt-br) +- [Español (Spanish, `sp`) - v1.21](README.sp) +- [Turkish (Turkish, `tr`) - v1.18](README.tr) +- [简体中文 (Simplified Chinese, `zh-Hans`) - v1.22](README.zh-Hans) +- [繁體中文 (Traditional Chinese, `zh-Hant`) - v1.15](README.zh-Hant) + +### FAQ + +The [FAQ] is available in the following languages: + +[FAQ]: https://github.com/Genymobile/scrcpy/blob/master/FAQ.md + + - [Italiano (Italiano, `it`) - v1.19](FAQ.it) + - [한국어 (Korean, `ko`) - v1.11](FAQ.ko) + - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.22](FAQ.zh-Hans) diff --git a/README.de.md b/README.de.md new file mode 100644 index 0000000..1299ae0 --- /dev/null +++ b/README.de.md @@ -0,0 +1,1016 @@ +_Only the original [README](README.md) is guaranteed to be up-to-date._ + +# scrcpy (v1.22) + +scrcpy + +_ausgesprochen "**scr**een **c**o**py**"_ + +Diese Anwendung liefert sowohl Anzeige als auch Steuerung eines Android-Gerätes über USB (oder [über TCP/IP](#tcpip-kabellos)). Dabei wird kein _root_ Zugriff benötigt. +Die Anwendung funktioniert unter _GNU/Linux_, _Windows_ und _macOS_. + +![screenshot](assets/screenshot-debian-600.jpg) + +Dabei liegt der Fokus auf: + + - **Leichtigkeit**: native, nur Anzeige des Gerätedisplays + - **Leistung**: 30~120fps, abhängig vom Gerät + - **Qualität**: 1920×1080 oder mehr + - **Geringe Latenz**: [35~70ms][lowlatency] + - **Kurze Startzeit**: ~1 Sekunde um das erste Bild anzuzeigen + - **Keine Aufdringlichkeit**: Es wird keine installierte Software auf dem Gerät zurückgelassen + - **Nutzervorteile**: kein Account, keine Werbung, kein Internetzugriff notwendig + - **Freiheit**: gratis und open-source + +[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646 + +Die Features beinhalten: + - [Aufnahme](#Aufnahme) + - Spiegeln mit [ausgeschaltetem Bildschirm](#bildschirm-ausschalten) + - [Copy&Paste](#copy-paste) in beide Richtungen + - [Einstellbare Qualität](#Aufnahmekonfiguration) + - Gerätebildschirm [als Webcam (V4L2)](#v4l2loopback) (nur Linux) + - [Simulation einer physischen Tastatur (HID)](#simulation-einer-physischen-tastatur-mit-hid) + (nur Linux) + - [Simulation einer physischen Maus (HID)](#simulation-einer-physischen-maus-mit-hid) + (nur Linux) + - [OTG Modus](#otg) (nur Linux) + - und mehr… + +## Voraussetzungen + +Das Android-Gerät benötigt mindestens API 21 (Android 5.0). + +Es muss sichergestellt sein, dass [adb debugging][enable-adb] auf dem Gerät aktiv ist. + +[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling + +Auf manchen Geräten müssen zudem [weitere Optionen][control] aktiv sein um das Gerät mit Maus und Tastatur steuern zu können. + +[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323 + + +## Installation der App + +Packaging status + +### Zusammenfassung + + - Linux: `apt install scrcpy` + - Windows: [download (siehe README)](README.md#windows) + - macOS: `brew install scrcpy` + +Direkt von der Source bauen: [BUILD] ([vereinfachter Prozess (englisch)][BUILD_simple]) + +[BUILD]: BUILD.md +[BUILD_simple]: BUILD.md#simple + + +### Linux + +Auf Debian und Ubuntu: + +``` +apt install scrcpy +``` + +Auf Arch Linux: + +``` +pacman -S scrcpy +``` + +Ein [Snap] package ist verfügbar: [`scrcpy`][snap-link]. + +[snap-link]: https://snapstats.org/snaps/scrcpy + +[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager) + +Für Fedora ist ein [COPR] package verfügbar: [`scrcpy`][copr-link]. + +[COPR]: https://fedoraproject.org/wiki/Category:Copr +[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/ + + +Für Gentoo ist ein [Ebuild] verfügbar: [`scrcpy/`][ebuild-link]. + +[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild +[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy + +Die App kann zudem [manuell gebaut werden][BUILD] ([vereinfachter Prozess (englisch)][BUILD_simple]). + + +### Windows + +Für Windows ist der Einfachheit halber ein vorgebautes Archiv mit allen Abhängigkeiten (inklusive `adb`) vorhanden. + + - [README](README.md#windows) + +Es ist zudem in [Chocolatey] vorhanden: + +[Chocolatey]: https://chocolatey.org/ + +```bash +choco install scrcpy +choco install adb # falls noch nicht vorhanden +``` + +Und in [Scoop]: + +```bash +scoop install scrcpy +scoop install adb # falls noch nicht vorhanden +``` + +[Scoop]: https://scoop.sh + +Die App kann zudem [manuell gebaut werden][BUILD]. + + +### macOS + +Die Anwendung ist in [Homebrew] verfügbar. Installation: + +[Homebrew]: https://brew.sh/ + +```bash +brew install scrcpy +``` + +Es wird `adb` benötigt, auf welches über `PATH` zugegriffen werden kann. Falls noch nicht vorhanden: + +```bash +brew install android-platform-tools +``` + +Es ist außerdem in [MacPorts] vorhanden, welches adb bereits aufsetzt: + +```bash +sudo port install scrcpy +``` + +[MacPorts]: https://www.macports.org/ + + +Die Anwendung kann zudem [manuell gebaut werden][BUILD]. + + +## Ausführen + +Ein Android-Gerät anschließen und diese Befehle ausführen: + +```bash +scrcpy +``` + +Dabei werden Kommandozeilenargumente akzeptiert, aufgelistet per: + +```bash +scrcpy --help +``` + +## Funktionalitäten + +### Aufnahmekonfiguration + +#### Größe reduzieren + +Manchmal ist es sinnvoll, das Android-Gerät mit einer geringeren Auflösung zu spiegeln, um die Leistung zu erhöhen. + +Um die Höhe und Breite auf einen Wert zu limitieren (z.B. 1024): + +```bash +scrcpy --max-size 1024 +scrcpy -m 1024 # short version +``` + +Die andere Größe wird dabei so berechnet, dass das Seitenverhältnis des Gerätes erhalten bleibt. +In diesem Fall wird ein Gerät mit einer 1920×1080-Auflösung mit 1024×576 gespiegelt. + + +#### Ändern der Bit-Rate + +Die Standard-Bitrate ist 8 Mbps. Um die Bitrate zu ändern (z.B. zu 2 Mbps): + +```bash +scrcpy --bit-rate 2M +scrcpy -b 2M # Kurzversion +``` + +#### Limitieren der Bildwiederholrate + +Die Aufnahme-Bildwiederholrate kann begrenzt werden: + +```bash +scrcpy --max-fps 15 +``` + +Dies wird offiziell seit Android 10 unterstützt, kann jedoch bereits auf früheren Versionen funktionieren. + +#### Zuschneiden + +Der Geräte-Bildschirm kann zugeschnitten werden, sodass nur ein Teil gespiegelt wird. + +Dies ist beispielsweise nützlich, um nur ein Auge der Oculus Go zu spiegeln: + +```bash +scrcpy --crop 1224:1440:0:0 # 1224x1440 am Versatz (0,0) +``` + +Falls `--max-size` auch festgelegt ist, wird das Ändern der Größe nach dem Zuschneiden angewandt. + + +#### Feststellen der Videoorientierung + + +Um die Orientierung während dem Spiegeln festzustellen: + +```bash +scrcpy --lock-video-orientation # ursprüngliche (momentane) Orientierung +scrcpy --lock-video-orientation=0 # normale Orientierung +scrcpy --lock-video-orientation=1 # 90° gegen den Uhrzeigersinn +scrcpy --lock-video-orientation=2 # 180° +scrcpy --lock-video-orientation=3 # 90° mit dem Uhrzeigersinn +``` + +Dies beeinflusst die Aufnahmeausrichtung. + +Das [Fenster kann auch unabhängig rotiert](#Rotation) werden. + + +#### Encoder + +Manche Geräte besitzen mehr als einen Encoder. Manche dieser Encoder können dabei sogar zu Problemen oder Abstürzen führen. +Die Auswahl eines anderen Encoders ist möglich: + +```bash +scrcpy --encoder OMX.qcom.video.encoder.avc +``` + +Um eine Liste aller verfügbaren Encoder zu erhalten (eine Fehlermeldung gibt alle verfügbaren Encoder aus): + +```bash +scrcpy --encoder _ +``` + +### Aufnahme + +#### Aufnehmen von Videos + +Es ist möglich, das Display während des Spiegelns aufzunehmen: + +```bash +scrcpy --record file.mp4 +scrcpy -r file.mkv +``` + +Um das Spiegeln während des Aufnehmens zu deaktivieren: + +```bash +scrcpy --no-display --record file.mp4 +scrcpy -Nr file.mkv +# Unterbrechen der Aufnahme mit Strg+C +``` + +"Übersprungene Bilder" werden aufgenommen, selbst wenn sie in Echtzeit (aufgrund von Performancegründen) nicht dargestellt werden. Die Einzelbilder sind mit _Zeitstempeln_ des Gerätes versehen are, sodass eine [Paketverzögerungsvariation] nicht die Aufnahmedatei beeinträchtigt. + +[Paketverzögerungsvariation]: https://www.wikide.wiki/wiki/en/Packet_delay_variation + + +#### v4l2loopback + +Auf Linux ist es möglich, den Video-Stream zu einem v4l2 loopback Gerät zu senden, sodass das Android-Gerät von jedem v4l2-fähigen Tool wie eine Webcam verwendet werden kann. + +Das Modul `v4l2loopback` muss dazu installiert werden: + +```bash +sudo apt install v4l2loopback-dkms +``` + +Um ein v4l2 Gerät zu erzeugen: + +```bash +sudo modprobe v4l2loopback +``` + +Dies erzeugt ein neues Video-Gerät in `/dev/videoN`, wobei `N` ein Integer ist (mehr [Optionen](https://github.com/umlaeute/v4l2loopback#options) sind verfügbar um mehrere Geräte oder Geräte mit spezifischen Nummern zu erzeugen). + +Um die aktivierten Geräte aufzulisten: + +```bash +# benötigt das v4l-utils package +v4l2-ctl --list-devices + +# simpel, kann aber ausreichend +ls /dev/video* +``` + +Um scrcpy mithilfe eines v4l2 sink zu starten: + +```bash +scrcpy --v4l2-sink=/dev/videoN +scrcpy --v4l2-sink=/dev/videoN --no-display # Fenster mit Spiegelung ausschalten +scrcpy --v4l2-sink=/dev/videoN -N # kurze Version +``` + +(`N` muss mit der Geräte-ID ersetzt werden, welche mit `ls /dev/video*` überprüft werden kann) + +Einmal aktiv, kann der Stream mit einem v4l2-fähigen Tool verwendet werden: + +```bash +ffplay -i /dev/videoN +vlc v4l2:///dev/videoN # VLC kann eine gewisse Bufferverzögerung herbeiführen +``` + +Beispielsweise kann das Video mithilfe von [OBS] aufgenommen werden. + +[OBS]: https://obsproject.com/ + + +#### Buffering + +Es ist möglich, Buffering hinzuzufügen. Dies erhöht die Latenz, reduziert aber etwaigen Jitter (see [#2464]). + +[#2464]: https://github.com/Genymobile/scrcpy/issues/2464 + +Diese Option ist sowohl für Video-Buffering: + +```bash +scrcpy --display-buffer=50 # fügt 50ms Buffering zum Display hinzu +``` + +als auch V4L2 sink verfügbar: + +```bash +scrcpy --v4l2-buffer=500 # fügt 500ms Buffering für v4l2 sink hinzu +``` + + +### Verbindung + +#### TCP/IP Kabellos + +_Scrcpy_ verwendet `adb`, um mit dem Gerät zu kommunizieren. `adb` kann sich per TCP/IP mit einem Gerät [verbinden]. Das Gerät muss dabei mit demselben Netzwerk wie der Computer verbunden sein. + +##### Automatisch + +Die Option `--tcpip` erlaubt es, die Verbindung automatisch zu konfigurieren. Dabei gibt es zwei Varianten. + +Falls das Gerät (verfügbar unter 192.168.1.1 in diesem Beispiel) bereit an einem Port (typically 5555) nach einkommenden adb-Verbindungen hört, dann führe diesen Befehl aus: + +```bash +scrcpy --tcpip=192.168.1.1 # Standard-Port ist 5555 +scrcpy --tcpip=192.168.1.1:5555 +``` + +Falls adb TCP/IP auf dem Gerät deaktiviert ist (oder falls die IP-Adresse des Gerätes nicht bekannt ist): Gerät per USB verbinden, anschließend diesen Befehl ausführen: + +```bash +scrcpy --tcpip # ohne weitere Argumente +``` + +Dies finden automatisch das Gerät und aktiviert den TCP/IP-Modus. Anschließend verbindet sich der Befehl mit dem Gerät bevor die Verbindung startet. + +##### Manuell + +Alternativ kann die TCP/IP-Verbindung auch manuell per `adb` aktiviert werden: + +1. Gerät mit demselben Wi-Fi wie den Computer verbinden. +2. IP-Adresse des Gerätes herausfinden, entweder über Einstellungen → Über das Telefon → Status, oder indem dieser Befehl ausgeführt wird: + + ```bash + adb shell ip route | awk '{print $9}' + ``` + +3. Aktivieren von adb über TCP/IP auf dem Gerät: `adb tcpip 5555`. +4. Ausstecken des Geräts. +5. Verbinden zum Gerät: `adb connect DEVICE_IP:5555` _(`DEVICE_IP` ersetzen)_. +6. `scrcpy` wie normal ausführen. + +Es kann sinnvoll sein, die Bit-Rate sowie dei Auflösung zu reduzieren: + +```bash +scrcpy --bit-rate 2M --max-size 800 +scrcpy -b2M -m800 # kurze Version +``` + +[verbinden]: https://developer.android.com/studio/command-line/adb.html#wireless + + +#### Mehrere Geräte + +Falls mehrere Geräte unter `adb devices` aufgelistet werden, muss die _Seriennummer_ angegeben werden: + +```bash +scrcpy --serial 0123456789abcdef +scrcpy -s 0123456789abcdef # kurze Version +``` + +Falls das Gerät über TCP/IP verbunden ist: + +```bash +scrcpy --serial 192.168.0.1:5555 +scrcpy -s 192.168.0.1:5555 # kurze Version +``` + +Es können mehrere Instanzen von _scrcpy_ für mehrere Geräte gestartet werden. + +#### Autostart beim Verbinden eines Gerätes + +Hierfür kann [AutoAdb] verwendet werden: + +```bash +autoadb scrcpy -s '{}' +``` + +[AutoAdb]: https://github.com/rom1v/autoadb + +#### Tunnel + +Um sich zu einem entfernten Gerät zu verbinden, kann der `adb` Client mit einem remote-`adb`-Server verbunden werden (Voraussetzung: Gleiche Version des `adb`-Protokolls). + +##### Remote ADB Server + +Um sich zu einem Remote-`adb`-Server zu verbinden: Der Server muss auf allen Ports hören + +```bash +adb kill-server +adb -a nodaemon server start +# Diesen Dialog offen halten +``` + +**Warnung: Die gesamte Kommunikation zwischen adb und den Geräten ist unverschlüsselt.** + +Angenommen, der Server ist unter 192.168.1.2 verfügbar. Dann kann von einer anderen Kommandozeile scrcpy aufgeführt werden: + +```bash +export ADB_SERVER_SOCKET=tcp:192.168.1.2:5037 +scrcpy --tunnel-host=192.168.1.2 +``` + +Standardmäßig verwendet scrcpy den lokalen Port für die Einrichtung des `adb forward`-Tunnels (typischerweise `27183`, siehe `--port`). +Es ist zudem möglich, einen anderen Tunnel-Port zuzuweisen (sinnvoll in Situationen, bei welchen viele Weiterleitungen erfolgen): + +``` +scrcpy --tunnel-port=1234 +``` + + +##### SSH Tunnel + +Um mit einem Remote-`adb`-Server sicher zu kommunizieren, wird ein SSH-Tunnel empfohlen. + +Sicherstellen, dass der Remote-`adb`-Server läuft: + +```bash +adb start-server +``` + +Erzeugung eines SSH-Tunnels: + +```bash +# local 5038 --> remote 5037 +# local 27183 <-- remote 27183 +ssh -CN -L5038:localhost:5037 -R27183:localhost:27183 your_remote_computer +# Diesen Dialog geöffnet halten +``` + +Von einer anderen Kommandozeile aus scrcpy ausführen: + +```bash +export ADB_SERVER_SOCKET=tcp:localhost:5038 +scrcpy +``` + +Um das Aktivieren von Remote-Weiterleitung zu verhindern, kann eine Vorwärts-Verbindung verwendet werden (`-L` anstatt von `-R`): + +```bash +# local 5038 --> remote 5037 +# local 27183 --> remote 27183 +ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer +# Diesen Dialog geöffnet halten +``` + +Von einer anderen Kommandozeile aus scrcpy ausführen: + +```bash +export ADB_SERVER_SOCKET=tcp:localhost:5038 +scrcpy --force-adb-forward +``` + + +Wie für kabellose Verbindungen kann es sinnvoll sein, die Qualität zu reduzieren: + +``` +scrcpy -b2M -m800 --max-fps 15 +``` + +### Fensterkonfiguration + +#### Titel + +Standardmäßig ist der Fenstertitel das Gerätemodell. Der Titel kann jedoch geändert werden: + +```bash +scrcpy --window-title 'Mein Gerät' +``` + +#### Position und Größe + +Die anfängliche Fensterposition und Größe können festgelegt werden: + +```bash +scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600 +``` + +#### Rahmenlos + +Um den Rahmen des Fensters zu deaktivieren: + +```bash +scrcpy --window-borderless +``` + +#### Immer im Vordergrund + +Um das Fenster immer im Vordergrund zu halten: + +```bash +scrcpy --always-on-top +``` + +#### Vollbild + +Die Anwendung kann direkt im Vollbildmodus gestartet werden: + +```bash +scrcpy --fullscreen +scrcpy -f # kurze Version +``` + +Das Vollbild kann dynamisch mit MOD+f gewechselt werden. + +#### Rotation + +Das Fenster kann rotiert werden: + +```bash +scrcpy --rotation 1 +``` + +Mögliche Werte sind: + - `0`: keine Rotation + - `1`: 90 grad gegen den Uhrzeigersinn + - `2`: 180 grad + - `3`: 90 grad mit dem Uhrzeigersinn + +die Rotation kann zudem dynamisch mit MOD+← +_(links)_ and MOD+→ _(rechts)_ angepasst werden. + +_scrcpy_ schafft 3 verschiedene Rotationen: + - MOD+r erfordert von Gerät den Wechsel zwischen Hochformat und Querformat (die momentane App kann dies verweigern, wenn die geforderte Ausrichtung nicht unterstützt wird). + - [`--lock-video-orientation`](#feststellen-der-videoorientierung) ändert die Ausrichtung der Spiegelung (die Ausrichtung des an den Computer gesendeten Videos). Dies beeinflusst eventuelle Aufnahmen. + - `--rotation` (or MOD+←/MOD+→) rotiert nur das Fenster, eventuelle Aufnahmen sind hiervon nicht beeinflusst. + + +### Andere Spiegel-Optionen + +#### Lesezugriff + +Um die Steuerung (alles, was mit dem Gerät interagieren kann: Tasten, Mausklicks, Drag-and-drop von Dateien) zu deaktivieren: + +```bash +scrcpy --no-control +scrcpy -n +``` + +#### Anzeige + +Falls mehrere Displays vorhanden sind, kann das zu spiegelnde Display gewählt werden: + +```bash +scrcpy --display 1 +``` + +Die Liste an verfügbaren Displays kann mit diesem Befehl ausgegeben werden: + +```bash +adb shell dumpsys display # Nach "mDisplayId=" in der Ausgabe suchen +``` + +Das zweite Display kann nur gesteuert werden, wenn das Gerät Android 10 oder höher besitzt. Ansonsten wird das Display nur mit Lesezugriff gespiegelt. + + +#### Wach bleiben + +Um zu verhindern, dass das Gerät nach einer Weile in den Ruhezustand übergeht (solange es eingesteckt ist): + +```bash +scrcpy --stay-awake +scrcpy -w +``` + +Der ursprüngliche Zustand wird beim Schließen von scrcpy wiederhergestellt. + + +#### Bildschirm ausschalten + +Es ist möglich, beim Starten des Spiegelns mithilfe eines Kommandozeilenarguments den Bildschirm des Gerätes auszuschalten: + +```bash +scrcpy --turn-screen-off +scrcpy -S +``` + +Oder durch das Drücken von MOD+o jederzeit. + +Um das Display wieder einzuschalten muss MOD+Shift+o gedrückt werden. + +Auf Android aktiviert der `POWER` Knopf das Display immer. +Für den Komfort wird, wenn `POWER` via scrcpy gesendet wird (über Rechtsklick oder MOD+p), wird versucht, das Display nach einer kurzen Zeit wieder auszuschalten (falls es möglich ist). +Der physische `POWER` Button aktiviert das Display jedoch immer. + +Dies kann zudem nützlich sein, um das Gerät vom Ruhezustand abzuhalten: + +```bash +scrcpy --turn-screen-off --stay-awake +scrcpy -Sw +``` + +#### Ausschalten beim Schließen + +Um den Gerätebildschirm abzuschalten, wenn scrcpy geschlossen wird: + +```bash +scrcpy --power-off-on-close +``` + + +#### Anzeigen von Berührungen + +Für Präsentationen kann es sinnvoll sein, die physischen Berührungen anzuzeigen (auf dem physischen Gerät). + +Android stellt dieses Feature in den _Entwickleroptionen_ zur Verfügung. + +_Scrcpy_ stellt die Option zur Verfügung, dies beim Start zu aktivieren und beim Schließen auf den Ursprungszustand zurückzusetzen: + +```bash +scrcpy --show-touches +scrcpy -t +``` + +Anmerkung: Nur _physische Berührungen_ werden angezeigt (mit dem Finger auf dem Gerät). + + +#### Bildschirmschoner deaktivieren + +Standardmäßig unterbindet scrcpy nicht den Bildschirmschoner des Computers. + +Um den Bildschirmschoner zu unterbinden: + +```bash +scrcpy --disable-screensaver +``` + + +### Eingabesteuerung + +#### Geräte-Bildschirm drehen + +MOD+r drücken, um zwischen Hoch- und Querformat zu wechseln. + +Anmerkung: Dis funktioniert nur, wenn die momentan geöffnete App beide Rotationen unterstützt. + +#### Copy-paste + +Immer, wenn sich die Zwischenablage von Android ändert wird dies mit dem Computer synchronisiert. + +Jedes Strg wird an das Gerät weitergegeben. Insbesonders: + - Strg+c kopiert typischerweise + - Strg+x schneidet typischerweise aus + - Strg+v fügt typischerweise ein (nach der Computer-zu-Gerät-Synchronisation) + +Dies funktioniert typischerweise wie erwartet. + +Die wirkliche Funktionsweise hängt jedoch von der jeweiligen Anwendung ab. Beispielhaft sendet _Termux_ SIGINT bei Strg+c, und _K-9 Mail_ erzeugt eine neue Nachricht. + +Um kopieren, ausschneiden und einfügen in diesen Fällen zu verwenden (nur bei Android >= 7 unterstützt): + - MOD+c gibt `COPY` ein + - MOD+x gibt `CUT` ein + - MOD+v gibt `PASTE` ein (nach der Computer-zu-Gerät-Synchronisation) + +Zusätzlich erlaubt es MOD+Shift+v den momentanen Inhalt der Zwischenablage als eine Serie von Tastenevents einzugeben. +Dies ist nützlich, fall die Applikation kein Einfügen unterstützt (z.B. _Termux_). Jedoch kann nicht-ASCII-Inhalt dabei zerstört werden. + +**WARNUNG:** Das Einfügen der Computer-Zwischenablage in das Gerät (entweder mit Strg+v oder MOD+v) kopiert den Inhalt in die Zwischenablage des Gerätes. +Als Konsequenz kann somit jede Android-Applikation diesen Inhalt lesen. Das Einfügen von sensiblen Informationen wie Passwörtern sollte aus diesem Grund vermieden werden. + +Mache Geräte verhalten sich nicht wie erwartet, wenn die Zwischenablage per Programm verändert wird. +Die Option `--legacy-paste` wird bereitgestellt, welche das Verhalten von Strg+v und MOD+v so ändert, dass die Zwischenablage wie bei MOD+Shift+v als eine Serie von Tastenevents ausgeführt wird. + +Um die automatische Synchronisierung der Zwischenablage zu deaktivieren: +`--no-clipboard-autosync`. + +#### Ziehen zum Zoomen + +Um "Ziehen-zum-Zoomen" zu simulieren: Strg+_klicken-und-bewegen_. + +Genauer: Strg halten, während Linksklick gehalten wird. Solange Linksklick gehalten wird, skalieren und rotieren die Mausbewegungen den Inhalt (soweit von der jeweiligen App unterstützt). + +Konkret erzeugt scrcpy einen am Mittelpunkt des Displays gespiegelten, "virtuellen" Finger. + +#### Simulation einer physischen Tastatur mit HID + +Standardmäßig verwendet scrcpy Android-Tasten oder Textinjektion. Dies funktioniert zwar immer, jedoch nur mit ASCII. + +Auf Linux kann scrcpy mithilfe von HID eine physische Tastatur simulieren, um eine bessere Eingabeerfahrung zu gewährleisten (dies nutzt [USB HID over AOAv2][hid-aoav2]): Die virtuelle Tastatur wird deaktiviert, es funktioniert für alle Zeichen und mit IME. + +[hid-aoav2]: https://source.android.com/devices/accessories/aoa2#hid-support + +Dies funktioniert jedoch nur, wenn das Gerät über USB verbunden ist. Zudem wird dies momentan nur unter Linux unterstützt. + +Um diesen Modus zu aktivieren: + +```bash +scrcpy --hid-keyboard +scrcpy -K # kurze Version +``` + +Falls dies auf gewissen Gründen fehlschlägt (z.B. Gerät ist nicht über USB verbunden), so fällt scrcpy auf den Standardmodus zurück (mit einer Ausgabe in der Konsole). +Dies erlaubt es, dieselben Kommandozeilenargumente zu verwenden, egal ob das Gerät per USB oder TCP/IP verbunden ist. + +In diesem Modus werden rohe Tastenevents (scancodes) an das Gerät gesendet. +Aus diesem Grund muss ein nicht passenden Tastaturformat in den Einstellungen des Android-Gerätes unter Einstellungen → System → Sprache und Eingabe → [Physical keyboard] konfiguriert werden. + +Diese Einstellungsseite kann direkt mit diesem Befehl geöffnet werden: + +```bash +adb shell am start -a android.settings.HARD_KEYBOARD_SETTINGS +``` + +Diese Option ist jedoch nur verfügbar, wenn eine HID-Tastatur oder eine physische Tastatur verbunden sind. + +[Physical keyboard]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915 + +#### Simulation einer physischen Maus mit HID + +Ähnlich zu einer Tastatur kann auch eine Maus mithilfe von HID simuliert werden. +Wie zuvor funktioniert dies jedoch nur, wenn das Gerät über USB verbunden ist. Zudem wird dies momentan nur unter Linux unterstützt. + +Standardmäßig verwendet scrcpy Android Maus Injektionen mit absoluten Koordinaten. +Durch die Simulation einer physischen Maus erscheint auf dem Display des Geräts ein Mauszeiger, zu welchem die Bewegungen, Klicks und Scrollbewegungen relativ eingegeben werden. + +Um diesen Modus zu aktivieren: + +```bash +scrcpy --hid-mouse +scrcpy -M # kurze Version +``` + +Es kann zudem`--forward-all-clicks` übergeben werden, um [alle Mausklicks an das Gerät weiterzugeben](#rechtsklick-und-mittelklick). + +Wenn dieser Modus aktiv ist, ist der Mauszeiger des Computers auf dem Fenster gefangen (Zeiger verschwindet von Computer und erscheint auf dem Android-Gerät). + +Spezielle Tasteneingaben wie Alt oder Super ändern den Zustand des Mauszeigers (geben diesen wieder frei/fangen ihn wieder ein). +Eine dieser Tasten kann verwendet werden, um die Kontrolle der Maus wieder zurück an den Computer zu geben. + + +#### OTG + +Es ist möglich, _scrcpy_ so auszuführen, dass nur Maus und Tastatur, wie wenn diese direkt über ein OTG-Kabel verbunden wären, simuliert werden. + +In diesem Modus ist _adb_ nicht nötig, ebenso ist das Spiegeln der Anzeige deaktiviert. + +Um den OTG-Modus zu aktivieren: + +```bash +scrcpy --otg +# Seriennummer übergeben, falls mehrere Geräte vorhanden sind +scrcpy --otg -s 0123456789abcdef +``` + +Es ist möglich, nur HID-Tastatur oder HID-Maus zu aktivieren: + +```bash +scrcpy --otg --hid-keyboard # nur Tastatur +scrcpy --otg --hid-mouse # nur Maus +scrcpy --otg --hid-keyboard --hid-mouse # Tastatur und Maus +# Der Einfachheit halber sind standardmäßig beide aktiv +scrcpy --otg # Tastatur und Maus +``` + +Wie `--hid-keyboard` und `--hid-mouse` funktioniert dies nur, wenn das Gerät per USB verbunden ist. +Zudem wird dies momentan nur unter Linux unterstützt. + + +#### Textinjektions-Vorliebe + +Beim Tippen von Text werden zwei verschiedene [Events][textevents] generiert: + - _key events_, welche signalisieren, ob eine Taste gedrückt oder losgelassen wurde; + - _text events_, welche signalisieren, dass Text eingegeben wurde. + +Standardmäßig werden key events verwendet, da sich bei diesen die Tastatur in Spielen wie erwartet verhält (typischerweise für WASD). + +Dies kann jedoch [Probleme verursachen][prefertext]. Trifft man auf ein solches Problem, so kann dies mit diesem Befehl umgangen werden: + +```bash +scrcpy --prefer-text +``` + +Dies kann jedoch das Tastaturverhalten in Spielen beeinträchtigen/zerstören. + +Auf der anderen Seite kann jedoch auch die Nutzung von key events erzwungen werden: + +```bash +scrcpy --raw-key-events +``` + +Diese Optionen haben jedoch keinen Einfluss auf eine etwaige HID-Tastatur, da in diesem modus alle key events als scancodes gesendet werden. + +[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input +[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343 + + +#### Wiederholen von Tasten + +Standardmäßig löst das gedrückt halten einer Taste das jeweilige Event mehrfach aus. Dies kann jedoch zu Performanceproblemen in manchen Spielen führen. + +Um das Weitergeben von sich wiederholenden Tasteneingaben zu verhindern: + +```bash +scrcpy --no-key-repeat +``` + +This option has no effect on HID keyboard (key repeat is handled by Android +directly in this mode). + + +#### Rechtsklick und Mittelklick + +Standardmäßig löst Rechtsklick BACK (wenn Bildschirm aus: POWER) und Mittelklick BACK aus. Um diese Kürzel abzuschalten und stattdessen die Eingaben direkt an das Gerät weiterzugeben: + +```bash +scrcpy --forward-all-clicks +``` + + +### Dateien ablegen + +#### APK installieren + +Um eine AKP zu installieren, kann diese per Drag-and-drop auf das _scrcpy_-Fenster gezogen werden. + +Dabei erfolgt kein visuelles Feedback, ein Log wird in die Konsole ausgegeben. + + +#### Datei auf Gerät schieben + +Um eine Datei nach `/sdcard/Download/` auf dem Gerät zu schieben, Drag-and-drop die (nicht-APK)-Datei auf das _scrcpy_-Fenster. + +Dabei erfolgt kein visuelles Feedback, ein Log wird in die Konsole ausgegeben. + +Das Zielverzeichnis kann beim Start geändert werden: + +```bash +scrcpy --push-target=/sdcard/Movies/ +``` + + +### Audioweitergabe + +Audio wird von _scrcpy_ nicht übertragen. Hierfür kann [sndcpy] verwendet werden. + +Siehe zudem [issue #14]. + +[sndcpy]: https://github.com/rom1v/sndcpy +[issue #14]: https://github.com/Genymobile/scrcpy/issues/14 + + +## Tastenkürzel + +In der folgenden Liste ist MOD der Kürzel-Auslöser. Standardmäßig ist dies (links) Alt oder (links) Super. + +Dies kann mithilfe von `--shortcut-mod` geändert werden. Mögliche Tasten sind `lstrg`, `rstrg`, +`lalt`, `ralt`, `lsuper` und `rsuper`. Beispielhaft: + +```bash +# Nutze rStrg als Auslöser +scrcpy --shortcut-mod=rctrl + +# Nutze entweder LStrg+LAlt oder LSuper für Tastenkürzel +scrcpy --shortcut-mod=lctrl+lalt,lsuper +``` + +_[Super] ist typischerweise die Windows oder Cmd Taste._ + +[Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button) + +| Aktion | Tastenkürzel | | +|--------------------------------------------------------|-----------------------------------------------------------|:-------------------------| +| Vollbild wechseln | MOD+f | | +| Display nach links rotieren | MOD+← _(links)_ | | +| Display nach links rotieren | MOD+→ _(rechts)_ | | +| Fenstergröße 1:1 replizieren (pixel-perfect) | MOD+g | | +| Fenstergröße zum entfernen der schwarzen Balken ändern | MOD+w | _Doppel-Linksklick¹_ | +| Klick auf `HOME` | MOD+h | _Mittelklick_ | +| Klick auf `BACK` | MOD+b | _Rechtsklick²_ | +| Klick auf `APP_SWITCH` | MOD+s | _4.-Taste-Klick³_ | +| Klick auf `MENU` (Bildschirm entsperren)⁴ | MOD+m | | +| Klick auf `VOLUME_UP` | MOD+↑ _(hoch)_ | | +| CKlick auf `VOLUME_DOWN` | MOD+↓ _(runter)_ | | +| Klick auf `POWER` | MOD+p | | +| Power an | _Rechtsklick²_ | | +| Gerätebildschirm ausschalten (weiterhin spiegeln) | MOD+o | | +| Gerätebildschirm einschalten | MOD+Shift+o | | +| Gerätebildschirm drehen | MOD+r | | +| Benachrichtigungs-Bereich anzeigen | MOD+n | _5.-Taste-Klick³_ | +| Erweitertes Einstellungs-Menü anzeigen | MOD+n+n | _Doppel-5.-Taste-Klick³_ | +| Bedienfelder einklappen | MOD+Shift+n | | +| In die Zwischenablage kopieren⁵ | MOD+c | | +| In die Zwischenablage kopieren⁵ | MOD+x | | +| Zwischenablage synchronisieren und einfügen⁵ | MOD+v | | +| Computer-Zwischenablage einfügen (per Tastenevents) | MOD+Shift+v | | +| FPS-Zähler aktivieren/deaktivieren (ing stdout) | MOD+i | | +| Ziehen zum Zoomen | Strg+_Klicken-und-Bewegen_ | | +| Drag-and-drop mit APK-Datei | APK von Computer installieren | | +| Drag-and-drop mit Nicht-APK Datei | [Datei auf das Gerät schieben](#datei-auf-gerät-schieben) | | + + +_¹Doppelklick auf die schwarzen Balken, um diese zu entfernen._ +_²Rechtsklick aktiviert den Bildschirm, falls dieser aus war, ansonsten ZURÜCK._ +_³4. und 5. Maustasten, wenn diese an der jeweiligen Maus vorhanden sind._ +_⁴Für react-native Applikationen in Entwicklung, `MENU` öffnet das Entwickler-Menü._ +_⁵Nur für Android >= 7._ + +Abkürzungen mit mehreren Tastenanschlägen werden durch das Loslassen und erneute Drücken der Taste erreicht. +Beispielhaft, um "Erweitere das Einstellungs-Menü" auszuführen: + + 1. Drücke und halte MOD. + 2. Doppelklicke n. + 3. Lasse MOD los. + +Alle Strg+_Taste_ Tastenkürzel werden an das Gerät übergeben, sodass sie von der jeweiligen Applikation ausgeführt werden können. + + +## Personalisierte Pfade + +Um eine spezifische _adb_ Binary zu verwenden, muss deren Pfad als Umgebungsvariable `ADB` deklariert werden: + +```bash +ADB=/path/to/adb scrcpy +``` + +Um den Pfad der `scrcpy-server` Datei zu bearbeiten, muss deren Pfad in `SCRCPY_SERVER_PATH` bearbeitet werden. + +Um das Icon von scrcpy zu ändern, muss `SCRCPY_ICON_PATH` geändert werden. + + +## Warum _scrcpy_? + +Ein Kollege hat mich dazu herausgefordert, einen Namen so unaussprechbar wie [gnirehtet] zu finden. + +[`strcpy`] kopiert einen **str**ing; `scrcpy` kopiert einen **scr**een. + +[gnirehtet]: https://github.com/Genymobile/gnirehtet +[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html + + +## Selbst bauen? + +Siehe [BUILD]. + + +## Typische Fehler + +Siehe [FAQ](FAQ.md). + + +## Entwickler + +[Entwicklerseite](DEVELOP.md). + + +## Licence + + Copyright (C) 2018 Genymobile + Copyright (C) 2018-2022 Romain Vimont + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + +## Artikel (auf Englisch) + +- [Introducing scrcpy][article-intro] +- [Scrcpy now works wirelessly][article-tcpip] + +[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/ +[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/ diff --git a/README.id.md b/README.id.md new file mode 100644 index 0000000..1230f0c --- /dev/null +++ b/README.id.md @@ -0,0 +1,696 @@ +_Only the original [README](README.md) is guaranteed to be up-to-date._ + +# scrcpy (v1.16) + +Aplikasi ini menyediakan tampilan dan kontrol perangkat Android yang terhubung pada USB (atau [melalui TCP/IP][article-tcpip]). Ini tidak membutuhkan akses _root_ apa pun. Ini bekerja pada _GNU/Linux_, _Windows_ and _macOS_. + +![screenshot](assets/screenshot-debian-600.jpg) + +Ini berfokus pada: + + - **keringanan** (asli, hanya menampilkan layar perangkat) + - **kinerja** (30~60fps) + - **kualitas** (1920×1080 atau lebih) + - **latensi** rendah ([35~70ms][lowlatency]) + - **waktu startup rendah** (~1 detik untuk menampilkan gambar pertama) + - **tidak mengganggu** (tidak ada yang terpasang di perangkat) + + +[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646 + + +## Persyaratan +Perangkat Android membutuhkan setidaknya API 21 (Android 5.0). + +Pastikan Anda [mengaktifkan debugging adb][enable-adb] pada perangkat Anda. + +[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling + +Di beberapa perangkat, Anda juga perlu mengaktifkan [opsi tambahan][control] untuk mengontrolnya menggunakan keyboard dan mouse. + +[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323 + + +## Dapatkan aplikasinya + +### Linux + +Di Debian (_testing_ dan _sid_ untuk saat ini) dan Ubuntu (20.04): + +``` +apt install scrcpy +``` + +Paket [Snap] tersedia: [`scrcpy`][snap-link]. + +[snap-link]: https://snapstats.org/snaps/scrcpy + +[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager) + +Untuk Fedora, paket [COPR] tersedia: [`scrcpy`][copr-link]. + +[COPR]: https://fedoraproject.org/wiki/Category:Copr +[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/ + +Untuk Arch Linux, paket [AUR] tersedia: [`scrcpy`][aur-link]. + +[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository +[aur-link]: https://aur.archlinux.org/packages/scrcpy/ + +Untuk Gentoo, tersedia [Ebuild]: [`scrcpy/`][ebuild-link]. + +[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild +[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy + +Anda juga bisa [membangun aplikasi secara manual][BUILD] (jangan khawatir, tidak terlalu sulit). + + +### Windows + +Untuk Windows, untuk kesederhanaan, arsip prebuilt dengan semua dependensi (termasuk `adb`) tersedia : + + - [README](README.md#windows) + +Ini juga tersedia di [Chocolatey]: + +[Chocolatey]: https://chocolatey.org/ + +```bash +choco install scrcpy +choco install adb # jika Anda belum memilikinya +``` + +Dan di [Scoop]: + +```bash +scoop install scrcpy +scoop install adb # jika Anda belum memilikinya +``` + +[Scoop]: https://scoop.sh + +Anda juga dapat [membangun aplikasi secara manual][BUILD]. + + +### macOS + +Aplikasi ini tersedia di [Homebrew]. Instal saja: + +[Homebrew]: https://brew.sh/ + +```bash +brew install scrcpy +``` +Anda membutuhkan `adb`, dapat diakses dari `PATH` Anda. Jika Anda belum memilikinya: + +```bash +brew cask install android-platform-tools +``` + +Anda juga dapat [membangun aplikasi secara manual][BUILD]. + + +## Menjalankan + +Pasang perangkat Android, dan jalankan: + +```bash +scrcpy +``` + +Ini menerima argumen baris perintah, didaftarkan oleh: + +```bash +scrcpy --help +``` + +## Fitur + +### Menangkap konfigurasi + +#### Mengurangi ukuran + +Kadang-kadang, berguna untuk mencerminkan perangkat Android dengan definisi yang lebih rendah untuk meningkatkan kinerja. + +Untuk membatasi lebar dan tinggi ke beberapa nilai (mis. 1024): + +```bash +scrcpy --max-size 1024 +scrcpy -m 1024 # versi pendek +``` + +Dimensi lain dihitung agar rasio aspek perangkat dipertahankan. +Dengan begitu, perangkat 1920×1080 akan dicerminkan pada 1024×576. + +#### Ubah kecepatan bit + +Kecepatan bit default adalah 8 Mbps. Untuk mengubah bitrate video (mis. Menjadi 2 Mbps): + +```bash +scrcpy --bit-rate 2M +scrcpy -b 2M # versi pendek +``` + +#### Batasi frekuensi gambar + +Kecepatan bingkai pengambilan dapat dibatasi: + +```bash +scrcpy --max-fps 15 +``` + +Ini secara resmi didukung sejak Android 10, tetapi dapat berfungsi pada versi sebelumnya. + +#### Memotong + +Layar perangkat dapat dipotong untuk mencerminkan hanya sebagian dari layar. + +Ini berguna misalnya untuk mencerminkan hanya satu mata dari Oculus Go: + +```bash +scrcpy --crop 1224:1440:0:0 # 1224x1440 Mengimbangi (0,0) +``` + +Jika `--max-size` juga ditentukan, pengubahan ukuran diterapkan setelah pemotongan. + + +#### Kunci orientasi video + +Untuk mengunci orientasi pencerminan: + +```bash +scrcpy --lock-video-orientation 0 # orientasi alami +scrcpy --lock-video-orientation 1 # 90° berlawanan arah jarum jam +scrcpy --lock-video-orientation 2 # 180° +scrcpy --lock-video-orientation 3 # 90° searah jarum jam +``` + +Ini mempengaruhi orientasi perekaman. + + +### Rekaman + +Anda dapat merekam layar saat melakukan mirroring: + +```bash +scrcpy --record file.mp4 +scrcpy -r file.mkv +``` + +Untuk menonaktifkan pencerminan saat merekam: + +```bash +scrcpy --no-display --record file.mp4 +scrcpy -Nr file.mkv +# berhenti merekam dengan Ctrl+C +``` + +"Skipped frames" are recorded, even if they are not displayed in real time (for +performance reasons). Frames are _timestamped_ on the device, so [packet delay +variation] does not impact the recorded file. + +"Frame yang dilewati" direkam, meskipun tidak ditampilkan secara real time (untuk alasan performa). Bingkai *diberi stempel waktu* pada perangkat, jadi [variasi penundaan paket] tidak memengaruhi file yang direkam. + +[variasi penundaan paket]: https://en.wikipedia.org/wiki/Packet_delay_variation + + +### Koneksi + +#### Wireless + +_Scrcpy_ menggunakan `adb` untuk berkomunikasi dengan perangkat, dan `adb` dapat [terhubung] ke perangkat melalui TCP / IP: + +1. Hubungkan perangkat ke Wi-Fi yang sama dengan komputer Anda. +2. Dapatkan alamat IP perangkat Anda (dalam Pengaturan → Tentang ponsel → Status). +3. Aktifkan adb melalui TCP / IP pada perangkat Anda: `adb tcpip 5555`. +4. Cabut perangkat Anda. +5. Hubungkan ke perangkat Anda: `adb connect DEVICE_IP: 5555` (*ganti* *`DEVICE_IP`*). +6. Jalankan `scrcpy` seperti biasa. + +Mungkin berguna untuk menurunkan kecepatan bit dan definisi: + +```bash +scrcpy --bit-rate 2M --max-size 800 +scrcpy -b2M -m800 # versi pendek +``` + +[terhubung]: https://developer.android.com/studio/command-line/adb.html#wireless + + +#### Multi-perangkat + +Jika beberapa perangkat dicantumkan di `adb devices`, Anda harus menentukan _serial_: + +```bash +scrcpy --serial 0123456789abcdef +scrcpy -s 0123456789abcdef # versi pendek +``` + +If the device is connected over TCP/IP: + +```bash +scrcpy --serial 192.168.0.1:5555 +scrcpy -s 192.168.0.1:5555 # versi pendek +``` + +Anda dapat memulai beberapa contoh _scrcpy_ untuk beberapa perangkat. + +#### Mulai otomatis pada koneksi perangkat + +Anda bisa menggunakan [AutoAdb]: + +```bash +autoadb scrcpy -s '{}' +``` + +[AutoAdb]: https://github.com/rom1v/autoadb + +#### Koneksi via SSH tunnel + +Untuk menyambung ke perangkat jarak jauh, dimungkinkan untuk menghubungkan klien `adb` lokal ke server `adb` jarak jauh (asalkan mereka menggunakan versi yang sama dari _adb_ protocol): + +```bash +adb kill-server # matikan server adb lokal di 5037 +ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 komputer_jarak_jauh_anda +# jaga agar tetap terbuka +``` + +Dari terminal lain: + +```bash +scrcpy +``` + +Untuk menghindari mengaktifkan penerusan port jarak jauh, Anda dapat memaksa sambungan maju sebagai gantinya (perhatikan `-L`, bukan `-R`): + +```bash +adb kill-server # matikan server adb lokal di 5037 +ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 komputer_jarak_jauh_anda +# jaga agar tetap terbuka +``` + +Dari terminal lain: + +```bash +scrcpy --force-adb-forward +``` + +Seperti koneksi nirkabel, mungkin berguna untuk mengurangi kualitas: + +``` +scrcpy -b2M -m800 --max-fps 15 +``` + +### Konfigurasi Jendela + +#### Judul + +Secara default, judul jendela adalah model perangkat. Itu bisa diubah: + +```bash +scrcpy --window-title 'Perangkat Saya' +``` + +#### Posisi dan ukuran + +Posisi dan ukuran jendela awal dapat ditentukan: + +```bash +scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600 +``` + +#### Jendela tanpa batas + +Untuk menonaktifkan dekorasi jendela: + +```bash +scrcpy --window-borderless +``` + +#### Selalu di atas + +Untuk menjaga jendela scrcpy selalu di atas: + +```bash +scrcpy --always-on-top +``` + +#### Layar penuh + +Aplikasi dapat dimulai langsung dalam layar penuh:: + +```bash +scrcpy --fullscreen +scrcpy -f # versi pendek +``` + +Layar penuh kemudian dapat diubah secara dinamis dengan MOD+f. + +#### Rotasi + +Jendela mungkin diputar: + +```bash +scrcpy --rotation 1 +``` + +Nilai yang mungkin adalah: + - `0`: tidak ada rotasi + - `1`: 90 derajat berlawanan arah jarum jam + - `2`: 180 derajat + - `3`: 90 derajat searah jarum jam + +Rotasi juga dapat diubah secara dinamis dengan MOD+← +_(kiri)_ and MOD+→ _(kanan)_. + +Perhatikan bahwa _scrcpy_ mengelola 3 rotasi berbeda:: + - MOD+r meminta perangkat untuk beralih antara potret dan lanskap (aplikasi yang berjalan saat ini mungkin menolak, jika mendukung orientasi yang diminta). + - `--lock-video-orientation` mengubah orientasi pencerminan (orientasi video yang dikirim dari perangkat ke komputer). Ini mempengaruhi rekaman. + - `--rotation` (atau MOD+←/MOD+→) + memutar hanya konten jendela. Ini hanya mempengaruhi tampilan, bukan rekaman. + + +### Opsi pencerminan lainnya + +#### Hanya-baca + +Untuk menonaktifkan kontrol (semua yang dapat berinteraksi dengan perangkat: tombol input, peristiwa mouse, seret & lepas file): + +```bash +scrcpy --no-control +scrcpy -n +``` + +#### Layar + +Jika beberapa tampilan tersedia, Anda dapat memilih tampilan untuk cermin: + +```bash +scrcpy --display 1 +``` + +Daftar id tampilan dapat diambil dengan:: + +``` +adb shell dumpsys display # cari "mDisplayId=" di keluaran +``` + +Tampilan sekunder hanya dapat dikontrol jika perangkat menjalankan setidaknya Android 10 (jika tidak maka akan dicerminkan dalam hanya-baca). + + +#### Tetap terjaga + +Untuk mencegah perangkat tidur setelah beberapa penundaan saat perangkat dicolokkan: + +```bash +scrcpy --stay-awake +scrcpy -w +``` + +Keadaan awal dipulihkan ketika scrcpy ditutup. + + +#### Matikan layar + +Dimungkinkan untuk mematikan layar perangkat saat pencerminan mulai dengan opsi baris perintah: + +```bash +scrcpy --turn-screen-off +scrcpy -S +``` + +Atau dengan menekan MOD+o kapan saja. + +Untuk menyalakannya kembali, tekan MOD+Shift+o. + +Di Android, tombol `POWER` selalu menyalakan layar. Untuk kenyamanan, jika `POWER` dikirim melalui scrcpy (melalui klik kanan atauMOD+p), itu akan memaksa untuk mematikan layar setelah penundaan kecil (atas dasar upaya terbaik). +Tombol fisik `POWER` masih akan menyebabkan layar dihidupkan. + +Ini juga berguna untuk mencegah perangkat tidur: + +```bash +scrcpy --turn-screen-off --stay-awake +scrcpy -Sw +``` + +#### Render frame kedaluwarsa + +Secara default, untuk meminimalkan latensi, _scrcpy_ selalu menampilkan frame yang terakhir didekodekan tersedia, dan menghapus frame sebelumnya. + +Untuk memaksa rendering semua frame (dengan kemungkinan peningkatan latensi), gunakan: + +```bash +scrcpy --render-expired-frames +``` + +#### Tunjukkan sentuhan + +Untuk presentasi, mungkin berguna untuk menunjukkan sentuhan fisik (pada perangkat fisik). + +Android menyediakan fitur ini di _Opsi Pengembang_. + +_Scrcpy_ menyediakan opsi untuk mengaktifkan fitur ini saat mulai dan mengembalikan nilai awal saat keluar: + +```bash +scrcpy --show-touches +scrcpy -t +``` + +Perhatikan bahwa ini hanya menunjukkan sentuhan _fisik_ (dengan jari di perangkat). + + +#### Nonaktifkan screensaver + +Secara default, scrcpy tidak mencegah screensaver berjalan di komputer. + +Untuk menonaktifkannya: + +```bash +scrcpy --disable-screensaver +``` + + +### Kontrol masukan + +#### Putar layar perangkat + +Tekan MOD+r untuk beralih antara mode potret dan lanskap. + +Perhatikan bahwa itu berputar hanya jika aplikasi di latar depan mendukung orientasi yang diminta. + +#### Salin-tempel + +Setiap kali papan klip Android berubah, secara otomatis disinkronkan ke papan klip komputer. + +Apa saja Ctrl pintasan diteruskan ke perangkat. Khususnya: + - Ctrl+c biasanya salinan + - Ctrl+x biasanya memotong + - Ctrl+v biasanya menempel (setelah sinkronisasi papan klip komputer-ke-perangkat) + +Ini biasanya berfungsi seperti yang Anda harapkan. + +Perilaku sebenarnya tergantung pada aplikasi yang aktif. Sebagai contoh, +_Termux_ mengirim SIGINT ke Ctrl+c sebagai gantinya, dan _K-9 Mail_ membuat pesan baru. + +Untuk menyalin, memotong dan menempel dalam kasus seperti itu (tetapi hanya didukung di Android> = 7): + - MOD+c injeksi `COPY` _(salin)_ + - MOD+x injeksi `CUT` _(potong)_ + - MOD+v injeksi `PASTE` (setelah sinkronisasi papan klip komputer-ke-perangkat) + +Tambahan, MOD+Shift+v memungkinkan untuk memasukkan teks papan klip komputer sebagai urutan peristiwa penting. Ini berguna ketika komponen tidak menerima penempelan teks (misalnya di _Termux_), tetapi dapat merusak konten non-ASCII. + +**PERINGATAN:** Menempelkan papan klip komputer ke perangkat (baik melalui +Ctrl+v or MOD+v) menyalin konten ke clipboard perangkat. Akibatnya, aplikasi Android apa pun dapat membaca kontennya. Anda harus menghindari menempelkan konten sensitif (seperti kata sandi) seperti itu. + + +#### Cubit untuk memperbesar/memperkecil + +Untuk mensimulasikan "cubit-untuk-memperbesar/memperkecil": Ctrl+_klik-dan-pindah_. + +Lebih tepatnya, tahan Ctrl sambil menekan tombol klik kiri. Hingga tombol klik kiri dilepaskan, semua gerakan mouse berskala dan memutar konten (jika didukung oleh aplikasi) relatif ke tengah layar. + +Secara konkret, scrcpy menghasilkan kejadian sentuh tambahan dari "jari virtual" di lokasi yang dibalik melalui bagian tengah layar. + + +#### Preferensi injeksi teks + +Ada dua jenis [peristiwa][textevents] dihasilkan saat mengetik teks: +- _peristiwa penting_, menandakan bahwa tombol ditekan atau dilepaskan; +- _peristiwa teks_, menandakan bahwa teks telah dimasukkan. + +Secara default, huruf dimasukkan menggunakan peristiwa kunci, sehingga keyboard berperilaku seperti yang diharapkan dalam game (biasanya untuk tombol WASD). + +Tapi ini mungkin [menyebabkan masalah][prefertext]. Jika Anda mengalami masalah seperti itu, Anda dapat menghindarinya dengan: + +```bash +scrcpy --prefer-text +``` + +(tapi ini akan merusak perilaku keyboard dalam game) + +[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input +[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343 + + +#### Ulangi kunci + +Secara default, menahan tombol akan menghasilkan peristiwa kunci yang berulang. Ini dapat menyebabkan masalah kinerja di beberapa game, di mana acara ini tidak berguna. + +Untuk menghindari penerusan peristiwa penting yang berulang: + +```bash +scrcpy --no-key-repeat +``` + + +### Seret/jatuhkan file + +#### Pasang APK + +Untuk menginstal APK, seret & lepas file APK (diakhiri dengan `.apk`) ke jendela _scrcpy_. + +Tidak ada umpan balik visual, log dicetak ke konsol. + + +#### Dorong file ke perangkat + +Untuk mendorong file ke `/sdcard/` di perangkat, seret & jatuhkan file (non-APK) ke jendela _scrcpy_. + +Tidak ada umpan balik visual, log dicetak ke konsol. + +Direktori target dapat diubah saat mulai: + +```bash +scrcpy --push-target /sdcard/foo/bar/ +``` + + +### Penerusan audio + +Audio tidak diteruskan oleh _scrcpy_. Gunakan [sndcpy]. + +Lihat juga [Masalah #14]. + +[sndcpy]: https://github.com/rom1v/sndcpy +[Masalah #14]: https://github.com/Genymobile/scrcpy/issues/14 + + +## Pintasan + +Dalam daftar berikut, MOD adalah pengubah pintasan. Secara default, ini (kiri) Alt atau (kiri) Super. + +Ini dapat diubah menggunakan `--shortcut-mod`. Kunci yang memungkinkan adalah `lctrl`, `rctrl`, `lalt`, `ralt`, `lsuper` dan `rsuper`. Sebagai contoh: + +```bash +# gunakan RCtrl untuk jalan pintas +scrcpy --shortcut-mod=rctrl + +# gunakan baik LCtrl+LAlt atau LSuper untuk jalan pintas +scrcpy --shortcut-mod=lctrl+lalt,lsuper +``` + +_[Super] biasanya adalah Windows atau Cmd key._ + +[Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button) + + | Aksi | Pintasan + | ------------------------------------------------------|:----------------------------- + | Alihkan mode layar penuh | MOD+f + | Putar layar kiri | MOD+← _(kiri)_ + | Putar layar kanan | MOD+→ _(kanan)_ + | Ubah ukuran jendela menjadi 1:1 (piksel-sempurna) | MOD+g + | Ubah ukuran jendela menjadi hapus batas hitam | MOD+w \| _klik-dua-kali¹_ + | Klik `HOME` | MOD+h \| _Klik-tengah_ + | Klik `BACK` | MOD+b \| _Klik-kanan²_ + | Klik `APP_SWITCH` | MOD+s + | Klik `MENU` (buka kunci layar) | MOD+m + | Klik `VOLUME_UP` | MOD+↑ _(naik)_ + | Klik `VOLUME_DOWN` | MOD+↓ _(turun)_ + | Klik `POWER` | MOD+p + | Menyalakan | _Klik-kanan²_ + | Matikan layar perangkat (tetap mirroring) | MOD+o + | Hidupkan layar perangkat | MOD+Shift+o + | Putar layar perangkat | MOD+r + | Luaskan panel notifikasi | MOD+n + | Ciutkan panel notifikasi | MOD+Shift+n + | Menyalin ke papan klip³ | MOD+c + | Potong ke papan klip³ | MOD+x + | Sinkronkan papan klip dan tempel³ | MOD+v + | Masukkan teks papan klip komputer | MOD+Shift+v + | Mengaktifkan/menonaktifkan penghitung FPS (di stdout) | MOD+i + | Cubit-untuk-memperbesar/memperkecil | Ctrl+_klik-dan-pindah_ + +_¹Klik-dua-kali pada batas hitam untuk menghapusnya._ +_²Klik-kanan akan menghidupkan layar jika mati, tekan BACK jika tidak._ +_³Hanya di Android >= 7._ + +Semua Ctrl+_key_ pintasan diteruskan ke perangkat, demikian adanya +ditangani oleh aplikasi aktif. + + +## Jalur kustom + +Untuk menggunakan biner _adb_ tertentu, konfigurasikan jalurnya di variabel lingkungan `ADB`: + + ADB=/path/to/adb scrcpy + +Untuk mengganti jalur file `scrcpy-server`, konfigurasikan jalurnya di +`SCRCPY_SERVER_PATH`. + +[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345 + + +## Mengapa _scrcpy_? + +Seorang kolega menantang saya untuk menemukan nama yang tidak dapat diucapkan seperti [gnirehtet]. + +[`strcpy`] menyalin sebuah **str**ing; `scrcpy` menyalin sebuah **scr**een. + +[gnirehtet]: https://github.com/Genymobile/gnirehtet +[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html + + +## Bagaimana Cara membangun? + +Lihat [BUILD]. + +[BUILD]: BUILD.md + + +## Masalah umum + +Lihat [FAQ](FAQ.md). + + +## Pengembang + +Baca [halaman pengembang]. + +[halaman pengembang]: DEVELOP.md + + +## Lisensi + + Copyright (C) 2018 Genymobile + Copyright (C) 2018-2022 Romain Vimont + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + +## Artikel + +- [Introducing scrcpy][article-intro] +- [Scrcpy now works wirelessly][article-tcpip] + +[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/ +[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/ + diff --git a/README.it.md b/README.it.md new file mode 100644 index 0000000..a35c7bb --- /dev/null +++ b/README.it.md @@ -0,0 +1,1041 @@ +_Apri il [README](README.md) originale (in inglese) e sempre aggiornato._ + +scrcpy + +# scrcpy (v1.23) + +_si pronuncia "**scr**een **c**o**py**"_ + +[Leggi in altre lingue](#traduzioni) + +Questa applicazione fornisce la visualizzazione e il controllo di dispositivi Android collegati via USB (o [via TCP/IP](#tcpip-wireless)). Non richiede alcun accesso _root_. +Funziona su _GNU/Linux_, _Windows_ e _macOS_. + +![screenshot](assets/screenshot-debian-600.jpg) + +Si concentra su: + + - **leggerezza**: nativo, mostra solo lo schermo del dispositivo + - **prestazioni**: 30~120fps, in funzione del dispositivo + - **qualità**: 1920×1080 o superiore + - **bassa latenza**: [35~70ms][lowlatency] + - **tempo di avvio basso**: ~ 1secondo per visualizzare la prima immagine + - **non invadenza**: nulla rimane installato sul dispositivo + - **vantaggi per l'utente**: nessun account, nessuna pubblicità, non è richiesta alcuna connessione a internet + - **libertà**: software libero e a codice aperto (_free and open source_) + +[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646 + +Le sue caratteristiche includono: + - [registrazione](#registrazione) + - mirroring con [schermo del dispositivo spento](#spegnere-lo-schermo) + - [copia-incolla](#copia-incolla) in entrambe le direzioni + - [qualità configurabile](#configurazione-di-acquisizione) + - schermo del dispositivo [come webcam (V4L2)](#v4l2loopback) (solo per Linux) + - [simulazione della tastiera fisica (HID)](#simulazione-della-tastiera-fisica-HID) + - [simulazione mouse fisico (HID)](#simulazione-del-mouse-fisico-HID) + - [modalità OTG](#otg) + - e altro ancora... + + +## Requisiti + +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 e Ubuntu: + +``` +apt install scrcpy +``` + +Su Arch Linux: + +``` +pacman -S scrcpy +``` + +È disponibile anche un pacchetto [Snap]: [`scrcpy`][snap-link]. + +[snap-link]: https://snapstats.org/snaps/scrcpy + +[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 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, elencati 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. + +L'attuale frame rate di acquisizione può essere stampato sulla console: + +``` +scrcpy --print-fps +``` + +Può anche essere abilitato o disabilitato in qualsiasi momento con MOD+i. + +#### 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 # orientamento iniziale (corrente) +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 _ +``` + +### Cattura + +#### 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 + + +#### v4l2loopback + +Su Linux è possibile inviare il flusso video ad un dispositivo v4l2 loopback, cosicché un dispositivo Android possa essere aperto come una webcam da qualsiasi strumento compatibile con v4l2. + +Il modulo `v4l2loopback` deve essere installato: + +```bash +sudo apt install v4l2loopback-dkms +``` + +Per creare un dispositvo v4l2: + +```bash +sudo modprobe v4l2loopback +``` + +Questo creerà un nuovo dispositivo video in `/dev/videoN` dove `N` è un intero (più [opzioni](https://github.com/umlaeute/v4l2loopback#options) sono disponibili per crere più dispositivi o dispositivi con ID specifici). + +Per elencare i dispositvi attivati: + +```bash +# necessita del pacchetto v4l-utils +v4l2-ctl --list-devices + +# semplice ma potrebbe essere sufficiente +ls /dev/video* +``` + +Per avviare scrcpy utilizzando un v4l2 sink: + +```bash +scrcpy --v4l2-sink=/dev/videoN +scrcpy --v4l2-sink=/dev/videoN --no-display # disabilita la finestra di trasmissione +scrcpy --v4l2-sink=/dev/videoN -N # versione corta +``` + +(sostituisci `N` con l'ID del dispositivo, controlla con `ls /dev/video*`) + +Una volta abilitato, puoi aprire il tuo flusso video con uno strumento compatibile con v4l2: + +```bash +ffplay -i /dev/videoN +vlc v4l2:///dev/videoN # VLC potrebbe aggiungere del ritardo per il buffer +``` + +Per esempio potresti catturare il video in [OBS]. + +[OBS]: https://obsproject.com/ + + +#### Buffering + +È possibile aggiungere del buffer. Questo aumenta la latenza ma riduce il jitter (vedi [#2464]). + +[#2464]: https://github.com/Genymobile/scrcpy/issues/2464 + +L'opzione è disponibile per il buffer della visualizzazione: + +```bash +scrcpy --display-buffer=50 # aggiungi 50 ms di buffer per la visualizzazione +``` + +e per il V4L2 sink: + +```bash +scrcpy --v4l2-buffer=500 # aggiungi 500 ms di buffer per il v4l2 sink +``` + + +### Connessione + +#### TCP/IP (wireless) + +_Scrcpy_ usa `adb` per comunicare col dispositivo e `adb` può [connettersi][connect] a un dispositivo mediante TCP/IP. Il dispositivo deve essere collegato alla stessa rete del computer. + +##### Automatico + +Un'opzione `--tcpip` permette di configurare automaticamente la connessione. Ci sono due varianti. + +Se il dispositivo (accessibile a 192.168.1.1 in questo esempio) ascolta già su una porta (tipicamente 5555) per le connessioni adb in entrata, allora esegui: + +```bash +scrcpy --tcpip=192.168.1.1 # la porta predefinita è 5555 +scrcpy --tcpip=192.168.1.1:5555 +``` + +Se la modalità TCP/IP di adb è disabilitata sul dispositivo (o se non si conosce l'indirizzo IP indirizzo), collegare il dispositivo tramite USB, quindi eseguire: + +```bash +scrcpy --tcpip # senza argomenti +``` + +Il comando troverà automaticamente l'indirizzo IP del dispositivo, abiliterà la modalità TCP/IP, quindi connettersi al dispositivo prima di iniziare. + +##### Manuale + +In alternativa, è possibile abilitare la connessione TCP/IP manualmente usando `adb`: + +1. Inserisci il dispositivo in una porta USB del tuo computer. +2. Connetti il dispositivo alla stessa rete Wi-Fi del tuo computer. +3. Ottieni l'indirizzo IP del tuo dispositivo, in Impostazioni → Informazioni sul telefono → Stato, o + eseguendo questo comando: + + ```bash + adb shell ip route | awk '{print $9}' + ``` + +4. Abilita adb via TCP/IP sul tuo dispositivo: `adb tcpip 5555`. +5. Scollega il tuo dispositivo. +6. Connettiti al tuo dispositivo: `adb connect DEVICE_IP:5555` _(sostituisci `DEVICE_IP` +con l'indirizzo IP del dispositivo che hai trovato)_. +7. Esegui `scrcpy` come al solito. + +Da Android 11, una [opzione di debug wireless][adb-wireless] permette di evitare di dover collegare fisicamente il dispositivo direttamente al computer. + +[adb-wireless]: https://developer.android.com/studio/command-line/adb#connect-to-a-device-over-wi-fi-android-11+ + +Se la connessione cade casualmente, esegui il comando `scrcpy` per riconnetterti. Se il comando dice che non ci sono dispositivi/emulatori trovati, prova ad eseguire `adb connect DEVICE_IP:5555` di nuovo, e poi `scrcpy` come al solito. Se dice ancora che non ne ha trovato nessuno, prova ad eseguire `adb disconnect` e poi esegui di nuovo questi due comandi. + +Potrebbe essere utile diminuire il bit-rate e la definizione: + +```bash +scrcpy --bit-rate 2M --max-size 800 +scrcpy -b2M -m800 # versione breve +``` + +[connect]: https://developer.android.com/studio/command-line/adb.html#wireless + +#### Multi dispositivo + +Se in `adb devices` sono elencati più dispositivi, è necessario specificare il _seriale_: + +```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 +``` + +Se solo un dispositivo è collegato via USB o TCP/IP, è possibile selezionarlo automaticamente: + +```bash +# Select the only device connected via USB +scrcpy -d # like adb -d +scrcpy --select-usb # long version + +# Select the only device connected via TCP/IP +scrcpy -e # like adb -e +scrcpy --select-tcpip # long version +``` + +Puoi avviare più istanze di _scrcpy_ per diversi dispositivi. + + +#### Avvio automativo alla connessione del dispositivo + +Potresti usare [AutoAdb]: + +```bash +autoadb scrcpy -s '{}' +``` + +[AutoAdb]: https://github.com/rom1v/autoadb + +#### Tunnels + +Per connettersi a un dispositivo remoto, è possibile collegare un client `adb` locale a un server remoto `adb` (purché usino la stessa versione del protocollo _adb_). ). + +##### Server ADB remoto + +Per connettersi a un server ADB remoto, fate ascoltare il server su tutte le interfacce: + +```bash +adb kill-server +adb -a nodaemon server start +# tienilo aperto +``` + +**Attenzione: tutte le comunicazioni tra i client e il server ADB non sono criptate.** + +Supponi che questo server sia accessibile a 192.168.1.2. Poi, da un altro terminale, esegui scrcpy: + +```bash +export ADB_SERVER_SOCKET=tcp:192.168.1.2:5037 +scrcpy --tunnel-host=192.168.1.2 +``` + +Per impostazione predefinita, scrcpy utilizza la porta locale utilizzata per il tunnel `adb forward` (tipicamente `27183`, vedi `--port`). È anche possibile forzare una diversa porta del tunnel (può essere utile in situazioni più complesse, quando sono coinvolti più reindirizzamenti): + +``` +scrcpy --tunnel-port=1234 +``` + +##### SSH tunnel + +Per comunicare con un server ADB remoto in modo sicuro, è preferibile utilizzare un tunnel SSH. + +Per prima cosa, assicurati che il server ADB sia in esecuzione sul computer remoto: + +```bash +adb start-server +``` + +Poi, crea un tunnel SSH: + +```bash +# local 5038 --> remote 5037 +# local 27183 <-- remote 27183 +ssh -CN -L5038:localhost:5037 -R27183:localhost:27183 your_remote_computer +# keep this open +``` + +Da un altro terminale, esegui scrcpy: + +```bash +export ADB_SERVER_SOCKET=tcp:localhost:5038 +scrcpy +``` + +Per evitare l'abilitazione dell'apertura porte remota potresti invece forzare una "forward connection" (notare il `-L` invece di `-R`) + +```bash +# local 5038 --> remote 5037 +# local 27183 --> remote 27183 +ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer +# tieni questo aperto +``` + +Da un altro terminale, esegui scrcpy: + +```bash +export ADB_SERVER_SOCKET=tcp:localhost:5038 +scrcpy --force-adb-forward +``` + +Come per le connessioni wireless potrebbe essere utile ridurre la qualità: + +``` +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 +``` + +#### Spegnimento alla chiusura + +Per spegnere lo schermo del dispositivo quando si chiude scrcpy: + +```bash +scrcpy --power-off-on-close +``` + + +#### 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 come ci si aspetta. + +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 invia `COPY` + - MOD+x invia `CUT` + - MOD+v invia `PASTE` (dopo la sincronizzazione degli appunti da computer a dispositivo) + +In aggiunta, MOD+Shift+v permette l'invio del testo degli appunti del computer come una sequenza di eventi pressione dei tasti. Questo è utile quando il componente non accetta l'incollaggio di testo (per esempio in _Termux_), ma questo può compromettere il contenuto non ASCII. + +**AVVISO:** Incollare gli appunti del computer nel dispositivo (sia con 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 inviino il testo degli appunti del computer come una sequenza di eventi di pressione dei tasti (nella stessa maniera di MOD+Shift+v). + +Per disabilitare la sincronizzazione automatica degli appunti, usa `--no-clipboard-autosync`. + +#### 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. + +#### Simulazione della tastiera fisica (HID) + +Per impostazione predefinita, scrcpy utilizza l'invio dei tasti o del testo di Android: funziona ovunque, ma è limitato all'ASCII. + +In alternativa scrcpy può simulare una tastiera fisica USB su Android per fornire una migliore esperienza di input (utilizzando [USB HID over AOAv2][hid-aoav2]): la tastiera virtuale è disabilitata e funziona per tutti i caratteri e IME. + +[hid-aoav2]: https://source.android.com/devices/accessories/aoa2#hid-support + +Tuttavia, funziona solo se il dispositivo è collegato via USB. + +Nota: su Windows, può funzionare solo in [odalità OTG](#otg), non durante il mirroring (non è possibile aprire un dispositivo USB se è già aperto da un altro processo come il daemon adb). + +Per abilitare questa modalità: + +```bash +scrcpy --hid-keyboard +scrcpy -K # versione breve +``` + +Se fallisce per qualche motivo (per esempio perché il dispositivo non è connesso via USB), ritorna automaticamente alla modalità predefinita (con un log nella console). Questo permette di usare le stesse opzioni della linea di comando quando si è connessi via USB e TCP/IP. + +In questa modalità, gli eventi i pressione originali (scancodes) sono inviati al dispositivo, indipendentemente dalla mappatura dei tasti dell'host. Pertanto, se il layout della tua tastiera non corrisponde, deve essere configurato sul dispositivo Android, in Impostazioni → Sistema → Lingue e input → [Tastiera fisica] (in inglese). + +Questa pagina di impostazioni può essere avviata direttamente: + +```bash +adb shell am start -a android.settings.HARD_KEYBOARD_SETTINGS +``` + +Tuttavia, l'opzione è disponibile solo quando la tastiera HID è abilitata (o quando una tastiera fisica è collegata). + +[Tastiera fisica]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915 + +#### Simulazione del mouse fisico (HID) + +In modo simile alla simulazione della tastiera fisica, è possibile simulare un mouse fisico. Allo stesso modo funziona solo se il dispositivo è connesso via USB. + +Per impostazione predefinita, scrcpy utilizza l'invio degli eventi del mouse di Android, utilizzando coordinate assolute. Simulando un mouse fisico, un puntatore del mouse appare sul dispositivo Android e vengono inviati i movimenti relativi del mouse, i click e gli scorrimenti. + +Per abilitare questa modalità: + +```bash +scrcpy --hid-mouse +scrcpy -M # versione breve +``` + +Si potrebbe anche aggiungere `--forward-all-clicks` a [inoltra tutti i pulsanti del mouse][forward_all_clicks]. + +[forward_all_clicks]: #click-destro-e-click-centrale + + +Quando questa modalità è attivata, il mouse del computer viene "catturato" (il puntatore del mouse scompare dal computer e appare invece sul dispositivo Android). + +I tasti speciali di cattura, Alt o Super, commutano (disabilitano o abilitano) la cattura del mouse. Usa uno di essi per ridare il controllo del mouse al computer. + + +#### OTG + +È possibile eseguire _scrcpy_ con la sola simulazione della tastiera fisica e del mouse (HID), come se la tastiera e il mouse del computer fossero collegati direttamente al dispositivo tramite un cavo OTG. + +In questa modalità, _adb_ (debug USB) non è necessario e il mirroring è disabilitato. + +Per attivare la modallità OTG: + +```bash +scrcpy --otg +# Passa la seriale se sono disponibili diversi dispositivi USB +scrcpy --otg -s 0123456789abcdef +``` + +È possibile abilitare solo la tastiera HID o il mouse HID: + +```bash +scrcpy --otg --hid-keyboard # solo la tastiera +scrcpy --otg --hid-mouse # solo mouse +scrcpy --otg --hid-keyboard --hid-mouse # tastiera e mouse +# per comodità, abilita entrambi per default +scrcpy --otg # tastiera e mouse +``` + +Come `--hid-keyboard` e `--hid-mouse`, funziona solo se il dispositivo è collegato via USB. + + +#### Preferenze di invio del testo + +Ci sono due tipi di [eventi][textevents] generati quando si scrive testo: + - _eventi di pressione_, segnalano che tasto è stato premuto o rilasciato; + - _eventi di testo_, segnalano che del testo è stato inserito. + +In maniera predefinita le lettere sono inviate usando gli eventi di pressione, in maniera tale che la tastiera si comporti come aspettato nei giochi (come accade solitamente per i tasti WASD). + +Questo, però, può [causare problemi][prefertext]. Se incontri un problema del genere, puoi evitarlo con: + +```bash +scrcpy --prefer-text +``` + +(ma questo romperà il normale funzionamento della tastiera nei giochi) + +Al contrario, si potrebbe forzare per inviare sempre eventi di pressione grezzi: + +```bash +scrcpy --raw-key-events +``` + +Queste opzioni non hanno effetto sulla tastiera HID (tutti gli eventi di pressione sono inviati come scancodes in questa modalità). + +[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input +[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343 + + +#### Ripetizione di tasti + +In maniera predefinita, tenere premuto un tasto genera una ripetizione degli eventi di pressione di tale tasto. Questo può creare problemi di performance in alcuni giochi, dove questi eventi sono inutilizzati. + +Per prevenire l'inoltro ripetuto degli eventi di pressione: + +```bash +scrcpy --no-key-repeat +``` + +Questa opzione non ha effetto sulla tastiera HID (la ripetizione dei tasti è gestita da Android direttamente in questa modalità). + + +#### Click destro e click centrale + +In maniera predefinita, click destro aziona BACK (indietro) o POWER on (accensione) e il click centrale aziona HOME. Per disabilitare queste scorciatoie e, invece, inviare i click al dispositivo: + +```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/Download` 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/Movies/ +``` + + +### 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] è solitamente 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 sinistro¹_ + | Premi il tasto `HOME` | MOD+h \| _Click centrale_ + | Premi il tasto `BACK` | MOD+b \| _Click destro²_ + | Premi il tasto `APP_SWITCH` | MOD+s \| _4° click³_ + | 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 \| _5° click³_ + | Espandi il pannello delle impostazioni | MOD+n+n \| _Doppio 5° click³_ + | Chiudi pannelli | MOD+Shift+n + | Copia negli appunti⁵ | MOD+c + | Taglia negli appunti⁵ | MOD+x + | Sincronizza gli appunti e incolla⁵ | MOD+v + | Invia 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_ + | Trascina file APK | Installa APK dal computer + | Trascina file non-APK | [Trasferisci file verso il dispositivo](#push-file-to-device) + +_¹Doppio click sui bordi neri per rimuoverli._ +_²Il tasto destro accende lo schermo se era spento, preme BACK in caso contrario._ +_³4° e 5° pulsante del mouse, se il tuo mouse ne dispone._ +_⁴Per le app native react in sviluppo, `MENU` attiva il menu di sviluppo._ +_⁵Solo in Android >= 7._ + +Le scorciatoie con pulsanti ripetuti sono eseguite rilasciando e premendo il pulsante una seconda volta. Per esempio, per eseguire "Espandi il pannello delle impostazioni": + +1. Premi e tieni premuto MOD. +2. Poi premi due volte n. +3. Infine rilascia MOD. + +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-2022 Romain Vimont + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + +## 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/ + +## Contatti + +Se incontri un bug, per favore leggi prima le [FAQ](FAQ.it.md), poi apri una [issue]. + +[issue]: https://github.com/Genymobile/scrcpy/issues + +Per domande generali o discussioni, puoi anche usare: + + - Reddit: [`r/scrcpy`](https://www.reddit.com/r/scrcpy) + - Twitter: [`@scrcpy_app`](https://twitter.com/scrcpy_app) diff --git a/README.jp.md b/README.jp.md new file mode 100644 index 0000000..583582f --- /dev/null +++ b/README.jp.md @@ -0,0 +1,799 @@ +_Only the original [README](README.md) is guaranteed to be up-to-date._ + +# scrcpy (v1.19) + +このアプリケーションはUSB(もしくは[TCP/IP経由][article-tcpip])で接続されたAndroidデバイスの表示と制御を提供します。このアプリケーションは _root_ でのアクセスを必要としません。このアプリケーションは _GNU/Linux_ 、 _Windows_ そして _macOS_ 上で動作します。 + +![screenshot](assets/screenshot-debian-600.jpg) + +以下に焦点を当てています: + + - **軽量** (ネイティブ、デバイス画面表示のみ) + - **パフォーマンス**　(30~60fps) + - **クオリティ**　(1920x1080以上) + - **低遅延**　([35~70ms][lowlatency]) + - **短い起動時間**　(初回画像を1秒以内に表示) + - **非侵入型**　(デバイスに何もインストールされていない状態になる) + +[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646 + + +## 必要要件 + +AndroidデバイスはAPI21(Android 5.0)以上。 + +Androidデバイスで[adbデバッグが有効][enable-adb]であること。 + +[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling + +一部のAndroidデバイスでは、キーボードとマウスを使用して制御する[追加オプション][control]を有効にする必要がある。 + +[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323 + + +## アプリの取得 + +Packaging status + +### Linux + +Debian (_testing_ と _sid_) とUbuntu(20.04): + +``` +apt install scrcpy +``` + +[Snap]パッケージが利用可能: [`scrcpy`][snap-link] + +[snap-link]: https://snapstats.org/snaps/scrcpy + +[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager) + +Fedora用[COPR]パッケージが利用可能: [`scrcpy`][copr-link] + +[COPR]: https://fedoraproject.org/wiki/Category:Copr +[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/ + +Arch Linux用[AUR]パッケージが利用可能: [`scrcpy`][aur-link] + +[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository +[aur-link]: https://aur.archlinux.org/packages/scrcpy/ + +Gentoo用[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]も可能（心配しないでください、それほど難しくはありません。） + + +### Windows + +Windowsでは簡単に、（`adb`を含む）すべての依存関係を構築済みのアーカイブを利用可能です。 + + - [README](README.md#windows) + +[Chocolatey]でも利用可能です: + +[Chocolatey]: https://chocolatey.org/ + +```bash +choco install scrcpy +choco install adb # まだ入手していない場合 +``` + +[Scoop]でも利用可能です: + +```bash +scoop install scrcpy +scoop install adb # まだ入手していない場合 +``` + +[Scoop]: https://scoop.sh + +また、[アプリケーションをビルド][BUILD]することも可能です。 + +### macOS + +アプリケーションは[Homebrew]で利用可能です。ただインストールするだけです。 + +[Homebrew]: https://brew.sh/ + +```bash +brew install scrcpy +``` + +`PATH`からアクセス可能な`adb`が必要です。もし持っていない場合はインストールしてください。 + +```bash +brew install android-platform-tools +``` + +`adb`は[MacPorts]からでもインストールできます。 + +```bash +sudo port install scrcpy +``` + +[MacPorts]: https://www.macports.org/ + +また、[アプリケーションをビルド][BUILD]することも可能です。 + +## 実行 + +Androidデバイスを接続し、実行: + +```bash +scrcpy +``` + +次のコマンドでリストされるコマンドライン引数も受け付けます: + +```bash +scrcpy --help +``` + +## 機能 + +### キャプチャ構成 + +#### サイズ削減 + +Androidデバイスを低解像度でミラーリングする場合、パフォーマンス向上に便利な場合があります。 + +幅と高さをある値(例：1024)に制限するには: + +```bash +scrcpy --max-size 1024 +scrcpy -m 1024 # 短縮版 +``` + +一方のサイズはデバイスのアスペクト比が維持されるように計算されます。この方法では、1920x1080のデバイスでは1024x576にミラーリングされます。 + + +#### ビットレート変更 + +ビットレートの初期値は8Mbpsです。ビットレートを変更するには(例:2Mbpsに変更): + +```bash +scrcpy --bit-rate 2M +scrcpy -b 2M # 短縮版 +``` + +#### フレームレート制限 + +キャプチャするフレームレートを制限できます: + +```bash +scrcpy --max-fps 15 +``` + +この機能はAndroid 10からオフィシャルサポートとなっていますが、以前のバージョンでも動作する可能性があります。 + +#### トリミング + +デバイスの画面は、画面の一部のみをミラーリングするようにトリミングできます。 + +これは、例えばOculus Goの片方の目をミラーリングする場合に便利です。: + +```bash +scrcpy --crop 1224:1440:0:0 # オフセット位置(0,0)で1224x1440 +``` + +もし`--max-size`も指定されている場合、トリミング後にサイズ変更が適用されます。 + +#### ビデオの向きをロックする + +ミラーリングの向きをロックするには: + +```bash +scrcpy --lock-video-orientation # 現在の向き +scrcpy --lock-video-orientation=0 # 自然な向き +scrcpy --lock-video-orientation=1 # 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で録画を中断する +``` + +"スキップされたフレーム"は(パフォーマンス上の理由で)リアルタイムで表示されなくても録画されます。 + +フレームはデバイス上で _タイムスタンプされる_ ため [パケット遅延のバリエーション] は録画されたファイルに影響を与えません。 + +[パケット遅延のバリエーション]: https://en.wikipedia.org/wiki/Packet_delay_variation + +#### v4l2loopback + +Linuxでは、ビデオストリームをv4l2ループバックデバイスに送信することができます。 +v4l2loopbackのデバイスにビデオストリームを送信することで、Androidデバイスをウェブカメラのようにv4l2対応ツールで開くこともできます。 + +`v4l2loopback` モジュールのインストールが必要です。 + +```bash +sudo apt install v4l2loopback-dkms +``` + +v4l2デバイスを作成する。 + +```bash +sudo modprobe v4l2loopback +``` + +これにより、新しいビデオデバイスが `/dev/videoN` に作成されます。（`N` は整数） +(複数のデバイスや特定のIDのデバイスを作成するために、より多くの[オプション](https://github.com/umlaeute/v4l2loopback#options)が利用可能です。 +多くの[オプション]()が利用可能で複数のデバイスや特定のIDのデバイスを作成できます。 + + +有効なデバイスを一覧表示する: + +```bash +# v4l-utilsパッケージが必要 +v4l2-ctl --list-devices + +# シンプルですが十分これで確認できます +ls /dev/video* +``` + +v4l2シンクを使用してscrcpyを起動する。 + +```bash +scrcpy --v4l2-sink=/dev/videoN +scrcpy --v4l2-sink=/dev/videoN --no-display # ミラーリングウィンドウを無効化する +scrcpy --v4l2-sink=/dev/videoN -N # 短縮版 +``` + +(`N` をデバイス ID に置き換えて、`ls /dev/video*` で確認してください) +有効にすると、v4l2対応のツールでビデオストリームを開けます。 + +```bash +ffplay -i /dev/videoN +vlc v4l2:///dev/videoN # VLCではバッファリングの遅延が発生する場合があります +``` + +例えばですが [OBS]の中にこの映像を取り込めことができます。 + +[OBS]: https://obsproject.com/ + + +#### Buffering + +バッファリングを追加することも可能です。これによりレイテンシーは増加しますが、ジッターは減少します。（参照 +[#2464]) + +[#2464]: https://github.com/Genymobile/scrcpy/issues/2464 + +このオプションでディスプレイバッファリングを設定できます。 + +```bash +scrcpy --display-buffer=50 # ディスプレイに50msのバッファリングを追加する +``` + +V4L2の場合はこちらのオプションで設定できます。 + +```bash +scrcpy --v4l2-buffer=500 # add 500 ms buffering for v4l2 sink +``` + +### 接続 + +#### ワイヤレス + +_Scrcpy_ はデバイスとの通信に`adb`を使用します。そして`adb`はTCP/IPを介しデバイスに[接続]することができます: + +1. あなたのコンピュータと同じWi-Fiに接続します。 +2. あなたのIPアドレスを取得します。設定 → 端末情報 → ステータス情報、もしくは、このコマンドを実行します: + + ```bash + adb shell ip route | awk '{print $9}' + ``` + +3. あなたのデバイスでTCP/IPを介したadbを有効にします: `adb tcpip 5555` +4. あなたのデバイスの接続を外します。 +5. あなたのデバイスに接続します: + `adb connect DEVICE_IP:5555` _(`DEVICE_IP`は置き換える)_ +6. 通常通り`scrcpy`を実行します。 + +この方法はビットレートと解像度を減らすのにおそらく有用です: + +```bash +scrcpy --bit-rate 2M --max-size 800 +scrcpy -b2M -m800 # 短縮版 +``` + +[接続]: https://developer.android.com/studio/command-line/adb.html#wireless + + +#### マルチデバイス + +もし`adb devices`でいくつかのデバイスがリストされる場合、 _シリアルナンバー_ を指定する必要があります: + +```bash +scrcpy --serial 0123456789abcdef +scrcpy -s 0123456789abcdef # 短縮版 +``` + +デバイスがTCP/IPを介して接続されている場合: + +```bash +scrcpy --serial 192.168.0.1:5555 +scrcpy -s 192.168.0.1:5555 # 短縮版 +``` + +複数のデバイスに対して、複数の _scrcpy_ インスタンスを開始することができます。 + +#### デバイス接続での自動起動 + +[AutoAdb]を使用可能です: + +```bash +autoadb scrcpy -s '{}' +``` + +[AutoAdb]: https://github.com/rom1v/autoadb + +#### SSHトンネル + +リモートデバイスに接続するため、ローカル`adb`クライアントからリモート`adb`サーバーへ接続することが可能です(同じバージョンの _adb_ プロトコルを使用している場合): + +```bash +adb kill-server # 5037ポートのローカルadbサーバーを終了する +ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer +# オープンしたままにする +``` + +他の端末から: + +```bash +scrcpy +``` + +リモートポート転送の有効化を回避するためには、代わりに転送接続を強制することができます(`-R`の代わりに`-L`を使用することに注意): + +```bash +adb kill-server # 5037ポートのローカルadbサーバーを終了する +ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer +# オープンしたままにする +``` + +他の端末から: + +```bash +scrcpy --force-adb-forward +``` + + +ワイヤレス接続と同様に、クオリティを下げると便利な場合があります: + +``` +scrcpy -b2M -m800 --max-fps 15 +``` + +### ウィンドウ構成 + +#### タイトル + +ウィンドウのタイトルはデバイスモデルが初期値です。これは変更できます: + +```bash +scrcpy --window-title 'My device' +``` + +#### 位置とサイズ + +ウィンドウの位置とサイズの初期値を指定できます: + +```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`: 90° 反時計回り + - `2`: 180° + - `3`: 90° 時計回り + +回転は次のコマンドで動的に変更することができます。 MOD+←_(左)_ 、 MOD+→_(右)_ + +_scrcpy_ は3つの回転を管理することに注意: + - MOD+rはデバイスに縦向きと横向きの切り替えを要求する(現在実行中のアプリで要求している向きをサポートしていない場合、拒否することがある) + - [`--lock-video-orientation`](#ビデオの向きをロックする)は、ミラーリングする向きを変更する(デバイスからPCへ送信される向き)。録画に影響します。 + - `--rotation` (もしくはMOD+←/MOD+→)は、ウィンドウのコンテンツのみを回転します。これは表示にのみに影響し、録画には影響しません。 + +### 他のミラーリングオプション + +#### Read-only　リードオンリー + +制御を無効にするには(デバイスと対話する全てのもの:入力キー、マウスイベント、ファイルのドラッグ&ドロップ): + +```bash +scrcpy --no-control +scrcpy -n +``` + +#### ディスプレイ + +いくつか利用可能なディスプレイがある場合、ミラーリングするディスプレイを選択できます: + +```bash +scrcpy --display 1 +``` + +ディスプレイIDのリストは次の方法で取得できます: + +``` +adb shell dumpsys display # search "mDisplayId=" in the output +``` + +セカンダリディスプレイは、デバイスが少なくともAndroid 10の場合にコントロール可能です。(それ以外ではリードオンリーでミラーリングされます) + + +#### 起動状態にする + +デバイス接続時、少し遅れてからデバイスのスリープを防ぐには: + +```bash +scrcpy --stay-awake +scrcpy -w +``` + +scrcpyが閉じられた時、初期状態に復元されます。 + +#### 画面OFF + +コマンドラインオプションを使用することで、ミラーリングの開始時にデバイスの画面をOFFにすることができます: + +```bash +scrcpy --turn-screen-off +scrcpy -S +``` + +もしくは、MOD+oを押すことでいつでもできます。 + +元に戻すには、MOD+Shift+oを押します。 + +Androidでは、`POWER`ボタンはいつでも画面を表示します。便宜上、`POWER`がscrcpyを介して(右クリックもしくはMOD+pを介して)送信される場合、(ベストエフォートベースで)少し遅れて、強制的に画面を非表示にします。ただし、物理的な`POWER`ボタンを押した場合は、画面は表示されます。 + +このオプションはデバイスがスリープしないようにすることにも役立ちます: + +```bash +scrcpy --turn-screen-off --stay-awake +scrcpy -Sw +``` + + +#### タッチを表示 + +プレゼンテーションの場合(物理デバイス上で)物理的なタッチを表示すると便利な場合があります。 + +Androidはこの機能を _開発者オプション_ で提供します。 + +_Scrcpy_　は開始時にこの機能を有効にし、終了時に初期値を復元するオプションを提供します: + +```bash +scrcpy --show-touches +scrcpy -t +``` + +(デバイス上で指を使った) _物理的な_ タッチのみ表示されることに注意してください。 + + +#### スクリーンセーバー無効 + +初期状態では、scrcpyはコンピュータ上でスクリーンセーバーが実行される事を妨げません。 + +これを無効にするには: + +```bash +scrcpy --disable-screensaver +``` + + +### 入力制御 + +#### デバイス画面の回転 + +MOD+rを押すことで、縦向きと横向きを切り替えます。 + +フォアグラウンドのアプリケーションが要求された向きをサポートしている場合のみ回転することに注意してください。 + +#### コピー-ペースト + +Androidのクリップボードが変更される度に、コンピュータのクリップボードに自動的に同期されます。 + +Ctrlのショートカットは全てデバイスに転送されます。特に: + - Ctrl+c 通常はコピーします + - Ctrl+x 通常はカットします + - Ctrl+v 通常はペーストします(コンピュータとデバイスのクリップボードが同期された後) + +通常は期待通りに動作します。 + +しかしながら、実際の動作はアクティブなアプリケーションに依存します。例えば、_Termux_ は代わりにCtrl+cでSIGINTを送信します、そして、_K-9 Mail_ は新しいメッセージを作成します。 + +このようなケースでコピー、カットそしてペーストをするには(Android 7以上でのサポートのみですが): + - MOD+c `COPY`を挿入 + - MOD+x `CUT`を挿入 + - MOD+v `PASTE`を挿入(コンピュータとデバイスのクリップボードが同期された後) + +加えて、MOD+Shift+vはコンピュータのクリップボードテキストにキーイベントのシーケンスとして挿入することを許可します。これはコンポーネントがテキストのペーストを許可しない場合(例えば _Termux_)に有用ですが、非ASCIIコンテンツを壊す可能性があります。 + +**警告:** デバイスにコンピュータのクリップボードを(Ctrl+vまたはMOD+vを介して)ペーストすることは、デバイスのクリップボードにコンテンツをコピーします。結果としてどのAndoridアプリケーションもそのコンテンツを読み取ることができます。機密性の高いコンテンツ(例えばパスワードなど)をこの方法でペーストすることは避けてください。 + +プログラムでデバイスのクリップボードを設定した場合、一部のデバイスは期待どおりに動作しません。`--legacy-paste`オプションは、コンピュータのクリップボードテキストをキーイベントのシーケンスとして挿入するため(MOD+Shift+vと同じ方法)、Ctrl+vとMOD+vの動作の変更を提供します。 + +#### ピンチしてズームする + +"ピンチしてズームする"をシミュレートするには: Ctrl+_クリック&移動_ + +より正確にするには、左クリックボタンを押している間、Ctrlを押したままにします。左クリックボタンを離すまで、全てのマウスの動きは、(アプリでサポートされている場合)画面の中心を基準として、コンテンツを拡大縮小および回転します。 + +具体的には、scrcpyは画面の中央を反転した位置にある"バーチャルフィンガー"から追加のタッチイベントを生成します。 + + +#### テキストインジェクション環境設定 + +テキストをタイプした時に生成される2種類の[イベント][textevents]があります: + - _key events_　はキーを押したときと離したことを通知します。 + - _text events_　はテキストが入力されたことを通知します。 + +初期状態で、文字はキーイベントで挿入されるため、キーボードはゲームで期待通りに動作します(通常は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をインストールするには、(`.apk`で終わる)APKファイルを _scrcpy_ の画面にドラッグ&ドロップします。 + +見た目のフィードバックはありません。コンソールにログが出力されます。 + + +#### デバイスにファイルを送る + +デバイスの`/sdcard/Download`ディレクトリにファイルを送るには、(APKではない)ファイルを _scrcpy_ の画面にドラッグ&ドロップします。 + +見た目のフィードバックはありません。コンソールにログが出力されます。 + +転送先ディレクトリを起動時に変更することができます: + +```bash +scrcpy --push-target=/sdcard/Movies/ +``` + + +### 音声転送 + +音声は _scrcpy_ では転送されません。[sndcpy]を使用します。 + +[issue #14]も参照ください。 + +[sndcpy]: https://github.com/rom1v/sndcpy +[issue #14]: https://github.com/Genymobile/scrcpy/issues/14 + + +## ショートカット + +次のリストでは、MODでショートカット変更します。初期状態では、(left)Altまたは(left)Superです。 + +これは`--shortcut-mod`で変更することができます。可能なキーは`lctrl`、`rctrl`、`lalt`、 `ralt`、 `lsuper`そして`rsuper`です。例えば: + +```bash +# RCtrlをショートカットとして使用します +scrcpy --shortcut-mod=rctrl + +# ショートカットにLCtrl+LAltまたはLSuperのいずれかを使用します +scrcpy --shortcut-mod=lctrl+lalt,lsuper +``` + +_[Super]は通常WindowsもしくはCmdキーです。_ + +[Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button) + + | アクション | ショートカット + | ------------------------------------------- |:----------------------------- + | フルスクリーンモードへの切り替え | MOD+f + | ディスプレイを左に回転 | MOD+← _(左)_ + | ディスプレイを右に回転 | MOD+→ _(右)_ + | ウィンドウサイズを変更して1:1に変更(ピクセルパーフェクト) | MOD+g + | ウィンドウサイズを変更して黒い境界線を削除 | MOD+w \| _ダブルクリック¹_ + | `HOME`をクリック | MOD+h \| _真ん中クリック_ + | `BACK`をクリック | MOD+b \| _右クリック²_ + | `APP_SWITCH`をクリック | MOD+s \| _4クリック³_ + | `MENU` (画面のアンロック)をクリック | MOD+m + | `VOLUME_UP`をクリック | MOD+↑ _(上)_ + | `VOLUME_DOWN`をクリック | MOD+↓ _(下)_ + | `POWER`をクリック | MOD+p + | 電源オン | _右クリック²_ + | デバイス画面をオフにする(ミラーリングしたまま) | MOD+o + | デバイス画面をオンにする | MOD+Shift+o + | デバイス画面を回転する | MOD+r + | 通知パネルを展開する | MOD+n \| _5ボタンクリック³_ + | 設定パネルを展開する | MOD+n+n \| _5ダブルクリック³_ + | 通知パネルを折りたたむ | MOD+Shift+n + | クリップボードへのコピー³ | MOD+c + | クリップボードへのカット³ | MOD+x + | クリップボードの同期とペースト³ | MOD+v + | コンピュータのクリップボードテキストの挿入 | MOD+Shift+v + | FPSカウンタ有効/無効(標準入出力上) | MOD+i + | ピンチしてズームする | Ctrl+_クリック&移動_ + +_¹黒い境界線を削除するため、境界線上でダブルクリック_ +_²もしスクリーンがオフの場合、右クリックでスクリーンをオンする。それ以外の場合はBackを押します._ +_³4と5はマウスのボタンです、もしあなたのマウスにボタンがあれば使えます._ +_⁴Android 7以上のみ._ + +キーを繰り返すショートカットはキーを離して2回目を押したら実行されます。例えば「設定パネルを展開する」を実行する場合は以下のように操作する。 + + 1. MOD キーを押し、押したままにする. + 2. その後に nキーを2回押す. + 3. 最後に MODキーを離す. + +全てのCtrl+_キー_ ショートカットはデバイスに転送されます、そのためアクティブなアプリケーションによって処理されます。 + +## カスタムパス + +特定の _adb_ バイナリを使用する場合、そのパスを環境変数`ADB`で構成します: + + ADB=/path/to/adb scrcpy + +`scrcpy-server`ファイルのパスを上書きするには、`SCRCPY_SERVER_PATH`でそのパスを構成します。 + +[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345 + + +## なぜ _scrcpy_? + +同僚が私に、[gnirehtet]のように発音できない名前を見つけるように要求しました。 + +[`strcpy`]は**str**ingをコピーします。`scrcpy`は**scr**eenをコピーします。 + +[gnirehtet]: https://github.com/Genymobile/gnirehtet +[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html + + +## ビルド方法は? + +[BUILD]を参照してください。 + +[BUILD]: BUILD.md + + +## よくある質問 + +[FAQ](FAQ.md)を参照してください。 + + +## 開発者 + +[開発者のページ]を読んでください。 + +[開発者のページ]: DEVELOP.md + + +## ライセンス + + Copyright (C) 2018 Genymobile + Copyright (C) 2018-2022 Romain Vimont + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + +## 記事 + +- [Introducing scrcpy][article-intro] +- [Scrcpy now works wirelessly][article-tcpip] + +[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/ +[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/ diff --git a/README.ko.md b/README.ko.md new file mode 100644 index 0000000..a77cde4 --- /dev/null +++ b/README.ko.md @@ -0,0 +1,498 @@ +_Only the original [README](README.md) is guaranteed to be up-to-date._ + +# scrcpy (v1.11) + +This document will be updated frequently along with the original Readme file +이 문서는 원어 리드미 파일의 업데이트에 따라 종종 업데이트 될 것입니다 + + 이 어플리케이션은 UBS ( 혹은 [TCP/IP][article-tcpip] ) 로 연결된 Android 디바이스를 화면에 보여주고 관리하는 것을 제공합니다. + _GNU/Linux_, _Windows_ 와 _macOS_ 상에서 작동합니다. + (아래 설명에서 디바이스는 안드로이드 핸드폰을 의미합니다.) + +[article-tcpip]:https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/ + +![screenshot](https://github.com/Genymobile/scrcpy/blob/master/assets/screenshot-debian-600.jpg?raw=true) + +주요 기능은 다음과 같습니다. + + - **가벼움** (기본적이며 디바이스의 화면만을 보여줌) + - **뛰어난 성능** (30~60fps) + - **높은 품질** (1920×1080 이상의 해상도) + - **빠른 반응 속도** ([35~70ms][lowlatency]) + - **짧은 부팅 시간** (첫 사진을 보여주는데 최대 1초 소요됨) + - **장치 설치와는 무관함** (디바이스에 설치하지 않아도 됨) + +[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646 + + +## 요구사항 + +안드로이드 장치는 최소 API 21 (Android 5.0) 을 필요로 합니다. + +디바이스에 [adb debugging][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 + + +## 앱 설치하기 + + +### Linux (리눅스) + +리눅스 상에서는 보통 [어플을 직접 설치][BUILD] 해야합니다. 어렵지 않으므로 걱정하지 않아도 됩니다. + +[BUILD]:https://github.com/Genymobile/scrcpy/blob/master/BUILD.md + +[Snap] 패키지가 가능합니다 : [`scrcpy`][snap-link]. + +[snap-link]: https://snapstats.org/snaps/scrcpy + +[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager) + +Arch Linux에서, [AUR] 패키지가 가능합니다 : [`scrcpy`][aur-link]. + +[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository +[aur-link]: https://aur.archlinux.org/packages/scrcpy/ + +Gentoo에서 ,[Ebuild] 가 가능합니다 : [`scrcpy/`][ebuild-link]. + +[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild +[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy + + +### Windows (윈도우) + +윈도우 상에서, 간단하게 설치하기 위해 종속성이 있는 사전 구축된 아카이브가 제공됩니다 (`adb` 포함) : +해당 파일은 Readme원본 링크를 통해서 다운로드가 가능합니다. + - [README](README.md#windows) + + +[어플을 직접 설치][BUILD] 할 수도 있습니다. + + +### macOS (맥 OS) + +이 어플리케이션은 아래 사항을 따라 설치한다면 [Homebrew] 에서도 사용 가능합니다 : + +[Homebrew]: https://brew.sh/ + +```bash +brew install scrcpy +``` + +`PATH` 로부터 접근 가능한 `adb` 가 필요합니다. 아직 설치하지 않았다면 다음을 따라 설치해야 합니다 : + +```bash +brew cask install android-platform-tools +``` + +[어플을 직접 설치][BUILD] 할 수도 있습니다. + + +## 실행 + +안드로이드 디바이스를 연결하고 실행하십시오: + +```bash +scrcpy +``` + +다음과 같이 명령창 옵션 기능도 제공합니다. + +```bash +scrcpy --help +``` + +## 기능 + +### 캡쳐 환경 설정 + + +### 사이즈 재정의 + +가끔씩 성능을 향상시키기위해 안드로이드 디바이스를 낮은 해상도에서 미러링하는 것이 유용할 때도 있습니다. + +너비와 높이를 제한하기 위해 특정 값으로 지정할 수 있습니다 (e.g. 1024) : + +```bash +scrcpy --max-size 1024 +scrcpy -m 1024 # 축약 버전 +``` + +이 외의 크기도 디바이스의 가로 세로 비율이 유지된 상태에서 계산됩니다. +이러한 방식으로 디바이스 상에서 1920×1080 는 모니터 상에서1024×576로 미러링될 것 입니다. + + +### bit-rate 변경 + +기본 bit-rate 는 8 Mbps입니다. 비디오 bit-rate 를 변경하기 위해선 다음과 같이 입력하십시오 (e.g. 2 Mbps로 변경): + +```bash +scrcpy --bit-rate 2M +scrcpy -b 2M # 축약 버전 +``` + +### 프레임 비율 제한 + +안드로이드 버전 10이상의 디바이스에서는, 다음의 명령어로 캡쳐 화면의 프레임 비율을 제한할 수 있습니다: + +```bash +scrcpy --max-fps 15 +``` + + +### Crop (잘라내기) + +디바이스 화면은 화면의 일부만 미러링하기 위해 잘라질 것입니다. + +예를 들어, *Oculus Go* 의 한 쪽 눈만 미러링할 때 유용합니다 : + +```bash +scrcpy --crop 1224:1440:0:0 # 1224x1440 at offset (0,0) +scrcpy -c 1224:1440:0:0 # 축약 버전 +``` + +만약 `--max-size` 도 지정하는 경우, 잘라낸 다음에 재정의된 크기가 적용될 것입니다. + + +### 화면 녹화 + +미러링하는 동안 화면 녹화를 할 수 있습니다 : + +```bash +scrcpy --record file.mp4 +scrcpy -r file.mkv +``` + +녹화하는 동안 미러링을 멈출 수 있습니다 : + +```bash +scrcpy --no-display --record file.mp4 +scrcpy -Nr file.mkv +# Ctrl+C 로 녹화를 중단할 수 있습니다. +# 윈도우 상에서 Ctrl+C 는 정상정으로 종료되지 않을 수 있으므로, 디바이스 연결을 해제하십시오. +``` + +"skipped frames" 은 모니터 화면에 보여지지 않았지만 녹화되었습니다 ( 성능 문제로 인해 ). 프레임은 디바이스 상에서 _타임 스탬프 ( 어느 시점에 데이터가 존재했다는 사실을 증명하기 위해 특정 위치에 시각을 표시 )_ 되었으므로, [packet delay +variation] 은 녹화된 파일에 영향을 끼치지 않습니다. + +[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation + +## 연결 + +### 무선연결 + +_Scrcpy_ 장치와 정보를 주고받기 위해 `adb` 를 사용합니다. `adb` 는 TCIP/IP 를 통해 디바이스와 [연결][connect] 할 수 있습니다 : + +1. 컴퓨터와 디바이스를 동일한 Wi-Fi 에 연결합니다. +2. 디바이스의 IP address 를 확인합니다 (설정 → 내 기기 → 상태 / 혹은 인터넷에 '내 IP'검색 시 확인 가능합니다. ). +3. TCP/IP 를 통해 디바이스에서 adb 를 사용할 수 있게 합니다: `adb tcpip 5555`. +4. 디바이스 연결을 해제합니다. +5. adb 를 통해 디바이스에 연결을 합니다\: `adb connect DEVICE_IP:5555` _(`DEVICE_IP` 대신)_. +6. `scrcpy` 실행합니다. + +다음은 bit-rate 와 해상도를 줄이는데 유용합니다 : + +```bash +scrcpy --bit-rate 2M --max-size 800 +scrcpy -b2M -m800 # 축약 버전 +``` + +[connect]: https://developer.android.com/studio/command-line/adb.html#wireless + + + +### 여러 디바이스 사용 가능 + +만약에 여러 디바이스들이 `adb devices` 목록에 표시되었다면, _serial_ 을 명시해야합니다: + +```bash +scrcpy --serial 0123456789abcdef +scrcpy -s 0123456789abcdef # 축약 버전 +``` + +_scrcpy_ 로 여러 디바이스를 연결해 사용할 수 있습니다. + + +#### SSH tunnel + +떨어져 있는 디바이스와 연결하기 위해서는, 로컬 `adb` client와 떨어져 있는 `adb` 서버를 연결해야 합니다. (디바이스와 클라이언트가 동일한 버전의 _adb_ protocol을 사용할 경우에 제공됩니다.): + +```bash +adb kill-server # 5037의 로컬 local adb server를 중단 +ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer +# 실행 유지 +``` + +다른 터미널에서는 : + +```bash +scrcpy +``` + +무선 연결과 동일하게, 화질을 줄이는 것이 나을 수 있습니다: + +``` +scrcpy -b2M -m800 --max-fps 15 +``` + +## Window에서의 배치 + +### 맞춤형 window 제목 + +기본적으로, window의 이름은 디바이스의 모델명 입니다. +다음의 명령어를 통해 변경하세요. + +```bash +scrcpy --window-title 'My device' +``` + + +### 배치와 크기 + +초기 window창의 배치와 크기는 다음과 같이 설정할 수 있습니다: + +```bash +scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600 +``` + + +### 경계 없애기 + +윈도우 장식(경계선 등)을 다음과 같이 제거할 수 있습니다: + +```bash +scrcpy --window-borderless +``` + +### 항상 모든 윈도우 위에 실행창 고정 + +이 어플리케이션의 윈도우 창은 다음의 명령어로 다른 window 위에 디스플레이 할 수 있습니다: + +```bash +scrcpy --always-on-top +scrcpy -T # 축약 버전 +``` + +### 전체 화면 + +이 어플리케이션은 전체화면으로 바로 시작할 수 있습니다. + +```bash +scrcpy --fullscreen +scrcpy -f # short version +``` + +전체 화면은 `Ctrl`+`f`키로 끄거나 켤 수 있습니다. + + +## 다른 미러링 옵션 + +### 읽기 전용(Read-only) + +권한을 제한하기 위해서는 (디바이스와 관련된 모든 것: 입력 키, 마우스 이벤트 , 파일의 드래그 앤 드랍(drag&drop)): + +```bash +scrcpy --no-control +scrcpy -n +``` + +### 화면 끄기 + +미러링을 실행하는 와중에 디바이스의 화면을 끌 수 있게 하기 위해서는 +다음의 커맨드 라인 옵션을(command line option) 입력하세요: + +```bash +scrcpy --turn-screen-off +scrcpy -S +``` + +혹은 `Ctrl`+`o`을 눌러 언제든지 디바이스의 화면을 끌 수 있습니다. + +다시 화면을 켜기 위해서는`POWER` (혹은 `Ctrl`+`p`)를 누르세요. + + +### 유효기간이 지난 프레임 제공 (Render expired frames) + +디폴트로, 대기시간을 최소화하기 위해 _scrcpy_ 는 항상 마지막으로 디코딩된 프레임을 제공합니다 +과거의 프레임은 하나씩 삭제합니다. + +모든 프레임을 강제로 렌더링하기 위해서는 (대기 시간이 증가될 수 있습니다) +다음의 명령어를 사용하세요: + +```bash +scrcpy --render-expired-frames +``` + + +### 화면에 터치 나타내기 + +발표를 할 때, 물리적인 기기에 한 물리적 터치를 나타내는 것이 유용할 수 있습니다. + +안드로이드 운영체제는 이런 기능을 _Developers options_에서 제공합니다. + +_Scrcpy_ 는 이런 기능을 시작할 때와 종료할 때 옵션으로 제공합니다. + +```bash +scrcpy --show-touches +scrcpy -t +``` + +화면에 _물리적인 터치만_ 나타나는 것에 유의하세요 (손가락을 디바이스에 대는 행위). + + +### 입력 제어 + +#### 복사-붙여넣기 + +컴퓨터와 디바이스 양방향으로 클립보드를 복사하는 것이 가능합니다: + + - `Ctrl`+`c` 디바이스의 클립보드를 컴퓨터로 복사합니다; + - `Ctrl`+`Shift`+`v` 컴퓨터의 클립보드를 디바이스로 복사합니다; + - `Ctrl`+`v` 컴퓨터의 클립보드를 text event 로써 _붙여넣습니다_ ( 그러나, ASCII 코드가 아닌 경우 실행되지 않습니다 ) + +#### 텍스트 삽입 우선 순위 + +텍스트를 입력할 때 생성되는 두 가지의 [events][textevents] 가 있습니다: + - _key events_, 키가 눌려있는 지에 대한 신호; + - _text events_, 텍스트가 입력되었는지에 대한 신호. + +기본적으로, 글자들은 key event 를 이용해 입력되기 때문에, 키보드는 게임에서처럼 처리합니다 ( 보통 WASD 키에 대해서 ). + +그러나 이는 [issues 를 발생][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 + + +### 파일 드랍 + +### APK 실행하기 + +APK를 실행하기 위해서는, APK file(파일명이`.apk`로 끝나는 파일)을 드래그하고 _scrcpy_ window에 드랍하세요 (drag and drop) + +시각적인 피드백은 없고,log 하나가 콘솔에 출력될 것입니다. + +### 디바이스에 파일 push하기 + +디바이스의`/sdcard/`에 파일을 push하기 위해서는, +APK파일이 아닌 파일을_scrcpy_ window에 드래그하고 드랍하세요.(drag and drop). + +시각적인 피드백은 없고,log 하나가 콘솔에 출력될 것입니다. + +해당 디렉토리는 시작할 때 변경이 가능합니다: + +```bash +scrcpy --push-target /sdcard/foo/bar/ +``` + +### 오디오의 전달 + +_scrcpy_는 오디오를 직접 전달해주지 않습니다. [USBaudio] (Linux-only)를 사용하세요. + +추가적으로 [issue #14]를 참고하세요. + +[USBaudio]: https://github.com/rom1v/usbaudio +[issue #14]: https://github.com/Genymobile/scrcpy/issues/14 + +## 단축키 + + | 실행내용 | 단축키 | 단축키 (macOS) + | -------------------------------------- |:----------------------------- |:----------------------------- + | 전체화면 모드로 전환 | `Ctrl`+`f` | `Cmd`+`f` + | window를 1:1비율로 전환하기(픽셀 맞춤) | `Ctrl`+`g` | `Cmd`+`g` + | 검은 공백 제거 위한 window 크기 조정 | `Ctrl`+`x` \| _Double-click¹_ | `Cmd`+`x` \| _Double-click¹_ + |`HOME` 클릭 | `Ctrl`+`h` \| _Middle-click_ | `Ctrl`+`h` \| _Middle-click_ + | `BACK` 클릭 | `Ctrl`+`b` \| _Right-click²_ | `Cmd`+`b` \| _Right-click²_ + | `APP_SWITCH` 클릭 | `Ctrl`+`s` | `Cmd`+`s` + | `MENU` 클릭 | `Ctrl`+`m` | `Ctrl`+`m` + | `VOLUME_UP` 클릭 | `Ctrl`+`↑` _(up)_ | `Cmd`+`↑` _(up)_ + | `VOLUME_DOWN` 클릭 | `Ctrl`+`↓` _(down)_ | `Cmd`+`↓` _(down)_ + | `POWER` 클릭 | `Ctrl`+`p` | `Cmd`+`p` + | 전원 켜기 | _Right-click²_ | _Right-click²_ + | 미러링 중 디바이스 화면 끄기 | `Ctrl`+`o` | `Cmd`+`o` + | 알림 패널 늘리기 | `Ctrl`+`n` | `Cmd`+`n` + | 알림 패널 닫기 | `Ctrl`+`Shift`+`n` | `Cmd`+`Shift`+`n` + | 디바이스의 clipboard 컴퓨터로 복사하기 | `Ctrl`+`c` | `Cmd`+`c` + | 컴퓨터의 clipboard 디바이스에 붙여넣기 | `Ctrl`+`v` | `Cmd`+`v` + | Copy computer clipboard to device | `Ctrl`+`Shift`+`v` | `Cmd`+`Shift`+`v` + | Enable/disable FPS counter (on stdout) | `Ctrl`+`i` | `Cmd`+`i` + +_¹검은 공백을 제거하기 위해서는 그 부분을 더블 클릭하세요_ +_²화면이 꺼진 상태에서 우클릭 시 다시 켜지며, 그 외의 상태에서는 뒤로 돌아갑니다. + +## 맞춤 경로 (custom path) + +특정한 _adb_ binary를 사용하기 위해서는, 그것의 경로를 환경변수로 설정하세요. +`ADB`: + + ADB=/path/to/adb scrcpy + +`scrcpy-server.jar`파일의 경로에 오버라이드 하기 위해서는, 그것의 경로를 `SCRCPY_SERVER_PATH`에 저장하세요. + +[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345 + + +## _scrcpy_ 인 이유? + +한 동료가 [gnirehtet]와 같이 발음하기 어려운 이름을 찾을 수 있는지 도발했습니다. + +[`strcpy`] 는 **str**ing을 copy하고; `scrcpy`는 **scr**een을 copy합니다. + +[gnirehtet]: https://github.com/Genymobile/gnirehtet +[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html + + + +## 빌드하는 방법? + +[BUILD]을 참고하세요. + +[BUILD]: BUILD.md + +## 흔한 issue + +[FAQ](FAQ.md)을 참고하세요. + + +## 개발자들 + +[developers page]를 참고하세요. + +[developers page]: DEVELOP.md + + +## 라이선스 + + Copyright (C) 2018 Genymobile + Copyright (C) 2018-2022 Romain Vimont + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + +## 관련 글 (articles) + +- [scrcpy 소개][article-intro] +- [무선으로 연결하는 Scrcpy][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.pt-br.md b/README.pt-br.md new file mode 100644 index 0000000..cc7e5f0 --- /dev/null +++ b/README.pt-br.md @@ -0,0 +1,880 @@ +_Apenas o [README](README.md) original é garantido estar atualizado._ + +# scrcpy (v1.19) + +Esta aplicação fornece exibição e controle de dispositivos Android conectados via +USB (ou [via TCP/IP][article-tcpip]). Não requer nenhum acesso _root_. +Funciona em _GNU/Linux_, _Windows_ e _macOS_. + +![screenshot](assets/screenshot-debian-600.jpg) + +Foco em: + + - **leveza** (nativo, mostra apenas a tela do dispositivo) + - **performance** (30~60fps) + - **qualidade** (1920×1080 ou acima) + - **baixa latência** ([35~70ms][lowlatency]) + - **baixo tempo de inicialização** (~1 segundo para mostrar a primeira imagem) + - **não intrusivo** (nada é deixado instalado no dispositivo) + +[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646 + + +## Requisitos + +O dispositivo Android requer pelo menos a API 21 (Android 5.0). + +Tenha certeza de ter [ativado a depuração adb][enable-adb] no(s) seu(s) dispositivo(s). + +[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling + +Em alguns dispositivos, você também precisa ativar [uma opção adicional][control] para +controlá-lo usando teclado e mouse. + +[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323 + + +## Obter o app + +Packaging status + +### Sumário + + - Linux: `apt install scrcpy` + - Windows: [baixar][direct-win64] + - macOS: `brew install scrcpy` + + Compilar pelos arquivos fontes: [BUILD] ([processo simplificado][BUILD_simple]) + +[BUILD]: BUILD.md +[BUILD_simple]: BUILD.md#simple + + +### Linux + +No Debian (_testing_ e _sid_ por enquanto) e Ubuntu (20.04): + +``` +apt install scrcpy +``` + +Um pacote [Snap] está disponível: [`scrcpy`][snap-link]. + +[snap-link]: https://snapstats.org/snaps/scrcpy + +[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager) + +Para Fedora, um pacote [COPR] está disponível: [`scrcpy`][copr-link]. + +[COPR]: https://fedoraproject.org/wiki/Category:Copr +[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/ + +Para Arch Linux, um pacote [AUR] está disponível: [`scrcpy`][aur-link]. + +[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository +[aur-link]: https://aur.archlinux.org/packages/scrcpy/ + +Para Gentoo, uma [Ebuild] está disponível: [`scrcpy/`][ebuild-link]. + +[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild +[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy + +Você também pode [compilar o app manualmente][BUILD] ([processo simplificado][BUILD_simple]). + + +### Windows + +Para Windows, por simplicidade, um arquivo pré-compilado com todas as dependências +(incluindo `adb`) está disponível: + + - [README](README.md#windows) + +Também está disponível em [Chocolatey]: + +[Chocolatey]: https://chocolatey.org/ + +```bash +choco install scrcpy +choco install adb # se você ainda não o tem +``` + +E no [Scoop]: + +```bash +scoop install scrcpy +scoop install adb # se você ainda não o tem +``` + +[Scoop]: https://scoop.sh + +Você também pode [compilar o app manualmente][BUILD]. + + +### macOS + +A aplicação está disponível em [Homebrew]. Apenas instale-a: + +[Homebrew]: https://brew.sh/ + +```bash +brew install scrcpy +``` + +Você precisa do `adb`, acessível pelo seu `PATH`. Se você ainda não o tem: + +```bash +brew install android-platform-tools +``` + +Está também disponivel em [MacPorts], que prepara o adb para você: + +```bash +sudo port install scrcpy +``` + +[MacPorts]: https://www.macports.org/ + + +Você também pode [compilar o app manualmente][BUILD]. + + +## Executar + +Conecte um dispositivo Android e execute: + +```bash +scrcpy +``` + +Também aceita argumentos de linha de comando, listados por: + +```bash +scrcpy --help +``` + +## Funcionalidades + +### Configuração de captura + +#### Reduzir tamanho + +Algumas vezes, é útil espelhar um dispositivo Android em uma resolução menor para +aumentar a performance. + +Para limitar ambos (largura e altura) para algum valor (ex: 1024): + +```bash +scrcpy --max-size 1024 +scrcpy -m 1024 # versão curta +``` + +A outra dimensão é calculada para que a proporção do dispositivo seja preservada. +Dessa forma, um dispositivo de 1920x1080 será espelhado em 1024x576. + + +#### Mudar bit-rate + +O bit-rate padrão é 8 Mbps. Para mudar o bit-rate do vídeo (ex: para 2 Mbps): + +```bash +scrcpy --bit-rate 2M +scrcpy -b 2M # versão curta +``` + +#### Limitar frame rate + +O frame rate de captura pode ser limitado: + +```bash +scrcpy --max-fps 15 +``` + +Isso é oficialmente suportado desde o Android 10, mas pode funcionar em versões anteriores. + +#### Cortar + +A tela do dispositivo pode ser cortada para espelhar apenas uma parte da tela. + +Isso é útil por exemplo, para espelhar apenas um olho do Oculus Go: + +```bash +scrcpy --crop 1224:1440:0:0 # 1224x1440 no deslocamento (0,0) +``` + +Se `--max-size` também for especificado, o redimensionamento é aplicado após o corte. + + +#### Travar orientação do vídeo + + +Para travar a orientação do espelhamento: + +```bash +scrcpy --lock-video-orientation # orientação inicial (Atual) +scrcpy --lock-video-orientation=0 # orientação natural +scrcpy --lock-video-orientation=1 # 90° sentido anti-horário +scrcpy --lock-video-orientation=2 # 180° +scrcpy --lock-video-orientation=3 # 90° sentido horário +``` + +Isso afeta a orientação de gravação. + +A [janela também pode ser rotacionada](#rotação) independentemente. + + +#### Encoder + +Alguns dispositivos têm mais de um encoder, e alguns deles podem causar problemas ou +travar. É possível selecionar um encoder diferente: + +```bash +scrcpy --encoder OMX.qcom.video.encoder.avc +``` + +Para listar os encoders disponíveis, você pode passar um nome de encoder inválido, o +erro dará os encoders disponíveis: + +```bash +scrcpy --encoder _ +``` + +### Captura + +#### Gravando + +É possível gravar a tela enquanto ocorre o espelhamento: + +```bash +scrcpy --record file.mp4 +scrcpy -r file.mkv +``` + +Para desativar o espelhamento durante a gravação: + +```bash +scrcpy --no-display --record file.mp4 +scrcpy -Nr file.mkv +# interrompa a gravação com Ctrl+C +``` + +"Frames pulados" são gravados, mesmo que não sejam exibidos em tempo real (por +motivos de performance). Frames têm seu _horário carimbado_ no dispositivo, então [variação de atraso nos +pacotes][packet delay variation] não impacta o arquivo gravado. + +[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation + + +#### v4l2loopback + +Em Linux, é possível enviar a transmissão do video para um disposiivo v4l2 loopback, assim +o dispositivo Android pode ser aberto como uma webcam por qualquer ferramneta capaz de v4l2 + +The module `v4l2loopback` must be installed: + +```bash +sudo apt install v4l2loopback-dkms +``` + +Para criar um dispositivo v4l2: + +```bash +sudo modprobe v4l2loopback +``` + +Isso criara um novo dispositivo de vídeo em `/dev/videoN`, onde `N` é uma integer +(mais [opções](https://github.com/umlaeute/v4l2loopback#options) estão disponiveis +para criar varios dispositivos ou dispositivos com IDs específicas). + +Para listar os dispositivos disponíveis: + +```bash +# requer o pacote v4l-utils +v4l2-ctl --list-devices + +# simples, mas pode ser suficiente +ls /dev/video* +``` + +Para iniciar o scrcpy usando o coletor v4l2 (sink): + +```bash +scrcpy --v4l2-sink=/dev/videoN +scrcpy --v4l2-sink=/dev/videoN --no-display # desativa a janela espelhada +scrcpy --v4l2-sink=/dev/videoN -N # versão curta +``` + +(troque `N` pelo ID do dipositivo, verifique com `ls /dev/video*`) + +Uma vez ativado, você pode abrir suas trasmissões de videos com uma ferramenta capaz de v4l2: + +```bash +ffplay -i /dev/videoN +vlc v4l2:///dev/videoN # VLC pode adicionar um pouco de atraso de buffering +``` + +Por exemplo, você pode capturar o video dentro do [OBS]. + +[OBS]: https://obsproject.com/ + + +#### Buffering + +É possivel adicionar buffering. Isso aumenta a latência, mas reduz a tenção (jitter) (veja +[#2464]). + +[#2464]: https://github.com/Genymobile/scrcpy/issues/2464 + +A opção éta disponivel para buffering de exibição: + +```bash +scrcpy --display-buffer=50 # adiciona 50 ms de buffering para a exibição +``` + +e coletor V4L2: + +```bash +scrcpy --v4l2-buffer=500 # adiciona 500 ms de buffering para coletor V4L2 +``` + +, +### Conexão + +#### Sem fio + +_Scrcpy_ usa `adb` para se comunicar com o dispositivo, e `adb` pode [conectar-se][connect] a um +dispositivo via TCP/IP: + +1. Conecte o dispositivo no mesmo Wi-Fi do seu computador. +2. Pegue o endereço IP do seu dispositivo, em Configurações → Sobre o telefone → Status, ou + executando este comando: + + ```bash + adb shell ip route | awk '{print $9}' + ``` + +3. Ative o adb via TCP/IP no seu dispositivo: `adb tcpip 5555`. +4. Desconecte seu dispositivo. +5. Conecte-se ao seu dispositivo: `adb connect DEVICE_IP:5555` _(substitua `DEVICE_IP`)_. +6. Execute `scrcpy` como de costume. + +Pode ser útil diminuir o bit-rate e a resolução: + +```bash +scrcpy --bit-rate 2M --max-size 800 +scrcpy -b2M -m800 # versão curta +``` + +[connect]: https://developer.android.com/studio/command-line/adb.html#wireless + + +#### Múltiplos dispositivos + +Se vários dispositivos são listados em `adb devices`, você deve especificar o _serial_: + +```bash +scrcpy --serial 0123456789abcdef +scrcpy -s 0123456789abcdef # versão curta +``` + +Se o dispositivo está conectado via TCP/IP: + +```bash +scrcpy --serial 192.168.0.1:5555 +scrcpy -s 192.168.0.1:5555 # versão curta +``` + +Você pode iniciar várias instâncias do _scrcpy_ para vários dispositivos. + +#### Iniciar automaticamente quando dispositivo é conectado + +Você pode usar [AutoAdb]: + +```bash +autoadb scrcpy -s '{}' +``` + +[AutoAdb]: https://github.com/rom1v/autoadb + +#### Túnel SSH + +Para conectar-se a um dispositivo remoto, é possível conectar um cliente `adb` local a +um servidor `adb` remoto (contanto que eles usem a mesma versão do protocolo +_adb_): + +```bash +adb kill-server # encerra o servidor adb local em 5037 +ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer +# mantenha isso aberto +``` + +De outro terminal: + +```bash +scrcpy +``` + +Para evitar ativar o encaminhamento de porta remota, você pode forçar uma conexão +de encaminhamento (note o `-L` em vez de `-R`): + +```bash +adb kill-server # encerra o servidor adb local em 5037 +ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer +# mantenha isso aberto +``` + +De outro terminal: + +```bash +scrcpy --force-adb-forward +``` + + +Igual a conexões sem fio, pode ser útil reduzir a qualidade: + +``` +scrcpy -b2M -m800 --max-fps 15 +``` + +### Configuração de janela + +#### Título + +Por padrão, o título da janela é o modelo do dispositivo. Isso pode ser mudado: + +```bash +scrcpy --window-title 'Meu dispositivo' +``` + +#### Posição e tamanho + +A posição e tamanho iniciais da janela podem ser especificados: + +```bash +scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600 +``` + +#### Sem bordas + +Para desativar decorações de janela: + +```bash +scrcpy --window-borderless +``` + +#### Sempre no topo + +Para manter a janela do scrcpy sempre no topo: + +```bash +scrcpy --always-on-top +``` + +#### Tela cheia + +A aplicação pode ser iniciada diretamente em tela cheia: + +```bash +scrcpy --fullscreen +scrcpy -f # versão curta +``` + +Tela cheia pode ser alternada dinamicamente com MOD+f. + +#### Rotação + +A janela pode ser rotacionada: + +```bash +scrcpy --rotation 1 +``` + +Valores possíveis são: + - `0`: sem rotação + - `1`: 90 graus sentido anti-horário + - `2`: 180 graus + - `3`: 90 graus sentido horário + +A rotação também pode ser mudada dinamicamente com MOD+← +_(esquerda)_ e MOD+→ _(direita)_. + +Note que _scrcpy_ controla 3 rotações diferentes: + - MOD+r requisita ao dispositivo para mudar entre retrato + e paisagem (a aplicação em execução pode se recusar, se ela não suporta a + orientação requisitada). + - [`--lock-video-orientation`](#travar-orientação-do-vídeo) muda a orientação de + espelhamento (a orientação do vídeo enviado pelo dispositivo para o + computador). Isso afeta a gravação. + - `--rotation` (ou MOD+←/MOD+→) + rotaciona apenas o conteúdo da janela. Isso afeta apenas a exibição, não a + gravação. + + +### Outras opções de espelhamento + +#### Apenas leitura + +Para desativar controles (tudo que possa interagir com o dispositivo: teclas de entrada, +eventos de mouse, arrastar e soltar arquivos): + +```bash +scrcpy --no-control +scrcpy -n +``` + +#### Display + +Se vários displays estão disponíveis, é possível selecionar o display para +espelhar: + +```bash +scrcpy --display 1 +``` + +A lista de IDs dos displays pode ser obtida por: + +``` +adb shell dumpsys display # busca "mDisplayId=" na saída +``` + +O display secundário pode apenas ser controlado se o dispositivo roda pelo menos Android +10 (caso contrário é espelhado como apenas leitura). + + +#### Permanecer ativo + +Para evitar que o dispositivo seja suspenso após um delay quando o dispositivo é conectado: + +```bash +scrcpy --stay-awake +scrcpy -w +``` + +O estado inicial é restaurado quando o scrcpy é fechado. + + +#### Desligar tela + +É possível desligar a tela do dispositivo durante o início do espelhamento com uma +opção de linha de comando: + +```bash +scrcpy --turn-screen-off +scrcpy -S +``` + +Ou apertando MOD+o a qualquer momento. + +Para ligar novamente, pressione MOD+Shift+o. + +No Android, o botão de `POWER` sempre liga a tela. Por conveniência, se +`POWER` é enviado via scrcpy (via clique-direito ou MOD+p), ele +forçará a desligar a tela após um delay pequeno (numa base de melhor esforço). +O botão `POWER` físico ainda causará a tela ser ligada. + +Também pode ser útil evitar que o dispositivo seja suspenso: + +```bash +scrcpy --turn-screen-off --stay-awake +scrcpy -Sw +``` + + +#### Mostrar toques + +Para apresentações, pode ser útil mostrar toques físicos (no dispositivo +físico). + +Android fornece esta funcionalidade nas _Opções do desenvolvedor_. + +_Scrcpy_ fornece esta opção de ativar esta funcionalidade no início e restaurar o +valor inicial no encerramento: + +```bash +scrcpy --show-touches +scrcpy -t +``` + +Note que isto mostra apenas toques _físicos_ (com o dedo no dispositivo). + + +#### Desativar descanso de tela + +Por padrão, scrcpy não evita que o descanso de tela rode no computador. + +Para desativá-lo: + +```bash +scrcpy --disable-screensaver +``` + + +### Controle de entrada + +#### Rotacionar a tela do dispositivo + +Pressione MOD+r para mudar entre os modos retrato e +paisagem. + +Note que só será rotacionado se a aplicação em primeiro plano suportar a +orientação requisitada. + +#### Copiar-colar + +Sempre que a área de transferência do Android muda, é automaticamente sincronizada com a +área de transferência do computador. + +Qualquer atalho com Ctrl é encaminhado para o dispositivo. Em particular: + - Ctrl+c tipicamente copia + - Ctrl+x tipicamente recorta + - Ctrl+v tipicamente cola (após a sincronização de área de transferência + computador-para-dispositivo) + +Isso tipicamente funciona como esperado. + +O comportamento de fato depende da aplicação ativa, no entanto. Por exemplo, +_Termux_ envia SIGINT com Ctrl+c, e _K-9 Mail_ +compõe uma nova mensagem. + +Para copiar, recortar e colar em tais casos (mas apenas suportado no Android >= 7): + - MOD+c injeta `COPY` + - MOD+x injeta `CUT` + - MOD+v injeta `PASTE` (após a sincronização de área de transferência + computador-para-dispositivo) + +Em adição, MOD+Shift+v permite injetar o +texto da área de transferência do computador como uma sequência de eventos de tecla. Isso é útil quando o +componente não aceita colar texto (por exemplo no _Termux_), mas pode +quebrar conteúdo não-ASCII. + +**ADVERTÊNCIA:** Colar a área de transferência do computador para o dispositivo (tanto via +Ctrl+v quanto MOD+v) copia o conteúdo +para a área de transferência do dispositivo. Como consequência, qualquer aplicação Android pode ler +o seu conteúdo. Você deve evitar colar conteúdo sensível (como senhas) dessa +forma. + +Alguns dispositivos não se comportam como esperado quando a área de transferência é definida +programaticamente. Uma opção `--legacy-paste` é fornecida para mudar o comportamento +de Ctrl+v e MOD+v para que eles +também injetem o texto da área de transferência do computador como uma sequência de eventos de tecla (da mesma +forma que MOD+Shift+v). + +#### Pinçar para dar zoom + +Para simular "pinçar para dar zoom": Ctrl+_clicar-e-mover_. + +Mais precisamente, segure Ctrl enquanto pressiona o botão de clique-esquerdo. Até que +o botão de clique-esquerdo seja liberado, todos os movimentos do mouse ampliar e rotacionam o +conteúdo (se suportado pelo app) relativo ao centro da tela. + +Concretamente, scrcpy gera eventos adicionais de toque de um "dedo virtual" em +uma posição invertida em relação ao centro da tela. + + +#### Preferência de injeção de texto + +Existem dois tipos de [eventos][textevents] gerados ao digitar um texto: + - _eventos de tecla_, sinalizando que a tecla foi pressionada ou solta; + - _eventos de texto_, sinalizando que o texto foi inserido. + +Por padrão, letras são injetadas usando eventos de tecla, assim o teclado comporta-se +como esperado em jogos (normalmente para teclas WASD). + +Mas isso pode [causar problemas][prefertext]. Se você encontrar tal problema, você +pode evitá-lo com: + +```bash +scrcpy --prefer-text +``` + +(mas isso vai quebrar o comportamento do teclado em jogos) + +[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 padrão, segurar uma tecla gera eventos de tecla repetidos. Isso pode causar +problemas de performance em alguns jogos, onde esses eventos são inúteis de qualquer forma. + +Para evitar o encaminhamento eventos de tecla repetidos: + +```bash +scrcpy --no-key-repeat +``` + + +#### Clique-direito e clique-do-meio + +Por padrão, clique-direito dispara BACK (ou POWER) e clique-do-meio dispara +HOME. Para desabilitar esses atalhos e encaminhar os cliques para o dispositivo: + +```bash +scrcpy --forward-all-clicks +``` + + +### Soltar arquivo + +#### Instalar APK + +Para instalar um APK, arraste e solte o arquivo APK (com extensão `.apk`) na janela +_scrcpy_. + +Não existe feedback visual, um log é imprimido no console. + + +#### Enviar arquivo para dispositivo + +Para enviar um arquivo para `/sdcard/Download/` no dispositivo, arraste e solte um arquivo (não-APK) para a +janela do _scrcpy_. + +Não existe feedback visual, um log é imprimido no console. + +O diretório alvo pode ser mudado ao iniciar: + +```bash +scrcpy --push-target /sdcard/foo/bar/ +``` + + +### Encaminhamento de áudio + +Áudio não é encaminhado pelo _scrcpy_. Use [sndcpy]. + +Também veja [issue #14]. + +[sndcpy]: https://github.com/rom1v/sndcpy +[issue #14]: https://github.com/Genymobile/scrcpy/issues/14 + + +## Atalhos + +Na lista a seguir, MOD é o modificador de atalho. Por padrão, é +Alt (esquerdo) ou Super (esquerdo). + +Ele pode ser mudado usando `--shortcut-mod`. Possíveis teclas são `lctrl`, `rctrl`, +`lalt`, `ralt`, `lsuper` e `rsuper`. Por exemplo: + +```bash +# usar RCtrl para atalhos +scrcpy --shortcut-mod=rctrl + +# usar tanto LCtrl+LAlt quanto LSuper para atalhos +scrcpy --shortcut-mod=lctrl+lalt,lsuper +``` + +_[Super] é tipicamente a tecla Windows ou Cmd._ + +[Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button) + + | Ação | Atalho + | ------------------------------------------- |:----------------------------- + | Mudar modo de tela cheia | MOD+f + | Rotacionar display para esquerda | MOD+← _(esquerda)_ + | Rotacionar display para direita | MOD+→ _(direita)_ + | Redimensionar janela para 1:1 (pixel-perfeito) | MOD+g + | Redimensionar janela para remover bordas pretas | MOD+w \| _Clique-duplo-esquerdo¹_ + | Clicar em `HOME` | MOD+h \| _Clique-do-meio_ + | Clicar em `BACK` | MOD+b \| _Clique-direito²_ + | Clicar em `APP_SWITCH` | MOD+s \| _Clique-do-4.°³_ + | Clicar em `MENU` (desbloquear tela) | MOD+m + | Clicar em `VOLUME_UP` | MOD+↑ _(cima)_ + | Clicar em `VOLUME_DOWN` | MOD+↓ _(baixo)_ + | Clicar em `POWER` | MOD+p + | Ligar | _Clique-direito²_ + | Desligar tela do dispositivo (continuar espelhando) | MOD+o + | Ligar tela do dispositivo | MOD+Shift+o + | Rotacionar tela do dispositivo | MOD+r + | Expandir painel de notificação | MOD+n \| _Clique-do-5.°³_ + | Expandir painel de configurção | MOD+n+n \| _Clique-duplo-do-5.°³_ + | Colapsar paineis | MOD+Shift+n + | Copiar para área de transferência⁴ | MOD+c + | Recortar para área de transferência⁴ | MOD+x + | Sincronizar áreas de transferência e colar⁴ | MOD+v + | Injetar texto da área de transferência do computador | MOD+Shift+v + | Ativar/desativar contador de FPS (em stdout) | MOD+i + | Pinçar para dar zoom | Ctrl+_Clicar-e-mover_ + +_¹Clique-duplo-esquerdo na borda preta para remove-la._ +_²Clique-direito liga a tela caso esteja desligada, pressione BACK caso contrário._ +_³4.° and 5.° botões do mouse, caso o mouse possua._ +_⁴Apenas em Android >= 7._ + +Atalhos com teclas reptidas são executados soltando e precionando a tecla +uma segunda vez. Por exemplo, para executar "Expandir painel de Configurção": + + 1. Mantenha pressionado MOD. + 2. Depois click duas vezes n. + 3. Finalmente, solte MOD. + +Todos os atalhos Ctrl+_tecla_ são encaminhados para o dispositivo, para que eles sejam +tratados pela aplicação ativa. + + +## Caminhos personalizados + +Para usar um binário _adb_ específico, configure seu caminho na variável de ambiente +`ADB`: + +```bash +ADB=/caminho/para/adb scrcpy +``` + +Para sobrepor o caminho do arquivo `scrcpy-server`, configure seu caminho em +`SCRCPY_SERVER_PATH`. + +[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345 + + +## Por quê _scrcpy_? + +Um colega me desafiou a encontrar um nome tão impronunciável quanto [gnirehtet]. + +[`strcpy`] copia uma **str**ing; `scrcpy` copia uma **scr**een. + +[gnirehtet]: https://github.com/Genymobile/gnirehtet +[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html + + +## Como compilar? + +Veja [BUILD]. + + +## Problemas comuns + +Veja o [FAQ](FAQ.md). + + +## Desenvolvedores + +Leia a [página dos desenvolvedores][developers page]. + +[developers page]: DEVELOP.md + + +## Licença + + Copyright (C) 2018 Genymobile + Copyright (C) 2018-2022 Romain Vimont + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + +## Artigos + +- [Introducing scrcpy][article-intro] +- [Scrcpy now works wirelessly][article-tcpip] + +[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/ +[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/ diff --git a/README.sp.md b/README.sp.md new file mode 100644 index 0000000..2fc3eb5 --- /dev/null +++ b/README.sp.md @@ -0,0 +1,974 @@ +Solo se garantiza que el archivo [README](README.md) original esté actualizado. + +# scrcpy (v1.21) + +scrcpy + +Esta aplicación proporciona control e imagen de un dispositivo Android conectado +por USB (o [por TCP/IP](#conexión)). No requiere acceso _root_. +Compatible con _GNU/Linux_, _Windows_ y _macOS_. + +![screenshot](assets/screenshot-debian-600.jpg) + +Se enfoca en: + - **ser ligera**: aplicación nativa, solo muestra la imagen del dispositivo + - **rendimiento**: 30~120fps, dependiendo del dispositivo + - **calidad**: 1920×1080 o superior + - **baja latencia**: [35~70ms][lowlatency] + - **inicio rápido**: ~1 segundo para mostrar la primera imagen + - **no intrusivo**: no deja nada instalado en el dispositivo + - **beneficios**: sin cuentas, sin anuncios, no requiere acceso a internet + - **libertad**: software gratis y de código abierto + +[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646 + +Con la aplicación puede: + - [grabar la pantalla](#capturas-y-grabaciones) + - duplicar la imagen con [la pantalla apagada](#apagar-la-pantalla) + - [copiar y pegar](#copiar-y-pegar) en ambos sentidos + - [configurar la calidad](#configuración-de-captura) + - usar la pantalla del dispositivo [como webcam (V4L2)](#v4l2loopback) (solo en Linux) + - [emular un teclado físico (HID)](#emular-teclado-físico-hid) + (solo en Linux) + - y mucho más… + +## 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 y Ubuntu: + +``` +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 configura 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 + +### Configuración de captura + +#### 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 # orientación inicial +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 _ +``` + +### Capturas y grabaciones + + +#### 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 +``` + +Los "skipped frames" son grabados, incluso si no se 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 + + +#### v4l2loopback + +En Linux se puede mandar el stream del video a un dispositivo loopback v4l2, por +lo que se puede abrir el dispositivo Android como una webcam con cualquier +programa compatible con v4l2. + +Se debe instalar el modulo `v4l2loopback`: + +```bash +sudo apt install v4l2loopback-dkms +``` + +Para crear un dispositivo v4l2: + +```bash +sudo modprobe v4l2loopback +``` + +Esto va a crear un nuevo dispositivo de video en `/dev/videoN`, donde `N` es un número +(hay más [opciones](https://github.com/umlaeute/v4l2loopback#options) disponibles +para crear múltiples dispositivos o usar un ID en específico). + +Para ver los dispositivos disponibles: + +```bash +# requiere el paquete v4l-utils +v4l2-ctl --list-devices +# simple pero generalmente suficiente +ls /dev/video* +``` + +Para iniciar scrcpy usando una fuente v4l2: + +```bash +scrcpy --v4l2-sink=/dev/videoN +scrcpy --v4l2-sink=/dev/videoN --no-display # deshabilita la transmisión de imagen +scrcpy --v4l2-sink=/dev/videoN -N # más corto +``` + +(reemplace `N` con el ID del dispositivo, compruebe con `ls /dev/video*`) + +Una vez habilitado, podés abrir el stream del video con una herramienta compatible con v4l2: + +```bash +ffplay -i /dev/videoN +vlc v4l2:///dev/videoN # VLC puede agregar un delay por buffering +``` + +Por ejemplo, podrías capturar el video usando [OBS]. + +[OBS]: https://obsproject.com/ + + +#### Buffering + +Es posible agregar buffering al video. Esto reduce el ruido en la imagen ("jitter") +pero aumenta la latencia (vea [#2464]). + +[#2464]: https://github.com/Genymobile/scrcpy/issues/2464 + +La opción de buffering está disponible para la transmisión de imagen: + +```bash +scrcpy --display-buffer=50 # agrega 50 ms de buffering a la imagen +``` + +y las fuentes V4L2: + +```bash +scrcpy --v4l2-buffer=500 # agrega 500 ms de buffering a la fuente v4l2 +``` + + +### Conexión + +#### TCP/IP (Inalámbrica) + +_Scrcpy_ usa `adb` para comunicarse con el dispositivo, y `adb` puede [conectarse] vía TCP/IP. +El dispositivo debe estar conectado a la misma red que la computadora: + +##### Automático + +La opción `--tcpip` permite configurar la conexión automáticamente. Hay 2 variables. + +Si el dispositivo (accesible en 192.168.1.1 para este ejemplo) ya está escuchando +en un puerto (generalmente 5555) esperando una conexión adb entrante, entonces corré: + +```bash +scrcpy --tcpip=192.168.1.1 # el puerto default es 5555 +scrcpy --tcpip=192.168.1.1:5555 +``` + +Si el dispositivo no tiene habilitado el modo adb TCP/IP (o si no sabés la dirección IP), +entonces conectá el dispositivo por USB y corré: + +```bash +scrcpy --tcpip # sin argumentos +``` + +El programa buscará automáticamente la IP del dispositivo, habilitará el modo TCP/IP, y +se conectará al dispositivo antes de comenzar a transmitir la imagen. + +##### Manual + +Como alternativa, se puede habilitar la conexión TCP/IP manualmente usando `adb`: + +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. + +#### Iniciar automáticamente al detectar dispositivo + +Puedes utilizar [AutoAdb]: + +```bash +autoadb scrcpy -s '{}' +``` + +[AutoAdb]: https://github.com/rom1v/autoadb + +#### Túneles + +Para conectarse a un dispositivo remoto, es posible conectar un cliente local `adb` a un servidor remoto `adb` (siempre y cuando utilicen la misma versión de protocolos _adb_). + +##### Servidor ADB remoto + +Para conectarse a un servidor ADB remoto, haz que el servidor escuche en todas las interfaces: + +```bash +adb kill-server +adb -a nodaemon server start +# conserva este servidor abierto +``` + +**Advertencia: todas las comunicaciones entre los clientes y el servidor ADB están desencriptadas.** + +Supondremos que este servidor se puede acceder desde 192.168.1.2. Entonces, desde otra +terminal, corré scrcpy: + +```bash +export ADB_SERVER_SOCKET=tcp:192.168.1.2:5037 +scrcpy --tunnel-host=192.168.1.2 +``` + +Por default, scrcpy usa el puerto local que se usó para establecer el tunel +`adb forward` (típicamente `27183`, vea `--port`). También es posible forzar un +puerto diferente (puede resultar útil en situaciones más complejas, donde haya +múltiples redirecciones): + +``` +scrcpy --tunnel-port=1234 +``` + + +##### Túnel SSH + +Para comunicarse con un servidor ADB remoto de forma segura, es preferible usar un túnel SSH. + +Primero, asegurate que el servidor ADB está corriendo en la computadora remota: + +```bash +adb start-server +``` + +Después, establecé el túnel SSH: + +```bash +# local 5038 --> remoto 5037 +# local 27183 <-- remoto 27183 +ssh -CN -L5038:localhost:5037 -R27183:localhost:27183 your_remote_computer +# conserva este servidor abierto +``` + +Desde otra terminal, corré scrcpy: + +```bash +export ADB_SERVER_SOCKET=tcp:localhost:5038 +scrcpy +``` + +Para evitar habilitar "remote port forwarding", puedes forzar una "forward connection" (nótese el argumento `-L` en vez de `-R`): + +```bash +# local 5038 --> remoto 5037 +# local 27183 --> remoto 27183 +ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer +# conserva este servidor abierto +``` + +Desde otra terminal, corré scrcpy: + +```bash +export ADB_SERVER_SOCKET=tcp:localhost:5038 +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 posibles valores 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 + +#### 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 +``` + + +#### Apagar al cerrar la aplicación + +Para apagar la pantalla del dispositivo al cerrar scrcpy: + +```bash +scrcpy --power-off-on-close +``` + +#### 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). + +Para deshabilitar la auto-sincronización del portapapeles, use `--no-clipboard-autosync`. + +#### 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. + +#### Emular teclado físico (HID) + +Por default, scrcpy usa el sistema de Android para la injección de teclas o texto: +funciona en todas partes, pero está limitado a ASCII. + +En Linux, scrcpy puede emular un teclado USB físico en Android para proveer +una mejor experiencia al enviar _inputs_ (usando [USB HID vía AOAv2][hid-aoav2]): +deshabilita el teclado virtual y funciona para todos los caracteres y IME. + +[hid-aoav2]: https://source.android.com/devices/accessories/aoa2#hid-support + +Sin embargo, solo funciona si el dispositivo está conectado por USB, y por ahora +solo funciona en Linux. + +Para habilitar este modo: + +```bash +scrcpy --hid-keyboard +scrcpy -K # más corto +``` + +Si por alguna razón falla (por ejemplo si el dispositivo no está conectado vía +USB), automáticamente vuelve al modo default (un mensaje se escribirá en la consola). +Se puede usar los mismos argumentos en la línea de comandos tanto si se conecta con +USB o vía TCP/IP. + +En este modo, los _raw key events_ (_scancodes_) se envían al dispositivo, independientemente +del mapeo del teclado en el host. Por eso, si el diseño de tu teclado no concuerda, debe ser +configurado en el dispositivo Android, en Ajustes → Sistema → Idioma y Entrada de Texto +→ [Teclado Físico]. + +Se puede iniciar automáticamente en esta página de ajustes: + +```bash +adb shell am start -a android.settings.HARD_KEYBOARD_SETTINGS +``` + +Sin embargo, la opción solo está disponible cuando el teclado HID está activo +(o cuando se conecta un teclado físico). + +[Teclado Físico]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915 + + +#### 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) + +Por el contrario, se puede forzar scrcpy para siempre injectar _raw key events_: + +```bash +scrcpy --raw-key-events +``` + +Estas opciones no tienen efecto en los teclados HID (todos los _key events_ son enviados como +_scancodes_ en este modo). + +[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 +``` + +Estas opciones no tienen efecto en los teclados HID (Android maneja directamente +las repeticiones de teclas en este modo) + + +#### 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/Download/` en el dispositivo, arrastre y suelte +un archivo (no APK) a la ventana de _scrcpy_. + +No hay ninguna respuesta visual, un mensaje se escribirá en la consola. + +El directorio de destino puede ser modificado al iniciar: + +```bash +scrcpy --push-target=/sdcard/Movies/ +``` + + +### 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 izquierdo¹_ + | Click en `INICIO` | MOD+h \| _Click medio_ + | Click en `RETROCEDER` | MOD+b \| _Click derecho²_ + | Click en `CAMBIAR APLICACIÓN` | MOD+s \| _Cuarto botón³_ + | 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 \| _Quinto botón³_ + | Abrir panel de configuración | MOD+n+n \| _Doble quinto botón³_ + | Cerrar paneles | 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_ + | Arrastrar y soltar un archivo (APK) | Instalar APK desde la computadora + | Arrastrar y soltar un archivo (no APK) | [Mover archivo al dispositivo](#enviar-archivos-al-dispositivo) + +_¹Doble click en los bordes negros para eliminarlos._ +_²Botón derecho enciende la pantalla si estaba apagada, sino ejecuta RETROCEDER._ +_³Cuarto y quinto botón del mouse, si tu mouse los tiene._ +_⁴Para las apps react-native en desarrollo, `MENU` activa el menú de desarrollo._ +_⁵Solo en Android >= 7._ + +Los shortcuts con teclas repetidas se ejecutan soltando y volviendo a apretar la tecla +por segunda vez. Por ejemplo, para ejecutar "Abrir panel de configuración": + + 1. Apretá y mantené apretado MOD. + 2. Después apretá dos veces la tecla n. + 3. Por último, soltá la tecla MOD. + +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`. + +Para sobreescribir el ícono, configure el path en `SCRCPY_ICON_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-2022 Romain Vimont + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + +## 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/README.tr.md b/README.tr.md new file mode 100644 index 0000000..9501a88 --- /dev/null +++ b/README.tr.md @@ -0,0 +1,824 @@ +# scrcpy (v1.18) + +Bu uygulama Android cihazların USB (ya da [TCP/IP][article-tcpip]) üzerinden +görüntülenmesini ve kontrol edilmesini sağlar. _root_ erişimine ihtiyaç duymaz. +_GNU/Linux_, _Windows_ ve _macOS_ sistemlerinde çalışabilir. + +![screenshot](assets/screenshot-debian-600.jpg) + +Öne çıkan özellikler: + +- **hafiflik** (doğal, sadece cihazın ekranını gösterir) +- **performans** (30~60fps) +- **kalite** (1920×1080 ya da üzeri) +- **düşük gecikme süresi** ([35~70ms][lowlatency]) +- **düşük başlangıç süresi** (~1 saniye ilk kareyi gösterme süresi) +- **müdaheleci olmama** (cihazda kurulu yazılım kalmaz) + +[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646 + +## Gereksinimler + +Android cihaz en düşük API 21 (Android 5.0) olmalıdır. + +[Adb hata ayıklamasının][enable-adb] cihazınızda aktif olduğundan emin olun. + +[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling + +Bazı cihazlarda klavye ve fare ile kontrol için [ilave bir seçenek][control] daha +etkinleştirmeniz gerekebilir. + +[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323 + +## Uygulamayı indirin + +Packaging status + +### Özet + +- Linux: `apt install scrcpy` +- Windows: [indir][direct-win64] +- macOS: `brew install scrcpy` + +Kaynak kodu derle: [BUILD] ([basitleştirilmiş süreç][build_simple]) + +[build]: BUILD.md +[build_simple]: BUILD.md#simple + +### Linux + +Debian (şimdilik _testing_ ve _sid_) ve Ubuntu (20.04) için: + +``` +apt install scrcpy +``` + +[Snap] paketi: [`scrcpy`][snap-link]. + +[snap-link]: https://snapstats.org/snaps/scrcpy +[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager) + +Fedora için, [COPR] paketi: [`scrcpy`][copr-link]. + +[copr]: https://fedoraproject.org/wiki/Category:Copr +[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/ + +Arch Linux için, [AUR] paketi: [`scrcpy`][aur-link]. + +[aur]: https://wiki.archlinux.org/index.php/Arch_User_Repository +[aur-link]: https://aur.archlinux.org/packages/scrcpy/ + +Gentoo için, [Ebuild] mevcut: [`scrcpy/`][ebuild-link]. + +[ebuild]: https://wiki.gentoo.org/wiki/Ebuild +[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy + +Ayrıca [uygulamayı el ile de derleyebilirsiniz][build] ([basitleştirilmiş süreç][build_simple]). + +### Windows + +Windows için (`adb` dahil) tüm gereksinimleri ile derlenmiş bir arşiv mevcut: + + - [README](README.md#windows) + +[Chocolatey] ile kurulum: + +[chocolatey]: https://chocolatey.org/ + +```bash +choco install scrcpy +choco install adb # if you don't have it yet +``` + +[Scoop] ile kurulum: + +```bash +scoop install scrcpy +scoop install adb # if you don't have it yet +``` + +[scoop]: https://scoop.sh + +Ayrıca [uygulamayı el ile de derleyebilirsiniz][build]. + +### macOS + +Uygulama [Homebrew] içerisinde mevcut. Sadece kurun: + +[homebrew]: https://brew.sh/ + +```bash +brew install scrcpy +``` + +`adb`, `PATH` içerisinden erişilebilir olmalıdır. Eğer değilse: + +```bash +brew install android-platform-tools +``` + +[MacPorts] kullanılarak adb ve uygulamanın birlikte kurulumu yapılabilir: + +```bash +sudo port install scrcpy +``` + +[macports]: https://www.macports.org/ + +Ayrıca [uygulamayı el ile de derleyebilirsiniz][build]. + +## Çalıştırma + +Android cihazınızı bağlayın ve aşağıdaki komutu çalıştırın: + +```bash +scrcpy +``` + +Komut satırı argümanları aşağıdaki komut ile listelenebilir: + +```bash +scrcpy --help +``` + +## Özellikler + +### Ekran yakalama ayarları + +#### Boyut azaltma + +Bazen, Android cihaz ekranını daha düşük seviyede göstermek performansı artırabilir. + +Hem genişliği hem de yüksekliği bir değere sabitlemek için (ör. 1024): + +```bash +scrcpy --max-size 1024 +scrcpy -m 1024 # kısa versiyon +``` + +Diğer boyut en-boy oranı korunacak şekilde hesaplanır. +Bu şekilde ekran boyutu 1920x1080 olan bir cihaz 1024x576 olarak görünür. + +#### Bit-oranı değiştirme + +Varsayılan bit-oranı 8 Mbps'dir. Değiştirmek için (ör. 2 Mbps): + +```bash +scrcpy --bit-rate 2M +scrcpy -b 2M # kısa versiyon +``` + +#### Çerçeve oranı sınırlama + +Ekran yakalama için maksimum çerçeve oranı için sınır koyulabilir: + +```bash +scrcpy --max-fps 15 +``` + +Bu özellik Android 10 ve sonrası sürümlerde resmi olarak desteklenmektedir, +ancak daha önceki sürümlerde çalışmayabilir. + +#### Kesme + +Cihaz ekranının sadece bir kısmı görünecek şekilde kesilebilir. + +Bu özellik Oculus Go'nun bir gözünü yakalamak gibi durumlarda kullanışlı olur: + +```bash +scrcpy --crop 1224:1440:0:0 # (0,0) noktasından 1224x1440 +``` + +Eğer `--max-size` belirtilmişse yeniden boyutlandırma kesme işleminden sonra yapılır. + +#### Video yönünü kilitleme + +Videonun yönünü kilitlemek için: + +```bash +scrcpy --lock-video-orientation # başlangıç yönü +scrcpy --lock-video-orientation=0 # doğal yön +scrcpy --lock-video-orientation=1 # 90° saatin tersi yönü +scrcpy --lock-video-orientation=2 # 180° +scrcpy --lock-video-orientation=3 # 90° saat yönü +``` + +Bu özellik kaydetme yönünü de etkiler. + +[Pencere ayrı olarak döndürülmüş](#rotation) olabilir. + +#### Kodlayıcı + +Bazı cihazlar birden fazla kodlayıcıya sahiptir, ve bunların bazıları programın +kapanmasına sebep olabilir. Bu durumda farklı bir kodlayıcı seçilebilir: + +```bash +scrcpy --encoder OMX.qcom.video.encoder.avc +``` + +Mevcut kodlayıcıları listelemek için geçerli olmayan bir kodlayıcı ismi girebilirsiniz, +hata mesajı mevcut kodlayıcıları listeleyecektir: + +```bash +scrcpy --encoder _ +``` + +### Yakalama + +#### Kaydetme + +Ekran yakalama sırasında kaydedilebilir: + +```bash +scrcpy --record file.mp4 +scrcpy -r file.mkv +``` + +Yakalama olmadan kayıt için: + +```bash +scrcpy --no-display --record file.mp4 +scrcpy -Nr file.mkv +# Ctrl+C ile kayıt kesilebilir +``` + +"Atlanan kareler" gerçek zamanlı olarak gösterilmese (performans sebeplerinden ötürü) dahi kaydedilir. +Kareler cihazda _zamandamgası_ ile saklanır, bu sayede [paket gecikme varyasyonu] +kayıt edilen dosyayı etkilemez. + +[paket gecikme varyasyonu]: https://en.wikipedia.org/wiki/Packet_delay_variation + +#### v4l2loopback + +Linux'ta video akışı bir v4l2 loopback cihazına gönderilebilir. Bu sayede Android +cihaz bir web kamerası gibi davranabilir. + +Bu işlem için `v4l2loopback` modülü kurulu olmalıdır: + +```bash +sudo apt install v4l2loopback-dkms +``` + +v4l2 cihazı oluşturmak için: + +```bash +sudo modprobe v4l2loopback +``` + +Bu komut `/dev/videoN` adresinde `N` yerine bir tamsayı koyarak yeni bir video +cihazı oluşturacaktır. +(birden fazla cihaz oluşturmak veya spesifik ID'ye sahip cihazlar için +diğer [seçenekleri](https://github.com/umlaeute/v4l2loopback#options) inceleyebilirsiniz.) + +Aktif cihazları listelemek için: + +```bash +# v4l-utils paketi ile +v4l2-ctl --list-devices + +# daha basit ama yeterli olabilecek şekilde +ls /dev/video* +``` + +v4l2 kullanarak scrpy kullanmaya başlamak için: + +```bash +scrcpy --v4l2-sink=/dev/videoN +scrcpy --v4l2-sink=/dev/videoN --no-display # ayna penceresini kapatarak +scrcpy --v4l2-sink=/dev/videoN -N # kısa versiyon +``` + +(`N` harfini oluşturulan cihaz ID numarası ile değiştirin. `ls /dev/video*` cihaz ID'lerini görebilirsiniz.) + +Aktifleştirildikten sonra video akışını herhangi bir v4l2 özellikli araçla açabilirsiniz: + +```bash +ffplay -i /dev/videoN +vlc v4l2:///dev/videoN # VLC kullanırken yükleme gecikmesi olabilir +``` + +Örneğin, [OBS] ile video akışını kullanabilirsiniz. + +[obs]: https://obsproject.com/ + +### Bağlantı + +#### Kablosuz + +_Scrcpy_ cihazla iletişim kurmak için `adb`'yi kullanır, Ve `adb` +bir cihaza TCP/IP kullanarak [bağlanabilir]. + +1. Cihazınızı bilgisayarınızla aynı Wi-Fi ağına bağlayın. +2. Cihazınızın IP adresini bulun. Ayarlar → Telefon Hakkında → Durum sekmesinden veya + aşağıdaki komutu çalıştırarak öğrenebilirsiniz: + + ```bash + adb shell ip route | awk '{print $9}' + ``` + +3. Cihazınızda TCP/IP üzerinden adb kullanımını etkinleştirin: `adb tcpip 5555`. +4. Cihazınızı bilgisayarınızdan sökün. +5. Cihazınıza bağlanın: `adb connect DEVICE_IP:5555` _(`DEVICE_IP` değerini değiştirin)_. +6. `scrcpy` komutunu normal olarak çalıştırın. + +Bit-oranını ve büyüklüğü azaltmak yararlı olabilir: + +```bash +scrcpy --bit-rate 2M --max-size 800 +scrcpy -b2M -m800 # kısa version +``` + +[bağlanabilir]: https://developer.android.com/studio/command-line/adb.html#wireless + +#### Birden fazla cihaz + +Eğer `adb devices` komutu birden fazla cihaz listeliyorsa _serial_ değerini belirtmeniz gerekir: + +```bash +scrcpy --serial 0123456789abcdef +scrcpy -s 0123456789abcdef # kısa versiyon +``` + +Eğer cihaz TCP/IP üzerinden bağlanmışsa: + +```bash +scrcpy --serial 192.168.0.1:5555 +scrcpy -s 192.168.0.1:5555 # kısa version +``` + +Birden fazla cihaz için birden fazla _scrcpy_ uygulaması çalıştırabilirsiniz. + +#### Cihaz bağlantısı ile otomatik başlatma + +[AutoAdb] ile yapılabilir: + +```bash +autoadb scrcpy -s '{}' +``` + +[autoadb]: https://github.com/rom1v/autoadb + +#### SSH Tünel + +Uzaktaki bir cihaza erişmek için lokal `adb` istemcisi, uzaktaki bir `adb` sunucusuna +(aynı _adb_ sürümünü kullanmak şartı ile) bağlanabilir : + +```bash +adb kill-server # 5037 portunda çalışan lokal adb sunucusunu kapat +ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer +# bunu açık tutun +``` + +Başka bir terminalde: + +```bash +scrcpy +``` + +Uzaktan port yönlendirme ileri yönlü bağlantı kullanabilirsiniz +(`-R` yerine `-L` olduğuna dikkat edin): + +```bash +adb kill-server # 5037 portunda çalışan lokal adb sunucusunu kapat +ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer +# bunu açık tutun +``` + +Başka bir terminalde: + +```bash +scrcpy --force-adb-forward +``` + +Kablosuz bağlantı gibi burada da kalite düşürmek faydalı olabilir: + +``` +scrcpy -b2M -m800 --max-fps 15 +``` + +### Pencere ayarları + +#### İsim + +Cihaz modeli varsayılan pencere ismidir. Değiştirmek için: + +```bash +scrcpy --window-title 'Benim cihazım' +``` + +#### Konum ve + +Pencerenin başlangıç konumu ve boyutu belirtilebilir: + +```bash +scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600 +``` + +#### Kenarlıklar + +Pencere dekorasyonunu kapatmak için: + +```bash +scrcpy --window-borderless +``` + +#### Her zaman üstte + +Scrcpy penceresini her zaman üstte tutmak için: + +```bash +scrcpy --always-on-top +``` + +#### Tam ekran + +Uygulamayı tam ekran başlatmak için: + +```bash +scrcpy --fullscreen +scrcpy -f # kısa versiyon +``` + +Tam ekran MOD+f ile dinamik olarak değiştirilebilir. + +#### Döndürme + +Pencere döndürülebilir: + +```bash +scrcpy --rotation 1 +``` + +Seçilebilecek değerler: + +- `0`: döndürme yok +- `1`: 90 derece saat yönünün tersi +- `2`: 180 derece +- `3`: 90 derece saat yönü + +Döndürme MOD+←_(sol)_ ve +MOD+→ _(sağ)_ ile dinamik olarak değiştirilebilir. + +_scrcpy_'de 3 farklı döndürme olduğuna dikkat edin: + +- MOD+r cihazın yatay veya dikey modda çalışmasını sağlar. + (çalışan uygulama istenilen oryantasyonda çalışmayı desteklemiyorsa döndürme + işlemini reddedebilir.) +- [`--lock-video-orientation`](#lock-video-orientation) görüntü yakalama oryantasyonunu + (cihazdan bilgisayara gelen video akışının oryantasyonu) değiştirir. Bu kayıt işlemini + etkiler. +- `--rotation` (or MOD+←/MOD+→) + pencere içeriğini dönderir. Bu sadece canlı görüntüyü etkiler, kayıt işlemini etkilemez. + +### Diğer ekran yakalama seçenekleri + +#### Yazma korumalı + +Kontrolleri devre dışı bırakmak için (cihazla etkileşime geçebilecek her şey: klavye ve +fare girdileri, dosya sürükleyip bırakma): + +```bash +scrcpy --no-control +scrcpy -n +``` + +#### Ekran + +Eğer cihazın birden fazla ekranı varsa hangi ekranın kullanılacağını seçebilirsiniz: + +```bash +scrcpy --display 1 +``` + +Kullanılabilecek ekranları listelemek için: + +```bash +adb shell dumpsys display # çıktı içerisinde "mDisplayId=" terimini arayın +``` + +İkinci ekran ancak cihaz Android sürümü 10 veya üzeri olmalıdır (değilse yazma korumalı +olarak görüntülenir). + +#### Uyanık kalma + +Cihazın uyku moduna girmesini engellemek için: + +```bash +scrcpy --stay-awake +scrcpy -w +``` + +scrcpy kapandığında cihaz başlangıç durumuna geri döner. + +#### Ekranı kapatma + +Ekran yakalama sırasında cihazın ekranı kapatılabilir: + +```bash +scrcpy --turn-screen-off +scrcpy -S +``` + +Ya da MOD+o kısayolunu kullanabilirsiniz. + +Tekrar açmak için ise MOD+Shift+o tuşlarına basın. + +Android'de, `GÜÇ` tuşu her zaman ekranı açar. Eğer `GÜÇ` sinyali scrcpy ile +gönderilsiyse (sağ tık veya MOD+p), ekran kısa bir gecikme +ile kapanacaktır. Fiziksel `GÜÇ` tuşuna basmak hala ekranın açılmasına sebep olacaktır. + +Bu cihazın uykuya geçmesini engellemek için kullanılabilir: + +```bash +scrcpy --turn-screen-off --stay-awake +scrcpy -Sw +``` + +#### Dokunuşları gösterme + +Sunumlar sırasında fiziksel dokunuşları (fiziksel cihazdaki) göstermek +faydalı olabilir. + +Android'de bu özellik _Geliştici seçenekleri_ içerisinde bulunur. + +_Scrcpy_ bu özelliği çalışırken etkinleştirebilir ve kapanırken eski +haline geri getirebilir: + +```bash +scrcpy --show-touches +scrcpy -t +``` + +Bu opsiyon sadece _fiziksel_ dokunuşları (cihaz ekranındaki) gösterir. + +#### Ekran koruyucuyu devre dışı bırakma + +Scrcpy varsayılan ayarlarında ekran koruyucuyu devre dışı bırakmaz. + +Bırakmak için: + +```bash +scrcpy --disable-screensaver +``` + +### Girdi kontrolü + +#### Cihaz ekranını dönderme + +MOD+r tuşları ile yatay ve dikey modlar arasında +geçiş yapabilirsiniz. + +Bu kısayol ancak çalışan uygulama desteklediği takdirde ekranı döndürecektir. + +#### Kopyala yapıştır + +Ne zaman Android cihazdaki pano değişse bilgisayardaki pano otomatik olarak +senkronize edilir. + +Tüm Ctrl kısayolları cihaza iletilir: + +- Ctrl+c genelde kopyalar +- Ctrl+x genelde keser +- Ctrl+v genelde yapıştırır (bilgisayar ve cihaz arasındaki + pano senkronizasyonundan sonra) + +Bu kısayollar genelde beklediğiniz gibi çalışır. + +Ancak kısayolun gerçekten yaptığı eylemi açık olan uygulama belirler. +Örneğin, _Termux_ Ctrl+c ile kopyalama yerine +SIGINT sinyali gönderir, _K-9 Mail_ ise yeni mesaj oluşturur. + +Bu tip durumlarda kopyalama, kesme ve yapıştırma için (Android versiyon 7 ve +üstü): + +- MOD+c `KOPYALA` +- MOD+x `KES` +- MOD+v `YAPIŞTIR` (bilgisayar ve cihaz arasındaki + pano senkronizasyonundan sonra) + +Bunlara ek olarak, MOD+Shift+v tuşları +bilgisayar pano içeriğini tuş basma eylemleri şeklinde gönderir. Bu metin +yapıştırmayı desteklemeyen (_Termux_ gibi) uygulamar için kullanışlıdır, +ancak ASCII olmayan içerikleri bozabilir. + +**UYARI:** Bilgisayar pano içeriğini cihaza yapıştırmak +(Ctrl+v ya da MOD+v tuşları ile) +içeriği cihaz panosuna kopyalar. Sonuç olarak, herhangi bir Android uygulaması +içeriğe erişebilir. Hassas içerikler (parolalar gibi) için bu özelliği kullanmaktan +kaçının. + +Bazı cihazlar pano değişikleri konusunda beklenilen şekilde çalışmayabilir. +Bu durumlarda `--legacy-paste` argümanı kullanılabilir. Bu sayede +Ctrl+v ve MOD+v tuşları da +pano içeriğini tuş basma eylemleri şeklinde gönderir +(MOD+Shift+v ile aynı şekilde). + +#### İki parmak ile yakınlaştırma + +"İki parmak ile yakınlaştırma" için: Ctrl+_tıkla-ve-sürükle_. + +Daha açıklayıcı şekilde, Ctrl tuşuna sol-tık ile birlikte basılı +tutun. Sol-tık serbest bırakılıncaya kadar yapılan tüm fare hareketleri +ekran içeriğini ekranın merkezini baz alarak dönderir, büyütür veya küçültür +(eğer uygulama destekliyorsa). + +Scrcpy ekranın merkezinde bir "sanal parmak" varmış gibi davranır. + +#### Metin gönderme tercihi + +Metin girilirken ili çeşit [eylem][textevents] gerçekleştirilir: + +- _tuş eylemleri_, bir tuşa basıldığı sinyalini verir; +- _metin eylemleri_, bir metin girildiği sinyalini verir. + +Varsayılan olarak, harfler tuş eylemleri kullanılarak gönderilir. Bu sayede +klavye oyunlarda beklenilene uygun olarak çalışır (Genelde WASD tuşları). + +Ancak bu [bazı problemlere][prefertext] yol açabilir. Eğer bu problemler ile +karşılaşırsanız metin eylemlerini tercih edebilirsiniz: + +```bash +scrcpy --prefer-text +``` + +(Ama bu oyunlardaki klavye davranışlarını bozacaktır) + +[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input +[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343 + +#### Tuş tekrarı + +Varsayılan olarak, bir tuşa basılı tutmak tuş eylemini tekrarlar. Bu durum +bazı oyunlarda problemlere yol açabilir. + +Tuş eylemlerinin tekrarını kapatmak için: + +```bash +scrcpy --no-key-repeat +``` + +#### Sağ-tık ve Orta-tık + +Varsayılan olarak, sağ-tık GERİ (ya da GÜÇ açma) eylemlerini, orta-tık ise +ANA EKRAN eylemini tetikler. Bu kısayolları devre dışı bırakmak için: + +```bash +scrcpy --forward-all-clicks +``` + +### Dosya bırakma + +#### APK kurulumu + +APK kurmak için, bilgisayarınızdaki APK dosyasını (`.apk` ile biten) _scrcpy_ +penceresine sürükleyip bırakın. + +Bu eylem görsel bir geri dönüt oluşturmaz, konsola log yazılır. + +#### Dosyayı cihaza gönderme + +Bir dosyayı cihazdaki `/sdcard/Download/` dizinine atmak için, (APK olmayan) +bir dosyayı _scrcpy_ penceresine sürükleyip bırakın. + +Bu eylem görsel bir geri dönüt oluşturmaz, konsola log yazılır. + +Hedef dizin uygulama başlatılırken değiştirilebilir: + +```bash +scrcpy --push-target=/sdcard/Movies/ +``` + +### Ses iletimi + +_Scrcpy_ ses iletimi yapmaz. Yerine [sndcpy] kullanabilirsiniz. + +Ayrıca bakınız [issue #14]. + +[sndcpy]: https://github.com/rom1v/sndcpy +[issue #14]: https://github.com/Genymobile/scrcpy/issues/14 + +## Kısayollar + +Aşağıdaki listede, MOD kısayol tamamlayıcısıdır. Varsayılan olarak +(sol) Alt veya (sol) Super tuşudur. + +Bu tuş `--shortcut-mod` argümanı kullanılarak `lctrl`, `rctrl`, +`lalt`, `ralt`, `lsuper` ve `rsuper` tuşlarından biri ile değiştirilebilir. +Örneğin: + +```bash +# Sağ Ctrl kullanmak için +scrcpy --shortcut-mod=rctrl + +# Sol Ctrl, Sol Alt veya Sol Super tuşlarından birini kullanmak için +scrcpy --shortcut-mod=lctrl+lalt,lsuper +``` + +_[Super] tuşu genelde Windows veya Cmd tuşudur._ + +[super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button) + +| Action | Shortcut | +| ------------------------------------------------ | :-------------------------------------------------------- | +| Tam ekran modunu değiştirme | MOD+f | +| Ekranı sola çevirme | MOD+← _(sol)_ | +| Ekranı sağa çevirme | MOD+→ _(sağ)_ | +| Pencereyi 1:1 oranına çevirme (pixel-perfect) | MOD+g | +| Penceredeki siyah kenarlıkları kaldırma | MOD+w \| _Çift-sol-tık¹_ | +| `ANA EKRAN` tuşu | MOD+h \| _Orta-tık_ | +| `GERİ` tuşu | MOD+b \| _Sağ-tık²_ | +| `UYGULAMA_DEĞİŞTİR` tuşu | MOD+s \| _4.tık³_ | +| `MENÜ` tuşu (ekran kilidini açma) | MOD+m | +| `SES_AÇ` tuşu | MOD+↑ _(yukarı)_ | +| `SES_KIS` tuşu | MOD+↓ _(aşağı)_ | +| `GÜÇ` tuşu | MOD+p | +| Gücü açma | _Sağ-tık²_ | +| Cihaz ekranını kapatma (ekran yakalama durmadan) | MOD+o | +| Cihaz ekranını açma | MOD+Shift+o | +| Cihaz ekranını dönderme | MOD+r | +| Bildirim panelini genişletme | MOD+n \| _5.tık³_ | +| Ayarlar panelini genişletme | MOD+n+n \| _Çift-5.tık³_ | +| Panelleri kapatma | MOD+Shift+n | +| Panoya kopyalama⁴ | MOD+c | +| Panoya kesme⁴ | MOD+x | +| Panoları senkronize ederek yapıştırma⁴ | MOD+v | +| Bilgisayar panosundaki metini girme | MOD+Shift+v | +| FPS sayacını açma/kapatma (terminalde) | MOD+i | +| İki parmakla yakınlaştırma | Ctrl+_tıkla-ve-sürükle_ | + +_¹Siyah kenarlıkları silmek için üzerine çift tıklayın._ +_²Sağ-tık ekran kapalıysa açar, değilse GERİ sinyali gönderir._ +_³4. ve 5. fare tuşları (eğer varsa)._ +_⁴Sadece Android 7 ve üzeri versiyonlarda._ + +Tekrarlı tuşu olan kısayollar tuş bırakılıp tekrar basılarak tekrar çalıştırılır. +Örneğin, "Ayarlar panelini genişletmek" için: + +1. MOD tuşuna basın ve basılı tutun. +2. n tuşuna iki defa basın. +3. MOD tuşuna basmayı bırakın. + +Tüm Ctrl+_tuş_ kısayolları cihaza gönderilir. Bu sayede istenilen komut +uygulama tarafından çalıştırılır. + +## Özel dizinler + +Varsayılandan farklı bir _adb_ programı çalıştırmak için `ADB` ortam değişkenini +ayarlayın: + +```bash +ADB=/path/to/adb scrcpy +``` + +`scrcpy-server` programının dizinini değiştirmek için `SCRCPY_SERVER_PATH` +değişkenini ayarlayın. + +[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345 + +## Neden _scrcpy_? + +Bir meslektaşım [gnirehtet] gibi söylenmesi zor bir isim bulmam için bana meydan okudu. + +[`strcpy`] **str**ing kopyalıyor; `scrcpy` **scr**een kopyalıyor. + +[gnirehtet]: https://github.com/Genymobile/gnirehtet +[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html + +## Nasıl derlenir? + +Bakınız [BUILD]. + +## Yaygın problemler + +Bakınız [FAQ](FAQ.md). + +## Geliştiriciler + +[Geliştiriciler sayfası]nı okuyun. + +[geliştiriciler sayfası]: DEVELOP.md + +## Lisans + + Copyright (C) 2018 Genymobile + Copyright (C) 2018-2022 Romain Vimont + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + +## Makaleler + +- [Introducing scrcpy][article-intro] +- [Scrcpy now works wirelessly][article-tcpip] + +[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/ +[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/ diff --git a/README.zh-Hans.md b/README.zh-Hans.md new file mode 100644 index 0000000..ac0713a --- /dev/null +++ b/README.zh-Hans.md @@ -0,0 +1,993 @@ +_Only the original [README](README.md) is guaranteed to be up-to-date._ + +_只有原版的 [README](README.md)是保证最新的。_ + +Current version is based on [f4c7044] + +本文根据[f4c7044]进行翻译。 + +[f4c7044]: https://github.com/Genymobile/scrcpy/blob/f4c7044b46ae28eb64cb5e1a15c9649a44023c70/README.md + +# scrcpy (v1.22) + +scrcpy + +_发音为 "**scr**een **c**o**py**"_ + +本应用程序可以显示并控制通过 USB (或 [TCP/IP][article-tcpip]) 连接的安卓设备，且不需要任何 _root_ 权限。本程序支持 _GNU/Linux_, _Windows_ 和 _macOS_。 + +![screenshot](assets/screenshot-debian-600.jpg) + +本应用专注于： + + - **轻量**： 原生，仅显示设备屏幕 + - **性能**： 30~120fps，取决于设备 + - **质量**： 分辨率可达 1920×1080 或更高 + - **低延迟**： [35~70ms][lowlatency] + - **快速启动**： 最快 1 秒内即可显示第一帧 + - **无侵入性**： 不会在设备上遗留任何程序 + - **用户利益**： 无需帐号，无广告，无需联网 + - **自由**： 自由和开源软件 + +[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646 + +功能： + - [屏幕录制](#屏幕录制) + - 镜像时[关闭设备屏幕](#关闭设备屏幕) + - 双向[复制粘贴](#复制粘贴) + - [可配置显示质量](#采集设置) + - 以设备屏幕[作为摄像头(V4L2)](#v4l2loopback) (仅限 Linux) + - [模拟物理键盘 (HID)](#物理键盘模拟-hid) (仅限 Linux) + - [物理鼠标模拟 (HID)](#物理鼠标模拟-hid) (仅限 Linux) + - [OTG模式](#otg) (仅限 Linux) + - 更多 …… + +## 系统要求 + +安卓设备最低需要支持 API 21 (Android 5.0)。 + +确保设备已[开启 adb 调试][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 上： + +``` +apt install scrcpy +``` + +在 Arch Linux 上: + +``` +pacman -S scrcpy +``` + +我们也提供 [Snap] 包： [`scrcpy`][snap-link]。 + +[snap-link]: https://snapstats.org/snaps/scrcpy + +[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager) + +对 Fedora 我们提供 [COPR] 包： [`scrcpy`][copr-link]。 + +[COPR]: https://fedoraproject.org/wiki/Category:Copr +[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/ + +对 Gentoo 我们提供 [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`) 的预编译包。 + + - [README](README.md#windows) + +也可以使用 [Chocolatey]： + +[Chocolatey]: https://chocolatey.org/ + +```bash +choco install scrcpy +choco install adb # 如果还没有 adb +``` + +或者 [Scoop]: + +```bash +scoop install scrcpy +scoop install adb # 如果还没有 adb +``` + +[Scoop]: https://scoop.sh + +您也可以[自行构建][BUILD]。 + + +### macOS + +本程序已发布到 [Homebrew]。直接安装即可： + +[Homebrew]: https://brew.sh/ + +```bash +brew install scrcpy +``` + +你还需要在 `PATH` 内有 `adb`。如果还没有： + +```bash +brew install android-platform-tools +``` + +或者通过 [MacPorts]，该方法同时设置好 adb： + +```bash +sudo port install scrcpy +``` + +[MacPorts]: https://www.macports.org/ + +您也可以[自行构建][BUILD]。 + + +## 运行 + +连接安卓设备，然后执行： + +```bash +scrcpy +``` + +本程序支持命令行参数，查看参数列表： + +```bash +scrcpy --help +``` + +## 功能介绍 + +### 采集设置 + +#### 降低分辨率 + +有时候，可以通过降低镜像的分辨率来提高性能。 + +要同时限制宽度和高度到某个值 (例如 1024)： + +```bash +scrcpy --max-size 1024 +scrcpy -m 1024 # 简写 +``` + +另一边会被按比例缩小以保持设备的显示比例。这样，1920×1080 分辨率的设备会以 1024×576 的分辨率进行镜像。 + + +#### 修改码率 + +默认码率是 8 Mbps。改变视频码率 (例如改为 2 Mbps)： + +```bash +scrcpy --bit-rate 2M +scrcpy -b 2M # 简写 +``` + +#### 限制帧率 + +要限制采集的帧率： + +```bash +scrcpy --max-fps 15 +``` + +本功能从 Android 10 开始才被官方支持，但在一些旧版本中也能生效。 + +#### 画面裁剪 + +可以对设备屏幕进行裁剪，只镜像屏幕的一部分。 + +例如可以只镜像 Oculus Go 的一只眼睛。 + +```bash +scrcpy --crop 1224:1440:0:0 # 以 (0,0) 为原点的 1224x1440 像素 +``` + +如果同时指定了 `--max-size`，会先进行裁剪，再进行缩放。 + + +#### 锁定屏幕方向 + + +要锁定镜像画面的方向： + +```bash +scrcpy --lock-video-orientation # 初始（目前）方向 +scrcpy --lock-video-orientation=0 # 自然方向 +scrcpy --lock-video-orientation=1 # 逆时针旋转 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 + + +#### v4l2loopback + +在 Linux 上，可以将视频流发送至 v4l2 回环 (loopback) 设备，因此可以使用任何 v4l2 工具像摄像头一样打开安卓设备。 + +需安装 `v4l2loopback` 模块： + +```bash +sudo apt install v4l2loopback-dkms +``` + +创建一个 v4l2 设备： + +```bash +sudo modprobe v4l2loopback +``` + +这样会在 `/dev/videoN` 创建一个新的视频设备，其中 `N` 是整数。 ([更多选项](https://github.com/umlaeute/v4l2loopback#options) 可以用来创建多个设备或者特定 ID 的设备)。 + +列出已启用的设备： + +```bash +# 需要 v4l-utils 包 +v4l2-ctl --list-devices + +# 简单但或许足够 +ls /dev/video* +``` + +使用一个 v4l2 漏开启 scrcpy： + +```bash +scrcpy --v4l2-sink=/dev/videoN +scrcpy --v4l2-sink=/dev/videoN --no-display # 禁用窗口镜像 +scrcpy --v4l2-sink=/dev/videoN -N # 简写 +``` + +(将 `N` 替换为设备 ID，使用 `ls /dev/video*` 命令查看) + +启用之后，可以使用 v4l2 工具打开视频流： + +```bash +ffplay -i /dev/videoN +vlc v4l2:///dev/videoN # VLC 可能存在一些缓冲延迟 +``` + +例如，可以在 [OBS] 中采集视频。 + +[OBS]: https://obsproject.com/ + + +#### 缓冲 + +可以加入缓冲，会增加延迟，但可以减少抖动 (见 [#2464])。 + +[#2464]: https://github.com/Genymobile/scrcpy/issues/2464 + +对于显示缓冲： + +```bash +scrcpy --display-buffer=50 # 为显示增加 50 毫秒的缓冲 +``` + +对于 V4L2 漏: + +```bash +scrcpy --v4l2-buffer=500 # 为 v4l2 漏增加 500 毫秒的缓冲 +``` + + +### 连接 + +#### TCP/IP （无线） + +_Scrcpy_ 使用 `adb` 与设备通信，并且 `adb` 支持通过 TCP/IP [连接]到设备（设备必须连接与电脑相同的网络）。 + +##### 自动配置 + +参数 `--tcpip` 允许自动配置连接。这里有两种方式。 + +对于传入的 adb 连接，如果设备（在这个例子中以192.168.1.1为可用地址）已经监听了一个端口（通常是5555），运行： + +```bash +scrcpy --tcpip=192.168.1.1 # 默认端口是5555 +scrcpy --tcpip=192.168.1.1:5555 +``` + +如果adb TCP/IP（无线） 模式在某些设备上不被启用（或者你不知道IP地址），用USB连接设备，然后运行： + +```bash +scrcpy --tcpip # 无需其他参数 +``` + +这将会自动寻找设备IP地址，启用TCP/IP模式，然后在启动之前连接到设备。 + +##### 手动配置 + +或者，可以通过 `adb` 使用手动启用 TCP/IP 连接： + +1. 将设备和电脑连接至同一 Wi-Fi。 +2. 打开 设置 → 关于手机 → 状态信息，获取设备的 IP 地址，也可以执行以下的命令： + + ```bash + adb shell ip route | awk '{print $9}' + ``` + +3. 启用设备的网络 adb 功能：`adb tcpip 5555`。 +4. 断开设备的 USB 连接。 +5. 连接到您的设备：`adb connect DEVICE_IP:5555` _(将 `DEVICE_IP` 替换为设备 IP)_。 +6. 正常运行 `scrcpy`。 + +降低比特率和分辨率可能很有用： + +```bash +scrcpy --bit-rate 2M --max-size 800 +scrcpy -b2M -m800 # 简写 +``` + +[连接]: https://developer.android.com/studio/command-line/adb.html#wireless + + +#### 多设备 + +如果 `adb devices` 列出了多个设备，您必须指定设备的 _序列号_ ： + +```bash +scrcpy --serial 0123456789abcdef +scrcpy -s 0123456789abcdef # 简写 +``` + +如果设备通过 TCP/IP 连接： + +```bash +scrcpy --serial 192.168.0.1:5555 +scrcpy -s 192.168.0.1:5555 # 简写 +``` + +您可以同时启动多个 _scrcpy_ 实例以同时显示多个设备的画面。 + +#### 在设备连接时自动启动 + +您可以使用 [AutoAdb]: + +```bash +autoadb scrcpy -s '{}' +``` + +[AutoAdb]: https://github.com/rom1v/autoadb + +#### 隧道 + +要远程连接到设备，可以将本地的 adb 客户端连接到远程的 adb 服务端 (需要两端的 _adb_ 协议版本相同)。 + +##### 远程ADB服务器 + +要连接到一个远程ADB服务器，让服务器在所有接口上监听： + +```bash +adb kill-server +adb -a nodaemon server start +# 保持该窗口开启 +``` + +**警告：所有客户端与ADB服务器的交流都是未加密的。** + +假设此服务器可在 192.168.1.2 访问。 然后，从另一个终端，运行 scrcpy： + +```bash +export ADB_SERVER_SOCKET=tcp:192.168.1.2:5037 +scrcpy --tunnel-host=192.168.1.2 +``` + +默认情况下，scrcpy使用用于 `adb forward` 隧道建立的本地端口（通常是 `27183`，见 `--port` ）。它也可以强制使用一个不同的隧道端口（当涉及更多的重定向时，这在更复杂的情况下可能很有用）: + +``` +scrcpy --tunnel-port=1234 +``` + + +##### SSH 隧道 + +为了安全地与远程ADB服务器通信，最好使用SSH隧道。 + +首先，确保ADB服务器正在远程计算机上运行： + +```bash +adb start-server +``` + +然后，建立一个SSH隧道： + +```bash +# 本地 5038 --> 远程 5037 +# 本地 27183 <-- 远程 27183 +ssh -CN -L5038:localhost:5037 -R27183:localhost:27183 your_remote_computer +# 保持该窗口开启 +``` + +在另一个终端上，运行scrcpy： + +```bash +export ADB_SERVER_SOCKET=tcp:localhost:5038 +scrcpy +``` + +若要不使用远程端口转发，可以强制使用正向连接（注意是 `-L` 而不是 `-R` ）： + +```bash +# 本地 5038 --> 远程 5037 +# 本地 27183 <-- 远程 27183 +ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer +# 保持该窗口开启 +``` + +在另一个终端上，运行scrcpy： + +```bash +export ADB_SERVER_SOCKET=tcp:localhost:5038 +scrcpy --force-adb-forward +``` + + +类似地，对于无线连接，可能需要降低画面质量： + +``` +scrcpy -b2M -m800 --max-fps 15 +``` + +### 窗口设置 + +#### 标题 + +窗口的标题默认为设备型号。可以通过如下命令修改： + +```bash +scrcpy --window-title "我的设备" +``` + +#### 位置和大小 + +您可以指定初始的窗口位置和大小： + +```bash +scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600 +``` + +#### 无边框 + +禁用窗口边框： + +```bash +scrcpy --window-borderless +``` + +#### 保持窗口在最前 + +您可以通过如下命令保持窗口在最前面： + +```bash +scrcpy --always-on-top +``` + +#### 全屏 + +您可以通过如下命令直接全屏启动 scrcpy： + +```bash +scrcpy --fullscreen +scrcpy -f # 简写 +``` + +全屏状态可以通过 MOD+f 随时切换。 + +#### 旋转 + +可以通过以下命令旋转窗口： + +```bash +scrcpy --rotation 1 +``` + +可选的值有： + - `0`: 无旋转 + - `1`: 逆时针旋转 90° + - `2`: 旋转 180° + - `3`: 顺时针旋转 90° + +也可以使用 MOD+← _(左箭头)_ 和 MOD+→ _(右箭头)_ 随时更改。 + +需要注意的是， _scrcpy_ 中有三类旋转方向： + - MOD+r 请求设备在竖屏和横屏之间切换 (如果前台应用程序不支持请求的朝向，可能会拒绝该请求)。 + - [`--lock-video-orientation`](#锁定屏幕方向) 改变镜像的朝向 (设备传输到电脑的画面的朝向)。这会影响录制。 + - `--rotation` (或 MOD+←/MOD+→) 只旋转窗口的内容。这只影响显示，不影响录制。 + + +### 其他镜像设置 + +#### 只读 + +禁用电脑对设备的控制 (任何可与设备交互的方式：如键盘输入、鼠标事件和文件拖放)： + +```bash +scrcpy --no-control +scrcpy -n +``` + +#### 显示屏 + +如果设备有多个显示屏，可以选择要镜像的显示屏： + +```bash +scrcpy --display 1 +``` + +可以通过如下命令列出所有显示屏的 id： + +``` +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 +``` + +#### 退出时息屏 + +scrcpy 退出时关闭设备屏幕： + +```bash +scrcpy --power-off-on-close +``` + +#### 显示触摸 + +在演示时，可能会需要显示 (在物理设备上的) 物理触摸点。 + +Android 在 _开发者选项_ 中提供了这项功能。 + +_Scrcpy_ 提供一个选项可以在启动时开启这项功能并在退出时恢复初始设置： + +```bash +scrcpy --show-touches +scrcpy -t +``` + +请注意这项功能只能显示 _物理_ 触摸 (用手指在屏幕上的触摸)。 + + +#### 关闭屏保 + +_Scrcpy_ 默认不会阻止电脑上开启的屏幕保护。 + +关闭屏幕保护： + +```bash +scrcpy --disable-screensaver +``` + + +### 输入控制 + +#### 旋转设备屏幕 + +使用 MOD+r 在竖屏和横屏模式之间切换。 + +需要注意的是，只有在前台应用程序支持所要求的模式时，才会进行切换。 + +#### 复制粘贴 + +每次安卓的剪贴板变化时，其内容都会被自动同步到电脑的剪贴板上。 + +所有的 Ctrl 快捷键都会被转发至设备。其中： + - Ctrl+c 通常执行复制 + - Ctrl+x 通常执行剪切 + - Ctrl+v 通常执行粘贴 (在电脑到设备的剪贴板同步完成之后) + +大多数时候这些按键都会执行以上的功能。 + +但实际的行为取决于设备上的前台程序。例如，_Termux_ 会在按下 Ctrl+c 时发送 SIGINT，又如 _K-9 Mail_ 会新建一封邮件。 + +要在这种情况下进行剪切，复制和粘贴 (仅支持 Android >= 7)： + - MOD+c 注入 `COPY` (复制) + - MOD+x 注入 `CUT` (剪切) + - MOD+v 注入 `PASTE` (粘贴) (在电脑到设备的剪贴板同步完成之后) + +另外，MOD+Shift+v 会将电脑的剪贴板内容转换为一串按键事件输入到设备。在应用程序不接受粘贴时 (比如 _Termux_)，这项功能可以派上一定的用场。不过这项功能可能会导致非 ASCII 编码的内容出现错误。 + +**警告：** 将电脑剪贴板的内容粘贴至设备 (无论是通过 Ctrl+v 还是 MOD+v) 都会将内容复制到设备的剪贴板。如此，任何安卓应用程序都能读取到。您应避免将敏感内容 (如密码) 通过这种方式粘贴。 + +一些设备不支持通过程序设置剪贴板。通过 `--legacy-paste` 选项可以修改 Ctrl+v 和 MOD+v 的工作方式，使它们通过按键事件 (同 MOD+Shift+v) 来注入电脑剪贴板内容。 + +要禁用自动剪贴板同步功能，使用`--no-clipboard-autosync`。 + +#### 双指缩放 + +模拟“双指缩放”：Ctrl+_按下并拖动鼠标_。 + +在按住 Ctrl 时按下鼠标左键，直到松开鼠标左键前，移动鼠标会使屏幕内容相对于屏幕中心进行缩放或旋转 (如果应用支持)。 + +具体来说，_scrcpy_ 会在鼠标位置，以及鼠标以屏幕中心镜像的位置分别生成触摸事件。 + +#### 物理键盘模拟 (HID) + +默认情况下，scrcpy 使用安卓按键或文本注入，这在任何情况都可以使用，但仅限于ASCII字符。 + +在 Linux 上，scrcpy 可以模拟为 Android 上的物理 USB 键盘，以提供更好地输入体验 (使用 [USB HID over AOAv2][hid-aoav2])：禁用虚拟键盘，并适用于任何字符和输入法。 + +[hid-aoav2]: https://source.android.com/devices/accessories/aoa2#hid-support + +不过，这种方法仅支持 USB 连接以及 Linux平台。 + +启用 HID 模式： + +```bash +scrcpy --hid-keyboard +scrcpy -K # 简写 +``` + +如果失败了 (如设备未通过 USB 连接)，则自动回退至默认模式 (终端中会输出日志)。这即允许通过 USB 和 TCP/IP 连接时使用相同的命令行参数。 + +在这种模式下，原始按键事件 (扫描码) 被发送给设备，而与宿主机按键映射无关。因此，若键盘布局不匹配，需要在 Android 设备上进行配置，具体为 设置 → 系统 → 语言和输入法 → [实体键盘]。 + +[实体键盘]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915 + +#### 物理鼠标模拟 (HID) + +与物理键盘模拟类似，可以模拟一个物理鼠标。 同样，它仅在设备通过 USB 连接时才有效，并且目前仅在 Linux 上受支持。 + +默认情况下，scrcpy 使用 Android 鼠标事件注入，使用绝对坐标。 通过模拟物理鼠标，在Android设备上出现鼠标指针，并注入鼠标相对运动、点击和滚动。 + +启用此模式: + +```bash +scrcpy --hid-mouse +scrcpy -M # 简写 +``` + +您还可以将 `--forward-all-clicks` 添加到 [转发所有点击][forward_all_clicks]. + +[forward_all_clicks]: #右键和中键 + +启用此模式后，计算机鼠标将被“捕获”（鼠标指针从计算机上消失并出现在 Android 设备上）。 + +特殊的捕获键，Alt 或 Super，切换（禁用或启用）鼠标捕获。 使用其中之一将鼠标的控制权交还给计算机。 + + +#### OTG + +可以仅使用物理键盘和鼠标模拟 (HID) 运行 _scrcpy_，就好像计算机键盘和鼠标通过 OTG 线直接插入设备一样。 + +在这个模式下，_adb_ (USB 调试)是不必要的，且镜像被禁用。 + +启用 OTG 模式: + +```bash +scrcpy --otg +# 如果有多个 USB 设备可用，则通过序列号选择 +scrcpy --otg -s 0123456789abcdef +``` + +只开启 HID 键盘 或 HID 鼠标 是可行的： + +```bash +scrcpy --otg --hid-keyboard # 只开启 HID 键盘 +scrcpy --otg --hid-mouse # 只开启 HID 鼠标 +scrcpy --otg --hid-keyboard --hid-mouse # 开启 HID 键盘 和 HID 鼠标 +# 为了方便，默认两者都开启 +scrcpy --otg # 开启 HID 键盘 和 HID 鼠标 +``` + +像 `--hid-keyboard` 和 `--hid-mouse` 一样，它只在设备通过 USB 连接时才有效，且目前仅在 Linux 上支持。 + + +#### 文本注入偏好 + +输入文字的时候，系统会产生两种[事件][textevents]： + - _按键事件_ ，代表一个按键被按下或松开。 + - _文本事件_ ，代表一个字符被输入。 + +程序默认使用按键事件来输入字母。只有这样，键盘才会在游戏中正常运作 (例如 WASD 键)。 + +但这也有可能[造成一些问题][prefertext]。如果您遇到了问题，可以通过以下方式避免： + +```bash +scrcpy --prefer-text +``` + +(但这会导致键盘在游戏中工作不正常) + +相反，您可以强制始终注入原始按键事件： + +```bash +scrcpy --raw-key-events +``` + +该选项不影响 HID 键盘 (该模式下，所有按键都发送为扫描码)。 + +[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 +``` + +该选项不影响 HID 键盘 (该模式下，按键重复由 Android 直接管理)。 + +#### 右键和中键 + +默认状态下，右键会触发返回键 (或电源键开启)，中键会触发 HOME 键。要禁用这些快捷键并把所有点击转发到设备： + +```bash +scrcpy --forward-all-clicks +``` + + +### 文件拖放 + +#### 安装APK + +将 APK 文件 (文件名以 `.apk` 结尾) 拖放到 _scrcpy_ 窗口来安装。 + +不会有视觉反馈，终端会输出一条日志。 + + +#### 将文件推送至设备 + +要推送文件到设备的 `/sdcard/Download/`，将 (非 APK) 文件拖放至 _scrcpy_ 窗口。 + +不会有视觉反馈，终端会输出一条日志。 + +在启动时可以修改目标目录： + +```bash +scrcpy --push-target=/sdcard/Movies/ +``` + + +### 音频转发 + +_Scrcpy_ 不支持音频。请使用 [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` 和 `rsuper`。例如： + +```bash +# 使用右 Ctrl 键 +scrcpy --shortcut-mod=rctrl + +# 使用左 Ctrl 键 + 左 Alt 键，或 Super 键 +scrcpy --shortcut-mod=lctrl+lalt,lsuper +``` + +_[Super] 键通常是指 Windows 或 Cmd 键。_ + +[Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button) + + | 操作 | 快捷键 + | --------------------------------- | :------------------------------------------- + | 全屏 | MOD+f + | 向左旋转屏幕 | MOD+← _(左箭头)_ + | 向右旋转屏幕 | MOD+→ _(右箭头)_ + | 将窗口大小重置为1:1 (匹配像素) | MOD+g + | 将窗口大小重置为消除黑边 | MOD+w \| _双击左键¹_ + | 点按 `主屏幕` | MOD+h \| _中键_ + | 点按 `返回` | MOD+b \| _右键²_ + | 点按 `切换应用` | MOD+s \| _第4键³_ + | 点按 `菜单` (解锁屏幕)⁴ | MOD+m + | 点按 `音量+` | MOD+↑ _(上箭头)_ + | 点按 `音量-` | MOD+↓ _(下箭头)_ + | 点按 `电源` | MOD+p + | 打开屏幕 | _鼠标右键²_ + | 关闭设备屏幕 (但继续在电脑上显示) | MOD+o + | 打开设备屏幕 | MOD+Shift+o + | 旋转设备屏幕 | MOD+r + | 展开通知面板 | MOD+n \| _第5键³_ + | 展开设置面板 | MOD+n+n \| _双击第5键³_ + | 收起通知面板 | MOD+Shift+n + | 复制到剪贴板⁵ | MOD+c + | 剪切到剪贴板⁵ | MOD+x + | 同步剪贴板并粘贴⁵ | MOD+v + | 注入电脑剪贴板文本 | MOD+Shift+v + | 打开/关闭FPS显示 (至标准输出) | MOD+i + | 捏拉缩放 | Ctrl+_按住并移动鼠标_ + | 拖放 APK 文件 | 从电脑安装 APK 文件 + | 拖放非 APK 文件 | [将文件推送至设备](#push-file-to-device) + +_¹双击黑边可以去除黑边。_ +_²点击鼠标右键将在屏幕熄灭时点亮屏幕，其余情况则视为按下返回键 。_ +_³鼠标的第4键和第5键。_ +_⁴对于开发中的 react-native 应用程序，`MENU` 触发开发菜单。_ +_⁵需要安卓版本 Android >= 7。_ + +有重复按键的快捷键通过松开再按下一个按键来进行，如“展开设置面板”： + + 1. 按下 MOD 不放。 + 2. 双击 n。 + 3. 松开 MOD。 + +所有的 Ctrl+_按键_ 的快捷键都会被转发到设备，所以会由当前应用程序进行处理。 + + +## 自定义路径 + +要使用指定的 _adb_ 二进制文件，可以设置环境变量 `ADB`： + +```bash +ADB=/path/to/adb scrcpy +``` + +要覆盖 `scrcpy-server` 的路径，可以设置 `SCRCPY_SERVER_PATH`。 + +要覆盖图标，可以设置其路径至 `SCRCPY_ICON_PATH`。 + + +## 为什么叫 _scrcpy_ ？ + +一个同事让我找出一个和 [gnirehtet] 一样难以发音的名字。 + +[`strcpy`] 源于 **str**ing （字符串）； `scrcpy` 源于 **scr**een （屏幕）。 + +[gnirehtet]: https://github.com/Genymobile/gnirehtet +[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html + + +## 如何构建？ + +请查看 [BUILD]。 + + +## 常见问题 + +请查看 [FAQ](FAQ.md)。 + + +## 开发者 + +请查看[开发者页面]。 + +[开发者页面]: DEVELOP.md + + +## 许可协议 + + Copyright (C) 2018 Genymobile + Copyright (C) 2018-2022 Romain Vimont + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + +## 相关文章 + +- [Introducing scrcpy][article-intro] +- [Scrcpy now works wirelessly][article-tcpip] + +[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/ +[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/ diff --git a/README.zh-Hant.md b/README.zh-Hant.md new file mode 100644 index 0000000..87c0a8d --- /dev/null +++ b/README.zh-Hant.md @@ -0,0 +1,702 @@ +_Only the original [README](README.md) is guaranteed to be up-to-date._ + +_只有原版的 [README](README.md)是保證最新的。_ + + +本文件翻譯時點: [521f2fe](https://github.com/Genymobile/scrcpy/commit/521f2fe994019065e938aa1a54b56b4f10a4ac4a#diff-04c6e90faac2675aa89e2176d2eec7d8) + + +# scrcpy (v1.15) + +Scrcpy 可以透過 USB、或是 [TCP/IP][article-tcpip] 來顯示或控制 Android 裝置。且 scrcpy 不需要 _root_ 權限。 + +Scrcpy 目前支援 _GNU/Linux_、_Windows_ 和 _macOS_。 + +![screenshot](assets/screenshot-debian-600.jpg) + +特色: + + - **輕量** (只顯示裝置螢幕) + - **效能** (30~60fps) + - **品質** (1920×1080 或更高) + - **低延遲** ([35~70ms][lowlatency]) + - **快速啟動** (~1 秒就可以顯示第一個畫面) + - **非侵入性** (不安裝、留下任何東西在裝置上) + +[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646 + + +## 需求 + +Android 裝置必須是 API 21+ (Android 5.0+)。 + +請確認裝置上的 [adb 偵錯 (通常位於開發者模式內)][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 + + +## 下載/獲取軟體 + + +### Linux + +Debian (目前支援 _testing_ 和 _sid_) 和 Ubuntu (20.04): + +``` +apt install scrcpy +``` + +[Snap] 上也可以下載: [`scrcpy`][snap-link]. + +[snap-link]: https://snapstats.org/snaps/scrcpy + +[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager) + +在 Fedora 上也可以使用 [COPR] 下載: [`scrcpy`][copr-link]. + +[COPR]: https://fedoraproject.org/wiki/Category:Copr +[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/ + +在 Arch Linux 上也可以使用 [AUR] 下載: [`scrcpy`][aur-link]. + +[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository +[aur-link]: https://aur.archlinux.org/packages/scrcpy/ + +在 Gentoo 上也可以使用 [Ebuild] 下載: [`scrcpy/`][ebuild-link]. + +[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild +[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy + +你也可以自己[編譯 _Scrcpy_][BUILD]。別擔心，並沒有想像中的難。 + + + +### Windows + +為了保持簡單，Windows 用戶可以下載一個包含所有必需軟體 (包含 `adb`) 的壓縮包: + + - [README](README.md#windows) + +[Chocolatey] 上也可以下載: + +[Chocolatey]: https://chocolatey.org/ + +```bash +choco install scrcpy +choco install adb # 如果你還沒有安裝的話 +``` + +[Scoop] 上也可以下載: + +```bash +scoop install scrcpy +scoop install adb # 如果你還沒有安裝的話 +``` + +[Scoop]: https://scoop.sh + +你也可以自己[編譯 _Scrcpy_][BUILD]。 + + +### macOS + +_Scrcpy_ 可以在 [Homebrew] 上直接安裝: + +[Homebrew]: https://brew.sh/ + +```bash +brew install scrcpy +``` + +由於執行期間需要可以藉由 `PATH` 存取 `adb` 。如果還沒有安裝 `adb` 可以使用下列方式安裝: + +```bash +brew cask install android-platform-tools +``` + +你也可以自己[編譯 _Scrcpy_][BUILD]。 + + +## 執行 + +將電腦和你的 Android 裝置連線，然後執行: + +```bash +scrcpy +``` + +_Scrcpy_ 可以接受命令列參數。輸入下列指令就可以瀏覽可以使用的命令列參數: + +```bash +scrcpy --help +``` + + +## 功能 + +> 以下說明中，有關快捷鍵的說明可能會出現 MOD 按鈕。相關說明請參見[快捷鍵]內的說明。 + +[快捷鍵]: #快捷鍵 + +### 畫面擷取 + +#### 縮小尺寸 + +使用比較低的解析度來投放 Android 裝置在某些情況可以提升效能。 + +限制寬和高的最大值(例如: 1024): + +```bash +scrcpy --max-size 1024 +scrcpy -m 1024 # 縮短版本 +``` + +比較小的參數會根據螢幕比例重新計算。 +根據上面的範例，1920x1080 會被縮小成 1024x576。 + + +#### 更改 bit-rate + +預設的 bit-rate 是 8 Mbps。如果要更改 bit-rate (例如: 2 Mbps): + +```bash +scrcpy --bit-rate 2M +scrcpy -b 2M # 縮短版本 +``` + +#### 限制 FPS + +限制畫面最高的 FPS: + +```bash +scrcpy --max-fps 15 +``` + +僅在 Android 10 後正式支援，不過也有可能可以在 Android 10 以前的版本使用。 + +#### 裁切 + +裝置的螢幕可以裁切。如此一來，鏡像出來的螢幕就只會是原本的一部份。 + +假如只要鏡像 Oculus Go 的其中一隻眼睛: + +```bash +scrcpy --crop 1224:1440:0:0 # 位於 (0,0)，大小1224x1440 +``` + +如果 `--max-size` 也有指定的話，裁切後才會縮放。 + + +#### 鎖定影像方向 + + +如果要鎖定鏡像影像方向: + +```bash +scrcpy --lock-video-orientation 0 # 原本的方向 +scrcpy --lock-video-orientation 1 # 逆轉 90° +scrcpy --lock-video-orientation 2 # 180° +scrcpy --lock-video-orientation 3 # 順轉 90° +``` + +這會影響錄影結果的影像方向。 + + +### 錄影 + +鏡像投放螢幕的同時也可以錄影: + +```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, PDV)][packet delay variation] 並不會影響錄影的檔案。 + +[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation + + +### 連線 + +#### 無線 + +_Scrcpy_ 利用 `adb` 和裝置通訊，而 `adb` 可以[透過 TCP/IP 連結][connect]: + +1. 讓電腦和裝置連到同一個 Wi-Fi。 +2. 獲取手機的 IP 位址(設定 → 關於手機 → 狀態). +3. 啟用裝置上的 `adb over TCP/IP`: `adb tcpip 5555`. +4. 拔掉裝置上的線。 +5. 透過 TCP/IP 連接裝置: `adb connect DEVICE_IP:5555` _(把 `DEVICE_IP` 換成裝置的IP位址)_. +6. 和平常一樣執行 `scrcpy`。 + +如果效能太差，可以降低 bit-rate 和解析度: + +```bash +scrcpy --bit-rate 2M --max-size 800 +scrcpy -b2M -m800 # 縮短版本 +``` + +[connect]: https://developer.android.com/studio/command-line/adb.html#wireless + + +#### 多裝置 + +如果 `adb devices` 內有多個裝置，則必須附上 _serial_: + +```bash +scrcpy --serial 0123456789abcdef +scrcpy -s 0123456789abcdef # 縮短版本 +``` + +如果裝置是透過 TCP/IP 連線: + +```bash +scrcpy --serial 192.168.0.1:5555 +scrcpy -s 192.168.0.1:5555 # 縮短版本 +``` + +你可以啟用復數個對應不同裝置的 _scrcpy_。 + +#### 裝置連結後自動啟動 + +你可以使用 [AutoAdb]: + +```bash +autoadb scrcpy -s '{}' +``` + +[AutoAdb]: https://github.com/rom1v/autoadb + +#### SSH tunnel + +本地的 `adb` 可以連接到遠端的 `adb` 伺服器(假設兩者使用相同版本的 _adb_ 通訊協定)，以連接到遠端裝置: + +```bash +adb kill-server # 停止在 Port 5037 的本地 adb 伺服 +ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer +# 保持開啟 +``` + +從另外一個終端機: + +```bash +scrcpy +``` + +如果要避免啟用 remote port forwarding，你可以強制它使用 forward connection (注意 `-L` 和 `-R` 的差別): + +```bash +adb kill-server # 停止在 Port 5037 的本地 adb 伺服 +ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer +# 保持開啟 +``` + +從另外一個終端機: + +```bash +scrcpy --force-adb-forward +``` + + +和無線連接一樣，有時候降低品質會比較好: + +``` +scrcpy -b2M -m800 --max-fps 15 +``` + +### 視窗調整 + +#### 標題 + +預設標題是裝置的型號，不過可以透過以下方式修改: + +```bash +scrcpy --window-title 'My device' +``` + +#### 位置 & 大小 + +初始的視窗位置和大小也可以指定: + +```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`: 90 度**逆**轉 + - `2`: 180 度 + - `3`: 90 度**順**轉 + +旋轉方向也可以使用 MOD+← _(左方向鍵)_ 和 MOD+→ _(右方向鍵)_ 調整。 + +_scrcpy_ 有 3 種不同的旋轉: + - MOD+r 要求裝置在垂直、水平之間旋轉 (目前運行中的 App 有可能會因為不支援而拒絕)。 + - `--lock-video-orientation` 修改鏡像的方向 (裝置傳給電腦的影像)。這會影響錄影結果的影像方向。 + - `--rotation` (或是 MOD+← / MOD+→) 只旋轉視窗的內容。這只會影響鏡像結果，不會影響錄影結果。 + + +### 其他鏡像選項 + +#### 唯讀 + +停用所有控制，包含鍵盤輸入、滑鼠事件、拖放檔案: + +```bash +scrcpy --no-control +scrcpy -n +``` + +#### 顯示螢幕 + +如果裝置有複數個螢幕，可以指定要鏡像哪個螢幕: + +```bash +scrcpy --display 1 +``` + +可以透過下列指令獲取螢幕 ID: + +``` +adb shell dumpsys display # 找輸出結果中的 "mDisplayId=" +``` + +第二螢幕只有在 Android 10+ 時可以控制。如果不是 Android 10+，螢幕就會在唯讀狀態下投放。 + + +#### 保持清醒 + +如果要避免裝置在連接狀態下進入睡眠: + +```bash +scrcpy --stay-awake +scrcpy -w +``` + +_scrcpy_ 關閉後就會回復成原本的設定。 + + +#### 關閉螢幕 + +鏡像開始時，可以要求裝置關閉螢幕: + +```bash +scrcpy --turn-screen-off +scrcpy -S +``` + +或是在任何時候輸入 MOD+o。 + +如果要開啟螢幕，輸入 MOD+Shift+o。 + +在 Android 上，`POWER` 按鈕總是開啟螢幕。 + +為了方便，如果 `POWER` 是透過 scrcpy 轉送 (右鍵 或 MOD+p)的話，螢幕將會在短暫的延遲後關閉。 + +實際在手機上的 `POWER` 還是會開啟螢幕。 + +防止裝置進入睡眠狀態: + +```bash +scrcpy --turn-screen-off --stay-awake +scrcpy -Sw +``` + + +#### 顯示過期的幀 + +為了降低延遲， _scrcpy_ 預設只會顯示最後解碼的幀，並且拋棄所有在這之前的幀。 + +如果要強制顯示所有的幀 (有可能會拉高延遲)，輸入: + +```bash +scrcpy --render-expired-frames +``` + +#### 顯示觸控點 + +對於要報告的人來說，顯示裝置上的實際觸控點有時候是有幫助的。 + +Android 在_開發者選項_中有提供這個功能。 + +_Scrcpy_ 可以在啟動時啟用這個功能，並且在停止後恢復成原本的設定: + +```bash +scrcpy --show-touches +scrcpy -t +``` + +這個選項只會顯示**實際觸碰在裝置上的觸碰點**。 + + +### 輸入控制 + + +#### 旋轉裝置螢幕 + +輸入 MOD+r 以在垂直、水平之間切換。 + +如果使用中的程式不支援，則不會切換。 + + +#### 複製/貼上 + +如果 Android 剪貼簿上的內容有任何更動，電腦的剪貼簿也會一起更動。 + +任何與 Ctrl 相關的快捷鍵事件都會轉送到裝置上。特別來說: + - Ctrl+c 通常是複製 + - Ctrl+x 通常是剪下 + - Ctrl+v 通常是貼上 (在電腦的剪貼簿與裝置上的剪貼簿同步之後) + +這些跟你通常預期的行為一樣。 + +但是，實際上的行為是根據目前運行中的應用程式而定。 + +舉例來說， _Termux_ 在收到 Ctrl+c 後，會傳送 SIGINT；而 _K-9 Mail_ 則是建立新訊息。 + +如果在這情況下，要剪下、複製或貼上 (只有在Android 7+時才支援): + - MOD+c 注入 `複製` + - MOD+x 注入 `剪下` + - MOD+v 注入 `貼上` (在電腦的剪貼簿與裝置上的剪貼簿同步之後) + +另外，MOD+Shift+v 則是以一連串的按鍵事件貼上電腦剪貼簿中的內容。當元件不允許文字貼上 (例如 _Termux_) 時，這就很有用。不過，這在非 ASCII 內容上就無法使用。 + +**警告:** 貼上電腦的剪貼簿內容 (無論是從 Ctrl+v 或 MOD+v) 時，會複製剪貼簿中的內容至裝置的剪貼簿上。這會讓所有 Android 程式讀取剪貼簿的內容。請避免貼上任何敏感內容 (像是密碼)。 + + +#### 文字輸入偏好 + +輸入文字時，有兩種[事件][textevents]會被觸發: + - _鍵盤事件 (key events)_，代表有一個按鍵被按下或放開 + - _文字事件 (text events)_，代表有一個文字被輸入 + +預設上，文字是被以鍵盤事件 (key events) 輸入的，所以鍵盤和遊戲內所預期的一樣 (通常是指 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 +``` + + +### 檔案 + +#### 安裝 APK + +如果要安裝 APK ，拖放一個 APK 檔案 (以 `.apk` 為副檔名) 到 _scrcpy_ 的視窗上。 + +視窗上不會有任何反饋；結果會顯示在命令列中。 + + +#### 推送檔案至裝置 + +如果要推送檔案到裝置上的 `/sdcard/` ，拖放一個非 APK 檔案 (**不**以 `.apk` 為副檔名) 到 _scrcpy_ 的視窗上。 + +視窗上不會有任何反饋；結果會顯示在命令列中。 + +推送檔案的目標路徑可以在啟動時指定: + +```bash +scrcpy --push-target /sdcard/foo/bar/ +``` + + +### 音訊轉送 + +_scrcpy_ **不**轉送音訊。請使用 [sndcpy]。另外，參見 [issue #14]。 + +[sndcpy]: https://github.com/rom1v/sndcpy +[issue #14]: https://github.com/Genymobile/scrcpy/issues/14 + + +## 快捷鍵 + +在以下的清單中，MOD 是快捷鍵的特殊按鍵。通常來說，這個按鍵是 (左) Alt 或是 (左) Super。 + +這個是可以使用 `--shortcut-mod` 更改的。可以用的選項有: +- `lctrl`: 左邊的 Ctrl +- `rctrl`: 右邊的 Ctrl +- `lalt`: 左邊的 Alt +- `ralt`: 右邊的 Alt +- `lsuper`: 左邊的 Super +- `rsuper`: 右邊的 Super + +```bash +# 以 右邊的 Ctrl 為快捷鍵特殊按鍵 +scrcpy --shortcut-mod=rctrl + +# 以 左邊的 Ctrl 和左邊的 Alt 或是 左邊的 Super 為快捷鍵特殊按鍵 +scrcpy --shortcut-mod=lctrl+lalt,lsuper +``` + +_[Super] 通常是 Windows 或 Cmd 鍵。_ + +[Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button) + + | Action | Shortcut + | ------------------------------------------------- |:----------------------------- + | 切換至全螢幕 | MOD+f + | 左旋顯示螢幕 | MOD+← _(左)_ + | 右旋顯示螢幕 | MOD+→ _(右)_ + | 縮放視窗成 1:1 (pixel-perfect) | MOD+g + | 縮放視窗到沒有黑邊框為止 | MOD+w \| _雙擊¹_ + | 按下 `首頁` 鍵 | MOD+h \| _中鍵_ + | 按下 `返回` 鍵 | MOD+b \| _右鍵²_ + | 按下 `切換 APP` 鍵 | MOD+s + | 按下 `選單` 鍵 (或解鎖螢幕) | MOD+m + | 按下 `音量+` 鍵 | MOD+↑ _(上)_ + | 按下 `音量-` 鍵 | MOD+↓ _(下)_ + | 按下 `電源` 鍵 | MOD+p + | 開啟 | _右鍵²_ + | 關閉裝置螢幕(持續鏡像) | MOD+o + | 開啟裝置螢幕 | MOD+Shift+o + | 旋轉裝置螢幕 | MOD+r + | 開啟通知列 | MOD+n + | 關閉通知列 | MOD+Shift+n + | 複製至剪貼簿³ | MOD+c + | 剪下至剪貼簿³ | MOD+x + | 同步剪貼簿並貼上³ | MOD+v + | 複製電腦剪貼簿中的文字至裝置並貼上 | MOD+Shift+v + | 啟用/停用 FPS 計數器(顯示於 stdout - 通常是命令列) | MOD+i + +_¹在黑邊框上雙擊以移除它們。_ +_²右鍵會返回。如果螢幕是關閉狀態，則會打開螢幕。_ +_³只支援 Android 7+。_ + +所有 Ctrl+_按鍵_ 快捷鍵都會傳送到裝置上，所以它們是由目前運作的應用程式處理的。 + + +## 自訂路徑 + +如果要使用特定的 _adb_ ，將它設定到環境變數中的 `ADB`: + + ADB=/path/to/adb scrcpy + +如果要覆寫 `scrcpy-server` 檔案的路徑，則將路徑設定到環境變數中的 `SCRCPY_SERVER_PATH`。 + +[相關連結][useful] + +[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345 + + +## 為何叫 _scrcpy_ ？ + +有一個同事要我找一個跟 [gnirehtet] 一樣難念的名字。 + +[`strcpy`] 複製一個字串 (**str**ing)；`scrcpy` 複製一個螢幕 (**scr**een)。 + +[gnirehtet]: https://github.com/Genymobile/gnirehtet +[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html + + +## 如何編譯？ + +請看[這份文件 (英文)][BUILD]。 + +[BUILD]: BUILD.md + + +## 常見問題 + +請看[這份文件 (英文)][FAQ]。 + +[FAQ]: FAQ.md + + +## 開發者文件 + +請看[這個頁面 (英文)][developers page]. + +[developers page]: DEVELOP.md + + +## Licence + + Copyright (C) 2018 Genymobile + Copyright (C) 2018-2022 Romain Vimont + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + +## 相關文章 + +- [Scrcpy 簡介 (英文)][article-intro] +- [Scrcpy 可以無線連線了 (英文)][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/