Android
ADB (Android Debug Bridge)

Introduction

Remarques

Imprimer la liste détaillée des appareils connectés

Pour obtenir une liste détaillée de tous les périphériques connectés à adb , écrivez la commande suivante dans votre terminal:

adb devices -l

Exemple de sortie

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 première colonne est le numéro de série de l'appareil. Si elle commence par emulator- , cet appareil est un émulateur.
• usb: le chemin du périphérique dans le sous-système USB.
• product: le code produit de l'appareil. Ceci est très spécifique au fabricant et, comme vous pouvez le voir dans le cas de l'appareil Archos A50PL ci-dessus, il peut être vide.
• model: le modèle d'appareil. Comme le product , peut être vide.
• device: le code de l'appareil. Ceci est également très spécifique au fabricant et peut être vide.

Lire les informations sur l'appareil

Écrivez la commande suivante dans votre terminal:

adb shell getprop

Cela imprimera toutes les informations disponibles sous la forme de paires clé / valeur.

Vous pouvez simplement lire des informations spécifiques en ajoutant le nom d'une clé spécifique à la commande. Par exemple:

adb shell getprop ro.product.model

Voici quelques informations intéressantes que vous obtenez:

• ro.product.model : Nom du modèle du périphérique (par exemple, Nexus 6P)
• ro.build.version.sdk : Niveau API du périphérique (par exemple 23)
• ro.product.brand : ro.product.brand marque de l'appareil (par ex. Samsung)

Exemple complet de sortie

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

Connecter ADB à un périphérique via WiFi

La configuration ADB standard implique une connexion USB à un périphérique physique.
Si vous préférez, vous pouvez passer en mode TCP / IP et connecter ADB via WiFi.

Appareil non enraciné

1. Obtenez sur le même réseau:

   • Assurez-vous que votre appareil et votre ordinateur sont sur le même réseau.

2. Connectez le périphérique à l'ordinateur hôte à l'aide d'un câble USB.

3. Connectez adb à un périphérique via le réseau:

   Alors que votre appareil est connecté à adb via USB, adb la commande suivante pour écouter une connexion TCP / IP sur un port (par défaut 5555):

   • Tapez adb tcpip <port> (passez en mode TCP / IP).
   • Déconnectez le câble USB du périphérique cible.
   • Tapez adb connect <ip address>:<port> (le port est facultatif; par défaut 5555).

   Par exemple:

   adb tcpip 5555
   adb connect 192.168.0.101:5555
   

   Si vous ne connaissez pas l'adresse IP de votre appareil, vous pouvez:

   • vérifiez l'adresse IP dans les paramètres WiFi de votre appareil.
   • utiliser ADB pour découvrir l'IP (via USB):
     1. Connectez l'appareil à l'ordinateur via USB
     2. Dans une ligne de commande, tapez adb shell ifconfig et copiez l'adresse IP de votre périphérique

   Pour revenir au débogage via USB, utilisez la commande suivante:

   adb usb
   

   Vous pouvez également connecter ADB via WiFi en installant un plug-in sur Android Studio. Pour ce faire, accédez à Paramètres> Plug -ins et Parcourir les référentiels, recherchez ADB WiFi , installez-le et rouvrez Android Studio. Vous verrez une nouvelle icône dans votre barre d'outils, comme indiqué dans l'image suivante. Connectez l'appareil à l'ordinateur hôte via USB et cliquez sur cette icône AndroidWiFiADB . Il affichera un message indiquant si votre appareil est connecté ou non. Une fois connecté, vous pouvez débrancher votre clé USB.

   

Appareil enraciné

Remarque: Certains appareils qui sont enracinés peuvent utiliser l'App WiFi ADB du Play Store pour activer cela de manière simple. En outre, pour certains périphériques (en particulier ceux dotés de ROM CyanogenMod), cette option est présente dans les options de développement parmi les paramètres. L'activer vous donnera l'adresse IP et le numéro de port requis pour vous connecter à adb en exécutant simplement adb connect <ip address>:<port> .

Lorsque vous avez un périphérique rooté mais que vous n'avez pas accès à un câble USB

Le processus est expliqué en détail dans la réponse suivante: http://stackoverflow.com/questions/2604727/how-can-i-connect-to-android-with-adb-over-tcp/3623727#3623727 Les commandes les plus importantes sont montrés ci-dessous.

Ouvrez un terminal dans l'appareil et tapez ce qui suit:

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

Par exemple:

setprop service.adb.tcp.port 5555

Et sur votre ordinateur:

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

Par exemple:

adb connect 192.168.1.2:5555

Pour l'éteindre:

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

Éviter le délai d'attente

Par défaut, adb après 5000 ms. Cela peut arriver dans certains cas, comme le WiFi lent ou un grand APK.

Un simple changement dans la configuration de Gradle peut faire l'affaire:

android {
    adbOptions {
        timeOutInMs 10 * 1000
    }
}

Extraire (pousser) des fichiers de (vers) l'appareil

Vous pouvez extraire (télécharger) des fichiers du périphérique en exécutant la commande suivante:

adb pull <remote> <local>

Par exemple:

adb pull /sdcard/ ~/

Vous pouvez également pousser (télécharger) des fichiers de votre ordinateur vers le périphérique:

adb push <local> <remote>

Par exemple:

adb push ~/image.jpg /sdcard/

Exemple pour récupérer une base de données depuis un périphérique

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

Redémarrer le périphérique

Vous pouvez redémarrer votre appareil en exécutant la commande suivante:

adb reboot

Effectuez cette commande pour redémarrer dans bootloader:

adb reboot bootloader

Redémarrez en mode de récupération:

adb reboot recovery

Sachez que l’appareil ne s’arrêtera pas en premier!

Activer / désactiver le Wifi

Allumer:

adb shell svc wifi enable

Éteindre:

adb shell svc wifi disable

Voir les appareils disponibles

Commander:

 adb devices

Exemple de résultat:

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

Première colonne - numéro de série de l'appareil

Deuxième colonne - état de la connexion

Documentation Android

Connecter le périphérique par IP

Entrer les commandes dans les applications dispositif terminal

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

Après cela, vous pouvez utiliser CMD et ADB pour vous connecter en utilisant la commande suivante

adb connect 192.168.0.101.5555

Et vous pouvez le désactiver et renvoyer ADB sur USB avec

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

Depuis un ordinateur, si vous avez déjà un accès USB (aucune racine requise)

Il est encore plus facile de passer à l’utilisation du Wi-Fi si vous avez déjà une connexion USB. À partir d’une ligne de commande sur l’ordinateur sur lequel le périphérique est connecté via USB, émettez les commandes

adb tcpip 5555
adb connect 192.168.0.101:5555

Remplacez 192.168.0.101 par l'adresse IP du périphérique

Démarrer / arrêter adb

Démarrer ADB:

adb kill-server

Arrêtez ADB:

adb start-server

Voir logcat

Vous pouvez exécuter logcat tant que commande adb ou directement à l'invite du shell de votre émulateur ou périphérique connecté. Pour afficher la sortie du journal à l'aide d' adb , accédez à votre répertoire platform-tools / toolkit SDK et exécutez:

$ adb logcat

Vous pouvez également créer une connexion shell à un périphérique puis exécuter:

$ adb shell
$ logcat

Une commande utile est:

adb logcat -v threadtime

Cela affiche la date, l'heure d'appel, la priorité, la balise et le PID et le TID du thread émettant le message dans un format de message long.

Filtration

Les journaux Logcat ont été appelés niveaux de journalisation:

V - Verbose, D - Debug, I - Info, W - Avertissement, E - Erreur, F - Fatal, S - Silencieux

Vous pouvez également filtrer logcat par niveau de journalisation. Par exemple, si vous souhaitez uniquement afficher le niveau de débogage:

adb logcat *:D

Logcat peut être filtré par un nom de package, bien sûr, vous pouvez le combiner avec le filtre de niveau de journalisation:

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

Vous pouvez également filtrer le journal à l'aide de grep (plus d'informations sur le filtrage des résultats de logcat ici ):

adb logcat | grep <some text>

Dans Windows, le filtre peut être utilisé avec findstr, par exemple:

adb logcat | findstr <some text>

Pour afficher un autre tampon de journal [main | events | radio], exécutez le logcat avec l'option -b :

adb logcat -b radio

Enregistrer la sortie dans le fichier:

adb logcat > logcat.txt

Enregistrez la sortie dans le fichier tout en le regardant:

adb logcat | tee logcat.txt

Nettoyage des journaux:

adb logcat -c

Commande ADB directe vers un périphérique spécifique dans un paramètre multi-périphérique

1. Ciblez un appareil par numéro de série

Utilisez l'option -s suivie d'un nom de périphérique pour sélectionner le périphérique sur lequel la commande adb doit s'exécuter. Les options -s doivent être en première ligne, avant la commande.

adb -s <device> <command>

Exemple:

adb devices

List of devices attached
emulator-5554       device
02157df2d1faeb33    device

adb -s emulator-5554 shell

Exemple # 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. Ciblez un périphérique lorsque seul un type de périphérique est connecté

Vous pouvez cibler le seul émulateur en cours d'exécution avec -e

adb -e <command>

Ou vous pouvez cibler le seul périphérique USB connecté avec -d

adb -d <command>

Prendre une capture d'écran et une vidéo (pour kitkat uniquement) à partir d'un écran de périphérique

Capture d'écran: Option 1 (pure adb)

La commande shell adb nous permet d'exécuter des commandes à l'aide du shell intégré d'un périphérique. La commande shell screencap capture le contenu actuellement visible sur un périphérique et l'enregistre dans un fichier image donné, par exemple /sdcard/screen.png :

adb shell screencap /sdcard/screen.png

Vous pouvez ensuite utiliser la commande pull pour télécharger le fichier depuis le périphérique dans le répertoire actuel de votre ordinateur:

adb pull /sdcard/screen.png

Capture d'écran: Option 2 (plus rapide)

Exécutez le one-liner suivant:

(Guimauve et plus tôt):

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

(Nougat et plus tard):

adb shell screencap -p > screen.png

L' -p redirige la sortie de la commande screencap vers stdout. L'expression Perl dans laquelle elle est dirigée nettoie certains problèmes de fin de ligne sur Marshmallow et les versions antérieures. Le flux est ensuite écrit dans un fichier nommé screen.png dans le répertoire en cours. Voir cet article et cet article pour plus d'informations.

Vidéo

cela ne fonctionne que dans KitKat et via ADB uniquement. Cela ne fonctionne pas sous Kitkat Pour commencer à enregistrer l'écran de votre appareil, exécutez la commande suivante:

adb shell screenrecord /sdcard/example.mp4 , Cette commande lance l'enregistrement de l'écran de votre appareil en utilisant les paramètres par défaut et enregistre la vidéo résultante dans un fichier dans le fichier /sdcard/example.mp4 de votre appareil.

Une fois l'enregistrement terminé, appuyez sur Ctrl + C (z sous Linux) dans la fenêtre d'invite de commandes pour arrêter l'enregistrement à l'écran. Vous pouvez ensuite trouver le fichier d'enregistrement d'écran à l'emplacement que vous avez spécifié. Notez que l'enregistrement d'écran est enregistré dans la mémoire interne de votre appareil et non sur votre ordinateur.

Les paramètres par défaut consistent à utiliser la résolution d'écran standard de votre appareil, à encoder la vidéo à un débit de 4 Mbits / s et à définir la durée maximale d'enregistrement sur l'écran à 180 secondes. Pour plus d'informations sur les options de ligne de commande que vous pouvez utiliser, exécutez la commande suivante:

adb shell screenrecord –help , Cela fonctionne sans rooter le périphérique. J'espère que cela t'aides.

Effacer les données d'application

On peut effacer les données d'utilisateur d'une application spécifique en utilisant adb :

adb shell pm clear <package>

C'est la même chose que pour parcourir les paramètres du téléphone, sélectionnez l'application et appuyez sur le bouton Effacer les données.

• pm appelle le gestionnaire de paquets sur l'appareil
• clear supprime toutes les données associées à un package

Envoi de diffusion

Il est possible d'envoyer la diffusion à BroadcastReceiver avec adb .

Dans cet exemple, nous envoyons la diffusion avec l'action com.test.app.ACTION et la chaîne extra dans le bundle 'foo'='bar' :

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

Vous pouvez mettre tout autre type pris en charge pour regrouper, pas seulement les chaînes:

--ez - booléen
--ei - entier
--el - long
--ef - float
--eu - uri
--eia - int array (séparé par ',')
--ela - tableau long (séparé par ',')
--efa - tableau flottant (séparé par ',')
--esa - tableau de chaînes (séparé par ',')

Pour envoyer l'intention à un paquet / classe spécifique, le paramètre -n ou -p peut être utilisé.
Envoi à forfait:

-p com.test.app

Envoi d'un composant spécifique ( SomeReceiver de classe en com.test.app package ):

-n com.test.app/.SomeReceiver

Exemples utiles:

• Envoi d'une diffusion "boot complete"
• Envoi d'une diffusion "heure changée" après mise à l'heure via la commande adb

Installer et exécuter une application

Pour installer un fichier APK , utilisez la commande suivante:

adb install path/to/apk/file.apk

ou si l'application existe et que nous souhaitons la réinstaller

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

Pour désinstaller une application , il faut spécifier son package

adb uninstall application.package.name

Utilisez la commande suivante pour démarrer une application avec un nom de package fourni (ou une activité spécifique dans une application):

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

Par exemple, pour démarrer Waze:

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

Sauvegarde

Vous pouvez utiliser la commande de adb backup pour sauvegarder votre appareil.

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

-f <filename> spécifie le nom de fichier par défaut: crée une sauvegarde.ab dans le répertoire en cours

-apk|noapk activer / désactiver la sauvegarde de .apks eux-mêmes par défaut: -noapk

-obb|noobb activer / désactiver la sauvegarde des fichiers supplémentaires par défaut: -noobb

-shared|noshared partagé / contenu de la carte SD du périphérique de sauvegarde -shared|noshared par défaut: -noshared

-all sauvegarde tous les apllications installés

-system|nosystem inclut les applications système par défaut: -system

<packages> une liste de paquets à sauvegarder (ex: com.example.android.myapp) (non nécessaire si -all est spécifié)

Pour une sauvegarde complète du périphérique, y compris tout, utilisez

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

Remarque: La sauvegarde complète peut prendre beaucoup de temps.

Pour restaurer une sauvegarde, utilisez

adb restore backup.ab

Installer ADB sur un système Linux

Comment installer Android Debugging Bridge (ADB) sur un système Linux avec le terminal utilisant les référentiels de votre distribution.

Installer sur le système Ubuntu / Debian via apt:

sudo apt-get update
sudo apt-get install adb

Installer sur le système Fedora / CentOS via yum:

sudo yum check-update
sudo yum install android-tools

Installer sur le système Gentoo avec portage:

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

Installer sur le système openSUSE avec zypper:

sudo zypper refresh
sudo zypper install android-tools 

Installer sur le système Arch avec pacman:

sudo pacman -Syyu
sudo pacman -S android-tools

Énumérer toutes les autorisations qui nécessitent une subvention d'exécution des utilisateurs sur Android 6.0

adb shell pm list permissions -g -d 

Afficher les données internes d'une application (données / données / ) sur un appareil

Tout d'abord, assurez-vous que votre application peut être sauvegardée dans AndroidManifest.xml , à savoir android:allowBackup n'est pas false .

Commande de sauvegarde:

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

Créez un tar avec la commande dd:

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

Extraire le goudron:

tar -xvf backup.tar

Vous pouvez ensuite afficher le contenu extrait.

Afficher la pile d'activités

adb -s <serialNumber> shell dumpsys activity activities

Très utile lorsqu'il est utilisé avec la commande watch unix:

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

Afficher et extraire les fichiers de cache d'une application

Vous pouvez utiliser cette commande pour répertorier les fichiers de votre propre apk déboguable:

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

Et ce script pour tirer du cache, cela copie le contenu à sdcard d'abord, le tire puis le supprime à la fin:

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

Ensuite, vous pouvez extraire un fichier du cache comme ceci:

./pull.sh cache/someCachedData.txt

Obtenir le fichier de base de données via ADB

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