Conectar dispositivo Android con ADB

información al respecto.
(https://google.com/racialequity?hl=es)
Android Debug Bridge (adb)

Android Debug Bridge (adb) es una herramienta de línea de comandos versátil que te permite
comunicarte con un dispositivo. El comando adb permite realizar una variedad de acciones en
el dispositivo, como instalar y depurar apps, y proporciona acceso a un shell de Unix que
puedes usar para ejecutar distintos comandos en un dispositivo. Es un programa cliente-
servidor que incluye tres componentes:
Un cliente, que envía comandos. El cliente se ejecuta en tu máquina de desarrollo.

Puedes invocar un cliente desde un terminal de línea de comandos emitiendo un
comando adb.
Un daemon (adbd), que ejecuta comandos en un dispositivo. El daemon se ejecuta como

un proceso en segundo plano en cada dispositivo.
Un servidor, que administra la comunicación entre el cliente y el daemon. El servidor se

ejecuta en tu máquina de desarrollo como un proceso en segundo plano.
adb está incluido en el paquete de herramientas de la plataforma de Android SDK. Puedes

descargar este paquete con SDK Manager
(https://developer.android.com/studio/intro/update?hl=es#sdk-manager), que lo instala en
android_sdk/platform-tools/. O, si quieres el paquete independiente de herramientas de la
plataforma del SDK de Android, puedes descargarlo aquí
(https://developer.android.com/studio/releases/platform-tools?hl=es).
A fin de descubrir cómo conectar un dispositivo para usar por medio de adb y cómo usar el
asistente de conexión con el objetivo de solucionar problemas comunes, consulta Cómo
ejecutar apps en un dispositivo de hardware (https://developer.android.com/studio/run/device?hl=es)
.
Cómo funciona adb
Cuando inicias un cliente adb, el cliente primero comprueba si hay un proceso del servidor de
adb en ejecución. Si no lo hay, inicia el proceso del servidor. Cuando se inicia el servidor, este
se vincula con el puerto TCP local 5037 y busca comandos enviados por los clientes de adb;
todos los clientes de adb usan el puerto 5037 para comunicarse con el servidor de adb.
Luego, el servidor establece conexiones con todos los dispositivos en ejecución. Localiza los
emuladores escaneando puertos con números impares en el rango de 5555 a 5585, que es el
que usan los primeros 16 emuladores. Cuando el servidor encuentra un daemon de adb,
establece una conexión con ese puerto. Ten en cuenta que cada emulador usa un par de
puertos secuenciales (un puerto con número par para las conexiones de la consola y uno con
número impar para las conexiones de adb). Por ejemplo:
Emulador 1, consola: 5554

Emulador 1, adb: 5555
Emulador 2, consola: 5556
Emulador 2, adb: 5557
y así sucesivamente.
Como se muestra, el emulador conectado al adb en el puerto 5555 es el mismo que el

emulador cuya consola se encarga de la recepción en el puerto 5554.
Una vez que el servidor establece conexiones con todos los dispositivos, puedes usar
comandos adb para acceder a esos dispositivos. Dado que el servidor administra las
conexiones con los dispositivos y maneja comandos de diferentes clientes de adb, puedes
controlar cualquier dispositivo desde cualquier cliente (o desde una secuencia de comandos).
Cómo habilitar la depuración de adb en tu dispositivo
A fin de usar adb con un dispositivo conectado a través de USB, debes habilitar Depuración
por USB en la configuración del sistema del dispositivo, que se encuentra en Opciones para
desarrolladores.
En Android 4.2 y versiones posteriores, la pantalla "Opciones para desarrolladores" se

encuentra oculta de forma predeterminada. Para poder visualizarla, dirígete a
Configuración > Acerca del dispositivo y presiona Número de compilación siete veces Cuando
regreses a la pantalla anterior, verás Opciones para desarrolladores en la parte inferior.
En algunos dispositivos, la pantalla "Opciones para desarrolladores" puede encontrarse en otro

lugar o tener un nombre diferente.
Ahora puedes conectar tu dispositivo con USB. Para ello, ejecuta adb devices desde el
directorio android_sdk/platform-tools/. Si está conectado, verás que el nombre del
dispositivo se enumera como "dispositivo".
Nota: Cuando conectas un dispositivo con Android 4.2.2 o una versión posterior, en el sistema se muestra
un diálogo en el que se solicita aceptar una clave RSA para realizar la depuración a través de esta
computadora. Este mecanismo de seguridad protege los dispositivos del usuario porque garantiza que la
depuración por USB y otros comandos adb no puedan ejecutarse a menos que puedas desbloquear el
dispositivo y aceptar el contenido del diálogo.
A fin de obtener más información para conectar un dispositivo mediante conexiones USB, lee
Cómo ejecutar apps en un dispositivo de hardware
(https://developer.android.com/studio/run/device?hl=es).
Cómo conectarse a un dispositivo mediante Wi-Fi (Android 11 y

versiones posteriores)
Android 11 y las versiones posteriores admiten la implementación y la depuración de tu app de

forma inalámbrica desde tu estación de trabajo con Android Debug Bridge (adb). Por ejemplo,
puedes implementar tu app depurable en varios dispositivos remotos sin conectar físicamente
tu dispositivo a través de USB. Esto elimina la necesidad de resolver problemas comunes de
conexión USB, como la instalación de controladores.
Para usar la depuración inalámbrica, debes sincronizar tu dispositivo con tu estación de

trabajo mediante un código de vinculación. Ambos elementos deben estar conectados a la
misma red inalámbrica. Para conectarte a tu dispositivo, sigue estos pasos:
Figura 1: Cuadro de diálogo de vinculación
de ADB inalámbrico
1. En tu estación de trabajo, actualiza a la versión más reciente de las Herramientas de la

plataforma del SDK (https://developer.android.com/studio/releases/platform-tools?hl=es).
2. En el dispositivo, habilita las Opciones para desarrolladores

(https://developer.android.com/studio/debug/dev-options?hl=es).
3. Habilita la opción Depuración inalámbrica.
4. En el cuadro de diálogo que pregunta ¿Quieres permitir la depuración inalámbrica en

esta red?, haz clic en Permitir.
5. Selecciona Vincular dispositivo con código de sincronización. Toma nota del código de
vinculación, la dirección IP y el número de puerto que se muestran en el dispositivo
(consulta la imagen).
6. En tu estación de trabajo, abre una terminal y navega hasta android_sdk/platform-

tools.
7. Ejecuta adb pair ipaddr:port. Usa la dirección IP y el número de puerto del paso 5.
8. Cuando se te pregunte, ingresa el código de vinculación que recibiste en el paso 5.

Debería aparecer un mensaje que indique que se vinculó correctamente tu dispositivo.
none
Enter pairing code: 482924
Successfully paired to 192.168.1.130:37099 [guid=adb-235XY]
9. Solo para Linux o Microsoft Windows: Ejecuta adb connect ipaddr:port. Usa la

dirección IP y el puerto que se indican en Depuración inalámbrica.
Figura 2: Número de puerto y dirección IP del adb inalámbrico
Cómo conectarse a un dispositivo mediante Wi-Fi (Android 10 y

versiones anteriores)
En general, adb se comunica con el dispositivo a través de USB, pero también puedes usar adb
a través de una red Wi-Fi después de realizar la configuración inicial a través de USB, como se
describe a continuación. Sin embargo, si estás desarrollando una app para Wear OS, deberías
consultar la guía a fin de depurar una app para Wear OS
(https://developer.android.com/training/wearables/apps/debugging?hl=es), que incluye instrucciones
especiales con el objetivo de usar adb con Wi-Fi y Bluetooth.
1. Conecta tu dispositivo Android y la computadora host adb a una red Wi-Fi común a la
que ambos puedan acceder. Ten en cuenta que no todos los puntos de acceso son
adecuados; quizá necesites usar un punto de acceso cuyo firewall esté configurado
correctamente para admitir adb.
2. Si te conectas a un dispositivo Wear OS, desactiva Bluetooth en el teléfono que esté

sincronizado con el dispositivo.
3. Conecta el dispositivo a la computadora host con un cable USB.
4. Configura el dispositivo de destino para que busque una conexión TCP/IP en el puerto
5555.
adb tcpip 5555
5. Desconecta el cable USB del dispositivo de destino.

6. Busca la dirección IP del dispositivo Android. Por ejemplo, en un dispositivo Nexus,
puedes encontrar la dirección IP en Configuración > Acerca de la tablet (o Acerca del
dispositivo ) > Estado > Dirección IP. O bien, en un dispositivo Wear OS, puedes buscar la
dirección IP en Settings > Wi-Fi Settings > Advanced > IP address.
7. Para conectarte al dispositivo, busca su dirección IP.
adb connect device_ip_address
8. Confirma que tu computadora host esté conectada al dispositivo de destino:
$ adb devices
List of devices attached
device_ip_address:5555 device
¡Ya estás listo para empezar!
Si se pierde la conexión de ADB:
1. Asegúrate de que tu host aún esté conectado a la misma red Wi-Fi a la que esté
conectado el dispositivo Android.
2. Vuelve a conectarte ejecutando el paso adb connect nuevamente.
3. Como alternativa, si eso no funciona, restablece tu host adb:
adb kill-server
Luego vuelve a comenzar desde el principio.
Cómo realizar consultas de dispositivos
Antes de emitir comandos adb, resultará útil conocer las instancias del emulador o dispositivo
conectadas al servidor de adb. Puedes generar una lista de dispositivos asociados usando el
comando devices.
adb devices -l
En respuesta, adb imprime esta información de estado para cada instancia:
Número de serie: es una string creada por adb para identificar de forma exclusiva un
dispositivo por su número de puerto. A continuación, puedes ver un ejemplo de número
de serie: emulator-5554
Estado: El estado de conexión del dispositivo puede ser uno de los siguientes:
offline: El dispositivo no está conectado a adb o no responde.
device: El dispositivo ahora está conectado al servidor de adb. Ten en cuenta que
este estado no implica que el sistema Android se haya iniciado y esté funcionando,
ya que el dispositivo se conecta a adb mientras el sistema aún se inicia. No
obstante, después del inicio, este es el estado operativo normal de un dispositivo.
no device: No hay ningún dispositivo conectado.
Descripción: Si incluyes la opción -l, el comando devices dice qué es el dispositivo.

Esta información es útil cuando tienes que diferenciar los distintos dispositivos
conectados.
En el siguiente ejemplo, se muestra el comando devices y su resultado. Hay tres dispositivos

en ejecución. Las primeras dos líneas de la lista son emuladores y la tercera línea es un
dispositivo de hardware que está asociado a la computadora.
$ adb devices
emulator-5556 device product:sdk_google_phone_x86_64 model:Android_SDK_built_for
emulator-5554 device product:sdk_google_phone_x86 model:Android_SDK_built_for_x8
0a388e93 device usb:1-1 product:razor model:Nexus_7 device:flo
El emulador no aparece en la lista
El comando adb devices tiene una secuencia de comandos de caso límite que hace que los
emuladores en ejecución no se muestren en el resultado de adb devices, a pesar de que los
emuladores están visibles en el escritorio. Esto sucede cuando se cumplen todas las
condiciones siguientes:
1. El servidor de adb no se está ejecutando.
2. Usas el comando emulator con la opción -port o -ports con un valor de puerto de

número impar entre 5554 y 5584.
3. El puerto de número impar que elegiste no está ocupado, por lo que la conexión del
puerto se puede realizar en el número de puerto especificado o, si está ocupado, el
emulador cambia a otro puerto que cumple con los requisitos de 2.
4. Inicias el servidor de adb después de iniciar el emulador.
Una forma de evitar esta situación es dejar que el emulador elija sus propios puertos y no
ejecutar más de 16 emuladores a la vez. Otra forma consiste en iniciar siempre el servidor de
adb antes de usar el comando emulator, como se explica en los siguientes ejemplos.
Ejemplo 1: En la siguiente secuencia de comandos, el comando adb devices inicia el servidor

de adb, pero la lista de dispositivos no aparece.
Detén el servidor de adb y escribe los siguientes comandos en el orden que se muestra. Para
el nombre de AVD, proporciona un nombre de AVD válido del sistema. Para obtener una lista
de nombres de AVD, escribe emulator -list-avds. El comando emulator está en el
directorio android_sdk/tools.
$ adb kill-server
$ emulator -avd Nexus_6_API_25 -port 5555
$ adb devices

* daemon not running. starting it now on port 5037 *
* daemon started successfully *
Ejemplo 2: En la siguiente secuencia de comandos, adb devices muestra la lista de

dispositivos porque se inició primero el servidor de adb.
Para ver el emulador en el resultado de adb devices, detén el servidor de adb y vuelve a
iniciarlo después de usar el comando emulator y antes de utilizar adb devices, de la
siguiente manera:
$ adb kill-server
$ emulator -avd Nexus_6_API_25 -port 5557
$ adb start-server
$ adb devices

emulator-5557 device
Para obtener más información sobre las opciones de línea de comandos del emulador,
consulta Cómo usar parámetros de la línea de comandos
(https://developer.android.com/studio/run/emulator-commandline?hl=es#startup-options).
Cómo enviar comandos a un dispositivo específico
Si se ejecutan varios dispositivos, debes especificar el dispositivo de destino cuando emitas el

comando adb. Si quieres especificar el destino, usa el comando devices para obtener el
número de serie del destino. Una vez que tengas el número de serie, usa la opción -s con los
comandos adb para especificar el número de serie. Si vas a emitir muchos comandos adb,
puedes configurar la variable del entorno $ANDROID_SERIAL para que incluya el número de
serie. Si usas -s y $ANDROID_SERIAL, -s anula $ANDROID_SERIAL.
En el siguiente ejemplo, se obtiene la lista de dispositivos asociados y se usa el número de

serie de uno de ellos para instalar helloWorld.apk en él.
$ adb devices
$ adb -s emulator-5555 install helloWorld.apk
Nota: Si emites un comando sin especificar un dispositivo de destino cuando hay varios dispositivos
disponibles, adb genera un error.
Si tienes varios dispositivos disponibles, pero solo uno es un emulador, usa la opción -e para
enviar comandos al emulador. Asimismo, si hay varios dispositivos, pero solo un dispositivo de
hardware asociado, usa la opción -d para enviar comandos al dispositivo de hardware.
Cómo instalar una app
Puedes usar adb para instalar un APK en un emulador o dispositivo conectado con el
comando install:
adb install path_to_apk
Debes usar la opción -t con el comando install cuando instales un APK de prueba. Para
obtener más información, consulta -t (#-t-option).
Para descubrir cómo crear un archivo APK que puedas instalar en una instancia del emulador
o dispositivo, consulta Cómo compilar y ejecutar tu app
(https://developer.android.com/studio/run?hl=es).
Ten en cuenta que, si usas Android Studio, no necesitas usar adb directamente para instalar tu
app en el emulador o dispositivo. En su lugar, Android Studio se encarga del empaquetado y de
la instalación de la app.
Cómo configurar la redirección de puertos
Puedes usar el comando forward para configurar la redirección de puertos arbitraria, que

reenvía las solicitudes en un puerto host específico a un puerto diferente en un dispositivo. En
el siguiente ejemplo, se configura la redirección del puerto de host 6100 al puerto de
dispositivo 7100:
adb forward tcp:6100 tcp:7100
En el siguiente ejemplo, se configura la redirección del puerto de host 6100 a local:logd:

adb forward tcp:6100 local:logd
Cómo copiar archivos a un dispositivo o desde este
Usa los comandos pull y push para copiar archivos desde un dispositivo y hacia este. A
diferencia del comando install, que solo copia un archivo APK en una ubicación específica,
los comandos pull y push te permiten copiar directorios y archivos arbitrarios a cualquier
lugar de un dispositivo.
Para copiar un archivo o directorio y sus subdirectorios desde el dispositivo, haz lo siguiente:
adb pull remote local
Para copiar un archivo o directorio y sus subdirectorios al dispositivo, haz lo siguiente:
adb push local remote
Reemplaza local y remote con las rutas al directorio o archivos de destino en la máquina de

desarrollo (local) y en el dispositivo (remoto). Por ejemplo:
adb push foo.txt /sdcard/foo.txt
Cómo detener el servidor de adb
En algunos casos, podría ser necesario que finalices el proceso del servidor de adb y lo
reinicies para resolver el problema (p. ej., si adb no responde a un comando).
Para detener el servidor de adb, usa el comando adb kill-server. Luego podrás reiniciar el
servidor emitiendo cualquier otro comando ADB.
Cómo emitir comandos ADB
Puedes emitir comandos ADB desde una línea de comandos en tu máquina de desarrollo o
desde una secuencia de comandos. El uso es el siguiente:
adb [-d | -e | -s serial_number] command
Si hay un solo emulador en ejecución o un solo dispositivo conectado, de forma

predeterminada, el comando adb se envía a ese dispositivo. Si se ejecutan varios emuladores
y se conectan varios dispositivos, debes usar la opción -d, -e o -s para especificar el
dispositivo de destino al que se debe dirigir el comando.
Para consultar la lista detallada de todos los comandos adb compatibles, usa el siguiente
comando:
adb --help
Cómo emitir comandos del shell
Puedes usar el comando shell para emitir comandos de dispositivo mediante adb o iniciar un
shell interactivo. Para emitir un solo comando, usa el comando shell de la siguiente manera:
adb [-d |-e | -s serial_number] shell shell_command
Para iniciar un shell interactivo en un dispositivo, usa el comando shell de la siguiente

manera:
adb [-d | -e | -s serial_number] shell
Para salir de un shell interactivo, presiona Ctrl + D o escribe exit.

Nota: Con la versión 23 de las herramientas de la plataforma de Android y versiones posteriores, adb
maneja los argumentos tal como lo hace el comando ssh(1). Este cambio solucionó muchos problemas
relacionados con la inserción de comandos (https://en.wikipedia.org/wiki/Code_injection#Shell_injection) y
permite ejecutar de forma segura comandos que contienen metacaracteres
(https://en.wikipedia.org/wiki/Metacharacter) del shell, como adb install Let\'sGo.apk. Sin embargo,
este cambio implica que también cambió la interpretación de los comandos que contienen metacaracteres
del shell. Por ejemplo, el comando adb shell setprop foo 'a b' ahora es un error porque las comillas
simples (') se incluyen en el shell local, y el dispositivo ve adb shell setprop foo a b. A fin de hacer que
el comando funcione, usa comillas dos veces: una para el shell local y una para el shell remoto, como haces
con ssh(1). Por ejemplo, adb shell setprop foo "'a b'".
Android proporciona la mayoría de las herramientas habituales de línea de comandos de Unix.

Para obtener una lista de las herramientas disponibles, usa el siguiente comando:
adb shell ls /system/bin
Hay ayuda disponible para la mayoría de los comandos mediante el argumento --help. toybox
(http://landley.net/toybox/) proporciona muchos de los comandos del shell. La ayuda general
que se puede aplicar a todos los comandos de toybox está disponible mediante toybox --
help.
Consulta también la herramienta de línea de comandos Logcat

(https://developer.android.com/studio/command-line/logcat?hl=es), que es útil para supervisar el
registro del sistema.
Cómo llamar al administrador de actividades (am)
En un shell de adb, puedes emitir comandos con la herramienta administrador de actividades

(am) para realizar varias acciones del sistema, como iniciar una actividad, forzar la detención
de un proceso, transmitir un intent y modificar las propiedades de la pantalla del dispositivo,
entre otras. En un shell, la sintaxis es la siguiente:
am command
También puedes emitir un comando del administrador de actividades directamente desde adb
sin ingresar a un shell remoto. Por ejemplo:
adb shell am start -a android.intent.action.VIEW
Tabla 2. Comandos disponibles del administrador de actividades
Comando Descripción
start [options] intent Inicia una Activity

(https://developer.android.com/reference/android/app/Activity?hl
especificada por intent.
Consulta Especificación para argumentos de intents (#IntentSpec)
Las opciones son las siguientes:
-D: Habilita la depuración.

-W: Establece una espera hasta que se complete el inicio.
--start-profiler file: Inicia el generador de perfiles y en
resultados a file.
-P file: Es similar a --start-profiler, pero se detiene la

generación de perfiles cuando la app queda inactiva.
-R count: Repite el inicio de la actividad count veces. Antes d

cada repetición, se finalizará la actividad principal.
-S: Fuerza la detención de la app de destino antes de iniciar la

actividad.
--opengl-trace: Habilita el rastreo de funciones OpenGL.

--user user_id | current: Especifica el usuario que debe
ejecutarse; si no se especifica, se ejecutará como el usuario act
startservice [options] intent Inicia el Service

(https://developer.android.com/reference/android/app/Service?hl
especificado por intent.

--user user_id | current: Especifica el usuario que debe
ejecutarse; si no se especifica, se ejecutará como el usuario act
force-stop package Fuerza la detención de todo lo que esté asociado con package (el
nombre de paquete de la app).
kill [options] package Elimina todos los procesos asociados con package (el nombre de
paquete de la app). Este comando solo elimina los procesos que e
seguro eliminar y que no afectarán la experiencia del usuario.
--user user_id | all | current: Especifica el usuario c

procesos se eliminarán; si no se especifica, se seleccionarán to
los usuarios.
kill-all Elimina todos los procesos que se ejecutan en segundo plano.
broadcast [options] intent Emite un intent de transmisión.

[--user user_id | all | current]: Especifica a qué us

se enviará; si no se especifica, se envía a todos los usuarios.
instrument [options] component Comienza la supervisión con una instancia Instrumentation

(https://developer.android.com/reference/android/app/Instrument
hl=es)
. Por lo general, el objetivo component es el formulario
test_package/runner_class.
-r: Imprime resultados sin procesar (de lo contrario, decodifica

report_key_streamresult). Se usa con [-e perf true]
de generar resultados sin procesar para las mediciones de
rendimiento.
-e name value: Establece el argumento name en value. Par

ejecutores de pruebas, una forma común es -e testrunner_
value[,value...].
-p file: Escribe datos de generación de perfiles en file.
-w: Espera a que la instrumentación finalice antes de regresar. E
obligatorio para los ejecutores de pruebas.
--no-window-animation: Desactiva las animaciones de ven
durante la ejecución.
--user user_id | current: Especifica en qué instrumenta

de usuario se debe ejecutar; si no se especifica, se seleccionará
usuario actual.
profile start process file Inicia el generador de perfiles en process, escribe los resultados e
file.
profile stop process Detiene el generador de perfiles en process.
dumpheap [options] process file Vuelca el montón de process, escribe en file.
--user [user_id | current]: Cuando se proporciona un

nombre de proceso, se debe especificar el usuario del proceso
volcará; si no se especifica, se usará el usuario actual.
-n: Vuelca el montón nativo en lugar del montón administrado.
set-debug-app [options] package Configura la app package para depurar.
-w: Espera al depurador cuando se inicia la app.

--persistent: Guarda este valor.
clear-debug-app Borra el conjunto anterior del paquete para depurar con set-debu
app.
monitor [options] Comienza a controlar la presencia de bloqueos o ANR.

--gdb: Inicia gdbserv en el puerto especificado en el bloqueo/A
screen-compat {on | off} Controla el modo de compatibilidad de pantalla

package (https://developer.android.com/guide/practices/screen-compat-m
hl=es)
de package.
display-size [reset | Anula el tamaño de visualización del dispositivo. Este comando es

widthxheight] para probar tu app en diferentes tamaños de pantalla imitando la
resolución de una pantalla pequeña en un dispositivo con pantalla
grande, y viceversa.
Ejemplo:
am display-size 1280x800
display-density dpi Anula la densidad de la pantalla del dispositivo. Este comando es ú
para probar tu app en diferentes densidades de pantalla, en un ento
de pantalla de alta densidad usando una pantalla de baja densidad
viceversa.
Ejemplo:
am display-density 480
to-uri intent Imprime la especificación del intent en cuestión como un URI.

to-intent-uri intent Imprime la especificación del intent determinado como URI de int
Especificación para argumentos de intents
Para los comandos del administrador de actividades que tienen un argumento intent, puedes
especificar el intent con las siguientes opciones:
Mostrar todo
-a action
Especifica la acción del intent, como android.intent.action.VIEW. Puedes declarar

esto una sola vez.
-d data_uri
Especifica el URI de datos del intent, como content://contacts/people/1. Puedes

declarar esto una sola vez.
-t mime_type
Especifica el tipo de MIME del intent, como image/png. Puedes declarar esto una sola
vez.
-c category
Especifica una categoría del intent, como android.intent.category.APP_CONTACTS.
-n component
Especifica el nombre del componente con el prefijo del nombre del paquete para crear un
intent explícito, como com.example.app/.ExampleActivity.
-f flags
Agrega marcas al intent, siempre que sean compatibles con setFlags()

(https://developer.android.com/reference/android/content/Intent?hl=es#setFlags(int)).
--esn extra_key
Agrega una clave extra nula. Esta opción no se admite para intents de URI.
-e | --es extra_key extra_string_value
Agrega datos de string como un par clave-valor.
--ez extra_key extra_boolean_value
Agrega datos booleanos como un par clave-valor.
--ei extra_key extra_int_value
Agrega datos enteros como un par clave-valor.
--el extra_key extra_long_value
Agrega datos extensos como un par clave-valor.
--ef extra_key extra_float_value
Agrega datos flotantes como un par clave-valor.
--eu extra_key extra_uri_value
Agrega datos de URI como un par clave-valor.
--ecn extra_key extra_component_name_value
Agrega un nombre de componente, que se convierte y se pasa como un objeto

ComponentName
(https://developer.android.com/reference/android/content/ComponentName?hl=es).
--eia extra_key extra_int_value[,extra_int_value...]

Agrega una matriz de valores enteros.
--ela extra_key extra_long_value[,extra_long_value...]
Agrega una matriz de valores extensos.
--efa extra_key extra_float_value[,extra_float_value...]
Agrega una matriz de valores flotantes.
--grant-read-uri-permission
Incluye la marca FLAG_GRANT_READ_URI_PERMISSION
(https://developer.android.com/reference/android/content/Intent?
hl=es#FLAG_GRANT_READ_URI_PERMISSION)
.
--grant-write-uri-permission
Incluye la marca FLAG_GRANT_WRITE_URI_PERMISSION
hl=es#FLAG_GRANT_WRITE_URI_PERMISSION)
.
--debug-log-resolution
Incluye la marca FLAG_DEBUG_LOG_RESOLUTION
hl=es#FLAG_DEBUG_LOG_RESOLUTION)
.
--exclude-stopped-packages
Incluye la marca FLAG_EXCLUDE_STOPPED_PACKAGES
hl=es#FLAG_EXCLUDE_STOPPED_PACKAGES)
.
--include-stopped-packages
Incluye la marca FLAG_INCLUDE_STOPPED_PACKAGES
hl=es#FLAG_INCLUDE_STOPPED_PACKAGES)
.
--activity-brought-to-front
Incluye la marca FLAG_ACTIVITY_BROUGHT_TO_FRONT
hl=es#FLAG_ACTIVITY_BROUGHT_TO_FRONT)
.
--activity-clear-top
Incluye la marca FLAG_ACTIVITY_CLEAR_TOP
hl=es#FLAG_ACTIVITY_CLEAR_TOP)
.
--activity-clear-when-task-reset
Incluye la marca FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET
hl=es#FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET)
.
--activity-exclude-from-recents
Incluye la marca FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS
hl=es#FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS)
.
--activity-launched-from-history
Incluye la marca FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY
hl=es#FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY)
.
--activity-multiple-task
Incluye la marca FLAG_ACTIVITY_MULTIPLE_TASK
hl=es#FLAG_ACTIVITY_MULTIPLE_TASK)
.
--activity-no-animation
Incluye la marca FLAG_ACTIVITY_NO_ANIMATION
hl=es#FLAG_ACTIVITY_NO_ANIMATION)
.
--activity-no-history
Incluye la marca FLAG_ACTIVITY_NO_HISTORY
hl=es#FLAG_ACTIVITY_NO_HISTORY)
.
--activity-no-user-action
Incluye la marca FLAG_ACTIVITY_NO_USER_ACTION
hl=es#FLAG_ACTIVITY_NO_USER_ACTION)
.
--activity-previous-is-top
Incluye la marca FLAG_ACTIVITY_PREVIOUS_IS_TOP
hl=es#FLAG_ACTIVITY_PREVIOUS_IS_TOP)
.
--activity-reorder-to-front
Incluye la marca FLAG_ACTIVITY_REORDER_TO_FRONT
hl=es#FLAG_ACTIVITY_REORDER_TO_FRONT)
.
--activity-reset-task-if-needed
Incluye la marca FLAG_ACTIVITY_RESET_TASK_IF_NEEDED
hl=es#FLAG_ACTIVITY_RESET_TASK_IF_NEEDED)
.
--activity-single-top
Incluye la marca FLAG_ACTIVITY_SINGLE_TOP
hl=es#FLAG_ACTIVITY_SINGLE_TOP)
.
--activity-clear-task
Incluye la marca FLAG_ACTIVITY_CLEAR_TASK
hl=es#FLAG_ACTIVITY_CLEAR_TASK)
.
--activity-task-on-home
Incluye la marca FLAG_ACTIVITY_TASK_ON_HOME
hl=es#FLAG_ACTIVITY_TASK_ON_HOME)
.
--receiver-registered-only
Incluye la marca FLAG_RECEIVER_REGISTERED_ONLY
hl=es#FLAG_RECEIVER_REGISTERED_ONLY)
.
--receiver-replace-pending
Incluye la marca FLAG_RECEIVER_REPLACE_PENDING
hl=es#FLAG_RECEIVER_REPLACE_PENDING)
.
--selector
Requiere el uso de las opciones -d y -t para configurar los datos del intent y el tipo de
este.
URI component package
Puedes especificar directamente un URI, un nombre de paquete y un nombre de

componente cuando no se complete con ninguna de las opciones anteriores. Cuando un
argumento está incompleto, la herramienta asume que el argumento es un URI si
contiene ":" (dos puntos); asume que el argumento es un nombre de componente si
contiene una "/" (barra); de lo contrario, asume que el argumento es un nombre de
paquete.
Cómo llamar al administrador de paquetes (pm)
En un shell de adb, puedes emitir comandos con la herramienta administrador de paquetes

(pm) para realizar acciones y consultas en paquetes de aplicaciones instalados en el
dispositivo. En un shell, la sintaxis es la siguiente:
pm command
También puedes emitir un comando del administrador de paquetes directamente desde adb
sin ingresar a un shell remoto. Por ejemplo:
adb shell pm uninstall com.example.MyApp
Tabla 3. Comandos disponibles del administrador de paquetes.
list packages [options] filter Imprime todos los paquetes u, opcionalmente, solo
aquellos cuyos nombres de paquete contengan el
texto en filter.
Opciones:
-f: Consulta su archivo asociado.

-d: Filtra para mostrar únicamente los paquete
inhabilitados.
-e: Filtra para mostrar únicamente los paquete

habilitados.
-s: Filtra para mostrar únicamente los paquete

del sistema.
-3: Filtra para mostrar únicamente los paquete

de terceros.
-i: Consulta los paquetes en el instalador.
-u: Incluye también paquetes desinstalados.
--user user_id: El espacio de consulta del
usuario.
list permission-groups Imprime todos los grupos de permisos conocidos.
list permissions [options] group Imprime todos los permisos conocidos y,

opcionalmente, solo aquellos en group.
Opciones:
-g: Organiza por grupo.

-f: Imprime toda la información.
-s: Resumen breve.
-d: Solo detalla los permisos peligrosos.
-u: Solo indica los permisos que verán los
usuarios.
list instrumentation [options] Indica todos los paquetes de prueba.

Opciones:
-f: Detalla el archivo APK para el paquete de

prueba.
target_package: Detalla paquetes de prueba

solo para esta app.
list features Imprime todas las funciones del sistema.
list libraries Imprime todas las bibliotecas admitidas por el

dispositivo actual.
list users Imprime todos los usuarios del sistema.
path package Imprime la ruta de acceso al APK de un package

determinado.
install [options] path Instala un paquete (especificado por path) en el

sistema.
Opciones:
-r: Reinstala una app existente y conserva sus
datos.
-t: Permite la instalación de APK de prueba.

Gradle genera un APK de prueba cuando solo
ejecutaste o depuraste tu app, o bien usaste el
comando Build > Build APK de Android Studio.
el APK se compila con un SDK de vista previa d
desarrollador (si targetSdkVersion es una
letra en lugar de un número), debes incluir la
opción -t
(https://developer.android.com/studio/comma
line/adb?hl=es#-t-option)
con el comando install si instalas un APK de
prueba.
-i installer_package_name: Especifica e
nombre de paquete del instalador.
--install-location location: Configura

ubicación de instalación mediante uno de los
siguientes valores:
0: Usa la ubicación de instalación

predeterminada.
1: Realiza la instalación en el
almacenamiento interno del dispositivo.
2: Realiza la instalación en medios

externos.
-f: Instala el paquete en la memoria interna de

sistema.
-d: Permite pasar a una versión anterior del

código de versión.
-g: Otorga todos los permisos que se indican e

el manifiesto de la app.
--fastdeploy: Actualiza rápidamente un

paquete instalado actualizando solo las partes
APK que cambiaron.
--incremental: Instala lo suficiente del APK

como para iniciar la app mientras se transmiten
los datos restantes en segundo plano. Para usa
esta función, debes firmar el APK y crear un
archivo Esquema de firma de APK v4
(https://developer.android.com/studio/comma
line/apksigner?hl=es#v4-signing-enabled)
. Esta función solo es compatible con algunos
dispositivos. Esta opción fuerza a adb a usar la
función o falla si no es compatible (con
información detallada sobre por qué falló). Agr
la opción --wait para esperar a que el APK es
completamente instalado antes de otorgar acc
al APK.
--no-incremental evita que adb use esta

función.
uninstall [options] package Quita un paquete del sistema.

Opciones:
-k: Mantiene los directorios de datos y caché

después de la eliminación del paquete.
clear package Borra todos los datos asociados con un paquete.
enable package_or_component Habilita un paquete o componente determinado

(escrito como “paquete/clase”).
disable package_or_component Inhabilita un paquete o componente determinado

(escrito como “paquete/clase”).
disable-user [options] package_or_component Opciones:
--user user_id: El usuario que debe

inhabilitarse.
grant package_name permission Otorga permiso a una app. En los dispositivos que
ejecutan Android 6.0 (nivel de API 23) y versiones
posteriores, el permiso puede ser cualquier permis
declarado en el manifiesto de la app. En dispositiv
con Android 5.1 (nivel de API 22) y versiones
anteriores, debe ser un permiso opcional definido
la app.
revoke package_name permission Revocar un permiso de una app. En los dispositivo

que ejecutan Android 6.0 (nivel de API 23) y versio
posteriores, el permiso puede ser cualquiera
declarado en el manifiesto de la app. En dispositiv
con Android 5.1 (nivel de API 22) y versiones
anteriores, debe ser un permiso opcional definido
la app.
set-install-location location Cambia la ubicación de instalación predeterminad

Valores de ubicación:
0: Auto; permite que el sistema decida la mejor
ubicación
1: Interno; instala en una ubicación de

almacenamiento interna del dispositivo
2: Externo; en medios externos
 Nota: Esto es solo para depurar; usarlo puede

provocar que las apps fallen y otros
comportamientos no deseados.
get-install-location Muestra la ubicación de instalación actual. Valores

que se muestran:
0 [auto]: Permite que el sistema decida la
mejor ubicación.
1 [internal]: Instala en una ubicación de

almacenamiento interna del dispositivo.
2 [external]: Instala en un medio externo.
set-permission-enforced permission [true | Especifica si se debe aplicar el permiso otorgado.

false]
trim-caches desired_free_space Recorta los archivos de caché para adaptarlos a u

espacio libre determinado.
create-user user_name Crea un usuario con el user_name proporcionado

imprime el identificador nuevo del usuario.
remove-user user_id Quita el usuario con un user_id determinado y

borra todos los datos asociados con ese usuario.
get-max-users Imprime la cantidad máxima de usuarios que adm

el dispositivo.
Cómo llamar al administrador de políticas del dispositivo (dpm)

Para ayudarte a desarrollar y probar tus apps de administración de dispositivos (o de
empresas), puedes emitir comandos a la herramienta del administrador de políticas del
dispositivo (dpm). Usa la herramienta para controlar la app de administración activa o cambia
los datos de estado de una política en el dispositivo. En un shell, la sintaxis es la siguiente:
dpm command
También puedes emitir un comando del administrador de políticas del dispositivo

directamente desde adb, sin ingresar a un shell remoto.
adb shell dpm command
Tabla 4: Comandos disponibles del administrador de políticas del dispositivo
set-active-admin [options] component Establece component como administrador activo.
--user user_id: Especifica el usuario de destino.

para seleccionar el usuario actual.
set-profile-owner [options] component Establece el component como administrador activo y su

usuario existente.

--name name: Especifica el nombre de la organizac
set-device-owner [options] component Establece el component como administrador activo y su

--name name: Especifica el nombre de la organizac

remove-active-admin [options] componentInhabilita un administrador activo. La app debe declarar
(https://developer.android.com/guide/topics/manifest/
manifiesto. Este comando también quita los propietario

clear-freeze-period-record Borra el registro del dispositivo de los períodos de suspe

actualizaciones de OTA del sistema. Esto es útil para ev
dispositivo cuando se desarrollan apps que administran
administrar actualizaciones del sistema
(https://developer.android.com/work/dpc/system-upda
Compatible con dispositivos con Android 9.0 (nivel de A
force-network-logs Hace que el sistema prepare cualquier registro de red ex

un DPC. Si hay conexiones o registros de DNS disponibl
onNetworkLogsAvailable()
(https://developer.android.com/reference/android/app/
hl=es#onNetworkLogsAvailable(android.content.Contex
. Consulta Cómo registrar la actividad de red
(https://developer.android.com/work/dpc/logging?hl=e
Este comando tiene un límite de índice. Compatible con

API 28) y versiones posteriores.
force-security-logs Hace que el sistema ponga cualquier registro de segurid

registros disponibles, el DPC recibe la devolución de llam
(https://developer.android.com/reference/android/app/
hl=es#onSecurityLogsAvailable(android.content.Contex
. Consulta Cómo registrar la actividad de dispositivos em
(https://developer.android.com/work/dpc/security?hl=e
Este comando tiene un límite de índice. Compatible con

API 28) y versiones posteriores.
Cómo hacer una captura de pantalla
El comando screencap es una utilidad del shell para realizar una captura de pantalla de la
pantalla de un dispositivo. En un shell, la sintaxis es la siguiente:
screencap filename
Para usar screencap desde la línea de comandos, escribe lo siguiente:
adb shell screencap /sdcard/screen.png
Aquí te mostramos un ejemplo de una sesión de captura de pantalla en la que se usa el shell
de adb para realizar la captura de pantalla y el comando pull a fin de descargar el archivo
desde el dispositivo:
$ adb shell
shell@ $ screencap /sdcard/screen.png
shell@ $ exit
$ adb pull /sdcard/screen.png
Cómo grabar un video
El comando screenrecord es una utilidad del shell que permite grabar la pantalla de

dispositivos con Android 4.4 (nivel de API 19) y versiones posteriores. La utilidad graba la
actividad en pantalla en un archivo MPEG-4. Puedes usar este archivo para crear videos
promocionales o de capacitación, o para depurar y realizar pruebas.
En un shell, usa la siguiente sintaxis:
screenrecord [options] filename
Para usar screenrecord desde la línea de comandos, escribe lo siguiente:
adb shell screenrecord /sdcard/demo.mp4

Detén la grabación de la pantalla presionando Control + C (Command + C en Mac); de lo
contrario, la grabación se detiene automáticamente a los tres minutos o cuando se alcanza el
tiempo límite establecido por --time-limit.
Para comenzar a grabar la pantalla de tu dispositivo, ejecuta el comando screenrecord a fin

de grabar el video. Luego, ejecuta el comando pull para descargar el video del dispositivo en
una computadora host. Aquí te mostramos un ejemplo de una sesión de grabación:
$ adb shell
shell@ $ screenrecord --verbose /sdcard/demo.mp4
(press Control + C to stop)
shell@ $ exit
$ adb pull /sdcard/demo.mp4
La utilidad screenrecord puede grabar en cualquier resolución admitida y tasa de bits que

solicites y, al mismo tiempo, conservar la relación de aspecto de la pantalla del dispositivo. De
forma predeterminada, la utilidad graba en la resolución y la orientación nativas de la pantalla,
con un tiempo de grabación máximo de tres minutos.
Limitaciones de la utilidad screenrecord:
No se graba audio con el archivo de video.
La grabación de video no está disponible para dispositivos que ejecutan Wear OS.
Es posible que algunos dispositivos no puedan grabar en su resolución de pantalla

nativa. Si tienes problemas con la grabación de la pantalla, intenta usar una resolución
de pantalla más baja.
No se admite la rotación de la pantalla durante la grabación. Si la pantalla gira durante la

grabación, parte de la pantalla aparecerá cortada en el video.
Tabla 5: Opciones screenrecord
Opciones Descripción
--help Muestra la sintaxis y las opciones del comando.
--size widthxheightEstablece el tamaño del video: 1280x720. El valor predeterminado es la

resolución nativa de la pantalla del dispositivo (si se admite); si no se admite, es
1280 x 720. Para obtener mejores resultados, usa un tamaño admitido por el
codificador de código de video avanzado (AVC) de tu dispositivo.
--bit-rate rate Fija la tasa de bits de video para el video en megabits por segundo. El valor
predeterminado es 4 Mbps. Puedes aumentar la tasa de bits para mejorar la
calidad del video, pero si lo haces, los archivos de video serán más grandes. En el
siguiente ejemplo, se fija la tasa de bits de grabación en 6 Mbps:
screenrecord --bit-rate 6000000 /sdcard/demo.mp4
--time-limit time Fija el tiempo de grabación máximo en segundos. El valor máximo

predeterminado es 180 (3 minutos).
--rotate Rota el video resultante 90 grados. Esta función es experimental.
--verbose Muestra información de registro en la pantalla de la línea de comandos. Si no

configuras esta opción, la utilidad no muestra información mientras se ejecuta.
Cómo leer perfiles de ART para apps
A partir de Android 7.0 (nivel de API 24), el tiempo de ejecución de Android (ART) recopila

perfiles de ejecución para las apps instaladas, los cuales se usan a fin de optimizar el
rendimiento de las apps. Te recomendamos examinar los perfiles recopilados para
comprender los métodos que se ejecutan con frecuencia y las clases que se usan durante el
inicio de una app.
Para producir un texto a partir de información del perfil, usa el siguiente comando:
adb shell cmd package dump-profiles package
Para recuperar el archivo creado, usa:
adb pull /data/misc/profman/package.txt
Cómo restablecer dispositivos de prueba
Si pruebas tu app en varios dispositivos, quizás te convenga restablecer el dispositivo entre las
pruebas, por ejemplo, para quitar datos de los usuarios y restablecer el entorno de prueba.
Puedes realizar un restablecimiento de fábrica de un dispositivo con Android 10 (nivel de
API 29) o versiones posteriores mediante el comando shell adb testharness como se
muestra a continuación.
adb shell cmd testharness enable
Cuando restableces el dispositivo con testharness, el dispositivo crea automáticamente una

copia de seguridad de la clave RSA que permite depurar a través de la estación de trabajo
actual en una ubicación persistente. Por lo tanto, una vez que se restablece el dispositivo, la
estación de trabajo puede continuar depurando y emitiendo comandos adb al dispositivo sin
tener que registrar de forma manual una clave nueva.
Además, a fin de que puedas continuar probando tu app de forma más fácil y segura, cuando
usas testharness para restaurar un dispositivo, también se cambian las siguientes opciones
de configuración del dispositivo:
El dispositivo configura algunos parámetros del sistema a fin de que no aparezcan los

asistentes de configuración iniciales del dispositivo. El decir, el dispositivo ingresa a un
estado desde el que puedes instalar, depurar y probar tu app.
Configuración:
Inhabilita la pantalla de bloqueo.
Inhabilita las alertas de emergencia.
Inhabilita la sincronización automática para las cuentas.
Inhabilita las actualizaciones del sistema automáticas.
Otro:
Inhabilita las apps de seguridad instaladas previamente.
Si tu app necesita detectar las opciones de configuración predeterminadas del comando

testharness y adaptarse a ellas, puedes usar
ActivityManager.isRunningInUserTestHarness()
(https://developer.android.com/reference/android/app/ActivityManager?
hl=es#isRunningInUserTestHarness())
.
sqlite
sqlite3 inicia el programa de la línea de comandos sqlite para examinar las bases de datos
sqlite. Incluye comandos como .dump para imprimir el contenido de una tabla y .schema para
imprimir la declaración SQL CREATE de una tabla existente. También puedes ejecutar
comandos SQLite desde la línea de comandos, como se muestra a continuación.
$ adb -s emulator-5554 shell

$ sqlite3 /data/data/com.example.app/databases/rssitems.db
SQLite version 3.3.12
Enter ".help" for instructions
Para obtener más información, consulta la documentación de la línea de comandos de sqlite3

(http://www.sqlite.org/cli.html).
Content and code samples on this page are subject to the licenses described in the Content License
(https://developer.android.com/license?hl=es). Java is a registered trademark of Oracle and/or its affiliates.
Last updated 2021-01-15 UTC.

Conectar dispositivo Android con ADB

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Conectar dispositivo Android con ADB

Cargado por

Copyright:

Formatos disponibles

información al respecto.

Android Debug Bridge (adb)

Un cliente, que envía comandos. El cliente se ejecuta en tu máquina de desarrollo.

Un daemon (adbd), que ejecuta comandos en un dispositivo. El daemon se ejecuta como

Un servidor, que administra la comunicación entre el cliente y el daemon. El servidor se

adb está incluido en el paquete de herramientas de la plataforma de Android SDK. Puedes

Cómo funciona adb

Emulador 1, consola: 5554

Como se muestra, el emulador conectado al adb en el puerto 5555 es el mismo que el

Cómo habilitar la depuración de adb en tu dispositivo

En Android 4.2 y versiones posteriores, la pantalla "Opciones para desarrolladores" se

En algunos dispositivos, la pantalla "Opciones para desarrolladores" puede encontrarse en otro

Cómo conectarse a un dispositivo mediante Wi-Fi (Android 11 y

Android 11 y las versiones posteriores admiten la implementación y la depuración de tu app de

Para usar la depuración inalámbrica, debes sincronizar tu dispositivo con tu estación de

1. En tu estación de trabajo, actualiza a la versión más reciente de las Herramientas de la

2. En el dispositivo, habilita las Opciones para desarrolladores

3. Habilita la opción Depuración inalámbrica.

4. En el cuadro de diálogo que pregunta ¿Quieres permitir la depuración inalámbrica en

6. En tu estación de trabajo, abre una terminal y navega hasta android_sdk/platform-

8. Cuando se te pregunte, ingresa el código de vinculación que recibiste en el paso 5.

9. Solo para Linux o Microsoft Windows: Ejecuta adb connect ipaddr:port. Usa la

Cómo conectarse a un dispositivo mediante Wi-Fi (Android 10 y

2. Si te conectas a un dispositivo Wear OS, desactiva Bluetooth en el teléfono que esté

3. Conecta el dispositivo a la computadora host con un cable USB.

adb tcpip 5555

5. Desconecta el cable USB del dispositivo de destino.

7. Para conectarte al dispositivo, busca su dirección IP.

adb connect device_ip_address

8. Conﬁrma que tu computadora host esté conectada al dispositivo de destino:

¡Ya estás listo para empezar!

Si se pierde la conexión de ADB:

2. Vuelve a conectarte ejecutando el paso adb connect nuevamente.

3. Como alternativa, si eso no funciona, restablece tu host adb:

Luego vuelve a comenzar desde el principio.

Cómo realizar consultas de dispositivos

En respuesta, adb imprime esta información de estado para cada instancia:

offline: El dispositivo no está conectado a adb o no responde.

no device: No hay ningún dispositivo conectado.

Descripción: Si incluyes la opción -l, el comando devices dice qué es el dispositivo.

En el siguiente ejemplo, se muestra el comando devices y su resultado. Hay tres dispositivos

El emulador no aparece en la lista

1. El servidor de adb no se está ejecutando.

2. Usas el comando emulator con la opción -port o -ports con un valor de puerto de

4. Inicias el servidor de adb después de iniciar el emulador.

Ejemplo 1: En la siguiente secuencia de comandos, el comando adb devices inicia el servidor

List of devices attached

Ejemplo 2: En la siguiente secuencia de comandos, adb devices muestra la lista de

List of devices attached

Cómo enviar comandos a un dispositivo específico

Si se ejecutan varios dispositivos, debes especiﬁcar el dispositivo de destino cuando emitas el

En el siguiente ejemplo, se obtiene la lista de dispositivos asociados y se usa el número de

$ adb -s emulator-5555 install helloWorld.apk

Cómo instalar una app

adb install path_to_apk

Cómo configurar la redirección de puertos

Puedes usar el comando forward para conﬁgurar la redirección de puertos arbitraria, que

adb forward tcp:6100 tcp:7100

En el siguiente ejemplo, se conﬁgura la redirección del puerto de host 6100 a local:logd:

Cómo copiar archivos a un dispositivo o desde este

adb pull remote local

Para copiar un archivo o directorio y sus subdirectorios al dispositivo, haz lo siguiente:

adb push local remote