Android
ADB (Android Debug Bridge)

Introducción

Observaciones

Imprimir lista detallada de dispositivos conectados

Para obtener una lista detallada de todos los dispositivos conectados a adb , escriba el siguiente comando en su terminal:

adb devices -l

Ejemplo de salida

List of devices attached
ZX1G425DC6             device usb:336592896X product:shamu model:Nexus_6 device:shamu
013e4e127e59a868       device usb:337641472X product:bullhead model:Nexus_5X device:bullhead
ZX1D229KCN             device usb:335592811X product:titan_retde model:XT1068 device:titan_umtsds
A50PL                  device usb:331592812X

• La primera columna es el número de serie del dispositivo. Si comienza con el emulator- , este dispositivo es un emulador.
• usb: la ruta del dispositivo en el subsistema USB.
• product: el código del producto del dispositivo. Esto es muy específico del fabricante, y como puede ver en el caso del dispositivo Archos A50PL anterior, puede estar en blanco.
• model: el modelo de dispositivo. Como product , puede estar vacío.
• device: el código del dispositivo. Esto también es muy específico del fabricante y puede estar vacío.

Leer información del dispositivo

Escribe el siguiente comando en tu terminal:

adb shell getprop

Esto imprimirá toda la información disponible en forma de pares clave / valor.

Solo puede leer información específica agregando el nombre de una clave específica al comando. Por ejemplo:

adb shell getprop ro.product.model

Aquí hay algunos datos interesantes que obtienes:

• ro.product.model : nombre del modelo del dispositivo (por ejemplo, Nexus 6P)
• ro.build.version.sdk : Nivel de API del dispositivo (por ejemplo, 23)
• ro.product.brand : marca del dispositivo (por ejemplo, Samsung)

Ejemplo completo de salida

[dalvik.vm.dex2oat-Xms]: [64m]
[dalvik.vm.dex2oat-Xmx]: [512m]
[dalvik.vm.heapsize]: [384m]
[dalvik.vm.image-dex2oat-Xms]: [64m]
[dalvik.vm.image-dex2oat-Xmx]: [64m]
[dalvik.vm.isa.x86.variant]: [dalvik.vm.isa.x86.features=default]
[dalvik.vm.isa.x86_64.features]: [default]
[dalvik.vm.isa.x86_64.variant]: [x86_64]
[dalvik.vm.lockprof.threshold]: [500]
[dalvik.vm.stack-trace-file]: [/data/anr/traces.txt]
[debug.atrace.tags.enableflags]: [0]
[debug.force_rtl]: [0]
[dev.bootcomplete]: [1]
[gsm.current.phone-type]: [1]
[gsm.defaultpdpcontext.active]: [true]
[gsm.network.type]: [UMTS]
[gsm.nitz.time]: [1469106902492]
[gsm.operator.alpha]: [Android]
[gsm.operator.iso-country]: [us]
[gsm.operator.isroaming]: [false]
[gsm.operator.numeric]: [310260]
[gsm.sim.operator.alpha]: [Android]
[gsm.sim.operator.iso-country]: [us]
[gsm.sim.operator.numeric]: [310260]
[gsm.sim.state]: [READY]
[gsm.version.ril-impl]: [android reference-ril 1.0]
[init.svc.adbd]: [running]
[init.svc.bootanim]: [stopped]
[init.svc.console]: [running]
[init.svc.debuggerd]: [running]
[init.svc.debuggerd64]: [running]
[init.svc.drm]: [running]
[init.svc.fingerprintd]: [running]
[init.svc.gatekeeperd]: [running]
[init.svc.goldfish-logcat]: [stopped]
[init.svc.goldfish-setup]: [stopped]
[init.svc.healthd]: [running]
[init.svc.installd]: [running]
[init.svc.keystore]: [running]
[init.svc.lmkd]: [running]
[init.svc.logd]: [running]
[init.svc.logd-reinit]: [stopped]
[init.svc.media]: [running]
[init.svc.netd]: [running]
[init.svc.perfprofd]: [running]
[init.svc.qemu-props]: [stopped]
[init.svc.ril-daemon]: [running]
[init.svc.servicemanager]: [running]
[init.svc.surfaceflinger]: [running]
[init.svc.ueventd]: [running]
[init.svc.vold]: [running]
[init.svc.zygote]: [running]
[init.svc.zygote_secondary]: [running]
[net.bt.name]: [Android]
[net.change]: [net.dns2]
[net.dns1]: [10.0.2.3]
[net.dns2]: [10.0.2.4]
[net.eth0.dns1]: [10.0.2.3]
[net.eth0.dns2]: [10.0.2.4]
[net.eth0.gw]: [10.0.2.2]
[net.gprs.local-ip]: [10.0.2.15]
[net.hostname]: [android-5e1af924d72dc578]
[net.qtaguid_enabled]: [1]
[net.tcp.default_init_rwnd]: [60]
[persist.sys.dalvik.vm.lib.2]: [libart.so]
[persist.sys.profiler_ms]: [0]
[persist.sys.timezone]: [Europe/Vienna]
[persist.sys.usb.config]: [adb]
[qemu.gles]: [1]
[qemu.hw.mainkeys]: [0]
[qemu.sf.fake_camera]: [none]
[qemu.sf.lcd_density]: [560]
[rild.libargs]: [-d /dev/ttyS0]
[rild.libpath]: [/system/lib/libreference-ril.so]
[ro.allow.mock.location]: [0]
[ro.baseband]: [unknown]
[ro.board.platform]: []
[ro.boot.hardware]: [ranchu]
[ro.bootimage.build.date]: [Thu Jul 7 15:56:30 UTC 2016]
[ro.bootimage.build.date.utc]: [1467906990]
[ro.bootimage.build.fingerprint]: [Android/sdk_google_phone_x86_64/generic_x86_64:6.0/MASTER/3038907:userdebug/test-keys]
[ro.bootloader]: [unknown]
[ro.bootmode]: [unknown]
[ro.build.characteristics]: [emulator]
[ro.build.date]: [Thu Jul  7 15:55:30 UTC 2016]
[ro.build.date.utc]: [1467906930]
[ro.build.description]: [sdk_google_phone_x86_64-userdebug 6.0 MASTER 3038907 test-keys]
[ro.build.display.id]: [sdk_google_phone_x86_64-userdebug 6.0 MASTER 3038907 test-keys]
[ro.build.fingerprint]: [Android/sdk_google_phone_x86_64/generic_x86_64:6.0/MASTER/3038907:userdebug/test-keys]
[ro.build.flavor]: [sdk_google_phone_x86_64-userdebug]
[ro.build.host]: [vpak15.mtv.corp.google.com]
[ro.build.id]: [MASTER]
[ro.build.product]: [generic_x86_64]
[ro.build.tags]: [test-keys]
[ro.build.type]: [userdebug]
[ro.build.user]: [android-build]
[ro.build.version.all_codenames]: [REL]
[ro.build.version.base_os]: []
[ro.build.version.codename]: [REL]
[ro.build.version.incremental]: [3038907]
[ro.build.version.preview_sdk]: [0]
[ro.build.version.release]: [6.0]
[ro.build.version.sdk]: [23]
[ro.build.version.security_patch]: [2015-10-01]
[ro.com.google.locationfeatures]: [1]
[ro.config.alarm_alert]: [Alarm_Classic.ogg]
[ro.config.nocheckin]: [yes]
[ro.config.notification_sound]: [OnTheHunt.ogg]
[ro.crypto.state]: [unencrypted]
[ro.dalvik.vm.native.bridge]: [0]
[ro.debuggable]: [1]
[ro.hardware]: [ranchu]
[ro.hardware.audio.primary]: [goldfish]
[ro.kernel.android.checkjni]: [1]
[ro.kernel.android.qemud]: [1]
[ro.kernel.androidboot.hardware]: [ranchu]
[ro.kernel.clocksource]: [pit]
[ro.kernel.console]: [0]
[ro.kernel.ndns]: [2]
[ro.kernel.qemu]: [1]
[ro.kernel.qemu.gles]: [1]
[ro.opengles.version]: [131072]
[ro.product.board]: []
[ro.product.brand]: [Android]
[ro.product.cpu.abi]: [x86_64]
[ro.product.cpu.abilist]: [x86_64,x86]
[ro.product.cpu.abilist32]: [x86]
[ro.product.cpu.abilist64]: [x86_64]
[ro.product.device]: [generic_x86_64]
[ro.product.locale]: [en-US]
[ro.product.manufacturer]: [unknown]
[ro.product.model]: [Android SDK built for x86_64]
[ro.product.name]: [sdk_google_phone_x86_64]
[ro.radio.use-ppp]: [no]
[ro.revision]: [0]
[ro.runtime.firstboot]: [1469106908722]
[ro.secure]: [1]
[ro.serialno]: []
[ro.wifi.channels]: []
[ro.zygote]: [zygote64_32]
[selinux.reload_policy]: [1]
[service.bootanim.exit]: [1]
[status.battery.level]: [5]
[status.battery.level_raw]: [50]
[status.battery.level_scale]: [9]
[status.battery.state]: [Slow]
[sys.boot_completed]: [1]
[sys.sysctl.extra_free_kbytes]: [43200]
[sys.sysctl.tcp_def_init_rwnd]: [60]
[sys.usb.config]: [adb]
[sys.usb.state]: [adb]
[vold.has_adoptable]: [1]
[wlan.driver.status]: [unloaded]
[xmpp.auto-presence]: [true]

Conecta ADB a un dispositivo a través de WiFi

La configuración estándar de ADB implica una conexión USB a un dispositivo físico.
Si lo prefiere, puede cambiar al modo TCP / IP y, en su lugar, conectar ADB a través de WiFi.

Dispositivo no rooteado

1. Entrar en la misma red:

   • Asegúrese de que su dispositivo y su computadora estén en la misma red.

2. Conecte el dispositivo a la computadora host con un cable USB.

3. Conecte adb al dispositivo a través de la red:

   Mientras su dispositivo está conectado a adb través de USB, realice el siguiente comando para escuchar una conexión TCP / IP en un puerto (predeterminado 5555):

   • Escriba adb tcpip <port> (cambie al modo TCP / IP).
   • Desconecte el cable USB del dispositivo de destino.
   • Escriba adb connect <ip address>:<port> (el puerto es opcional; predeterminado 5555).

   Por ejemplo:

   adb tcpip 5555
   adb connect 192.168.0.101:5555
   

   Si no conoce la IP de su dispositivo, puede:

   • Compruebe la IP en la configuración de WiFi de su dispositivo.
   • use ADB para descubrir IP (a través de USB):
     1. Conecta el dispositivo a la computadora a través de USB
     2. En una línea de comando, escriba adb shell ifconfig y copie la dirección IP de su dispositivo

   Para volver a la depuración a través de USB, use el siguiente comando:

   adb usb
   

   También puede conectar ADB a través de WiFi mediante la instalación de un complemento para Android Studio. Para hacerlo, vaya a Configuración> Complementos y repositorios de navegación, busque ADB WiFi , instálelo y vuelva a abrir Android Studio. Verá un nuevo icono en su barra de herramientas como se muestra en la siguiente imagen. Conecte el dispositivo al ordenador host mediante USB y haga clic en este icono de AndroidWiFiADB . Mostrará un mensaje si su dispositivo está conectado o no. Una vez que se conecta puede desconectar su USB.

   

---

Dispositivo rooteado

Nota: Algunos dispositivos que están rooteados pueden usar la aplicación WiFi ADB de Play Store para habilitar esto de una manera simple. Además, para ciertos dispositivos (especialmente aquellos con ROM de CyanogenMod), esta opción está presente en las Opciones de Desarrollador entre las Configuraciones. Habilitarlo le dará la dirección IP y el número de puerto necesarios para conectarse a adb simplemente ejecutando adb connect <ip address>:<port> .

Cuando tienes un dispositivo rooteado pero no tienes acceso a un cable USB

El proceso se explica en detalle en la siguiente respuesta: http://stackoverflow.com/questions/2604727/how-can-i-connect-to-android-with-adb-over-tcp/3623727#3623727 Los comandos más importantes se muestran a continuación.

Abra un terminal en el dispositivo y escriba lo siguiente:

su
setprop service.adb.tcp.port <a tcp port number>
stop adbd
start adbd

Por ejemplo:

setprop service.adb.tcp.port 5555

Y en tu computadora:

adb connect <ip address>:<a tcp port number>

Por ejemplo:

adb connect 192.168.1.2:5555

Para apagarlo:

setprop service.adb.tcp.port -1
stop adbd
start adbd

Evitar el tiempo de espera

Por defecto, adb se agotará después de 5000 ms. Esto puede suceder en algunos casos, como WiFi lento o APK grande.

Un simple cambio en la configuración de Gradle puede hacer el truco:

android {
    adbOptions {
        timeOutInMs 10 * 1000
    }
}

Tire de (empuje) archivos desde (hacia) el dispositivo

Puede extraer (descargar) archivos del dispositivo ejecutando el siguiente comando:

adb pull <remote> <local>

Por ejemplo:

adb pull /sdcard/ ~/

---

También puede enviar (cargar) archivos desde su computadora al dispositivo:

adb push <local> <remote>

Por ejemplo:

adb push ~/image.jpg /sdcard/

Ejemplo para recuperar la base de datos del dispositivo

sudo adb -d shell "run-as com.example.name cat /data/da/com.example.name /databases/DATABASE_NAME  > /sdcard/file

Reiniciar dispositivo

Puede reiniciar su dispositivo ejecutando el siguiente comando:

adb reboot

Ejecuta este comando para reiniciar en el gestor de arranque:

adb reboot bootloader

Reinicie al modo de recuperación:

adb reboot recovery

¡Tenga en cuenta que el dispositivo no se apagará primero!

Encender / apagar Wifi

Encender:

adb shell svc wifi enable

Apagar:

adb shell svc wifi disable

Ver dispositivos disponibles

Mando:

 adb devices

Ejemplo de resultado:

List of devices attached
emulator-5554  device
PhoneRT45Fr54  offline
123.454.67.45  no device

Primera columna - número de serie del dispositivo

Segunda columna - estado de conexión

Documentación de Android

Conectar dispositivo por IP

Ingrese estos comandos en el terminal de dispositivo Android

su
setprop service.adb.tcp.port 5555
stop adbd
start adbd

Después de esto, puede usar CMD y ADB para conectarse usando el siguiente comando

adb connect 192.168.0.101.5555

Y puede deshabilitarlo y volver a ADB a escuchar en USB con

setprop service.adb.tcp.port -1
stop adbd
start adbd

Desde una computadora, si ya tiene acceso USB (no se requiere root)

Es incluso más fácil cambiar a usar Wi-Fi, si ya tiene USB. Desde una línea de comandos en la computadora que tiene el dispositivo conectado a través de USB, ejecute los comandos

adb tcpip 5555
adb connect 192.168.0.101:5555

Reemplace 192.168.0.101 con el dispositivo IP

Iniciar / detener adb

Iniciar ADB:

adb kill-server

Detener ADB:

adb start-server

Ver logcat

Puede ejecutar logcat como un comando adb o directamente en un indicador de shell de su emulador o dispositivo conectado. Para ver la salida del registro usando adb , navegue a su plataforma-herramientas / directorio SDK y ejecute:

$ adb logcat

Alternativamente, puede crear una conexión de shell a un dispositivo y luego ejecutar:

$ adb shell
$ logcat

---

Un comando útil es:

adb logcat -v threadtime

Esto muestra la fecha, la hora de invocación, la prioridad, la etiqueta y el PID y TID del hilo que emite el mensaje en un formato de mensaje largo.

---

Filtración

Logcat logs obtuvo los llamados niveles de registro:

V - Verbosa, D - Depuración, I - Información, W - Advertencia, E - Error, F - Fatal, S - Silencio

También puede filtrar logcat por nivel de registro. Por ejemplo, si solo desea generar un nivel de depuración:

adb logcat *:D

Logcat se puede filtrar por un nombre de paquete, por supuesto, puede combinarlo con el filtro de nivel de registro:

adb logcat <package-name>:<log level>

También puede filtrar el registro usando grep (más información sobre cómo filtrar la salida logcat aquí ):

adb logcat | grep <some text>

En Windows, el filtro se puede usar usando findstr, por ejemplo:

adb logcat | findstr <some text>

Para ver el búfer de registro alternativo [main | events | radio], ejecute el logcat con la opción -b :

adb logcat -b radio

Guardar salida en el archivo:

adb logcat > logcat.txt

Guarda la salida en el archivo mientras también lo miras:

adb logcat | tee logcat.txt

Limpiando los troncos:

adb logcat -c

Dirigir el comando ADB a un dispositivo específico en una configuración de múltiples dispositivos

1. Dirigir un dispositivo por número de serie

Use la opción -s seguida de un nombre de dispositivo para seleccionar en qué dispositivo debe ejecutarse el comando adb . Las opciones -s deben ser las primeras en la línea, antes del comando.

adb -s <device> <command>

Ejemplo:

adb devices

List of devices attached
emulator-5554       device
02157df2d1faeb33    device

adb -s emulator-5554 shell

Ejemplo # 2:

adb devices -l

List of devices attached
06157df65c6b2633    device usb:1-3 product:zerofltexx model:SM_G920F device:zeroflte
LC62TB413962        device usb:1-5 product:a50mgp_dug_htc_emea model:HTC_Desire_820G_dual_sim device:htc_a50mgp_dug

adb -s usb:1-3 shell

2. Dirigirse a un dispositivo, cuando solo hay conectado un tipo de dispositivo

Puedes apuntar al único emulador en ejecución con -e

adb -e <command>

O puede apuntar al único dispositivo USB conectado con -d

adb -d <command>

Captura de pantalla y video (solo para kitkat) desde la pantalla del dispositivo

Captura de pantalla: Opción 1 (adb puro)

El comando shell adb nos permite ejecutar comandos utilizando el shell integrado de un dispositivo. El comando de shell screencap captura el contenido actualmente visible en un dispositivo y lo guarda en un archivo de imagen dado, por ejemplo, /sdcard/screen.png :

adb shell screencap /sdcard/screen.png

Luego puede usar el comando de extracción para descargar el archivo desde el dispositivo al directorio actual en su computadora:

adb pull /sdcard/screen.png

Captura de pantalla: Opción 2 (más rápido)

Ejecutar el siguiente de una sola línea:

(Marshmallow y anteriores):

adb shell screencap -p | perl -pe 's/\x0D\x0A/\x0A/g' > screen.png

(Turrón y posteriores):

adb shell screencap -p > screen.png

El indicador -p redirige la salida del comando screencap a la salida estándar. La expresión de Perl en la que se canaliza limpia algunos problemas de final de línea en Marshmallow y versiones anteriores. La secuencia se escribe en un archivo llamado screen.png dentro del directorio actual. Vea este artículo y este artículo para más información.

Vídeo

Esto solo funciona en KitKat y solo a través de ADB. Esto no funciona debajo de Kitkat Para comenzar a grabar la pantalla de su dispositivo, ejecute el siguiente comando:

adb shell screenrecord /sdcard/example.mp4 , este comando comenzará a grabar la pantalla de su dispositivo usando la configuración predeterminada y guardará el video resultante en un archivo en /sdcard/example.mp4 en su dispositivo.

Cuando haya terminado de grabar, presione Ctrl + C (z en Linux) en la ventana del símbolo del sistema para detener la grabación de la pantalla. Luego puede encontrar el archivo de grabación de pantalla en la ubicación que especificó. Tenga en cuenta que la grabación de la pantalla se guarda en el almacenamiento interno de su dispositivo, no en su computadora.

La configuración predeterminada es usar la resolución de pantalla estándar de su dispositivo, codificar el video a una tasa de bits de 4 Mbps y establecer el tiempo máximo de grabación de pantalla en 180 segundos. Para obtener más información sobre las opciones de línea de comandos que puede usar, ejecute el siguiente comando:

adb shell screenrecord –help , esto funciona sin enraizar el dispositivo. Espero que esto ayude.

Borrar datos de la aplicación

Uno puede borrar los datos de usuario de una aplicación específica usando adb :

adb shell pm clear <package>

Esto es lo mismo que para navegar por la configuración del teléfono, seleccionar la aplicación y presionar el botón de borrar datos.

• pm invoca el gestor de paquetes en el dispositivo
• clear borra todos los datos asociados con un paquete

Enviando transmisión

Es posible enviar transmisión a BroadcastReceiver con adb .

En este ejemplo, estamos enviando difusión con la acción com.test.app.ACTION y la cadena extra en el paquete 'foo'='bar' :

adb shell am broadcast -a action com.test.app.ACTION --es foo "bar"

Puede incluir cualquier otro tipo compatible en el paquete, no solo las cadenas:

--ez - booleano
--ei - entero
--el - largo
--ef - flotar
--eu - uri
--eia - int array (separado por ',')
--ela - matriz larga (separada por ',')
--efa - matriz flotante (separada por ',')
--esa - cadena de cadenas (separadas por ',')

Para enviar la intención a un paquete específico / clase -n o -p se puede usar el parámetro.
Enviando al paquete:

-p com.test.app

Envío a un componente específico ( SomeReceiver clase en com.test.app package ):

-n com.test.app/.SomeReceiver

Ejemplos utiles:

• Enviando una transmisión de "arranque completo"
• Enviar una transmisión de "hora modificada" después de configurar la hora mediante el comando adb

Instalar y ejecutar una aplicación

Para instalar un archivo APK , use el siguiente comando:

adb install path/to/apk/file.apk

O si la aplicación ya existe y queremos reinstalarla.

adb install -r path/to/apk/file.apk 

Para desinstalar una aplicación , tenemos que especificar su paquete.

adb uninstall application.package.name

Use el siguiente comando para iniciar una aplicación con un nombre de paquete provisto (o una actividad específica en una aplicación):

adb shell am start -n adb shell am start <package>/<activity>

Por ejemplo, para iniciar Waze:

adb shell am start -n adb shell am start com.waze/com.waze.FreeMapAppActivity

Apoyo

Puede usar el comando adb backup para hacer una copia de seguridad de su dispositivo.

adb backup [-f <file>] [-apk|-noapk] [-obb|-noobb] [-shared|-noshared] [-all] 
           [-system|nosystem] [<packages...>]

-f <filename> especifique el nombre de archivo predeterminado: crea backup.ab en el directorio actual

-apk|noapk habilita / deshabilita la copia de seguridad de .apks ellos mismos por defecto: -noapk

-obb|noobb habilita / deshabilita la copia de seguridad de archivos adicionales por defecto: -noobb

-shared|noshared compartido de la tarjeta SD / almacenamiento compartido del dispositivo de copia de seguridad no compartidos por defecto: -noshared

-all respaldan todas las aplicaciones instaladas.

-system|nosystem incluye las aplicaciones del sistema por defecto: -system

<packages> una lista de paquetes para realizar copias de seguridad (por ejemplo com.example.android.myapp) (no es necesario si -all se especifica)

---

Para una copia de seguridad completa del dispositivo, incluyendo todo, use

adb backup -apk -obb -shared -all -system -f fullbackup.ab

Nota: Hacer una copia de seguridad completa puede llevar mucho tiempo.

---

Para restaurar una copia de seguridad, utilice

adb restore backup.ab

Instalar ADB en el sistema Linux

Cómo instalar el Puente de depuración de Android (ADB) en un sistema Linux con el terminal utilizando los repositorios de su distro.

Instalar en el sistema Ubuntu / Debian a través de apt:

sudo apt-get update
sudo apt-get install adb

Instalar en el sistema Fedora / CentOS a través de yum:

sudo yum check-update
sudo yum install android-tools

Instalar en el sistema Gentoo con portage:

sudo emerge --ask dev-util/android-tools

Instalar en el sistema openSUSE con zypper:

sudo zypper refresh
sudo zypper install android-tools 

Instalar en el sistema Arch con pacman:

sudo pacman -Syyu
sudo pacman -S android-tools

Listar todos los permisos que requieren la concesión de tiempo de ejecución de los usuarios en Android 6.0

adb shell pm list permissions -g -d 

Ver los datos internos de una aplicación (datos / datos / ) en un dispositivo

Primero, asegúrese de que se pueda hacer una copia de seguridad de su aplicación en AndroidManifest.xml , es decir, android:allowBackup no es false .

Comando de copia de seguridad:

adb -s <device_id> backup -noapk <sample.package.id>

Crea un tar con el comando dd:

dd if=backup.ab bs=1 skip=24 | python -c "import zlib,sys;sys.stdout.write(zlib.decompress(sys.stdin.read()))" > backup.tar

Extraer el alquitrán:

tar -xvf backup.tar

A continuación, puede ver el contenido extraído.

Ver pila de actividades

adb -s <serialNumber> shell dumpsys activity activities

Muy útil cuando se usa junto con el comando watch unix:

watch -n 5 "adb -s <serialNumber> shell dumpsys activity activities | sed -En -e '/Stack #/p' -e '/Running activities/,/Run #0/p'"

Ver y extraer archivos de caché de una aplicación

Puede usar este comando para enumerar los archivos para su propia apk debuggable:

adb shell run-as <sample.package.id> ls /data/data/sample.package.id/cache

Y esta secuencia de comandos para extraer de la memoria caché, primero copia el contenido a sdcard, extrae y luego lo elimina al final:

#!/bin/sh
adb shell "run-as <sample.package.id> cat '/data/data/<sample.package.id>/$1' > '/sdcard/$1'"
adb pull "/sdcard/$1"
adb shell "rm '/sdcard/$1'"

Luego puedes extraer un archivo de la memoria caché de esta manera:

./pull.sh cache/someCachedData.txt

Obtener archivo de base de datos a través de ADB

sudo adb -d shell "run-as com.example.name cat /data/da/com.example.name /databases/STUDENT_DATABASE  > /sdcard/file