Android
ADB (Android Debug Bridge)

introduzione

Osservazioni

Stampa elenco dettagliato dei dispositivi collegati

Per ottenere un elenco dettagliato di tutti i dispositivi collegati ad adb , scrivi il seguente comando nel tuo terminale:

adb devices -l

Esempio di output

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 prima colonna è il numero di serie del dispositivo. Se inizia con l' emulator- , questo dispositivo è un emulatore.
• usb: il percorso del dispositivo nel sottosistema USB.
• product: il codice prodotto del dispositivo. Questo è molto specifico del produttore e, come puoi vedere nel caso del dispositivo Archos A50PL , può essere vuoto.
• model: il model: del dispositivo. Come il product , può essere vuoto.
• device: il codice del dispositivo. Questo è anche molto specifico del produttore e può essere vuoto.

Leggi le informazioni sul dispositivo

Scrivi il seguente comando nel tuo terminale:

adb shell getprop

Questo stamperà tutte le informazioni disponibili sotto forma di coppie chiave / valore.

Puoi solo leggere informazioni specifiche aggiungendo il nome di una chiave specifica al comando. Per esempio:

adb shell getprop ro.product.model

Ecco alcune informazioni interessanti che ottieni:

• ro.product.model : nome del modello del dispositivo (ad es. Nexus 6P)
• ro.build.version.sdk : Livello API del dispositivo (ad es. 23)
• ro.product.brand : marchio del dispositivo (ad esempio Samsung)

Pieno esempio di output

[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]

Collega ADB a un dispositivo tramite WiFi

La configurazione ADB standard prevede una connessione USB a un dispositivo fisico.
Se si preferisce, è possibile passare alla modalità TCP / IP e collegare invece ADB tramite WiFi.

Dispositivo non rootato

1. Entra nella stessa rete:

   • Assicurati che il tuo dispositivo e il tuo computer siano sulla stessa rete.

2. Collegare il dispositivo al computer host con un cavo USB.

3. Collega adb al dispositivo tramite rete:

   Mentre il dispositivo è connesso ad adb via USB, eseguire il seguente comando per ascoltare una connessione TCP / IP su una porta (predefinito 5555):

   • Digitare adb tcpip <port> (passare alla modalità TCP / IP).
   • Scollegare il cavo USB dal dispositivo di destinazione.
   • Digitare adb connect <ip address>:<port> (la porta è facoltativa; predefinita 5555).

   Per esempio:

   adb tcpip 5555
   adb connect 192.168.0.101:5555
   

   Se non conosci l'IP del tuo dispositivo puoi:

   • controlla l'IP nelle impostazioni WiFi del tuo dispositivo.
   • usa ADB per scoprire IP (via USB):
     1. Collegare il dispositivo al computer tramite USB
     2. In una riga di comando, digita adb shell ifconfig e copia l'indirizzo IP del dispositivo

   Per tornare al debug tramite USB, utilizzare il seguente comando:

   adb usb
   

   Puoi anche collegare ADB tramite WiFi installando un plug-in su Android Studio. Per farlo, vai su Impostazioni> Plugin e Sfoglia repository, cerca ADB WiFi , installalo e riapri Android Studio. Verrà visualizzata una nuova icona nella barra degli strumenti come mostrato nell'immagine seguente. Collega il dispositivo al computer host tramite USB e fai clic sull'icona di AndroidWiFiADB . Visualizzerà un messaggio se il tuo dispositivo è connesso o meno. Una volta collegato, puoi scollegare l'USB.

   

---

Dispositivo rooted

Nota: alcuni dispositivi che sono rootati possono utilizzare l'app WiFi ADB dal Play Store per abilitarla in modo semplice. Inoltre, per alcuni dispositivi (specialmente quelli con CyanogenMod ROM) questa opzione è presente nelle Opzioni sviluppatore tra le Impostazioni. Abilitandolo ti darò l'indirizzo IP e il numero di porta necessari per connettersi ad adb semplicemente eseguendo adb connect <ip address>:<port> .

Quando si dispone di un dispositivo rooted ma non si ha accesso a un cavo USB

Il processo è spiegato in dettaglio nella seguente risposta: http://stackoverflow.com/questions/2604727/how-can-i-connect-to-android-with-adb-over-tcp/3623727#3623727 I comandi più importanti sono mostrati sotto.

Aprire un terminale nel dispositivo e digitare quanto segue:

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

Per esempio:

setprop service.adb.tcp.port 5555

E sul tuo computer:

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

Per esempio:

adb connect 192.168.1.2:5555

Per disattivarlo:

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

Evitare il timeout

Per impostazione predefinita, adb terminerà il timeout dopo 5000 ms. Questo può accadere in alcuni casi, come il WiFi lento o l'APK di grandi dimensioni.

Un semplice cambiamento nella configurazione di Gradle può fare il trucco:

android {
    adbOptions {
        timeOutInMs 10 * 1000
    }
}

Tirare (spingere) i file da (a) il dispositivo

È possibile estrarre (scaricare) i file dal dispositivo eseguendo il seguente comando:

adb pull <remote> <local>

Per esempio:

adb pull /sdcard/ ~/

---

Puoi anche inviare (caricare) file dal tuo computer al dispositivo:

adb push <local> <remote>

Per esempio:

adb push ~/image.jpg /sdcard/

Esempio per recuperare il database dal dispositivo

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

Riavvia il dispositivo

È possibile riavviare il dispositivo eseguendo il seguente comando:

adb reboot

Esegui questo comando per riavviare nel bootloader:

adb reboot bootloader

Riavvia in modalità di ripristino:

adb reboot recovery

Tieni presente che il dispositivo non si spegne prima!

Accendi / spegni Wifi

Accendere:

adb shell svc wifi enable

Spegni:

adb shell svc wifi disable

Visualizza i dispositivi disponibili

Comando:

 adb devices

Esempio di risultato:

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

Prima colonna: numero di serie del dispositivo

Seconda colonna: stato della connessione

Documentazione di Android

Connetti dispositivo tramite IP

Inserisci questi comandi nel terminale del dispositivo Android

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

Dopo questo, è possibile utilizzare CMD e ADB per connettersi utilizzando il seguente comando

adb connect 192.168.0.101.5555

E puoi disabilitarlo e restituire ADB all'ascolto su USB con

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

Da un computer, se si dispone già dell'accesso USB (non è richiesta la root)

È ancora più semplice passare all'uso del Wi-Fi, se disponi già di USB. Da una riga di comando sul computer che ha il dispositivo connesso tramite USB, emettere i comandi

adb tcpip 5555
adb connect 192.168.0.101:5555

Sostituisci 192.168.0.101 con l'IP del dispositivo

Avvia / interrompi adb

Avvia ADB:

adb kill-server

Ferma ADB:

adb start-server

Visualizza logcat

È possibile eseguire logcat come comando adb o direttamente nel prompt della shell del proprio emulatore o dispositivo connesso. Per visualizzare l'output del registro utilizzando adb , accedere alla directory / strumenti della piattaforma SDK ed eseguire:

$ adb logcat

In alternativa, puoi creare una connessione shell a un dispositivo e quindi eseguire:

$ adb shell
$ logcat

---

Un comando utile è:

adb logcat -v threadtime

Visualizza la data, il tempo di chiamata, la priorità, il tag e il PID e il TID del thread che ha emesso il messaggio in un formato di messaggio lungo.

---

filtraggio

I log di Logcat hanno i cosiddetti livelli di log:

V - Verbose, D - Debug, I - Info, W - Warning, E - Error, F - Fatal, S - Silent

Puoi anche filtrare logcat per livello di log. Ad esempio se vuoi solo emettere il livello di Debug:

adb logcat *:D

Logcat può essere filtrato dal nome di un pacchetto, ovviamente è possibile combinarlo con il filtro del livello di log:

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

È anche possibile filtrare il log utilizzando grep (ulteriori informazioni sull'output del filtro logcat qui ):

adb logcat | grep <some text>

In Windows, il filtro può essere utilizzato con findstr, ad esempio:

adb logcat | findstr <some text>

Per visualizzare il buffer di registro alternativo [main | events | radio], eseguire il logcat con l'opzione -b :

adb logcat -b radio

Salva l'output nel file:

adb logcat > logcat.txt

Salva l'output nel file mentre lo guardi anche:

adb logcat | tee logcat.txt

Pulizia dei registri:

adb logcat -c

Comando ADB diretto su dispositivo specifico in un'impostazione multi-dispositivo

1. Indirizzare un dispositivo per numero di serie

Utilizzare l'opzione -s seguita dal nome di un dispositivo per selezionare su quale dispositivo deve essere eseguito il comando adb . Le opzioni -s dovrebbero essere prima in linea, prima del comando.

adb -s <device> <command>

Esempio:

adb devices

List of devices attached
emulator-5554       device
02157df2d1faeb33    device

adb -s emulator-5554 shell

Esempio # 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. Scegli come target un dispositivo, quando è connesso un solo tipo di dispositivo

Puoi scegliere come target l'unico emulatore in esecuzione con -e

adb -e <command>

Oppure puoi scegliere come target l'unico dispositivo USB collegato con -d

adb -d <command>

Acquisizione di uno screenshot e video (solo per kitkat) da un display del dispositivo

Schermata: Opzione 1 (adb puro)

Il comando shell adb ci consente di eseguire comandi utilizzando la shell incorporata di un dispositivo. Il comando screencap shell acquisisce il contenuto attualmente visibile su un dispositivo e lo salva in un determinato file immagine, ad es. /sdcard/screen.png :

adb shell screencap /sdcard/screen.png

È quindi possibile utilizzare il comando pull per scaricare il file dal dispositivo nella directory corrente sul proprio computer:

adb pull /sdcard/screen.png

Schermata: Opzione 2 (più veloce)

Esegui il seguente one-liner:

(Marshmallow e precedenti):

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

(Torrone e successivo):

adb shell screencap -p > screen.png

Il flag -p reindirizza l'output del comando screencap su stdout. L'espressione di Perl che viene convogliata per eliminare alcuni problemi di fine riga su Marshmallow e precedenti. Lo stream viene quindi scritto in un file denominato screen.png all'interno della directory corrente. Vedi questo articolo e questo articolo per maggiori informazioni.

video

questo funziona solo in KitKat e solo tramite ADB. Questo non funziona sotto Kitkat Per avviare la registrazione dello schermo del tuo dispositivo, esegui il seguente comando:

adb shell screenrecord /sdcard/example.mp4 , questo comando inizierà a registrare lo schermo del tuo dispositivo usando le impostazioni predefinite e salva il video risultante in un file nel file /sdcard/example.mp4 sul tuo dispositivo.

Quando hai finito di registrare, premi Ctrl + C (z in Linux) nella finestra del prompt dei comandi per interrompere la registrazione dello schermo. È quindi possibile trovare il file di registrazione dello schermo nella posizione specificata. Si noti che la registrazione dello schermo viene salvata nella memoria interna del dispositivo, non nel computer.

Le impostazioni predefinite servono per utilizzare la risoluzione dello schermo standard del dispositivo, codificare il video con un bitrate di 4 Mbps e impostare il tempo massimo di registrazione dello schermo su 180 secondi. Per ulteriori informazioni sulle opzioni della riga di comando che è possibile utilizzare, eseguire il seguente comando:

adb shell screenrecord –help , funziona senza fare il root del dispositivo. Spero che questo ti aiuti.

Cancella i dati dell'applicazione

È possibile cancellare i dati utente di un'app specifica utilizzando adb :

adb shell pm clear <package>

È lo stesso di navigare le impostazioni sul telefono, selezionare l'app e premere il pulsante Cancella dati.

• pm invoca il gestore pacchetti sul dispositivo
• clear cancella tutti i dati associati ad un pacchetto

Invio di trasmissione

È possibile inviare broadcast a BroadcastReceiver con adb .

In questo esempio, inviamo broadcast con action com.test.app.ACTION e stringa extra in bundle 'foo'='bar' :

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

Puoi mettere in bundle qualsiasi altro tipo supportato, non solo le stringhe:

--ez - booleano
--ei - intero
--el - lungo
--ef - float
--eu - uri
--eia - array int (separato da ',')
--ela - array lungo (separato da ',')
--efa - array float (separato da ',')
--esa - array di stringhe (separato da ',')

Per inviare l'intento a specifici pacchetti / classi -n o -p parametro può essere usato.
Invio al pacchetto:

-p com.test.app

Invio a un componente specifico ( SomeReceiver classe nel com.test.app package ):

-n com.test.app/.SomeReceiver

Esempi utili:

• Invio di una trasmissione "boot complete"
• Invio di una trasmissione "tempo modificato" dopo aver impostato l'ora tramite il comando adb

Installa ed esegui un'applicazione

Per installare un file APK , utilizzare il seguente comando:

adb install path/to/apk/file.apk

o se l'app è esistente e vogliamo reinstallarla

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

Per disinstallare un'applicazione , dobbiamo specificare il suo pacchetto

adb uninstall application.package.name

Utilizzare il comando seguente per avviare un'app con un nome pacchetto fornito (o un'attività specifica in un'app):

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

Ad esempio, per avviare Waze:

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

di riserva

È possibile utilizzare il comando adb backup per eseguire il backup del dispositivo.

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

-f <filename> specifica nomefile predefinito: crea backup.ab nella directory corrente

-apk|noapk abilita / disabilita il backup di .apks : default: -noapk

-obb|noobb abilita / disabilita il backup di file aggiuntivi default: -noobb

-shared|noshared di memoria condivisa del dispositivo di backup -shared|noshared / predefinito della scheda SD : -noshared

-all backup di tutte le applicazioni installate

-system|nosystem include le applicazioni di sistema predefinite: -sistema

<packages> un elenco di pacchetti di cui eseguire il backup (es. com.example.android.myapp) (non necessario se -all è specificato)

---

Per un backup completo del dispositivo, incluso tutto, utilizzare

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

Nota: l' esecuzione di un backup completo può richiedere molto tempo.

---

Per ripristinare un backup, utilizzare

adb restore backup.ab

Installa ADB su sistema Linux

Come installare Android Debugging Bridge (ADB) su un sistema Linux con il terminale usando i repository della tua distro.

Installa sul sistema Ubuntu / Debian tramite apt:

sudo apt-get update
sudo apt-get install adb

Installa nel sistema Fedora / CentOS via yum:

sudo yum check-update
sudo yum install android-tools

Installa sul sistema Gentoo con portage:

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

Installa sul sistema openSUSE con zypper:

sudo zypper refresh
sudo zypper install android-tools 

Installa su Arch system con pacman:

sudo pacman -Syyu
sudo pacman -S android-tools

Elencare tutte le autorizzazioni che richiedono la concessione di runtime dagli utenti su Android 6.0

adb shell pm list permissions -g -d 

Visualizza i dati interni di un'app (dati / dati / ) su un dispositivo

Innanzitutto, assicurati che la tua app possa essere sottoposta a backup in AndroidManifest.xml , ad esempio android:allowBackup non è false .

Comando di backup:

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

Creare un tar con il 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

Estrai il tar:

tar -xvf backup.tar

È quindi possibile visualizzare il contenuto estratto.

Visualizza lo stack delle attività

adb -s <serialNumber> shell dumpsys activity activities

Molto utile se utilizzato insieme al comando watch unix:

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

Visualizza e tira i file di cache di un'app

È possibile utilizzare questo comando per elencare i file per il proprio apk di debugging:

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

E questo script per estrarre dalla cache, copiare prima il contenuto in sdcard, estrarlo e quindi rimuoverlo alla fine:

#!/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'"

Quindi puoi estrarre un file dalla cache in questo modo:

./pull.sh cache/someCachedData.txt

Ottieni file di database tramite ADB

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