O Android Debug Bridge (adb
) é uma ferramenta de linha de comando versátil que permite a comunicação com um
dispositivo. O comando adb
facilita várias ações do dispositivo, como instalar e
depurar apps. adb
fornece acesso a um shell Unix que pode ser usado para executar diversos
comandos em um dispositivo. Ele é um programa cliente-servidor com três componentes:
- Um cliente, que envia comandos. O cliente é executado na máquina de desenvolvimento. Você pode
emitir um comando
adb
para invocar o cliente de um terminal de linha de comando. - Um daemon (adbd), que executa comandos em um dispositivo. O daemon é executado como um processo em segundo plano em cada dispositivo.
- Um servidor, que gerencia a comunicação entre o cliente e o daemon. O servidor é executado como um processo em segundo plano na máquina de desenvolvimento.
adb
está incluído no pacote Android SDK Platform Tools. Faça o download desse
pacote com o SDK Manager, que o instala
em android_sdk/platform-tools/
. Se quiser o pacote autônomo Android SDK
Platform Tools, faça o download aqui.
Para saber mais sobre como conectar um dispositivo para uso no adb
, incluindo como usar o Connection
Assistant para solucionar problemas comuns, consulte
Executar apps em um dispositivo de hardware.
Como o adb funciona
Quando você inicia um cliente adb
, primeiro ele verifica se há um
processo do servidor adb
em execução. Se não houver, ele iniciará esse processo.
Quando o servidor é iniciado, ele é vinculado à porta TCP 5037 local e detecta comandos enviados de
clientes adb
.
Observação: todos os clientes adb
usam a porta 5037 para se comunicar
com o servidor adb
.
Em seguida, o servidor configura as conexões para todos os dispositivos em execução.
Ele localiza os emuladores verificando as portas de número ímpar no intervalo
de 5555 a 5585, o que é usado pelos primeiros 16 emuladores. Onde o servidor encontra um daemon
do adb
(adbd), ele configura uma conexão com a porta em questão.
Cada emulador usa um par de portas sequenciais: uma porta com numeração par para
conexões de console e uma porta ímpar para conexões adb
. Exemplo:
Emulador 1, console: 5554
Emulador 1, adb
: 5555
Emulador 2, console: 5556
Emulador 2, adb
: 5557
e assim por diante.
Conforme mostrado, o emulador conectado ao adb
na porta 5555 é o mesmo que tem um
console que ouve na porta 5554.
Depois que o servidor configurar conexões com todos os dispositivos, você vai poder usar os comandos adb
para
acessá-los. Como o servidor gerencia conexões com dispositivos e manipula
comandos de vários clientes adb
, você pode controlar qualquer dispositivo de qualquer cliente (ou
de um script).
Ativar a depuração do adb no seu dispositivo
Para usar o adb com um dispositivo conectado via USB, você precisa ativar a opção Depuração USB nas configurações do sistema do dispositivo, em Opções do desenvolvedor. No Android 4.2 (nível 17 da API) e versões mais recentes, a tela Opções do desenvolvedor está oculta por padrão. Para que ela fique visível, ative as Opções do desenvolvedor.
Agora você pode conectar seu dispositivo a uma porta USB. Verifique se o dispositivo está conectado executando adb devices
no diretório android_sdk/platform-tools/
. Se eles estiverem conectados,
o nome do dispositivo estará listado como “device”.
Observação: ao conectar um dispositivo com o Android 4.2.2 (nível 17 da API) ou versões mais recentes, o sistema vai mostrar uma caixa de diálogo perguntando se o usuário quer aceitar uma Chave RSA que permite fazer a depuração pelo computador. Esse mecanismo de segurança protege dispositivos de usuários, já que garante que a depuração USB e outros comandos do adb não sejam executados, a menos que você desbloqueie o dispositivo e confirme a caixa de diálogo.
Para saber mais sobre a conexão com um dispositivo por USB, leia Executar apps em um dispositivo de hardware.
Conectar-se a um dispositivo por Wi-Fi
Observação: as instruções abaixo não se aplicam a dispositivos Wear com o Android 11 (nível 30 da API). Para mais informações, consulte o guia sobre como depurar um app do Wear OS.
O Android 11 (nível 30 da API) e versões mais recentes oferecem suporte à implantação e depuração do app por Wi-Fi na estação de trabalho usando o Android Debug Bridge (adb). Por exemplo, é possível implantar a função depurável a vários dispositivos remotos sem precisar conectá-lo fisicamente via USB Isso elimina a necessidade de resolver problemas comuns de conexão USB, como e instalação.
Antes de começar a usar a depuração por Wi-Fi, siga estas etapas:
-
Confira se a estação de trabalho e o dispositivo estão conectados à mesma rede Wi-Fi.
-
Confira se o dispositivo está executando o Android 11 (nível 30 da API) ou uma versão mais recente para smartphone ou o Android 13 (nível 33 da API) ou uma versão mais recente para TV e WearOS. Para saber mais, consulte Verificar e atualizar a versão do Android.
-
Se você estiver usando o ambiente de desenvolvimento integrado, confira se tem a versão mais recente do Android Studio instalada. Você pode fazer o download dele clicando aqui.
-
Na sua estação de trabalho, instale a versão mais recente do SDK Platform Tools.
Para usar a depuração por Wi-Fi, é necessário parear seu dispositivo à estação de trabalho usando um QR code ou de pareamento. A estação de trabalho e o dispositivo precisam estar conectados à mesma rede Wi-Fi. Para se conectar ao dispositivo, siga estas etapas:
-
Ative as Opções do desenvolvedor no dispositivo.
-
Abra o Android Studio e selecione Pair Devices Using Wi-Fi no menu de configurações de execução.
Figura 1. Menu de configurações de execução.A janela Pair devices over Wi-Fi aparece, como mostrado na Figura 2.
Figura 2. Janela pop-up de pareamento de dispositivos por QR code ou código de pareamento. -
No dispositivo, toque em Depuração por Wi-Fi e faça o pareamento:
Figura 3. Captura de tela da configuração de depuração por Wi-Fi em um smartphone Google Pixel.-
Se quiser parear o dispositivo com um QR code, selecione Parear o dispositivo com um QR code e leia o código recebido pelo pop-up Pair devices over Wi-Fi mostrado na Figura 2.
-
Se quiser usar um código de pareamento, selecione Parear o dispositivo com um código de pareamento na janela pop-up Pair devices over Wi-Fi descrita acima. No dispositivo, selecione Parear usando o código de pareamento e salve o código de seis dígitos fornecido. Quando o dispositivo aparecer na janela Pair devices over Wi-Fi, selecione Pair e digite o código de seis dígitos mostrado no dispositivo.
Figura 4. Exemplo de entrada de código de seis dígitos.
-
-
Após o pareamento, você pode tentar implantar o app no dispositivo.
Se quiser parear um dispositivo diferente ou remover o seu da estação de trabalho, acesse Depuração por Wi-Fi no dispositivo. Toque no nome da estação em Dispositivos pareados e selecione Esquecer.
-
Se quiser ativar ou desativar rapidamente a depuração por Wi-Fi, use os Blocos de desenvolvedor para configurações rápidas da Depuração por Wi-Fi, encontrados em Opções do desenvolvedor > Blocos de desenvolvedor para configurações rápidas.
Figura 5. A configuração Blocos de desenvolvedor para configurações rápidas permite ativar e desativar rapidamente a depuração por Wi-Fi.
Conexão Wi-Fi usando a linha de comando
Para se conectar ao dispositivo por linha de comando sem usar o Android Studio, siga estas etapas:
-
Ative as Opções do desenvolvedor no seu dispositivo, conforme descrito acima.
-
Ative a Depuração por Wi-Fi no seu dispositivo, conforme descrito acima.
-
Na estação de trabalho, abra uma janela do terminal e navegue até
android_sdk/platform-tools
. -
Encontre seu endereço IP, o número da porta e o código de pareamento selecionando Parear o dispositivo com um código de pareamento. Salve o endereço IP, o número da porta e o código de pareamento mostrados no dispositivo.
-
No terminal da estação de trabalho, execute o
adb pair ipaddr:port
. Use o endereço IP e o número da porta das etapas acima. -
Quando solicitado, digite o código de pareamento, conforme mostrado abaixo.
Figura 6. Uma mensagem indica que o pareamento do dispositivo foi concluído.
Resolver problemas de conexão sem fio
Se você estiver com problemas para conectar o dispositivo sem usar fios, tente seguir as etapas de solução de problemas abaixo.
Conferir se a estação de trabalho e o dispositivo atendem aos pré-requisitos
Confira se a estação de trabalho e o dispositivo atendem aos pré-requisitos listados no início desta seção.
Conferir se há outros problemas conhecidos
Esta é uma lista dos problemas conhecidos atuais da depuração por Wi-Fi (com adb ou Android). Studio) e como resolvê-los:
-
O Wi-Fi não conecta: redes Wi-Fi seguras, como as corporativas, O pode bloquear conexões P2P e não permitir que você se conecte por Wi-Fi. Tente conectar com um cabo ou outra rede Wi-Fi (não corporativa). Conexão sem fio usando
adb connect ip:port
por TCP/IP (após uma conexão USB inicial) é outra opção, caso usar uma rede não corporativa seja uma opção. -
Às vezes, o
adb
por Wi-Fi é desativado automaticamente: isso pode acontecer se o dispositivo alternar entre redes Wi-Fi ou se desconectar da rede. Para resolver, reconecte-se à rede. -
O dispositivo não se conecta após o pareamento: o
adb
depende do mDNS para descobrir e se conectar automaticamente a dispositivos pareados. Se sua rede ou dispositivo configuração não oferecer suporte ao mDNS ou o tiver desativado, será necessário conecte-se ao dispositivo usandoadb connect ip:port
.
Conectar-se sem fio a um dispositivo após uma conexão USB inicial (somente opção disponível no Android 10 e versões anteriores)
Observação:esse fluxo de trabalho também se aplica ao Android 11 (e superior), com a ressalva de que isso também envolve uma conexão *inicial* via USB físico.
Observação: as instruções abaixo não se aplicam a dispositivos Wear com o Android 10 (nível 29 da API) ou versões anteriores. Para saber mais, consulte o guia sobre como depurar um app do Wear OS.
O adb
normalmente se comunica com o dispositivo por USB, mas você também pode usar
adb
por Wi-Fi. Para conectar por USB um dispositivo com o Android 10 (nível 29 da API) ou uma versão anterior,
siga estas etapas iniciais:
-
Conecte o dispositivo Android e o computador host
adb
a uma rede Wi-Fi comum. - Conecte o dispositivo ao computador host usando um cabo USB.
-
Configure o dispositivo de destino para detectar uma conexão TCP/IP na porta 5555:
adb tcpip 5555
- Desconecte a porta USB do dispositivo de destino.
- Encontre o endereço IP do dispositivo Android. Por exemplo, em um dispositivo Nexus, você pode encontrar o endereço IP em Configurações > Sobre o tablet (ou Sobre o dispositivo) > Status > Endereço IP.
-
Conecte-se ao dispositivo pelo endereço IP.
adb connect device_ip_address:5555
-
Confirme se o computador host está conectado ao dispositivo de destino:
$ adb devices List of devices attached device_ip_address:5555 device
Observação: nem todos os pontos de acesso
são adequados. Pode ser necessário usar um ponto de acesso
com um firewall configurado para oferecer suporte a adb
.
Seu dispositivo está conectado ao adb
.
Se a conexão adb
com o dispositivo for perdida, siga estas etapas:
- Confira se o host ainda está conectado à mesma rede Wi-Fi do dispositivo Android.
-
Execute o comando
adb connect
novamente para reconectar. -
Se isso não funcionar, redefina o host do
adb
:adb kill-server
Em seguida, reinicie o processo.
Consultar dispositivos
Antes de emitir comandos adb
, é útil saber quais instâncias do dispositivo estão conectadas
ao servidor adb
. Gere uma lista de dispositivos conectados usando o
comando devices
:
adb devices -l
Em resposta, o adb
mostra as seguintes informações de status para cada dispositivo:
- Número de série:
adb
cria uma string para identificar exclusivamente o dispositivo pelo número da porta. Veja um exemplo de número de série:emulator-5554
. - Estado: o estado da conexão do dispositivo pode ser um dos seguintes:
offline
: o dispositivo não está conectado aoadb
ou não está respondendo.device
: o dispositivo está conectado ao servidoradb
. Observe que esse estado não implica que o sistema Android esteja totalmente inicializado e operacional, já que o dispositivo se conecta aoadb
enquanto o sistema ainda está sendo inicializado. Após a inicialização, esse é o estado operacional normal de um dispositivo.no device
: não há dispositivos conectados.
- Descrição: se você incluir a opção
-l
, o comandodevices
vai informar qual é o dispositivo. Essa informação é útil quando há vários dispositivos conectados para que você possa diferenciá-los.
O exemplo a seguir mostra o comando devices
e a saída dele. Existem três
dispositivos em execução. As duas primeiras linhas da lista são emuladores e a terceira linha é um dispositivo
de hardware conectado ao computador.
$ adb devices List of devices attached emulator-5556 device product:sdk_google_phone_x86_64 model:Android_SDK_built_for_x86_64 device:generic_x86_64 emulator-5554 device product:sdk_google_phone_x86 model:Android_SDK_built_for_x86 device:generic_x86 0a388e93 device usb:1-1 product:razor model:Nexus_7 device:flo
Emulador não listado
adb devices
tem uma sequência de comando de caso isolado que faz com que os emuladores
em execução não apareçam na saída de adb devices
mesmo que
estejam visíveis na sua área de trabalho. Isso acontece quando todas estas condições
são verdadeiras:
- O servidor
adb
não está em execução. - Você usa o comando
emulator
com a opção-port
ou-ports
com um valor de porta ímpar entre 5554 e 5584. - A porta de numeração ímpar escolhida não está ocupada, portanto, a conexão pode ser feita no número especificado. Se estiver ocupada, o emulador alternará para outra porta que atenda aos requisitos do item 2.
- Você inicia o servidor
adb
depois de iniciar o emulador.
Uma maneira de evitar essa situação é deixar o emulador escolher as próprias portas e executar até
16 emuladores de uma só vez. Outra maneira é sempre iniciar o servidor adb
antes de usar o
comando emulator
, conforme explicado nos exemplos a seguir.
Exemplo 1: na sequência de comandos a seguir, o comando adb devices
inicia
o servidor adb
, mas a lista de dispositivos não é mostrada.
Pare o servidor adb
e insira os comandos a seguir na ordem mostrada. Para o nome, forneça
um nome de AVD válido do seu sistema. Para ver uma lista de nomes de AVD, digite
emulator -list-avds
. O comando emulator
está no
diretório android_sdk/tools
.
$ adb kill-server $ emulator -avd Nexus_6_API_25 -port 5555 $ adb devices List of devices attached * daemon not running. starting it now on port 5037 * * daemon started successfully *
Exemplo 2: na sequência de comandos a seguir, adb devices
mostra a
lista de dispositivos porque o servidor adb
foi iniciado primeiro.
Para ver o emulador na saída adb devices
, pare o servidor adb
e reinicie-o
depois de usar o comando emulator
e antes de usar o
comando adb devices
, como mostrado a seguir:
$ adb kill-server $ emulator -avd Nexus_6_API_25 -port 5557 $ adb start-server $ adb devices List of devices attached emulator-5557 device
Para saber mais sobre as opções de linha de comando do emulador, consulte Opções de inicialização de linha de comando.
Enviar comandos a um dispositivo específico
Se vários dispositivos estiverem em execução, você vai precisar especificar o dispositivo de destino
ao emitir o comando adb
.
Para especificar o destino, siga estas etapas:
- Use o comando
devices
para ver o número de série do destino. - Com o número de série em mãos, use a
opção
-s
com os comandosadb
para especificar o número de série.- Se você for emitir muitos comandos
adb
, defina a variável de ambiente$ANDROID_SERIAL
para conter o número de série. - Se você usar
-s
e$ANDROID_SERIAL
,-s
vai modificar$ANDROID_SERIAL
.
- Se você for emitir muitos comandos
No exemplo a seguir, a lista de dispositivos conectados é acessada e, em seguida, o número
de série de um dos dispositivos é usado para instalar o helloWorld.apk
no dispositivo.
$ adb devices List of devices attached emulator-5554 device emulator-5555 device 0.0.0.0:6520 device # To install on emulator-5555 $ adb -s emulator-5555 install helloWorld.apk # To install on 0.0.0.0:6520 $ adb -s 0.0.0.0:6520 install helloWorld.apk
Observação:se você emitir um comando sem especificar um dispositivo de destino.
Quando vários dispositivos estão disponíveis, o adb
mostra um erro
"adb: mais de um dispositivo/emulador".
Se você tiver vários dispositivos disponíveis, mas apenas um for um emulador,
use a opção -e
para enviar comandos ao emulador. Se houver vários
dispositivos, mas apenas um dispositivo de hardware anexado, use a opção -d
para enviar comandos ao
dispositivo de hardware.
Instalar um app
Você pode usar o adb
para instalar um APK em um emulador ou dispositivo conectado
com o comando install
:
adb install path_to_apk
Use a opção -t
com o comando install
ao instalar um APK de teste. Para ver mais informações,
consulte -t
.
Para instalar vários APKs, use install-multiple
. Isso é útil se você fizer o download de todos
os APKs de um dispositivo específico para seu app no Play Console e quiser instalá-los em um
emulador ou dispositivo físico.
Para saber mais sobre a criação de um arquivo de APK que possa ser instalado em uma instância de emulador/dispositivo, consulte Criar e executar o app.
Observação: se você está usando o Android Studio, não precisa usar
adb
diretamente para instalar o app no emulador ou dispositivo. Em vez disso, o Android Studio
vai realizar o empacotamento e a instalação do app para você.
Configurar o encaminhamento de portas
Use o comando forward
para configurar o encaminhamento de portas arbitrário, que
encaminha solicitações em uma porta de host específica para uma porta diferente em um dispositivo.
O exemplo a seguir configura o encaminhamento da porta de host 6100 para a porta de dispositivo 7100:
adb forward tcp:6100 tcp:7100
O exemplo a seguir configura o encaminhamento da porta de host 6100 para local:logd:
adb forward tcp:6100 local:logd
Isso pode ser útil ao tentar determinar o que está sendo enviado para uma porta específica no dispositivo. Todos os dados recebidos são gravados no daemon de geração de registros do sistema e mostrados nos registros do dispositivo.
Copiar arquivos de e para um dispositivo
Use os comandos pull
e push
para copiar arquivos de
e para um dispositivo. Diferente do comando install
,
que apenas copia um arquivo de APK para um local específico, pull
e push
permitem copiar diretórios e arquivos arbitrários para qualquer local em um dispositivo.
Para copiar um arquivo ou diretório e os subdiretórios dele do dispositivo, faça o seguinte:
adb pull remote local
Para copiar um arquivo ou diretório e os subdiretórios dele para o dispositivo, faça o seguinte:
adb push local remote
Substitua local
e remote
pelos caminhos para
o diretório/os arquivos de destino na máquina de desenvolvimento (local) e no
dispositivo (remoto). Exemplo:
adb push myfile.txt /sdcard/myfile.txt
Interromper o servidor do adb
Em alguns casos, pode ser necessário encerrar o processo do servidor do adb
e reiniciá-lo
para resolver o problema. Por exemplo, esse pode ser o caso quando adb
não responde a um comando.
Para interromper o servidor do adb
, use o comando adb kill-server
.
Em seguida, é possível emitir qualquer outro comando do adb
para reiniciar o servidor.
Emitir comandos do adb
Execute comandos do adb
em uma linha de comando na máquina de desenvolvimento ou em um script usando o
seguinte:
adb [-d | -e | -s serial_number] command
Se houver apenas um emulador em execução ou um dispositivo conectado, o comando do adb
será
enviado para esse dispositivo por padrão. Se houver vários emuladores em execução e/ou vários dispositivos
conectados, será necessário usar a opção -d
, -e
ou -s
para especificar o dispositivo de destino a que o comando será direcionado.
Acesse uma lista detalhada de todos os comandos do adb
com suporte usando este
comando:
adb --help
Emitir comandos do shell
Você pode usar o comando do shell
para emitir comandos do dispositivo pelo adb
ou para iniciar um
shell interativo. Para emitir um único comando, use o comando do shell
desta maneira:
adb [-d |-e | -s serial_number] shell shell_command
Para iniciar um shell interativo em um dispositivo, use o comando do shell
desta maneira:
adb [-d | -e | -s serial_number] shell
Para sair de um shell interativo, pressione Control+D
ou digite exit
.
O Android fornece a maioria das ferramentas de linha de comando Unix comuns. Para ver uma lista de ferramentas disponíveis, use o seguinte comando:
adb shell ls /system/bin
Você pode receber ajuda com a maioria dos comandos usando o argumento --help
.
Muitos dos comandos do shell são fornecidos pelo
toybox.
Há uma ajuda geral aplicável a todos os comandos do toybox disponível em toybox --help
.
Com o Android Platform Tools 23 e mais recentes, adb
processa argumentos da mesma forma que
o comando ssh(1)
. Essa mudança corrigiu muitos problemas com a
injeção de comando
e tornou possível executar com segurança comandos que contêm
metacaracteres de shell (em inglês),
como adb install Let\'sGo.apk
. Essa mudança significa que a interpretação
de qualquer comando que contenha metacaracteres de shell também mudou.
Por exemplo, o comando adb shell setprop key 'value'
agora é um erro, já que as
aspas simples ('
) são omitidas pelo shell local e o dispositivo vê
adb shell setprop key value
. Para que o comando funcione, coloque duas aspas,
uma para o shell local e outra para o shell remoto, de forma parecida com
ssh(1)
. Por exemplo, adb shell setprop key 'value'
.
Consulte também a Ferramenta de linha de comando Logcat, que é útil para monitorar o registro do sistema.
Chamar o gerenciador de atividades
Em um shell do adb
, é possível emitir comandos com a ferramenta gerenciador de atividades (am
) para
executar diversas ações do sistema, como iniciar uma atividade, forçar a parada de um processo,
transmitir uma intent, modificar as propriedades da tela do dispositivo e muito mais.
Em um shell, a sintaxe de am
é a seguinte:
am command
Também é possível emitir um comando do gerenciador de atividades diretamente do adb
sem entrar em um shell remoto. Exemplo:
adb shell am start -a android.intent.action.VIEW
Tabela 1. Comandos disponíveis do gerenciador de atividades.
Comando | Descrição |
---|---|
start [options] intent
|
Inicia uma Activity especificada pela
intent . Consulte Especificação para argumentos de intent. As opções são as seguintes:
|
startservice [options] intent
|
Inicia o Service especificado por
intent . Consulte Especificação para argumentos de intent. As opções são as seguintes:
|
force-stop package
|
Força o fechamento de tudo o que estiver associado a package .
|
kill [options] package
|
Encerra todos os processos associados a package . Esse comando encerra apenas
processos que podem ser encerrados com segurança e que não afetarão a experiência
do usuário.
As opções são as seguintes:
|
kill-all
|
Encerra todos os processos em segundo plano. |
broadcast [options] intent
|
Emite uma intent de transmissão. Consulte Especificação para argumentos de intent. As opções são as seguintes:
|
instrument [options] component
|
Começa a monitorar com uma
instância de Instrumentation .
Geralmente, o component
de destino segue o formato test_package/runner_class . As opções são as seguintes:
|
profile start process file
|
Inicia o criador de perfil em process e grava os resultados em file .
|
profile stop process
|
Interrompe o criador de perfil no process .
|
dumpheap [options] process file
|
Despeja o heap de process , grava em file . As opções são as seguintes:
|
set-debug-app [options] package
|
Define o package do app para depurar. As opções são as seguintes:
|
clear-debug-app
|
Limpa o conjunto anterior do pacote para depuração com set-debug-app .
|
monitor [options]
|
Começa a monitorar falhas ou ANRs. As opções são as seguintes:
|
screen-compat {on | off} package
|
Controla o modo de compatibilidade
de tela do package .
|
display-size [reset | widthxheight]
|
Modifica o tamanho de exibição do dispositivo.
Esse comando é útil para testar seu app em diferentes tamanhos de tela, porque ele imita a resolução de telas pequenas
usando um dispositivo com uma tela grande, e vice-versa.
Por exemplo: |
display-density dpi
|
Modifica a densidade de exibição do dispositivo.
Esse comando é útil para testar seu app em diferentes densidades de tela, porque ele imita o ambiente de tela de alta
densidade usando uma tela de baixa densidade, e vice-versa.
Por exemplo: |
to-uri intent
|
Exibe a especificação de intent fornecida como um URI. Consulte Especificação para argumentos de intent. |
to-intent-uri intent
|
Exibe a especificação de intent fornecida como um URI de intent: . Consulte Especificação para argumentos de intent. |
Especificação para argumentos de intent
Para comandos do gerenciador de atividades que incluem um argumento de intent
, você pode
especificar a intent com as seguintes opções:
Chamar o gerenciador de pacotes (pm
)
Em um shell do adb
, é possível emitir comandos com a ferramenta gerenciador de pacotes (pm
) para
executar ações e consultas em pacotes de apps instalados no dispositivo.
Em um shell, a sintaxe de pm
é a seguinte:
pm command
Você também pode emitir um comando do gerenciador de pacotes diretamente do adb
sem entrar em um shell remoto. Exemplo:
adb shell pm uninstall com.example.MyApp
Tabela 2. Comandos disponíveis do gerenciador de pacotes.
Comando | Descrição |
---|---|
list packages [options] filter
|
Mostra todos os pacotes ou, opcionalmente, apenas
os pacotes com nomes incluídos no texto de filter . Opções:
|
list permission-groups
|
Mostra todos os grupos de permissões conhecidos. |
list permissions [options] group
|
Mostra todas as permissões conhecidas ou, opcionalmente, apenas
as que estão em group . Opções:
|
list instrumentation [options]
|
Lista todos os pacotes de teste. Opções:
|
list features
|
Mostra todos os recursos do sistema. |
list libraries
|
Mostra todas as bibliotecas com suporte no dispositivo atual. |
list users
|
Mostra todos os usuários no sistema. |
path package
|
Mostra o caminho para o APK do package em questão.
|
install [options] path
|
Instala um pacote (especificado por path ) no sistema. Opções:
|
uninstall [options] package
|
Remove um pacote do sistema. Opções:
|
clear package
|
Exclui todos os dados associados a um pacote. |
enable package_or_component
|
Ativa o pacote ou componente fornecido (gravado como "pacote/classe"). |
disable package_or_component
|
Desativa o pacote ou componente fornecido (gravado como "pacote/classe"). |
disable-user [options] package_or_component
|
Opções:
|
grant package_name permission
|
Concede uma permissão a um app. Em dispositivos com Android 6.0 (nível 23 da API) ou mais recente, a permissão pode ser qualquer permissão declarada no manifesto do app. Em dispositivos com o Android 5.1 (nível 22 da API) e anteriores, ela precisa ser uma permissão opcional definida pelo app. |
revoke package_name permission
|
Revoga uma permissão a um app. Em dispositivos com Android 6.0 (nível 23 da API) ou mais recente, a permissão pode ser qualquer permissão declarada no manifesto do app. Em dispositivos com o Android 5.1 (nível 22 da API) e anteriores, ela precisa ser uma permissão opcional definida pelo app. |
set-install-location location
|
Muda o local de instalação padrão. Valores de local:
Observação: essa opção é destinada apenas à depuração. O uso dela pode causar a falha de apps e outros comportamentos indesejáveis. |
get-install-location
|
Retorna o local de instalação atual. Valores de retorno:
|
set-permission-enforced permission [true | false]
|
Especifica se a permissão vai ser aplicada. |
trim-caches desired_free_space
|
Reduz arquivos em cache para alcançar o espaço livre fornecido. |
create-user user_name
|
Cria um novo usuário com o user_name fornecido,
exibindo o identificador de novo usuário dele.
|
remove-user user_id
|
Remove o usuário com o user_id fornecido,
excluindo todos os dados associados a esse usuário.
|
get-max-users
|
Mostra o número máximo de usuários permitido pelo dispositivo. |
get-app-links [options] [package]
|
Mostra o estado de verificação do domínio para o package especificado ou para todos os pacotes caso não haja especificação. Os códigos de estado são definidos da seguinte maneira:
As opções são as seguintes:
|
reset-app-links [options] [package]
|
Redefine o estado de verificação do domínio para o pacote especificado ou para todos os pacotes caso não haja especificação.
As opções são as seguintes:
|
verify-app-links [--re-verify] [package]
|
Transmite um pedido de verificação para o package especificado ou para todos os pacotes caso não haja especificação. O envio só é feito caso o pacote ainda não tenha registrado uma resposta.
|
set-app-links [--package package] state domains
|
Define manualmente o estado de um domínio para um pacote. O domínio precisa ser declarado pelo pacote como autoVerify para que isso funcione. Esse comando não informa sobre uma falha de domínios que não podem ser aplicados.
|
set-app-links-user-selection --user user_id [--package package]
enabled domains
|
Define manualmente o estado de uma seleção de usuários host para um pacote. O domínio precisa ser declarado pelo pacote para que isso funcione. Esse comando não informa sobre uma falha de domínios que não puderam ser aplicados.
|
set-app-links-user-selection --user user_id [--package package]
enabled domains
|
Define manualmente o estado de uma seleção de usuários host para um pacote. O domínio precisa ser declarado pelo pacote para que isso funcione. Esse comando não informa sobre uma falha de domínios que não puderam ser aplicados.
|
set-app-links-allowed --user user_id [--package package] allowed
|
Ativa a configuração de processamento de links verificados automaticamente para um pacote.
|
get-app-link-owners --user user_id [--package package] domains
|
Mostra os proprietários de um domínio específico para um usuário em ordem de prioridade baixa a alta.
|
Chamar o gerenciador de políticas do dispositivo (dpm
)
Para ajudar você a desenvolver e testar seus apps de gerenciamento de dispositivos, emita
comandos para a ferramenta gerenciador de políticas de dispositivos (dpm
). Use a ferramenta para controlar o app de administração ativo
ou mudar os dados de status de uma política no dispositivo.
Em um shell, a sintaxe de dpm
é a seguinte:
dpm command
Você também pode emitir um comando do gerenciador de políticas de dispositivo diretamente do adb
sem inserir um shell remoto:
adb shell dpm command
Tabela 3. Comandos disponíveis do gerenciador de políticas de dispositivos.
Comando | Descrição |
---|---|
set-active-admin [options] component
|
Define component como administrador ativo.
As opções são as seguintes:
|
set-profile-owner [options] component
|
Define component como administrador ativo, e o pacote dele como proprietário do perfil de um usuário existente.
As opções são as seguintes:
|
set-device-owner [options] component
|
Define component como administrador ativo e o pacote dele como proprietário do dispositivo.
As opções são as seguintes:
|
remove-active-admin [options] component
|
Desativa um administrador ativo. O app precisa declarar
android:testOnly
no manifesto. Esse comando também remove os proprietários de dispositivo e perfil.
As opções são as seguintes:
|
clear-freeze-period-record
|
Limpa o registro do dispositivo de períodos de congelamento definidos anteriormente para atualizações do sistema OTA. Isso é útil
para evitar as restrições de programação do dispositivo ao desenvolver apps que gerenciam períodos de congelamento. Consulte
Gerenciar atualizações do sistema.
Com suporte em dispositivos que executam o Android 9.0 (nível 28 da API) ou mais recentes. |
force-network-logs
|
Força o sistema a deixar os registros de rede existentes prontos para recuperação por um DPC. Se houver
registros de conexão ou DNS disponíveis, o DPC receberá o
callback
onNetworkLogsAvailable() . Consulte Registro de atividades de rede.
Este comando tem limitação de taxa. Com suporte dispositivos que executam o Android 9.0 (nível 28 da API) ou mais recentes. |
force-security-logs
|
Força o sistema a disponibilizar qualquer registro de segurança existente para o DPC. Se houver registros
disponíveis, o DPC receberá o
callback
onSecurityLogsAvailable() . Consulte Registrar atividade empresarial
do dispositivo.
Este comando tem limitação de taxa. Compatível com dispositivos que executam o Android 9.0 (nível 28 da API) ou versões mais recentes. |
Fazer uma captura de tela
O comando screencap
é um utilitário do shell para fazer uma captura de tela de um
dispositivo.
Em um shell, a sintaxe de screencap
é a seguinte:
screencap filename
Para usar screencap
na linha de comando, digite o seguinte:
adb shell screencap /sdcard/screen.png
Veja um exemplo de uma sessão de captura de tela usando o shell do adb
para fazer a captura e o
comando pull
para fazer o download do arquivo do dispositivo:
$ adb shell shell@ $ screencap /sdcard/screen.png shell@ $ exit $ adb pull /sdcard/screen.png
Gravar um vídeo
O comando screenrecord
é um utilitário de shell para gravar a tela de dispositivos
com Android 4.4 (nível 19 da API) e versões mais recentes. O utilitário grava as atividades na tela em um arquivo
MPEG-4. Você pode usar esse arquivo para criar vídeos promocionais ou de treinamento ou para depuração e teste.
Em um shell, use a seguinte sintaxe:
screenrecord [options] filename
Para usar screenrecord
na linha de comando, digite o seguinte:
adb shell screenrecord /sdcard/demo.mp4
Para parar a gravação da tela, pressione Control+C. Caso contrário, a gravação
é interrompido automaticamente após três minutos ou no limite de tempo definido por --time-limit
.
Para começar a gravar a tela do seu dispositivo, execute o comando screenrecord
para gravar
o vídeo. Em seguida, execute o comando pull
para fazer o download do vídeo do dispositivo para o computador
host. Veja um exemplo de sessão de gravação:
$ adb shell shell@ $ screenrecord --verbose /sdcard/demo.mp4 (press Control + C to stop) shell@ $ exit $ adb pull /sdcard/demo.mp4
O utilitário screenrecord
pode gravar em qualquer resolução e taxa de bits compatível que você
solicitar, mantendo a proporção da tela do dispositivo. O utilitário grava na resolução e orientação nativa
da tela por padrão, com uma duração máxima de três minutos.
Limitações do utilitário screenrecord
:
- O áudio não é gravado nesse arquivo de vídeo.
- A gravação de vídeo não está disponível para dispositivos que executam Wear OS.
- Alguns dispositivos podem não conseguir gravar na resolução nativa das respectivas telas. Se tiver problemas ao gravar a tela, tente usar uma resolução menor.
- Não é possível girar a tela durante a gravação. Se isso acontecer, parte da tela será cortada na gravação.
Tabela 4. Opções de screenrecord
.
Opções | Descrição |
---|---|
--help
|
Mostra a sintaxe e as opções do comando. |
--size widthxheight
|
Define o tamanho do vídeo: 1280x720 . O valor padrão será a resolução nativa
da tela do dispositivo, se for compatível, ou 1.280 x 720, se não for. Para conseguir os melhores resultados, use um tamanho compatível com
o codificador de Advanced Video Coding (AVC) do seu dispositivo. |
--bit-rate rate |
Define a taxa de bits do vídeo em megabits por segundo. O valor padrão é 20 Mbps.
É possível aumentar a taxa de bits para melhorar a qualidade do vídeo, mas isso resultará em arquivos
de filme mais pesados. O exemplo a seguir define a taxa de bits da gravação para 6 Mbps:
screenrecord --bit-rate 6000000 /sdcard/demo.mp4 |
--time-limit time |
Define o tempo máximo de gravação em segundos. O valor padrão e máximo é 180 (3 minutos). |
--rotate |
Gira a saída em 90 graus. Esse recurso é experimental. |
--verbose |
Mostra informações de registro na tela da linha de comando. Se você não definir essa opção, o utilitário não vai exibir informações durante a execução. |
Ler perfis do ART para apps
A partir do Android 7.0 (API de nível 24), o Android Runtime (ART) coleta perfis de execução dos apps instalados, que são usados para otimizar o desempenho do app. Examine os perfis coletados para entender quais métodos são executados com frequência e quais classes são usadas durante a inicialização do app.
Observação: só será possível recuperar o nome de arquivo do perfil de execução se você tiver acesso à raiz do sistema de arquivos, por exemplo, em um emulador.
Para produzir as informações de perfil em forma de texto, use este comando:
adb shell cmd package dump-profiles package
Para recuperar o arquivo produzido, use este comando:
adb pull /data/misc/profman/package.prof.txt
Redefinir dispositivos de teste
Se você testa seu app em vários dispositivos de teste, pode ser útil redefinir o dispositivo entre
os testes, por exemplo, para remover dados do usuário e redefinir o ambiente de teste. Você pode executar uma redefinição
para a configuração original de um dispositivo de teste com o Android 10 (API de nível 29) ou mais recente usando o
comando testharness
do shell adb
, conforme mostrado abaixo.
adb shell cmd testharness enable
Ao restaurar o dispositivo usando testharness
, ele faz backup automaticamente da Chave
RSA que permite a depuração na estação de trabalho atual em um local persistente. Ou seja, depois que
o dispositivo é redefinido, a estação de trabalho pode continuar depurando e emitindo comandos do adb
para o dispositivo sem registrar uma nova chave manualmente.
Além disso, para ajudar a tornar mais fácil e segura a ação de continuar testando seu app, o uso de
testharness
para restaurar um dispositivo também muda as seguintes configurações:
- O dispositivo define determinadas configurações do sistema para que os assistentes de configuração inicial do dispositivo não apareçam. Ou seja, o dispositivo entra em um estado em que você pode instalar, depurar e testar rapidamente seu app.
- Configurações:
- Desativa a tela de bloqueio.
- Desativa os alertas de emergência.
- Desativa a sincronização automática para contas.
- Desativa as atualizações automáticas do sistema.
- Outro:
- Desativa apps de segurança pré-instalados.
Se o app precisar detectar e se adaptar às configurações padrão do comando
testharness
, use
ActivityManager.isRunningInUserTestHarness()
.
sqlite
O sqlite3
inicia o programa da linha de comando sqlite
para examinar bancos de dados SQLite.
Inclui comandos como .dump
para mostrar o conteúdo de uma tabela e .schema
para mostrar a instrução SQL CREATE
de uma tabela existente.
Você também pode executar comandos SQLite na linha de comando, como mostrado abaixo.
$ adb -s emulator-5554 shell $ sqlite3 /data/data/com.example.app/databases/rssitems.db SQLite version 3.3.12 Enter ".help" for instructions
Observação: só é possível acessar um banco de dados SQLite se você tem acesso raiz ao sistema de arquivos, por exemplo, em um emulador.
Para saber mais, consulte a documentação da linha de comando sqlite3
.
Back-ends USB do adb
O servidor adb pode interagir com a pilha USB por dois back-ends. Ele pode usar o modelo
do SO (Windows, Linux ou macOS) ou pode usar o back-end libusb
.
Alguns recursos, como attach
, detach
e detecção de velocidade do USB,
disponível apenas ao usar o back-end libusb
.
É possível escolher um back-end usando a variável de ambiente ADB_LIBUSB
.
Se ela não for definida, o adb usará o back-end padrão. O comportamento padrão varia de acordo com o SO. Iniciando
com o adb v34, a
O back-end liubusb
é usado por padrão em todos os SOs, exceto no Windows, em que o back-end nativo é
são usados por padrão. Se ADB_LIBUSB
for
definido, ele determina se o back-end nativo ou libusb
é usado. Consulte a
Página de manual do adb
para saber mais sobre as variáveis de ambiente do adb.
Back-ends de mDNS do adb
O adb pode usar o protocolo DNS multicast para conectar automaticamente o servidor e os dispositivos. O servidor ADB é fornecido com dois back-ends: Bonjour (mdnsResponder da Apple) e Openscreen.
O back-end Bonjour precisa que um daemon esteja em execução na máquina host.
No macOS, o daemon integrado da Apple está sempre em execução, mas no Windows e no Linux, o usuário precisa garantir que o daemon mdnsd
esteja funcionando.
Se o comando adb mdns check
retornar um erro, é provável que o adb esteja usando o back-end do Bonjour, mas não haja nenhum daemon do Bonjour em execução.
O back-end do Openscreen não precisa que um daemon esteja em execução na máquina. O suporte para o back-end Openscreen no macOS começa no ADB v35. Há suporte para Windows e Linux a partir do adb v34.
Por padrão, o adb usa o back-end Bonjour. Para alterar esse comportamento, use a variável de ambiente ADB_MDNS_OPENSCREEN
(definido como 1
ou 0
).
Consulte a página do manual do adb para mais detalhes.