Android Debug Bridge

[Título original: Android Debug Bridge]

Documento original: Android Debug Bridge

El "Android Debug Bridge" ("adb") es un herramienta muy versátil que te permite controlar el estado de un dispositivo o un emulador.

Algunas de las funciones cosas que puedes hacer con "adb" son:

Actualización de código del dispositivo o emulador, tales como aplicaciones o actualizaciones del sistema Android.

Ejecutar comandos de "shell" en el dispositivo.

Administrar el direccionamiento de puertos de un emulator o dispositivo.

Copiar archivos hacia o desde un emulador o dispositivo.

Las siguientes secciones describen algunos de los comandos más comunes de usar con "adb".

Introducción

[Título original: Overview]

La herramienta "adb" es un programa cliente/servidor que incluye los siguientes componentes:

Un cliente que corre en tu máquina de desarrollo. Tú puedes invocar este cliente desde una consola de comandos ejecutando el comando "adb". Otras herramientas de Android, tales como el "ADT plugin" y "DDMS", crean sus propios clientes "adb".

Un servidor que se ejecuta como un proceso en segundo plano en tu máquina de desarrollo. Este servidor administra la comunicación entre el cliente y el "adb daemon" que corre dentro del emulador o dispositivo.

Un "daemon" que se ejecuta como un proceso de segundo plano en cada instancia de un emulador o dispositivo.

Cuando tú inicias un cliente "adb", lo primero que hace este cliente es verificar si hay un proceso servidor "adb" que esté corriendo. Si no lo hay, entonces el cliente inicia un proceso servidor "adb". Cuando el proceso servidor "adb" comienza a ejecutarse, asocia su servicio al puerto TCP número 5037 y se queda escuchando la llegada de comandos enviados desde los clientes "adb". Todos los clientes "adb" utilizan el puerto 5037 para comunicarse con el servidor "adb".

Posteriormente, el servidor "adb" establece conexiones hacia todas las instancias de emuladores/dispositivos que estén corriendo. El servidor "adb" localiza a las instancias de emuladores/dispositivos examinando todos los puertos con número impar dentro del rango de 5555 a 5585, el cual es el rango utilizado por los emuladores/dispositivos. Cuando el servidor "adb" encuentra un "adb daemon", estable de inmediato una conexión con él. Algo importante de saber es que cada emulador/dispositivo adquiere un par de puertos consecutivos:

un puerto de número par para recibir solicitudes de conexión de consola.

un número de puerto impar para las conexiones con el servidor "adb".

Por ejemplo:

Emulador #1:
consola: 5554
adb daemon: 5555

Emulador #2:
consola: 5556
adb daemon: 5557

Como se muestra en el ejemplo anterior, la instancia del emulador que está conectada con el servidor "adb" a través del puerto 5555, es la misma instancia cuya consola está escuchando en el puerto 5554.

Una vez que el servidor "adb" ha establecido las conexiones con las instancias de los emuladores/dispositivos, podemos comenzar a usar comandos "adb" para controlar y tener acceso a esas instancias. Debido a que el servidor "adb" administra las conexiones hacia todas las instancias de emuladores/dispositivos y maneja los comandos enviados por múltiples clientes "adb", podemos controlar cualquier instancia de un emulador/dispositivo desde cualquier cliente "adb" o "script".

Las secciones que leerás a continuación describen los comandos que tú puedes utilizar para utilizar las capacidades de "adb" y administrar el estado de un emulador/dispositivo. Ten en consideración que si tu estás desarrollando aplicaciones Android en Eclipse y has instalado el "ADT plugin", no es necesario que invoques "adb" desde una consola de comandos. El "ADT plugin" provee una integración transparente con "adb" dentro del entorno de desarrollo de Eclipse. Sin embargo, siempre puedes utilizar "adb" directamente.

Utilizando comandos "adb"

[Título original: Issuing adb Commands]

Puedes invocar cualquier comando "adb" desde una consola de comandos en tu máquina de desarrollo o desde un "script". La sintáxis de los comandos es:

adb [-d {<ID><serialNumber>}] <command>

Cuando tú When you despachar un comando, el programa invoca un cliente "adb", el cual no está asociado a ninguna instancia de emulador en particular, por lo tanto si hay múltiples emuladores/dispositivos corriendo tienes que utilizar el parámetro "-d" para indicar la instancia hacia la cual el comando debe ser dirigido. Para mayor información sobre cómo usar este parámetro lee "Dirigiendo comando hacia un emulador/dispositivo específico".

Averiguando qué emuladores/dispositivos están conectados

[Título original: Querying for Emulator/Device Instances]

Antes de comenzar a ejecutar comando "adb", es de mucha utilidad saber qué instancias de emuladores/dispositivos están conectadas al servidor "adb". Para obtener un listado de las instancias de emuladores/dispositivos que están corriendo y el estado de cada uno de ellos, podemos usar el siguiente comando:

En respuesta, "adb" imprime la siguiente información de estado para cada una de las instancias:

Idetificador : es un identificador asignado por "adb" a cada instancia que es inicializada ("adb" asigna el identificador "1" a la primera instancia inicializada, y así sucesivamente).

Número de serie : es una cadena de caracteres creada por "adb" para identificar de manera única a cada instancia de emulaor/dispositivo asociado a un puerto específico.

Estado : es el estado de la conexión de la instancia. Hay tres estados que son soportados: (A) device : indica que la instancia está conectada al servidor "adb". (B) offline : indica que la instancia no está conectada o no responde. (C) bootloader : indica que el "bootloader" está corriendo.

Bloqueo: Indica si la instancia está bloqueada. Un valor de "0" significa que está no está bloqueada.

La salida de cada instancia es desplegada con el siguiente formato:

[ID] [serialNumber] [state] [lock]

Este es un ejemplo de cómo podría ser la salida de este comando:

$ adb devices
List of devices attached 
1 emulator-tcp-5555 device 0
2 emulator-tcp-5557 device 0
3 emulator-tcp-5559 device 0

Si no hubiera ningún emulador/dispositivo corriendo, "adb" imprimiría "no device".

Dirigiendo comando hacia un emulador/dispositivo específico

[Título original: Directing Commands to a Specific Emulator/Device Instance]

Si múltiples instancias de emuladores/dispositivos están corriendo, necesitas indicar a cual de ellas vas a dirigir tus comandos. Para hacer esto, usa el parámetro "-d" en cada uno de los comandos. La sintáxis para este parámetros es:

Como se mostró, indicas la instancia objetivo utilizando el número de serie que "adb" asignó a cada una de ellas. Puedes utilizar el comando "devices" para obtener el número serial de las instancias de emuladores/dispositivos que estén corriendo.

A continuación hay dos ejemplos:

adb -d 2 install helloWorld.apk

adb -d emulator-tcp-5557 install helloWorld.apk

Ten en consideración que si envias un comando sin indicar el emulador/dispositivo objetivo, entonces "adb" por omisión enviará al comando a la primera instancia asociada al puerto "5555" (si es que hubiera una instancia conectada a ese puerto).

Instalación de una aplicación

[Título original: Installing an Application]

Tú puedes utilizar "adb" para copiar una aplicación desde tu computador de desarrollo e instalar la en una instancia de emulador/dispositivo. Para hacer esto, usa el comando "install". Al usar este comando tú tienes que indicar la ubicación del archivo ".apk" que deseas instalar:

adb install path_to_apk 

Para mayor información sobre cómo crear un archivo ".apk" que pueda ser instalado en una instancia de emulador/dispositivo lee "Usando aapt".

NOTA: Si tú estás usando Eclipse e instalaste "ADT plugin", no necesitas usar "adb" o "aapt" para instalar tus aplicaciones en el emulador/dispositivo. El "ADT plugin" se encarga del empaquetado e instalación de las aplicación.

Redireccionamiento de puerto

[Título original: Port Forwarding]

Podemos usar el comando "forward" para fijar arbitrariamente el redireccionamiento de un puerto, y así direccionar los requerimientos de un puerto hacia uno diferente en una instancia de un emulador/dispositivo. A continuación hay un ejemplo de cómo fijar el redireccionamiento del puerto 6100 en el host al puerto 7100 en el emulador/dispositivo:

adb forward tcp:6100 tcp:7100

También podemos usar "adb" para redireccionar un puerto hacia un dominio de socket abstracto de UNIX. El siguiente ejemplo ilustra este caso:

adb forward tcp:5556 local:logd 

Copiando archivos desde o hacia una instancia de emulador/dispositivo

[Título original: Copying Files to or from an Emulator/Device Instance]

Podemos usar los comandos "pull" y "push" para copiar archivos hacia y desde una instancia de emulador/dispositivo. A diferencia del comando "install", el cual sólo copia un archivo ".apk" a una ubicación específica, los comandos "pull" y "push" nos permiten copiar archivos y directorios arbitrarios a cualquier ubicación dentro de la instancia del emulador/dispositivo.

Para copiar un archivo o directorio (recursivamente) desde el emulador/dispositivo usa:

adb pull <remote> <local>

Para copiar un archivo o directorio (recursivamente) hacia el emulador/dispositivo usa:

adb push <local> <remote>

En los comandos, "local" y "remote" se refieren a ubicaciones de archivos/directorios en tu máquina de desarrollo ("local") y en la instancia del emulador/dispositivo ("remote").

A continuación se muestra un ejemplo:

adb push foo.txt /tmp/foo.txt

Listado de comandos "adb"

[Título original: Listing of adb Commands]

A continuación se listan los comandos soportados por "adb" y se explica su significado y uso:

Categoría: Opcional

[Título original: Category: Option]

Comando: -d {<ID><serialNumber>}
Descripción: Permite que indiquemos una instancia de emulador/dispositivo a la cual deseamos enviar un comando. 
La instancia del emulador/dispositivo es referenciada utilizando su identificador o número de serie.
Comentario: Si no se indica este parámetro, "adb" dirigirá el comando a la instancia por omisión 
(es decir, la instancia que está asociada al puerto "5555". 

Categoría: General

[Título original: Category: General]

Comando: devices
Descripción: Imprime un listado de todos los emuladores/dispositivos que están conectados.
Comentario: Para más detalles lee "Averiguando qué emuladores/dispositivos están conectados".

Comando: help 
Descripción: Imprime un listado con los comandos soportados por "adb"
Comentario:

Comando: version
Descripción: Imprime la versión de "adb"
Comentario:

Categoría: Depuración

[Título original: Category: Debug]

Comando: logcat [<option>] [<filter-specs>]
Descripción: Imprime el log de datos en la pantalla.
Comentario:

Comando: bugreport
Descripción: Imprime información de "dumpsys", "dumpstate" y "logcat" en la pantalla, con el propósito de crear un reporte de defectos.
Comentario:

Categoría: Datos

[Título original: Category: Data]

Comando: install <path-to-apk>
Descripción: Instala una aplicación Android en el emulador/dispositivo (debe indicarse la ubicación completa del archivo ".apk".
Comentario:

Comando: pull <remote> <local>
Descripción: Copia un determinado archivo desde una instancia de emulador/dispositivo hacia tu máquina de desarrollo.
Comentario:

Comando: push <local> <remote>
Descripción: Copia un determinado archivo desde tu máquina de desarrollo hacia una instancia del emulador/dispositivo.
Comentario:

Categoría: Puertos y redes

[Título original: Category: Ports and Networking]

Comando: forward <local> <remote>
Descripción: Direcciona conexiones de socket desde un específico puerto local a un específico puerto remoto en una instancia de emulador/dispositivo.
Comentario: La especificación de un puerto puede utilizar los siguientes esquemas:

tcp:<portnum> 
local:<UNIX domain socket name> 
dev:<character device name>

Comando: ppp <tty> [parm]...
Descripción: Ejecuta "PPP" sobre "USB".
<tty> es el "tty" para el "PPP stream". Por ejemplo, "dev:/dev/omap_csmi_ttyl.
[parm]... es cero o más opciones "PPP/PPPD", tales como "defaultroute", "local", "notty", etc.
NOTA: No debería iniciar automáticamente una conexión "PDP".
Comentario:

Categoría: Comandos de línea

[Título original: Category: Scripting]

Comando: get-serialno
Descripción: Imprime el identificador de la instancia.
Comentario:

Comando: get-state
Descripción: Imprime el estado "adb" de una instancia de emulador/dispositivo.
Comentario:

Comando: wait-for-bootloader
Descripción: Bloquea la ejecución hasta que el "bootloader" esté en línea, esto es hasta que el estado de la instancia es "bootloader".
Comentario:

Comando: wait-for-device
Descripción: Bloquea la ejecución hasta que el dispositivo esté en línea, esto es hasta que el estado de la instancia es "device".
Comentario: Este comando puede ser anexado a otros comandos "adb". 
En este caso, "adb" va a esperar hasta que la instancia del emulador/dispositivo esté conectada antes de enviar el otro comando. 
Por ejemplo: adb wait-for-device <command>.

Categoría: Servidor

[Título original: Category: Server]

Comando: start-server
Descripción: Verifica si el proceso del servidor "adb" está corriendo y lo activa si no lo estuviera.
Comentario:

Comando: kill-server
Descripción: Termina el proceso del servidor "adb".
Comentario:

Categoría: Intérprete de comandos

[Título original: Category: Shell]

Comando: shell
Descripción: Inicia una "shell" remota en la instancia del emulador/dispositivo objetivo.
Comentario: Lee "Enviando comandos de shell".

Comando: shell [<shellCommand>]
Descripción: Envia un comando de "shell" a la instancia del emulador/dispositivo objetivo y luego termina la "shell" remota.
Comentario: Lee "Enviando comandos de shell".

Enviando comandos al intérprete de comandos

[Título original: Issuing Shell Commands]

Podemos usar el comando "shell" para enviar comandos de "shell" remotos a una instancia de emulador/dispositivo. Podemos enviar un simple comando sin tener que abrir una sesión remota de "shell" o también podemos abrir una sesión de shell en donde naveguemos y enviemos comandos UNIX.

Para enviar un simple comando sin ingresar a una sesión remota de "shell", usa el siguiente comando:

adb [-d {<ID><serialNumber>}] shell <shellCommand>

Para abrir una sesión remota de "shell" en una instancia de emulador/dispositivo, usa el siguiente comando:

adb [-d {<ID><serialNumber>}] shell

Cuando hayas terminado de ejecutar tus comando, usa "CTRL+D" o "exit" para cerrar la sesión de "shell".

Las siguientes secciones proveen más información sobre comandos de "shell" que tú podrías utilizar.

Examinando base de datos sqlite3 desde una shell remota

[Título original: Examining sqlite3 Databases from a Remote Shell]

Desde una sesión de shell remota, podemos usar "sqlite3", el cual es un programa de comandos de línea para administrar las base de datos "SQLite" creadas por las aplicaciones. La herramienta "sql3" incluye comandos de mucha utilidad, tales como ".dump" que permite imprimir el contenido de una tabla, y ".schema" que permite genera la sentencia "SQL CREATE" necesaria para reproducir una tabla existente. La herramienta también te provee la capacidad de ejecutar comando dinámicamente.

Para usar "sqlite3", ingresa a una sesión de "shell" remota en la instancia del emulador, tal como se describió anteriormente, y luego invoca la herramienta usando el comando "sqlite3". De manera opcional, al invocar "sqlite3" puedes especificar la ubicación completa de la base de datos que deseas explorar. Las bases de datos en el emulador o dispositivo son almacenadas en el directorio "/data/data/nombrepaquete/databases/".

A continuación se muestra dos ejemplos:

$ adb -d emulator-tcp-5557 shell
# sqlite3 /data/data/com.example.google.rss.rssexample/databases/rssitems.db
SQLite version 3.3.12
Enter ".help" for instructions
.... enter commands, then quit...
sqlite> .exit 

C:\Android SDK\android_sdk_windows_m3-rc20a\tools>adb shell
sqlite3 /data/data/com.google.android.providers.contacts/databases/contacts.db
sqlite> .tables
.tables
_deleted_people contact_methods peopleLookup
calls people phones
sqlite> .exit
.exit

Una vez que has invocado "sqlite3", puedes ingresar comandos "sqlite3" en la "shell". Pata terminar la sesión y retornar a la sesión de "shell" remota de "adb" usa el comando "exit" o "CTRL+D".

Otros comandos del intérprete de comandos

[Título original: Other Shell Commands]

Comando de shell: dumpsys
Descripción: Vacía el contenido de los datos del sistema.
Comentario: La herramienta "Dalvik Debug Monitor Service (DDMS)" ofrece un entorno integrado de depuración que encontrarás más sencillo de utilizar.

Comando de shell: dumpstate
Descripción: Vacía la información de estado a un archivo.
Comentario:

Comando de shell: logcat [<option>]... [<filter-spec>]...
Descripción: Habilita el "radio logging" e imprime la salida a la pantalla.
Comentario:

Comando de shell: dmesg
Descripción: Imprime los mensajes de depuración a la pantalla.
Comentario:

Comando de shell: start
Descripción: Activa (reinicializa) una instancia de emulador/dispositivo.
Comentario:

Comando de shell: stop
Descripción: Detiene la ejecución de una instancia de emulador/dispositivo.
Comentario:

Habilitando logcat

[Título original: Enabling logcat Logging]

El sistema de bitácora de Android provee un mecanismo para recolectar y ver la información de depuración del sistema. Bitácoras de varias aplicaciones y porciones del systema son recolectadas en una serie de áreas de memoria temporal, las cuales pueden ser vistas y filtradas a través del comando "logcat".

Usando comandos "logcat"

[Título original: Using logcat Commands]

Tú puedes usar el comando para ver y seguir el contenido de la bitácora del sistema. La sintaxis general de uso es:

[adb] logcat [<option>] ... [<filter-spec>] ...

Las secciones a continuación explican las especificaciones de filtrado y las opciones del comando. Para mayor información lee "Listado de opciones del comando logcat".

Tú puedes usar el comando "logcat" desde tu computador de desarrollo o desde una sesión de "shell" remota en una instancia de emulador/dispositivo. Para ver la salida de la bitácora en tu computador de desarrollo, usa el siguiente comando:

$ adb logcat

y desde la sesión de "shell" remota, usa el siguiente comando:

# logcat

Filtrando la salida de la bitácora

[Título original: Filtering Log Output]

Cada mensaje de bitácora de Android tiene una etiqueta y una prioridad asociada.

La etiqueta de un mensaje de bitácora es una pequeña cadena de caracteres indicando el componente de sistema donde el mensaje fue originado (por ejemplo, "View" para una vista del sistema).

La prioridad es uno de los siguientes caracteres, ordenados desde la más baja a la más alta prioridad:

V - Verbose (baja prioridad) 
D - Debug 
I - Info 
W - Warning 
E - Error 
F - Fatal 
S - Silent (alta prioridad, en la cual nada es impreso) 

Tú puedes obtener una lista de etiquetas usadas en el sistema junto con las prioridades, ejecutando el comando "logcat" y examinando las primeras dos columnas de cada mensaje dado como: <priority>/<tag>.

A continuación hay un ejemplo de la salida de "logcat" que muestra un mensaje asociado con la prioridad de nivel "I" y con la etiqueta "ActivityManager":

Para reducir la salida de la bitácora a un nivel manejable, tú puedes restringir la cantidad de información usando expresiones que filtren estos datos. Las expresiones de filtro te permiten indicarle al sistemas las prioridad y etiquetas en las cuales tú estás interesado y así el sistema suprime todos los otros mensajes.

Una expresión de filtrado sigue el siguiente formato: "tag:priority ...", donde "tag" indica la etiqueta en la cual estamos interesados y "priority" indica el nivel mínimo de prioridad que deseamos examinar. Todos los mensajes para esa etiqueta que sean de la priodidad indica superior serán registrado en la bitácora. Podemos indicar cualquier número de especificaciones "tag:priority" es una expresión de filtrado. Las series de especificaciones son delimitadas por espacios en blanco.

A continuación verás un ejemplo de una expresión de filtrado que suprime todos los mensajes de bitácora excepto aquellos con la etiqueta "ActivityManager" cuya prioridad es "Info" o superior, y todos los mensajes con etiqueta "MyApp" con prioridad "Debug" o superior:

adb logcat ActivityManager:I MyApp:D *:S

El elemento final de la expresión "*:S", fija el nivel de prioridad de todas las etiquetas a "silent", de esa forma nos aseguramos de ver sólo aquellos mensajes con "View" y "MyApp". El uso de "*:S" es una excelente forma de asegurar que la salida de la bitácora está restringida a los filtros que nosotros hemos explícitamente indicado y así nuestros filtros actúan como una "lista blanca" de mensajes de bitácora.

La siguiente expresión desplega todos los mensajes de bitácora cuyo nivel de prioridad es "warning" o superior, para todas las etiquetas:

Si tú estás corriendo "logcat" desde tu computador de desarrollo (en vez de correrlo en una sesión de "shell" remota), también puedes fijar una expresión de filtrado por omisión. Para hacer esto exporta la variable de entorno "ANDROID_LOG_TAGS":

export ANDROID_LOG_TAGS="ActivityManager:I MyApp:D *:S"

NOTA: La variable de entorno "ANDROID_LOG_TAGS" no es exportada a la instancia del emulador/dispositivo, si tú estás corriendo "logcat" desde una sesión de "shell" remota o usando "adb shell logcat".

Controlando la salida de la bitácora

[Título original: Controlling Log Output Format]

Los mensaje de bitácora, además de las etiquetas y nivel de prioridad, contienen información de metadatos. Podemos modificar el formato de salida de los mensajes para que se desplegue determinada información de metadatos. Para hacer esto, usa la opción "-v" e indica uno de los siguientes formatos listados a continuación:

brief   - Desplega prioridad/etiqueta y PID del proceso que originó el mensaje (formato por omisión). 
process - Desplega sólo el PID. 
tag     - Desplega sólo prioridad/etiqueta. 
thread  - Desplega sólo proceso:thread y prioridad/etiqueta. 
raw     - Desplega toda la información del mensaje, sin metadatos. 
time    - Desplega la fecha, hora de invocación, prioridad/etiqueta y PID del proceso que originó el mensaje. 
long    - Desplega toda la información de metadatos y los mensajes separados por líneas en blanco. 

A continuación está la sintaxis general para ejecutar "logcat" e indicar el formato de salida que deseas:

[adb] logcat [-v <format>]

Aquí hay un ejemplo que muestra cómo generar mensajes usando el formato "thread":

adb logcat -v thread

NOTA: Sólo puedes indicar un sólo formato de salida con la opción"-v".

Examinando bitácoras alternativas

[Título original: Viewing Alternative Log Buffers]

El sistema de bitácora de Android mantiene múltiples bitácoras circulares para registrar los mensajes de eventos, y no todos los mensajes son enviados a la bitácora circular por omisión. Para examinar mensajes adicionales, puedes correr "logcat" con la opción "-b", lo cual te permitirá ver bitácoras circulares alternativas. Puedes examinar cualquiera de las siguientes bitácoras alternativas:

radio  - Muestra la bitácora de mensajes relacionados con radio/telefonía.
events - Muestra la bitácora de mensajes conteniendo mensajes asociados a eventos.
main   - Muestra la bitácora principal de mensajes (por omisión) 

Sintaxis de uso de la opción "-b":

[adb] logcat [-b <buffer>]

Aquí hay un ejemplo de cómo examinar la bitácora que contiene mensajes asociados a "radio" y telefonía:

adb logcat -b radio

Examinando Viewing stdout y stderr

[Título original: Viewing stdout and stderr]

Por omisión, el sistema Android tiene asociado "stdout" y "stderr" ("System.out" y "System.err") con "/dev/null". En procesos que corren "Dalvik VM", el sistema puede escribir una copia de los mensajes de salida a un archivo de bitácora. En este caso, el sistema escribe los mensajes de bitácora usando las etiquetas "stdout" y "stderr", ambas con prioridad "I".

Para rutear la salida de esta forma, debes detener la instancia del emulador/dispositivo y entonces usar el comando de shell "setprop" para habilitar el redireccionamiento de la salida. Aquí se muestra cómo hacerlo:

$ adb shell stop
$ adb shell setprop log.redirect-stdio true
$ adb shell start

El sistema mantiene esta configuración hasta que tu termines la ejecución de la instancia del emulador/dispositivo. Para usar esta configuración por omisión en la instancia del emulador/dispositivolt debes modificar el archivo "/data/local.prop" en el dispositivo.

Listado de las opciones del comando logcat

[Título original: Listing of logcat Command Options]

Opción: -b <buffer>
Descripción: Carga una bitácora alternativa para ser examinada, tal como "event" o "radio".

Opción: -c
Descripción: Borra completamente la bitácora y finaliza.

Opción: -d
Descripción: Vacía la bitácora a la pantalla y finaliza.

Opción: -f <filename>
Descripción: Escribe los mensajes de bitácora al archivo "filename". Por omisión es "stdout".

Opción: -g
Descripción: Imprime el tamaño de la bitácora y finaliza.

Opción: -n <count>
Descripción: Fija el número máximo de vueltas de una bitácora a "count". El valor por omisión es "4". Requiere la opción "-r".

Opción: -r <kbytes>
Descripción: Rota el archivo de bitácora cada "kbytes" de datos. El valor por omisión es "16". Requiere la opción "-f". 

Opción: -s
Descripción: Fija el filtro a "silent". 

Opción: -v <format>
Descripción: Fija el formato de salida de los mensajes de bitácora. Por omisión, el formato es "brief". 

Deteniendo el servidor "adb"

[Título original: Stopping the adb Server]

En algunos casos, podrías necesitar detener el proceso del servidor "adb" y luego reiniciarlo. Por ejemplo, si "adb" no está respondiendo a un comando. En este ejemplo, detener y reiniciar el proceso podría resolver el problema.

Para detener el proceso del servidor "adb", usa el comando "kill-server". Posteriormente, puedes reiniciar el servidor enviando cualquier comando "adb".

Información adicional

[Título original: No es parte de la documentación oficial]

Ejemplo salida : adb shell dmesg

[Título original: No es parte de la documentación oficial]

C:\android_sdk_windows_m3-rc22a\tools>adb shell dmesg 

<5>Linux version 2.6.23-gcc3bc3b4 (arve@arvelnx.corp.google.com) (gcc version 4.2.1) #3 Tue Oct 30 16:28:18 PDT 2007 
<4>CPU: ARM926EJ-S [41069265] revision 5 (ARMv5TEJ), cr=00003137 
<4>Machine: Goldfish 
<4>Memory policy: ECC disabled, Data cache writeback 
<7>On node 0 totalpages: 24576 
<7> DMA zone: 192 pages used for memmap 
<7> DMA zone: 0 pages reserved 
<7> DMA zone: 24384 pages, LIFO batch:3 
<7> Normal zone: 0 pages used for memmap 
<7> Movable zone: 0 pages used for memmap 
<4>CPU0: D VIVT write-through cache 
<4>CPU0: I cache: 4096 bytes, associativity 4, 32 byte lines, 32 sets 
<4>CPU0: D cache: 65536 bytes, associativity 4, 32 byte lines, 512 sets 
<4>Built 1 zonelists in Zone order. Total pages: 24384 
<5>Kernel command line: qemu=1 console=null android.checkjni=1 android.ril=ttyS0 
...