drgreen/scrcpy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated the translated README to v1.24

Bruno M 2022-08-16 10:23:21 -03:00
parent 97f1ba4b69
commit bd1dcfa8ae
1 changed files with 333 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

378
README.pt-br.md

@ -2,7 +2,7 @@ _Apenas o [README] original é garantido estar atualizado._
[README]: https://github.com/Genymobile/scrcpy/blob/master/README.md [README]: https://github.com/Genymobile/scrcpy/blob/master/README.md
# scrcpy (v1.19) # scrcpy (v1.24)
Esta aplicação fornece exibição e controle de dispositivos Android conectados via 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_. USB (ou [via TCP/IP][article-tcpip]). Não requer nenhum acesso _root_.
@ -13,7 +13,7 @@ Funciona em _GNU/Linux_, _Windows_ e _macOS_.
Foco em: Foco em:
- **leveza** (nativo, mostra apenas a tela do dispositivo) - **leveza** (nativo, mostra apenas a tela do dispositivo)
- **performance** (30~60fps) - **performance** (30~120fps, dependendo do dispositivo)
- **qualidade** (1920×1080 ou acima) - **qualidade** (1920×1080 ou acima)
- **baixa latência** ([35~70ms][lowlatency]) - **baixa latência** ([35~70ms][lowlatency])
- **baixo tempo de inicialização** (~1 segundo para mostrar a primeira imagem) - **baixo tempo de inicialização** (~1 segundo para mostrar a primeira imagem)
@ -43,24 +43,31 @@ controlá-lo usando teclado e mouse.
### Sumário ### Sumário
- Linux: `apt install scrcpy` - Linux: `apt install scrcpy`
- Windows: [baixar][README-windows] - Windows: [baixar][direct-win64]
- macOS: `brew install scrcpy` - macOS: `brew install scrcpy`
[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.24/scrcpy-win64-v1.24.zip
Compilar pelos arquivos fontes: [BUILD] ([processo simplificado][BUILD_simple]) Compilar pelos arquivos fontes: [BUILD] ([processo simplificado][BUILD_simple])
[README-windows]: https://github.com/Genymobile/scrcpy/blob/master/README.md#windows [BUILD]: BUILD.md
[BUILD]: https://github.com/Genymobile/scrcpy/blob/master/BUILD.md [BUILD_simple]: BUILD.md#simple
[BUILD_simple]: https://github.com/Genymobile/scrcpy/blob/master/BUILD.md#simple
### Linux ### Linux
No Debian (_testing_ e _sid_ por enquanto) e Ubuntu (20.04): No Debian e Ubuntu:
``` ```
apt install scrcpy apt install scrcpy
``` ```
No Arch Linux:
```
pacman -S scrcpy
```
Um pacote [Snap] está disponível: [`scrcpy`][snap-link]. Um pacote [Snap] está disponível: [`scrcpy`][snap-link].
[snap-link]: https://snapstats.org/snaps/scrcpy [snap-link]: https://snapstats.org/snaps/scrcpy
@ -72,11 +79,6 @@ Para Fedora, um pacote [COPR] está disponível: [`scrcpy`][copr-link].
[COPR]: https://fedoraproject.org/wiki/Category:Copr [COPR]: https://fedoraproject.org/wiki/Category:Copr
[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/ [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]. Para Gentoo, uma [Ebuild] está disponível: [`scrcpy/`][ebuild-link].
[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
@ -90,7 +92,7 @@ Você também pode [compilar o app manualmente][BUILD] ([processo simplificado][
Para Windows, por simplicidade, um arquivo pré-compilado com todas as dependências Para Windows, por simplicidade, um arquivo pré-compilado com todas as dependências
(incluindo `adb`) está disponível: (incluindo `adb`) está disponível:
- [README][README-windows] - [README](README.md#windows)
Também está disponível em [Chocolatey]: Também está disponível em [Chocolatey]:
@ -194,6 +196,14 @@ scrcpy --max-fps 15
Isso é oficialmente suportado desde o Android 10, mas pode funcionar em versões anteriores. Isso é oficialmente suportado desde o Android 10, mas pode funcionar em versões anteriores.
O frame rate atual pode ser exibido no console:
```
scrcpy --print-fps
```
E pode ser desabilitado a qualquer momento com <kbd>MOD</kbd>+<kbd>i</kbd>.
#### Cortar #### Cortar
A tela do dispositivo pode ser cortada para espelhar apenas uma parte da tela. A tela do dispositivo pode ser cortada para espelhar apenas uma parte da tela.
@ -261,8 +271,7 @@ scrcpy -Nr file.mkv
``` ```
"Frames pulados" são gravados, mesmo que não sejam exibidos em tempo real (por "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 motivos de performance). Frames têm seu _horário carimbado_ no dispositivo, então [variação de atraso nos pacotes] não impacta o arquivo gravado.
pacotes][packet delay variation] não impacta o arquivo gravado.
[packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation [packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation
@ -270,9 +279,9 @@ pacotes][packet delay variation] não impacta o arquivo gravado.
#### v4l2loopback #### v4l2loopback
Em Linux, é possível enviar a transmissão do video para um disposiivo v4l2 loopback, assim 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 o dispositivo Android pode ser aberto como uma webcam por qualquer ferramenta capaz de v4l2
The module `v4l2loopback` must be installed: O módulo `v4l2loopback` precisa ser instalado:
```bash ```bash
sudo apt install v4l2loopback-dkms sudo apt install v4l2loopback-dkms
@ -298,7 +307,7 @@ v4l2-ctl --list-devices
ls /dev/video* ls /dev/video*
``` ```
Para iniciar o scrcpy usando o coletor v4l2 (sink): Para iniciar o `scrcpy` usando o coletor v4l2 (sink):
```bash ```bash
scrcpy --v4l2-sink=/dev/videoN scrcpy --v4l2-sink=/dev/videoN
@ -345,20 +354,55 @@ scrcpy --v4l2-buffer=500 # adiciona 500 ms de buffering para coletor V4L2
#### Sem fio #### Sem fio
_Scrcpy_ usa `adb` para se comunicar com o dispositivo, e `adb` pode [conectar-se][connect] a um _Scrcpy_ usa `adb` para se comunicar com o dispositivo, e `adb` pode [conectar-se][connect] a um
dispositivo via TCP/IP: dispositivo via TCP/IP. O dispositivo precisa estar conectado na mesma rede
que o computador.
1. Conecte o dispositivo no mesmo Wi-Fi do seu computador. #### Automático
2. Pegue o endereço IP do seu dispositivo, em Configurações → Sobre o telefone → Status, ou
A opção `--tcpip` permite configurar a conexão automaticamente. Há duas
variantes.
Se o dispositivo (acessível em 192.168.1.1 neste exemplo) escuta em uma porta
(geralmente 5555) para conexões _adb_ de entrada, então execute:
```bash
scrcpy --tcpip=192.168.1.1 # porta padrão é 5555
scrcpy --tcpip=192.168.1.1:5555
```
Se o modo TCP/IP do _adb_ estiver desabilitado no dispositivo (ou se você não
souber o endereço de IP), conecte-o via USB e execute:
```bash
scrcpy --tcpip # sem argumentos
```
Ele vai encontrar o endereço de IP do dispositivo automaticamente, habilitar
o modo TCP/IP, e então, conectar-se ao dispositivo antes de iniciar.
#### Manual
1. Conecte o dispositivo em uma porta USB do seu computador.
2. Conecte o dispositivo no mesmo Wi-Fi do seu computador.
3. Pegue o endereço IP do seu dispositivo, em Configurações → Sobre o telefone → Status, ou
executando este comando: executando este comando:
```bash ```bash
adb shell ip route | awk '{print $9}' adb shell ip route | awk '{print $9}'
``` ```
3. Ative o adb via TCP/IP no seu dispositivo: `adb tcpip 5555`. 4. Ative o adb via TCP/IP no seu dispositivo: `adb tcpip 5555`.
4. Desconecte seu dispositivo. 5. Desconecte seu dispositivo.
5. Conecte-se ao seu dispositivo: `adb connect DEVICE_IP:5555` _(substitua `DEVICE_IP`)_. 6. Conecte-se ao seu dispositivo: `adb connect DEVICE_IP:5555` _(substitua `DEVICE_IP`)_.
6. Execute `scrcpy` como de costume. 7. Execute `scrcpy` como de costume.
Desde o Android 11, a opção [Depuração por Wi-Fi][adb-wireless]
[adb-wireless]: https://developer.android.com/studio/command-line/adb#connect-to-a-device-over-wi-fi-android-11+
Se a conexão cair aleatoriamente, execute o comando `scrcpy` para reconectar. Se disser
que não encontrou dispositivos/emuladores, tente executar `adb connect DEVICE_IP:5555` novamente, e então `scrcpy` como de costume. Se ainda disser
que não encontrou nada, tente executar `adb disconnect`, e então execute os dois comandos novamente.
Pode ser útil diminuir o bit-rate e a resolução: Pode ser útil diminuir o bit-rate e a resolução:
@ -379,6 +423,9 @@ scrcpy --serial 0123456789abcdef
scrcpy -s 0123456789abcdef # versão curta scrcpy -s 0123456789abcdef # versão curta
``` ```
O serial também pode ser consultado pela variável de ambiente `ANDROID _SERIAL`
(também utilizado por `adb`)
Se o dispositivo está conectado via TCP/IP: Se o dispositivo está conectado via TCP/IP:
```bash ```bash
@ -386,6 +433,18 @@ scrcpy --serial 192.168.0.1:5555
scrcpy -s 192.168.0.1:5555 # versão curta scrcpy -s 192.168.0.1:5555 # versão curta
``` ```
Se somente um dispositivo está conectado via USB ou TCP/IP, é possível
selecioná-lo automaticamente:
```bash
# Seleciona o único dispositivo conectado via USB
scrcpy -d # assim como adb -d
scrcpy --select-usb # método extenso
# Seleciona o único dispositivo conectado via TCP/IP`
scrcpy -e # assim como adb -e
scrcpy --select-tcpip # método extenso
Você pode iniciar várias instâncias do _scrcpy_ para vários dispositivos. Você pode iniciar várias instâncias do _scrcpy_ para vários dispositivos.
#### Iniciar automaticamente quando dispositivo é conectado #### Iniciar automaticamente quando dispositivo é conectado
@ -402,17 +461,88 @@ autoadb scrcpy -s '{}'
Para conectar-se a um dispositivo remoto, é possível conectar um cliente `adb` local a 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 um servidor `adb` remoto (contanto que eles usem a mesma versão do protocolo
_adb_): _adb_)
#### Servidor ADB remoto
Para se conectar a um _adb server_ remoto, o servidor precisa escutar em todas as interfaces:
```bash ```bash
adb kill-server # encerra o servidor adb local em 5037 adb kill-server
ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer adb -a nodaemon server start
# mantenha isso aberto # mantenha isso aberto
``` ```
De outro terminal: **Aviso: todas a comunicações entre clientes e o _adb server_ não são criptografadas.**
Supondo que o servidor esteja acessível em 192.168.1.2. Então, em outro
terminal, execute `scrcpy`:
```bash ```bash
# no bash
export ADB_server_SOCKET=tcp:192.168.1.2:5037
scrcpy --tunnel-host=192.168.1.2
```
```cmd
:: in cmd
set ADB_SERVER_SOCKET=tcp:192.168.1.2:5037
scrcpy --tunnel-host=192.168.1.2
```
```powershell
# in PowerShell
$env:ADB_SERVER_SOCKET = 'tcp:192.168.1.2:5037'
scrcpy --tunnel-host=192.168.1.2
```
Por padrão, `scrcpy` usa a porta local utilizada por `adb forward` no estabelecimento de tunelagem (Tipicamente `27183`, veja `--port`). Também
é possível forçar uma porta de tunelagem diferente (pode ser útil em
situações mais complexas, quando há mais redirecionamentos envolvidos):
```
scrcpy --tunnel-port=1234
```
#### Túnel SSH
Para se comunicar a um _adb server_ remoto de um jeito seguro, é
preferível utilizar um túnel SSH.
Primeiro, tenha certeza de que o _adb server_ esteja rodando em um
computador remoto:
```bash
adb start-server
```
Então, estabeleça um túnel SSH:
```bash
# local 5038 --> remoto 5037
# local 27183 <-- remoto 27183
ssg -CN -L5038:localhost:5037 -R27183:localhost:27183 seu_computador_remoto
# mantenha isso aberto
```
De outro terminal, execute `scrcpy`:
```bash
# in bash
export ADB_SERVER_SOCKET=tcp:localhost:5038
scrcpy
```
```cmd
:: in cmd
set ADB_SERVER_SOCKET=tcp:localhost:5038
scrcpy
```
```powershell
# in PowerShell
$env:ADB_SERVER_SOCKET = 'tcp:localhost:5038'
scrcpy scrcpy
``` ```
@ -420,14 +550,29 @@ Para evitar ativar o encaminhamento de porta remota, você pode forçar uma cone
de encaminhamento (note o `-L` em vez de `-R`): de encaminhamento (note o `-L` em vez de `-R`):
```bash ```bash
adb kill-server # encerra o servidor adb local em 5037 # local 5038 --> remoto 5037
ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer # local 27183 <-- remoto 27183
ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 seu_computador_remoto
# mantenha isso aberto # mantenha isso aberto
``` ```
De outro terminal: De outro terminal, execute `scrcpy`:
```bash ```bash
# no bash
export ADB_SERVER_SOCKET=tcp:localhost:5038
scrcpy --force-adb-forward
```
```cmd
:: in cmd
set ADB_SERVER_SOCKET=tcp:localhost:5038
scrcpy --force-adb-forward
```
```powershell
# no PowerShell
$env:ADB_SERVER_SOCKET = 'tcp:localhost:5038'
scrcpy --force-adb-forward scrcpy --force-adb-forward
``` ```
@ -535,7 +680,7 @@ scrcpy --display 1
A lista de IDs dos displays pode ser obtida por: A lista de IDs dos displays pode ser obtida por:
``` ```bash
adb shell dumpsys display # busca "mDisplayId=" na saída adb shell dumpsys display # busca "mDisplayId=" na saída
``` ```
@ -552,7 +697,7 @@ scrcpy --stay-awake
scrcpy -w scrcpy -w
``` ```
O estado inicial é restaurado quando o scrcpy é fechado. O estado inicial é restaurado quando o _scrcpy_ é fechado.
#### Desligar tela #### Desligar tela
@ -581,6 +726,25 @@ scrcpy --turn-screen-off --stay-awake
scrcpy -Sw scrcpy -Sw
``` ```
#### Desligar ao fechar
Para desligar a tela do dispositivo ao fechar _scrcpy_:
```bash
scrcpy --power-off-on-close
```
#### Ligar ao iniciar
Por padrão, ao iniciar, o dispositivo é ligado.
Para prevenir esse comportamento:
```bash
scrcpy --no-power-on
```
#### Mostrar toques #### Mostrar toques
@ -602,7 +766,7 @@ Note que isto mostra apenas toques _físicos_ (com o dedo no dispositivo).
#### Desativar descanso de tela #### Desativar descanso de tela
Por padrão, scrcpy não evita que o descanso de tela rode no computador. Por padrão, _scrcpy_ não evita que o descanso de tela rode no computador.
Para desativá-lo: Para desativá-lo:
@ -661,6 +825,9 @@ de <kbd>Ctrl</kbd>+<kbd>v</kbd> e <kbd>MOD</kbd>+<kbd>v</kbd> 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 também injetem o texto da área de transferência do computador como uma sequência de eventos de tecla (da mesma
forma que <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>). forma que <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>).
Para desabilitar a sincronização automática da área de transferência, utilize
`--no-clipboard-autosync`
#### Pinçar para dar zoom #### Pinçar para dar zoom
Para simular "pinçar para dar zoom": <kbd>Ctrl</kbd>+_clicar-e-mover_. Para simular "pinçar para dar zoom": <kbd>Ctrl</kbd>+_clicar-e-mover_.
@ -669,9 +836,106 @@ Mais precisamente, segure <kbd>Ctrl</kbd> enquanto pressiona o botão de clique-
o botão de clique-esquerdo seja liberado, todos os movimentos do mouse ampliar e rotacionam o 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. conteúdo (se suportado pelo app) relativo ao centro da tela.
Concretamente, scrcpy gera eventos adicionais de toque de um "dedo virtual" em Concretamente, _scrcpy_ gera eventos adicionais de toque de um "dedo virtual" em
uma posição invertida em relação ao centro da tela. uma posição invertida em relação ao centro da tela.
#### Simulação de teclado físico (HID)
Por padrão, _scrcpy_ utiliza injeção de chave ou texto: funciona em qualquer lugar,
mas é limitado a ASCII.
Alternativamente, `scrcpy` pode simular um teclado USB físico no Android
para servir uma melhor experiência de entrada de teclas (utilizando [USB HID por AOAv2][hid-aoav2]):
o teclado virtual é desabilitado e funciona para todos os caractéres e IME.
[hid-aoav2]: https://source.android.com/devices/accessories/aoa2#hid-support
Porém, só funciona se o dispositivo estiver conectado via USB.
Nota: No Windows, pode funcionar somente no [modo OTG](#otg), não esquanto espelhando (não
é possível abrir um dispositivo USB se ele já estiver em uso por outro processo
como o _adb daemon_).
Para habilitar esse modo:
```bash
scrcpy --hid-keyboard
scrcpy -K # versão curta
```
Se falhar por algum motivo (por exemplo, se o dispositivo não estiver conectado via
USB), ele automaticamente retorna para o modo padrão (com um log no console). Isso permite utilizar as mesmas linhas de comando de quando conectado por
USB e TCP/IP.
Neste modo, eventos de tecla bruta (scancodes) são enviados ao dispositivo, independentemente
do mapeamento de teclas do hospedeiro. Portanto, se o seu layout de teclas não é igual, ele
precisará ser configurado no dispositivo Android, em Configurações → Sistema → Idiomas e entrada → [Teclado_físico].
Essa página de configurações pode ser aberta diretamente:
```bash
adb shell am start -a android.settings.HARD_KEYBOARD_SETTINGS
```
Porém, essa opção só está disponível quando o teclado HID está habilitado (ou quando
um teclado físico é conectado).
[Teclado_físico]: https://github.com/Genymobile/scrcpy/pull/2632#issuecomment-923756915
#### Simulação de mouse físico (HID)
Similar a simulação de teclado físico, é possível simular um mouse físico. Da mesma forma, só funciona se o dispositivo está conectado por USB.
Por padrão, _scrcpy_ utilizada injeção de eventos do mouse com coordenadas absolutas. Ao simular um mouse físico, o ponteiro de mouse aparece no
dispositivo Android, e o movimento relativo do mouse, cliques e scrolls são injetados.
Para habilitar esse modo:
```bash
scrcpy --hid-mouse
scrcpy -M # versão curta
```
Você também pode adicionar `--forward-all-clicks` para [enviar todos os botões do mouse][forward_all_clicks].
[forward_all_clicks]: #clique-direito-e-clique-do-meio
Quando esse modo é habilitado, o mouse do computador é "capturado" (o ponteiro do mouse
desaparece do computador e aparece no dispositivo Android).
Teclas especiais de captura, como <kbd>Alt</kbd> ou <kbd>Super</kbd>, alterna
(desabilita e habilita) a captura do mouse. Utilize uma delas para dar o controle
do mouse de volta para o computador.
#### OTG
É possível executar _scrcpy_ somente com simulação de mouse e teclado físicos
(HID), como se o teclado e mouse do computador estivessem conectados diretamente ao dispositivo
via cabo OTG.
Nesse modo, `adb` (Depuração USB) não é necessária, e o espelhamento é desabilitado.
Para habilitar o modo OTG:
```bash
scrcpy --otg
# Passe o serial de houver diversos dispositivos USB disponíveis
scrcpy --otg -s 0123456789abcdef
```
É possível habilitar somente teclado HID ou mouse HID:
```bash
scrcpy --otg --hid-keyboard # somente teclado
scrcpy --otg --hid-mouse # somente mouse
scrcpy --otg --hid-keyboard --hid-mouse # teclado e mouse
# para conveniência, habilite ambos por padrão
scrcpy --otg # teclado e mouse
```
Como `--hid-keyboard` e `--hid-mouse`, só funciona se o dispositivo estiver conectado por USB.
#### Preferência de injeção de texto #### Preferência de injeção de texto
@ -691,6 +955,14 @@ scrcpy --prefer-text
(mas isso vai quebrar o comportamento do teclado em jogos) (mas isso vai quebrar o comportamento do teclado em jogos)
Ao contrário, você pode forçar para sempre injetar eventos de teclas brutas:
```bash
scrcpy --raw-key-events
```
Essas opções não surgem efeito no teclado HID (todos os eventos de tecla são enviados como scancodes nesse modo).
[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input [textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343 [prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
@ -706,6 +978,8 @@ Para evitar o encaminhamento eventos de tecla repetidos:
scrcpy --no-key-repeat scrcpy --no-key-repeat
``` ```
Essa opção não surge efeito no teclado HID (repetição de tecla é gerida diretamente pelo
Android nesse modo).
#### Clique-direito e clique-do-meio #### Clique-direito e clique-do-meio
@ -737,7 +1011,7 @@ Não existe feedback visual, um log é imprimido no console.
O diretório alvo pode ser mudado ao iniciar: O diretório alvo pode ser mudado ao iniciar:
```bash ```bash
scrcpy --push-target /sdcard/foo/bar/ scrcpy --push-target=/sdcard/Movies/
``` ```
@ -745,10 +1019,10 @@ scrcpy --push-target /sdcard/foo/bar/
Áudio não é encaminhado pelo _scrcpy_. Use [sndcpy]. Áudio não é encaminhado pelo _scrcpy_. Use [sndcpy].
Também veja [issue #14]. Também veja [issue_#14].
[sndcpy]: https://github.com/rom1v/sndcpy [sndcpy]: https://github.com/rom1v/sndcpy
[issue #14]: https://github.com/Genymobile/scrcpy/issues/14 [issue_#14]: https://github.com/Genymobile/scrcpy/issues/14
## Atalhos ## Atalhos
@ -798,11 +1072,14 @@ _<kbd>[Super]</kbd> é tipicamente a tecla <kbd>Windows</kbd> ou <kbd>Cmd</kbd>.
| Injetar texto da área de transferência do computador | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> | Injetar texto da área de transferência do computador | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
| Ativar/desativar contador de FPS (em stdout) | <kbd>MOD</kbd>+<kbd>i</kbd> | Ativar/desativar contador de FPS (em stdout) | <kbd>MOD</kbd>+<kbd>i</kbd>
| Pinçar para dar zoom | <kbd>Ctrl</kbd>+_Clicar-e-mover_ | Pinçar para dar zoom | <kbd>Ctrl</kbd>+_Clicar-e-mover_
| Segure e arraste um arquivo APK | Instala APK pelo computador
| Segure e arraste arquivo não-APK | [Enviar arquivo para o dispositivo](#push-file-to-device)
_¹Clique-duplo-esquerdo na borda preta para remove-la._ _¹Clique-duplo-esquerdo na borda preta para remove-la._
_²Clique-direito liga a tela caso esteja desligada, pressione BACK caso contrário._ _²Clique-direito liga a tela caso esteja desligada, pressione BACK caso contrário._
_³4.° and 5.° botões do mouse, caso o mouse possua._ _³4.° and 5.° botões do mouse, caso o mouse possua._
_⁴Apenas em Android >= 7._ _⁴Para aplicativos react-native em desenvolvimento,`MENU` dispara o menu de desenvolvimento_
_⁵Apenas em Android >= 7._
Atalhos com teclas reptidas são executados soltando e precionando a tecla Atalhos com teclas reptidas são executados soltando e precionando a tecla
uma segunda vez. Por exemplo, para executar "Expandir painel de Configurção": uma segunda vez. Por exemplo, para executar "Expandir painel de Configurção":
@ -827,7 +1104,7 @@ ADB=/caminho/para/adb scrcpy
Para sobrepor o caminho do arquivo `scrcpy-server`, configure seu caminho em Para sobrepor o caminho do arquivo `scrcpy-server`, configure seu caminho em
`SCRCPY_SERVER_PATH`. `SCRCPY_SERVER_PATH`.
[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345 Para sobrepor o ícone, configure seu caminho em `SCRCPY_ICON_PATH`.
## Por quê _scrcpy_? ## Por quê _scrcpy_?
@ -849,14 +1126,14 @@ Veja [BUILD].
Veja o [FAQ]. Veja o [FAQ].
[FAQ]: https://github.com/Genymobile/scrcpy/blob/master/FAQ.md [FAQ:] FAQ.md
## Desenvolvedores ## Desenvolvedores
Leia a [página dos desenvolvedores][DEVELOP]. Leia a [página dos desenvolvedores][developers_page].
[DEVELOP]: https://github.com/Genymobile/scrcpy/blob/master/DEVELOP.md [developers_page]: DEVELOP.md
## Licença ## Licença
@ -883,3 +1160,14 @@ Leia a [página dos desenvolvedores][DEVELOP].
[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/ [article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/ [article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
## Contato
Se você encontrar um bug, por favor leia o [FAQ] primeiro, depois abra um [issue].
[issue]: https://github.com/Genymobile/scrcpy/issues
Para perguntar em geral ou discussões, você também pode usar:
- Reddit: [`r/scrcpy`](https://www.reddit.com/r/scrcpy)
- Twitter: [`@scrcpy_app`](https://twitter.com/scrcpy_app)