Android
ADB (Android Debug Bridge)

Einführung

Bemerkungen

Ausführliche Liste der verbundenen Geräte drucken

Um eine ausführliche Liste aller an adb angeschlossenen Geräte zu erhalten, schreiben Sie den folgenden Befehl in Ihr Terminal:

adb devices -l

Beispielausgabe

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

• Die erste Spalte enthält die Seriennummer des Geräts. Wenn es mit dem emulator- beginnt, ist dieses Gerät ein Emulator.
• usb: der Pfad des Geräts im USB-Subsystem.
• product: Der Produktcode des Geräts. Dies ist sehr herstellerspezifisch. Wie Sie im Fall des Archos-Geräts A50PL oben sehen können, kann es leer sein.
• model: das Gerätemodell. Kann wie das product leer sein.
• device: der Gerätecode. Dies ist auch sehr herstellerspezifisch und kann leer sein.

Geräteinformationen lesen

Schreiben Sie den folgenden Befehl in Ihr Terminal:

adb shell getprop

Dadurch werden alle verfügbaren Informationen in Form von Schlüssel / Wert-Paaren gedruckt.

Sie können nur bestimmte Informationen lesen, indem Sie den Namen einer bestimmten Taste an den Befehl anhängen. Zum Beispiel:

adb shell getprop ro.product.model

Hier sind ein paar interessante Informationen, die Sie bekommen:

• ro.product.model : Modellname des Geräts (zB Nexus 6P)
• ro.build.version.sdk : API-Ebene des Geräts (zB 23)
• ro.product.brand : Branding des Geräts (zB Samsung)

Volle Beispielausgabe

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

Verbinden Sie ADB über WLAN mit einem Gerät

Die Standard-ADB-Konfiguration beinhaltet eine USB-Verbindung zu einem physischen Gerät.
Wenn Sie möchten, können Sie in den TCP / IP-Modus wechseln und ADB stattdessen über WLAN verbinden.

Nicht gerootetes Gerät

1. Holen Sie sich im selben Netzwerk:

   • Stellen Sie sicher, dass sich Ihr Gerät und Ihr Computer im selben Netzwerk befinden.

2. Schließen Sie das Gerät mit einem USB-Kabel an den Host-Computer an.

3. Verbinden Sie adb mit dem Gerät über das Netzwerk:

   Wenn Ihr Gerät über USB mit adb verbunden ist, führen Sie den folgenden Befehl aus, um eine TCP / IP-Verbindung an einem Port zu überwachen (Standardeinstellung 5555):

   • adb tcpip <port> (wechseln Sie in den TCP / IP-Modus).
   • Trennen Sie das USB-Kabel vom Zielgerät.
   • adb connect <ip address>:<port> (Port ist optional; Standardeinstellung 5555).

   Zum Beispiel:

   adb tcpip 5555
   adb connect 192.168.0.101:5555
   

   Wenn Sie die IP-Adresse Ihres Geräts nicht kennen, können Sie:

   • Überprüfen Sie die IP-Adresse in den WLAN-Einstellungen Ihres Geräts.
   • Verwenden Sie ADB zum Ermitteln von IP (über USB):
     1. Verbinden Sie das Gerät über USB mit dem Computer
     2. adb shell ifconfig in einer Befehlszeile adb shell ifconfig und kopieren Sie die IP-Adresse Ihres Geräts

   Um wieder zum Debuggen über USB zurückzukehren, verwenden Sie den folgenden Befehl:

   adb usb
   

   Sie können ADB auch über WLAN verbinden, indem Sie ein Plugin für Android Studio installieren. Wechseln Sie dazu zu Einstellungen> Plugins und durchsuchen Sie Repositorys, suchen Sie nach ADB WiFi , installieren Sie es und öffnen Sie Android Studio erneut. In der Symbolleiste wird ein neues Symbol angezeigt, wie in der folgenden Abbildung dargestellt. Verbinden Sie das Gerät über USB mit dem Host-Computer und klicken Sie auf dieses AndroidWiFiADB- Symbol. Es wird eine Meldung angezeigt, ob Ihr Gerät angeschlossen ist oder nicht. Sobald die Verbindung hergestellt ist, können Sie den USB-Stecker entfernen.

   

---

Gerootetes Gerät

Hinweis: Einige Geräte , die verwurzelt sind , kann die ADB WiFi App aus dem Play Store verwenden , dies auf einfache Art und Weise zu ermöglichen. Für bestimmte Geräte (insbesondere solche mit CyanogenMod-ROMs) ist diese Option auch in den Entwickleroptionen unter den Einstellungen vorhanden. Wenn Sie diese adb adb connect <ip address>:<port> , erhalten Sie die IP-Adresse und die Portnummer, die für die Verbindung zu adb erforderlich sind, indem Sie einfach adb connect <ip address>:<port> ausführen.

Wenn Sie über ein gerootetes Gerät verfügen, aber keinen Zugriff auf ein USB-Kabel haben

Der Vorgang wird in der folgenden Antwort ausführlich erläutert: http://stackoverflow.com/questions/2604727/how-can-i-connect-to-android-with-adb-over-tcp/3623727#3623727 sind unten gezeigt.

Öffnen Sie ein Terminal im Gerät und geben Sie Folgendes ein:

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

Zum Beispiel:

setprop service.adb.tcp.port 5555

Und auf deinem Computer:

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

Zum Beispiel:

adb connect 192.168.1.2:5555

Um es auszuschalten:

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

Timeout vermeiden

Standardmäßig tritt adb nach 5000 ms auf. Dies kann in einigen Fällen wie langsames WLAN oder große APK vorkommen.

Eine einfache Änderung in der Gradle-Konfiguration kann den Trick ausführen:

android {
    adbOptions {
        timeOutInMs 10 * 1000
    }
}

Ziehen Sie Dateien von (zum) Gerät

Sie können Dateien vom Gerät abrufen (herunterladen), indem Sie den folgenden Befehl ausführen:

adb pull <remote> <local>

Zum Beispiel:

adb pull /sdcard/ ~/

---

Sie können auch Dateien von Ihrem Computer auf das Gerät übertragen (hochladen):

adb push <local> <remote>

Zum Beispiel:

adb push ~/image.jpg /sdcard/

Beispiel zum Abrufen der Datenbank vom Gerät

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

Gerät neustarten

Sie können Ihr Gerät neu starten, indem Sie den folgenden Befehl ausführen:

adb reboot

Führen Sie diesen Befehl aus, um den Bootloader neu zu starten:

adb reboot bootloader

Neustart im Wiederherstellungsmodus:

adb reboot recovery

Beachten Sie, dass das Gerät nicht zuerst heruntergefahren wird!

Schalten Sie Wifi ein / aus

Anschalten:

adb shell svc wifi enable

Abschalten:

adb shell svc wifi disable

Verfügbare Geräte anzeigen

Befehl:

 adb devices

Ergebnisbeispiel:

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

Erste Spalte - Geräteseriennummer

Zweite Spalte - Verbindungsstatus

Android-Dokumentation

Gerät per IP verbinden

Geben Sie diese Befehle in Android - Gerät - Terminal

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

Danach können Sie CMD und ADB verwenden , um die Verbindung mit dem folgenden Befehl herzustellen

adb connect 192.168.0.101.5555

Sie können es deaktivieren und mit ADB wieder auf USB hören

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

Von einem Computer aus, wenn Sie bereits über einen USB-Zugriff verfügen (kein Root erforderlich)

Wenn Sie bereits über USB verfügen, ist es noch einfacher, auf WLAN zu wechseln. Geben Sie die Befehle über eine Befehlszeile auf dem Computer aus, an den das Gerät über USB angeschlossen ist

adb tcpip 5555
adb connect 192.168.0.101:5555

Ersetzen Sie 192.168.0.101 durch die Geräte-IP

Adb starten / stoppen

ADB starten:

adb kill-server

Stop ADB:

adb start-server

Logcat anzeigen

Sie können logcat als logcat Befehl oder direkt in einer Shell-Eingabeaufforderung Ihres Emulators oder eines verbundenen Geräts logcat . Um die Protokollausgabe mit adb anzuzeigen, navigieren Sie zu Ihrem SDK platform-tools / -Verzeichnis und führen Sie Folgendes aus

$ adb logcat

Alternativ können Sie eine Shell-Verbindung zu einem Gerät erstellen und dann Folgendes ausführen:

$ adb shell
$ logcat

---

Ein nützlicher Befehl ist:

adb logcat -v threadtime

Daraufhin werden Datum, Aufrufzeit, Priorität, Tag sowie PID und TID des ausstellenden Threads in einem langen Nachrichtenformat angezeigt.

---

Filterung

Logcat-Protokolle erhielten so genannte Protokollierungsstufen:

V - Verbose, D - Debug, I - Info, W - Warnung, E - Fehler, F - Fatal, S - Stumm

Sie können Logcat auch nach Log-Level filtern. Zum Beispiel, wenn Sie nur den Debug-Level ausgeben möchten:

adb logcat *:D

Logcat kann nach einem Paketnamen gefiltert werden, natürlich können Sie es mit dem Log-Level-Filter kombinieren:

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

Sie können das Protokoll auch mit grep filtern (mehr zum Filtern der Logcat-Ausgabe hier ):

adb logcat | grep <some text>

In Windows kann der Filter beispielsweise mit findstr verwendet werden:

adb logcat | findstr <some text>

Um den alternativen Protokollpuffer [main | events | radio] logcat , führen Sie logcat mit der Option -b :

adb logcat -b radio

Ausgabe in Datei speichern:

adb logcat > logcat.txt

Speichern Sie die Ausgabe in einer Datei und beobachten Sie sie gleichzeitig:

adb logcat | tee logcat.txt

Reinigung der Protokolle:

adb logcat -c

Direkter ADB-Befehl an ein bestimmtes Gerät in einer Einstellung für mehrere Geräte

1. Richten Sie ein Gerät anhand der Seriennummer aus

Verwenden Sie die Option -s gefolgt von einem Gerätenamen, um auszuwählen, auf welchem ​​Gerät der Befehl adb ausgeführt werden soll. Die -s Optionen sollten vor dem Befehl an erster Stelle stehen.

adb -s <device> <command>

Beispiel:

adb devices

List of devices attached
emulator-5554       device
02157df2d1faeb33    device

adb -s emulator-5554 shell

Beispiel # 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. Zielen Sie auf ein Gerät, wenn nur ein Gerätetyp angeschlossen ist

Sie können den einzigen laufenden Emulator mit -e anvisieren

adb -e <command>

Oder Sie können das einzige angeschlossene USB-Gerät mit -d anvisieren

adb -d <command>

Screenshot und Video (nur für Kitkat) von einer Geräteanzeige machen

Screenshot: Option 1 (reine Adb)

Mit dem shell Befehl adb können Sie Befehle unter Verwendung der integrierten Shell eines Geräts ausführen. Mit dem Befehl screencap shell wird der aktuell auf einem Gerät sichtbare Inhalt erfasst und in einer bestimmten Bilddatei gespeichert, z. B. /sdcard/screen.png :

adb shell screencap /sdcard/screen.png

Sie können dann den Pull-Befehl verwenden , um die Datei vom Gerät in das aktuelle Verzeichnis auf Ihrem Computer herunterzuladen:

adb pull /sdcard/screen.png

Screenshot: Option 2 (schneller)

Führen Sie den folgenden Einzeiler aus:

(Marshmallow und früher):

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

(Nougat und später):

adb shell screencap -p > screen.png

Die -p - Flag leitet den Ausgang des screencap Befehl stdout. Der Perl-Ausdruck, in den dieser Pipe geleitet wird, bereinigt einige End-of-Line-Probleme in Marshmallow und früheren Versionen. Der Stream wird dann in eine Datei mit dem Namen screen.png im aktuellen Verzeichnis geschrieben. Weitere Informationen finden Sie in diesem Artikel und in diesem Artikel .

Video

Dies funktioniert nur in KitKat und nur über ADB. Dies funktioniert nicht unter Kitkat Führen Sie den folgenden Befehl aus, um mit der Aufnahme des Bildschirms Ihres Geräts zu beginnen:

adb shell screenrecord /sdcard/example.mp4 , Mit diesem Befehl wird der Bildschirm Ihres Geräts mit den Standardeinstellungen /sdcard/example.mp4 und das resultierende Video in einer Datei unter /sdcard/example.mp4 auf Ihrem Gerät gespeichert.

Wenn Sie mit der Aufnahme fertig sind, drücken Sie im Eingabeaufforderungsfenster Strg + C (z in Linux), um die Bildschirmaufnahme zu stoppen. Sie können die Bildschirmaufzeichnungsdatei dann an dem von Ihnen angegebenen Ort finden. Beachten Sie, dass die Bildschirmaufnahme im internen Speicher Ihres Geräts gespeichert wird, nicht auf Ihrem Computer.

In der Standardeinstellung verwenden Sie die Standard-Bildschirmauflösung Ihres Geräts, kodieren Sie das Video mit einer Bitrate von 4 MBit / s und stellen Sie die maximale Bildschirmaufnahmezeit auf 180 Sekunden ein. Führen Sie den folgenden Befehl aus, um weitere Informationen zu den Befehlszeilenoptionen zu erhalten:

adb shell screenrecord –help , Dies funktioniert ohne das Gerät zu adb shell screenrecord –help . Hoffe das hilft.

Anwendungsdaten löschen

Mit adb können Sie die Benutzerdaten einer bestimmten App adb :

adb shell pm clear <package>

Dies ist das gleiche wie beim Durchsuchen der Einstellungen auf dem Telefon. Wählen Sie die App aus und drücken Sie die Taste zum Löschen der Daten.

• pm ruft den Paketmanager auf dem Gerät auf
• clear löscht alle Daten, die einem Paket zugeordnet sind

Sendung senden

Es ist möglich, BroadcastReceiver mit adb an BroadcastReceiver zu senden.

In diesem Beispiel senden wir Broadcast mit der Aktion com.test.app.ACTION und der Zeichenfolge extra im Bundle 'foo'='bar' :

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

Sie können jeden anderen unterstützten Typ zum Bündeln verwenden, nicht nur Strings:

--ez - boolean
--ei - ganze Zahl
--el - lang
--ef - Schwimmer
--eu - uri
--eia - int array (getrennt durch ',')
--ela - long array (getrennt durch ',')
--efa - float array (getrennt durch ',')
--esa - String-Array (getrennt durch ',')

Um Intents an bestimmte Pakete / Klassen zu senden, kann der Parameter -n oder -p verwendet werden.
Versand ins Paket:

-p com.test.app

Senden an eine bestimmte Komponente ( SomeReceiver Klasse im com.test.app package ):

-n com.test.app/.SomeReceiver

Nützliche Beispiele:

• Senden einer "Boot Complete" -Sendung
• Senden einer "Zeit geändert" -Sendung nach dem Einstellen der Zeit mit dem Befehl adb

Installieren Sie eine Anwendung und führen Sie sie aus

Verwenden Sie den folgenden Befehl, um eine APK-Datei zu installieren :

adb install path/to/apk/file.apk

oder wenn die App vorhanden ist und wir neu installieren möchten

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

Um eine Anwendung zu deinstallieren , müssen wir ihr Paket angeben

adb uninstall application.package.name

Verwenden Sie den folgenden Befehl, um eine App mit einem angegebenen Paketnamen (oder einer bestimmten Aktivität in einer App) zu starten:

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

Zum Beispiel, um Waze zu starten:

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

Backup

Sie können den Befehl adb backup um Ihr Gerät zu sichern.

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

-f <filename> Angabe Dateiname Standard: erstellt backup.ab im aktuellen Verzeichnis

-apk|noapk Aktiviert / deaktiviert die Sicherung von .apks. Standardwert: -noapk

-obb|noobb Aktivieren / Deaktivieren der Sicherung zusätzlicher Dateien Standardwert: -noobb

-shared|noshared des gemeinsam genutzten Speicher- / SD-Karteninhalts des -shared|noshared Backup-Geräts : -noshared

-all Sicherung aller installierten Anwendungen

-system|nosystem include Systemanwendungen Standard: -system

<packages> eine Liste der zu sichernden Pakete (z. B. com.example.android.myapp) (nicht erforderlich, wenn -all angegeben ist)

---

Verwenden Sie für eine vollständige Gerätesicherung, einschließlich alles

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

Hinweis: Das Durchführen einer vollständigen Sicherung kann lange dauern.

---

Um eine Sicherung wiederherzustellen, verwenden Sie

adb restore backup.ab

Installieren Sie ADB auf einem Linux-System

So installieren Sie die Android Debugging Bridge (ADB) auf einem Linux-System, wobei das Terminal die Repositorys Ihrer Distribution verwendet.

Installation auf Ubuntu / Debian-System über apt:

sudo apt-get update
sudo apt-get install adb

Installation auf Fedora / CentOS-System über yum:

sudo yum check-update
sudo yum install android-tools

Installation auf dem Gentoo-System mit portage:

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

Installieren Sie das OpenSUSE-System mit Zypper:

sudo zypper refresh
sudo zypper install android-tools 

Installation in Arch-System mit Pacman:

sudo pacman -Syyu
sudo pacman -S android-tools

Listen Sie alle Berechtigungen auf, für die Benutzer unter Android 6.0 eine Laufzeitgewährung benötigen

adb shell pm list permissions -g -d 

Anzeigen der internen Daten einer App (Daten / Daten / ) auf einem Gerät

AndroidManifest.xml sicher, dass Ihre App in AndroidManifest.xml gesichert werden AndroidManifest.xml , dh android:allowBackup ist nicht false .

Sicherungsbefehl:

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

Erstellen Sie einen tar mit dem Befehl dd:

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

Extrahieren Sie den Teer:

tar -xvf backup.tar

Sie können dann den extrahierten Inhalt anzeigen.

Aktivitätsstapel anzeigen

adb -s <serialNumber> shell dumpsys activity activities

Sehr nützlich in Verbindung mit dem Befehl watch unix:

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

Anzeigen und Abrufen von Cache-Dateien einer App

Sie können diesen Befehl verwenden, um die Dateien für Ihre eigene debuggable apk aufzulisten:

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

Und dieses Skript zum Abrufen aus dem Cache-Speicher, kopieren Sie den Inhalt zuerst auf die SD-Karte, ziehen Sie ihn ab und entfernen Sie ihn am Ende:

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

Dann können Sie eine Datei wie folgt aus dem Cache ziehen:

./pull.sh cache/someCachedData.txt

Datenbankdatei über ADB abrufen

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