README.pt br

Apenas o README original é garantido estar atualizado.

scrcpy (v1.24)

Esta aplicação fornece exibição e controle de dispositivos Android conectados via USB (ou via TCP/IP). Não requer nenhum acesso root. Funciona em GNU/Linux, Windows e macOS.

screenshot

Foco em:

leveza (nativo, mostra apenas a tela do dispositivo)
performance (30~120fps, dependendo do dispositivo)
qualidade (1920×1080 ou acima)
baixa latência (35~70ms)
baixo tempo de inicialização (~1 segundo para mostrar a primeira imagem)
não intrusivo (nada é deixado instalado no dispositivo)

Requisitos

O dispositivo Android requer pelo menos a API 21 (Android 5.0).

Tenha certeza de ter ativado a depuração adb no(s) seu(s) dispositivo(s).

Em alguns dispositivos, você também precisa ativar uma opção adicional para controlá-lo usando teclado e mouse.

Obter o app

Sumário

Linux: apt install scrcpy
Windows: baixar
macOS: brew install scrcpy

Compilar pelos arquivos fontes: BUILD (processo simplificado)

Linux

No Debian e Ubuntu:

apt install scrcpy

No Arch Linux:

pacman -S scrcpy

Um pacote Snap está disponível: scrcpy.

Para Fedora, um pacote COPR está disponível: scrcpy.

Para Gentoo, uma Ebuild está disponível: scrcpy/.

Você também pode compilar o app manualmente (processo simplificado).

Windows

Para Windows, por simplicidade, um arquivo pré-compilado com todas as dependências (incluindo adb) está disponível:

README

Também está disponível em Chocolatey:

choco install scrcpy
choco install adb    # se você ainda não o tem

E no Scoop:

scoop install scrcpy
scoop install adb    # se você ainda não o tem

Você também pode compilar o app manualmente.

macOS

A aplicação está disponível em Homebrew. Apenas instale-a:

brew install scrcpy

Você precisa do adb, acessível pelo seu PATH. Se você ainda não o tem:

brew install android-platform-tools

Está também disponivel em MacPorts, que prepara o adb para você:

sudo port install scrcpy

Você também pode compilar o app manualmente.

Executar

Conecte um dispositivo Android e execute:

scrcpy

Também aceita argumentos de linha de comando, listados por:

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

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

scrcpy --bit-rate 2M
scrcpy -b 2M  # versão curta

Limitar frame rate

O frame rate de captura pode ser limitado:

scrcpy --max-fps 15

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

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:

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:

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

Encoder

Alguns dispositivos têm mais de um encoder, e alguns deles podem causar problemas ou travar. É possível selecionar um encoder diferente:

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:

scrcpy --encoder _

Captura

Gravando

É possível gravar a tela enquanto ocorre o espelhamento:

scrcpy --record file.mp4
scrcpy -r file.mkv

Para desativar o espelhamento durante a gravação:

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] não impacta o arquivo gravado.

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 ferramenta capaz de v4l2

O módulo v4l2loopback precisa ser instalado:

sudo apt install v4l2loopback-dkms

Para criar um dispositivo v4l2:

sudo modprobe v4l2loopback

Isso criara um novo dispositivo de vídeo em /dev/videoN, onde N é uma integer (mais opções estão disponiveis para criar varios dispositivos ou dispositivos com IDs específicas).

Para listar os dispositivos disponíveis:

# 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):

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:

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.

Buffering

É possivel adicionar buffering. Isso aumenta a latência, mas reduz a tenção (jitter) (veja #2464).

A opção éta disponivel para buffering de exibição:

scrcpy --display-buffer=50  # adiciona 50 ms de buffering para a exibição

e coletor V4L2:

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 a um dispositivo via TCP/IP. O dispositivo precisa estar conectado na mesma rede que o computador.

Automático

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:

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:

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

Conecte o dispositivo em uma porta USB do seu computador.
Conecte o dispositivo no mesmo Wi-Fi do seu computador.
Pegue o endereço IP do seu dispositivo, em Configurações → Sobre o telefone → Status, ou executando este comando:
```
adb shell ip route | awk '{print $9}'
```
Ative o adb via TCP/IP no seu dispositivo: adb tcpip 5555.
Desconecte seu dispositivo.
Conecte-se ao seu dispositivo: adb connect DEVICE_IP:5555 (substitua DEVICE_IP).
Execute scrcpy como de costume.

Desde o Android 11, a opção Depuração por Wi-Fi

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:

scrcpy --bit-rate 2M --max-size 800
scrcpy -b2M -m800  # versão curta

Múltiplos dispositivos

Se vários dispositivos são listados em adb devices, você deve especificar o serial:

scrcpy --serial 0123456789abcdef
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:

scrcpy --serial 192.168.0.1:5555
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:

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

#### Iniciar automaticamente quando dispositivo é conectado

Você pode usar [AutoAdb]:

```bash
autoadb scrcpy -s '{}'

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)

Servidor ADB remoto

Para se conectar a um adb server remoto, o servidor precisa escutar em todas as interfaces:

adb kill-server
adb -a nodaemon server start
# mantenha isso aberto

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:

# no bash
export ADB_server_SOCKET=tcp:192.168.1.2:5037
scrcpy --tunnel-host=192.168.1.2

:: in cmd
set ADB_SERVER_SOCKET=tcp:192.168.1.2:5037
scrcpy --tunnel-host=192.168.1.2

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

adb start-server

Então, estabeleça um túnel SSH:

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

# in bash
export ADB_SERVER_SOCKET=tcp:localhost:5038
scrcpy

:: in cmd
set ADB_SERVER_SOCKET=tcp:localhost:5038
scrcpy

# in PowerShell
$env:ADB_SERVER_SOCKET = 'tcp:localhost:5038'
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):

# local  5038 --> remoto  5037
# local 27183 <-- remoto 27183
ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 seu_computador_remoto
# mantenha isso aberto

De outro terminal, execute scrcpy:

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

:: in cmd
set ADB_SERVER_SOCKET=tcp:localhost:5038
scrcpy --force-adb-forward

# no PowerShell
$env:ADB_SERVER_SOCKET = 'tcp:localhost:5038'
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:

scrcpy --window-title 'Meu dispositivo'

Posição e tamanho

A posição e tamanho iniciais da janela podem ser especificados:

scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600

Sem bordas

Para desativar decorações de janela:

scrcpy --window-borderless

Sempre no topo

Para manter a janela do scrcpy sempre no topo:

scrcpy --always-on-top

Tela cheia

A aplicação pode ser iniciada diretamente em tela cheia:

scrcpy --fullscreen
scrcpy -f  # versão curta

Tela cheia pode ser alternada dinamicamente com MOD+f.

Rotação

A janela pode ser rotacionada:

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

scrcpy --no-control
scrcpy -n

Display

Se vários displays estão disponíveis, é possível selecionar o display para espelhar:

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:

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:

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:

scrcpy --turn-screen-off --stay-awake
scrcpy -Sw

Desligar ao fechar

Para desligar a tela do dispositivo ao fechar scrcpy:

scrcpy --power-off-on-close

Ligar ao iniciar

Por padrão, ao iniciar, o dispositivo é ligado.

Para prevenir esse comportamento:

scrcpy --no-power-on

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:

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:

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

Para desabilitar a sincronização automática da área de transferência, utilize --no-clipboard-autosync

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.

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): o teclado virtual é desabilitado e funciona para todos os caractéres e IME.

Porém, só funciona se o dispositivo estiver conectado via USB.

Nota: No Windows, pode funcionar somente no modo 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:

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:

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

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:

scrcpy --hid-mouse
scrcpy -M  # versão curta

Você também pode adicionar --forward-all-clicks para enviar todos os botões do mouse.

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 Alt ou Super, 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:

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:

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

Existem dois tipos de eventos 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. Se você encontrar tal problema, você pode evitá-lo com:

scrcpy --prefer-text

(mas isso vai quebrar o comportamento do teclado em jogos)

Ao contrário, você pode forçar para sempre injetar eventos de teclas brutas:

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

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:

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

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:

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:

scrcpy --push-target=/sdcard/Movies/

Encaminhamento de áudio

Áudio não é encaminhado pelo scrcpy. Use sndcpy.

Também veja issue_#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:

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

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
Segure e arraste um arquivo APK	Instala APK pelo computador
Segure e arraste arquivo não-APK	Enviar arquivo para o dispositivo

¹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. ⁴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 uma segunda vez. Por exemplo, para executar "Expandir painel de Configurção":

Mantenha pressionado MOD.
Depois click duas vezes n.
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:

ADB=/caminho/para/adb scrcpy

Para sobrepor o caminho do arquivo scrcpy-server, configure seu caminho em SCRCPY_SERVER_PATH.

Para sobrepor o ícone, configure seu caminho em SCRCPY_ICON_PATH.

Por quê scrcpy?

Um colega me desafiou a encontrar um nome tão impronunciável quanto gnirehtet.

strcpy copia uma string; scrcpy copia uma screen.

Como compilar?

Veja BUILD.

Problemas comuns

Veja o FAQ.

Desenvolvedores

Leia a página dos desenvolvedores.

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

Contato

Se você encontrar um bug, por favor leia o FAQ primeiro, depois abra um issue.

Para perguntar em geral ou discussões, você também pode usar:

Reddit: r/scrcpy
Twitter: @scrcpy_app

README.pt br

scrcpy (v1.24)

Requisitos

Obter o app

Sumário

Linux

Windows

macOS

Executar

Funcionalidades

Configuração de captura

Reduzir tamanho

Mudar bit-rate

Limitar frame rate

Cortar

Travar orientação do vídeo

Encoder

Captura

Gravando

v4l2loopback

Buffering

Conexão

Sem fio

Automático

Manual

Múltiplos dispositivos

Túnel SSH

Servidor ADB remoto

Túnel SSH

Configuração de janela

Título

Posição e tamanho

Sem bordas

Sempre no topo

Tela cheia

Rotação

Outras opções de espelhamento

Apenas leitura

Display

Permanecer ativo

Desligar tela

Desligar ao fechar

Ligar ao iniciar

Mostrar toques

Desativar descanso de tela

Controle de entrada

Rotacionar a tela do dispositivo

Copiar-colar

Pinçar para dar zoom

Simulação de teclado físico (HID)

Simulação de mouse físico (HID)

OTG

Preferência de injeção de texto

Repetir tecla

Clique-direito e clique-do-meio

Soltar arquivo

Instalar APK

Enviar arquivo para dispositivo

Encaminhamento de áudio

Atalhos

Caminhos personalizados

Por quê scrcpy?

Como compilar?

Problemas comuns

Desenvolvedores

Licença

Artigos

Contato

Clone this wiki locally