Android
ADB (Android Debug Bridge)

Wprowadzenie

Uwagi

Wydrukuj pełną listę podłączonych urządzeń

Aby uzyskać pełną listę wszystkich urządzeń podłączonych do adb , napisz następujące polecenie w swoim terminalu:

adb devices -l

Przykładowy wynik

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

• Pierwsza kolumna to numer seryjny urządzenia. Jeśli zaczyna się od emulator- , to urządzenie jest emulatorem.
• usb: ścieżka urządzenia w podsystemie USB.
• product: kod produktu urządzenia. Jest to bardzo specyficzne dla producenta i jak widać w przypadku urządzenia Archos A50PL powyżej, może być puste.
• model: model urządzenia. Podobnie jak product , może być pusty.
• device: kod urządzenia. Jest to również bardzo specyficzne dla producenta i może być puste.

Przeczytaj informacje o urządzeniu

Napisz następujące polecenie w swoim terminalu:

adb shell getprop

Spowoduje to wydrukowanie wszystkich dostępnych informacji w postaci par klucz / wartość.

Możesz po prostu odczytać określone informacje, dodając nazwę określonego klucza do polecenia. Na przykład:

adb shell getprop ro.product.model

Oto kilka interesujących informacji, które otrzymujesz:

• ro.product.model : nazwa modelu urządzenia (np. Nexus 6P)
• ro.build.version.sdk : Poziom API urządzenia (np. 23)
• ro.product.brand : Branding urządzenia (np. Samsung)

Pełny przykładowy wynik

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

Podłącz ADB do urządzenia przez Wi-Fi

Standardowa konfiguracja ADB obejmuje połączenie USB z urządzeniem fizycznym.
Jeśli wolisz, możesz przełączyć na tryb TCP / IP i zamiast tego podłączyć ADB przez WiFi.

Nie zrootowane urządzenie

1. Wejdź do tej samej sieci:

   • Upewnij się, że urządzenie i komputer są w tej samej sieci.

2. Podłącz urządzenie do komputera hosta za pomocą kabla USB.

3. Podłącz adb do urządzenia przez sieć:

   Gdy urządzenie jest podłączone do adb przez USB, wykonaj następujące polecenie, aby nasłuchiwać połączenia TCP / IP na porcie (domyślnie 5555):

   • Wpisz adb tcpip <port> (przełącz na tryb TCP / IP).
   • Odłącz kabel USB od urządzenia docelowego.
   • Wpisz adb connect <ip address>:<port> (port jest opcjonalny; domyślnie 5555).

   Na przykład:

   adb tcpip 5555
   adb connect 192.168.0.101:5555
   

   Jeśli nie znasz adresu IP swojego urządzenia, możesz:

   • sprawdź adres IP w ustawieniach WiFi urządzenia.
   • użyj ADB do wykrycia adresu IP (przez USB):
     1. Podłącz urządzenie do komputera przez USB
     2. W wierszu polecenia wpisz adb shell ifconfig i skopiuj adres IP urządzenia

   Aby przywrócić debugowanie przez USB, użyj następującego polecenia:

   adb usb
   

   Możesz także podłączyć ADB przez Wi-Fi, instalując wtyczkę do Android Studio. W tym celu wybierz Ustawienia> Wtyczki i przeglądaj repozytoria, wyszukaj ADB WiFi , zainstaluj je i ponownie otwórz Android Studio. Zobaczysz nową ikonę na pasku narzędzi, jak pokazano na poniższym obrazku. Podłącz urządzenie do komputera hosta przez USB i kliknij ikonę AndroidWiFiADB . Wyświetli się komunikat, czy urządzenie jest podłączone, czy nie. Po podłączeniu możesz odłączyć USB.

   

---

Zrootowane urządzenie

Uwaga: niektóre urządzenia zrootowane mogą korzystać z aplikacji ADB WiFi ze Sklepu Play, aby włączyć to w prosty sposób. Ponadto w przypadku niektórych urządzeń (szczególnie tych z ROMami CyanogenMod) ta opcja jest dostępna w Opcjach programisty wśród Ustawień. Włączenie go da ci adres IP i numer portu wymagany do połączenia z adb po prostu wykonując adb connect <ip address>:<port> .

Gdy masz zrootowane urządzenie, ale nie masz dostępu do kabla USB

Proces jest szczegółowo wyjaśniony w następującej odpowiedzi: http://stackoverflow.com/questions/2604727/how-can-i-connect-to-android-with-adb-over-tcp/3623727#3623727 Najważniejsze polecenia pokazano poniżej.

Otwórz terminal w urządzeniu i wpisz następujące polecenie:

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

Na przykład:

setprop service.adb.tcp.port 5555

I na twoim komputerze:

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

Na przykład:

adb connect 192.168.1.2:5555

Aby to wyłączyć:

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

Unikaj przekroczenia limitu czasu

Domyślnie adb wygaśnie po 5000 ms. Może się to zdarzyć w niektórych przypadkach, takich jak wolne WiFi lub duży pakiet APK.

Prosta zmiana w konfiguracji Gradle może załatwić sprawę:

android {
    adbOptions {
        timeOutInMs 10 * 1000
    }
}

Wyciągaj (wypychaj) pliki z (do) urządzenia

Możesz pobierać (pobierać) pliki z urządzenia, wykonując następujące polecenie:

adb pull <remote> <local>

Na przykład:

adb pull /sdcard/ ~/

---

Możesz także wypychać (przesyłać) pliki ze swojego komputera na urządzenie:

adb push <local> <remote>

Na przykład:

adb push ~/image.jpg /sdcard/

Przykład pobierania bazy danych z urządzenia

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

Uruchom ponownie urządzenie

Możesz ponownie uruchomić urządzenie, wykonując następujące polecenie:

adb reboot

Wykonaj tę komendę, aby zrestartować się do bootloadera:

adb reboot bootloader

Uruchom ponownie w trybie odzyskiwania:

adb reboot recovery

Pamiętaj, że urządzenie nie wyłączy się najpierw!

Włącz / wyłącz Wi-Fi

Włączyć:

adb shell svc wifi enable

Wyłączyć:

adb shell svc wifi disable

Wyświetl dostępne urządzenia

Komenda:

 adb devices

Przykład wyniku:

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

Pierwsza kolumna - numer seryjny urządzenia

Druga kolumna - status połączenia

Dokumentacja Androida

Podłącz urządzenie przez IP

Wprowadź te polecenia w terminalu urządzenia z Androidem

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

Następnie możesz użyć CMD i ADB do połączenia za pomocą następującego polecenia

adb connect 192.168.0.101.5555

Możesz go wyłączyć i przywrócić ADB do słuchania na USB za pomocą

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

Z komputera, jeśli masz już dostęp USB (nie wymaga rootowania)

Jeszcze łatwiej jest przejść na Wi-Fi, jeśli masz już USB. Z wiersza poleceń na komputerze, do którego podłączone jest urządzenie przez USB, wydaj polecenia

adb tcpip 5555
adb connect 192.168.0.101:5555

Zastąp 192.168.0.101 adresem IP urządzenia

Uruchom / zatrzymaj adb

Uruchom ADB:

adb kill-server

Zatrzymaj ADB:

adb start-server

Wyświetl logcat

Możesz uruchomić logcat jako polecenie adb lub bezpośrednio w wierszu poleceń emulatora lub podłączonego urządzenia. Aby wyświetlić dane wyjściowe dziennika za pomocą adb , przejdź do katalogu SDK platforma-tools / i wykonaj:

$ adb logcat

Alternatywnie możesz utworzyć połączenie powłoki z urządzeniem, a następnie wykonać:

$ adb shell
$ logcat

---

Jednym z przydatnych poleceń jest:

adb logcat -v threadtime

Wyświetla datę, czas wywołania, priorytet, znacznik oraz PID i TID wątku wysyłającego wiadomość w formacie długiej wiadomości.

---

Filtracja

Dzienniki Logcat mają tak zwane poziomy dziennika:

V - pełne, D - debugowanie, I - informacje, W - ostrzeżenie, E - błąd, F - fatalny, S - cichy

Możesz filtrować logcat według poziomu logu. Na przykład, jeśli chcesz tylko wyświetlać poziom debugowania:

adb logcat *:D

Logcat można filtrować według nazwy pakietu, oczywiście można go połączyć z filtrem poziomu dziennika:

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

Możesz także filtrować dziennik za pomocą grep (więcej o filtrowaniu danych wyjściowych logcat tutaj ):

adb logcat | grep <some text>

W systemie Windows można użyć filtru za pomocą findstr, na przykład:

adb logcat | findstr <some text>

Aby wyświetlić alternatywny bufor dziennika [main | events | radio], uruchom logcat z opcją -b :

adb logcat -b radio

Zapisz dane wyjściowe w pliku:

adb logcat > logcat.txt

Zapisz dane wyjściowe w pliku podczas oglądania:

adb logcat | tee logcat.txt

Czyszczenie dzienników:

adb logcat -c

Skieruj polecenie ADB do określonego urządzenia w ustawieniach wielu urządzeń

1. Wybierz urządzenie według numeru seryjnego

Użyj opcji -s , a następnie nazwy urządzenia, aby wybrać urządzenie, na którym ma zostać uruchomione polecenie adb . Opcje -s powinny być pierwsze w linii, przed poleceniem.

adb -s <device> <command>

Przykład:

adb devices

List of devices attached
emulator-5554       device
02157df2d1faeb33    device

adb -s emulator-5554 shell

Przykład 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. Wybierz urządzenie, gdy podłączony jest tylko jeden typ urządzenia

Do jedynego działającego emulatora można kierować za pomocą -e

adb -e <command>

Lub możesz kierować reklamy na jedyne podłączone urządzenie USB za pomocą -d

adb -d <command>

Robienie zrzutu ekranu i wideo (tylko KitKat) z wyświetlacza urządzenia

Zrzut ekranu: Opcja 1 (czysty adb)

Polecenie shell adb pozwala nam wykonywać polecenia przy użyciu wbudowanej powłoki urządzenia. Polecenie powłoki screencap przechwytuje zawartość aktualnie widoczną na urządzeniu i zapisuje ją w danym pliku obrazu, np. /sdcard/screen.png :

adb shell screencap /sdcard/screen.png

Następnie możesz użyć polecenia pull, aby pobrać plik z urządzenia do bieżącego katalogu na komputerze:

adb pull /sdcard/screen.png

Zrzut ekranu: Opcja 2 (szybciej)

Wykonaj następującą linijkę:

(Marshmallow i wcześniejsze):

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

(Nugat i później):

adb shell screencap -p > screen.png

Flaga -p przekierowuje wyjście polecenia screencap na standardowe wyjście. Wyrażenie Perla, w którym jest przesyłane, usuwa niektóre problemy z końcem linii w Marshmallow i wcześniejszych. Strumień jest następnie zapisywany w pliku o nazwie screen.png w bieżącym katalogu. Zobacz ten artykuł i ten artykuł, aby uzyskać więcej informacji.

Wideo

działa to tylko w KitKat i tylko przez ADB. To nie działa poniżej Kitkat Aby rozpocząć nagrywanie ekranu urządzenia, uruchom następujące polecenie:

adb shell screenrecord /sdcard/example.mp4 , To polecenie rozpocznie nagrywanie ekranu urządzenia przy użyciu ustawień domyślnych i zapisze wynikowe wideo w pliku w pliku /sdcard/example.mp4 na twoim urządzeniu.

Po zakończeniu nagrywania naciśnij Ctrl + C (z w Linuksie) w oknie wiersza polecenia, aby zatrzymać nagrywanie ekranu. Następnie możesz znaleźć plik nagrania ekranu we wskazanej lokalizacji. Pamiętaj, że nagranie ekranu jest zapisywane w pamięci wewnętrznej urządzenia, a nie na komputerze.

Domyślne ustawienia to używanie standardowej rozdzielczości ekranu urządzenia, kodowanie wideo z szybkością 4 Mb / s oraz maksymalny czas nagrywania ekranu na 180 sekund. Aby uzyskać więcej informacji o opcjach wiersza polecenia, których możesz użyć, uruchom następujące polecenie:

adb shell screenrecord –help , Działa to bez rootowania urządzenia. Mam nadzieję że to pomoże.

Wyczyść dane aplikacji

Można wyczyścić dane użytkownika konkretnej aplikacji za pomocą adb :

adb shell pm clear <package>

To samo dotyczy przeglądania ustawień w telefonie, wybierania aplikacji i naciskania przycisku usuwania danych.

• pm wywołuje menedżera pakietów na urządzeniu
• clear usuwa wszystkie dane związane z pakietem

Wysyłanie transmisji

Możliwe jest wysłanie transmisji do BroadcastReceiver z adb .

W tym przykładzie wysyłamy transmisję z akcją com.test.app.ACTION i dodatkowym łańcuchem w pakiecie 'foo'='bar' :

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

Możesz umieścić dowolny inny obsługiwany typ w pakiecie, nie tylko łańcuchy:

--ez - boolean
--ei - liczba całkowita
--el - długi
--ef - float
--eu - uri
--eia - int tablica (oddzielona znakiem „,”)
--ela - długa tablica (oddzielona znakiem „,”)
--efa - tablica zmiennoprzecinkowa (oddzielona przez „,”)
--esa - tablica ciągów (oddzielona znakiem „,”)

Aby wysłać zamiar do konkretnego pakietu / klasy, można użyć parametru -n lub -p .
Wysyłanie do paczki:

-p com.test.app

Wysyłanie do konkretnego składnika ( SomeReceiver klasy w com.test.app package ):

-n com.test.app/.SomeReceiver

Przydatne przykłady:

• Wysyłanie transmisji „rozruchu zakończonego”
• Wysyłanie transmisji „z czasem zmienionym” po ustawieniu czasu za pomocą polecenia adb

Zainstaluj i uruchom aplikację

Aby zainstalować plik APK , użyj następującego polecenia:

adb install path/to/apk/file.apk

lub jeśli aplikacja istnieje i chcemy ją ponownie zainstalować

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

Aby odinstalować aplikację , musimy określić jej pakiet

adb uninstall application.package.name

Użyj następującego polecenia, aby uruchomić aplikację z podaną nazwą pakietu (lub określoną czynnością w aplikacji):

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

Na przykład, aby uruchomić Waze:

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

Utworzyć kopię zapasową

Aby wykonać adb backup zapasową urządzenia, możesz użyć polecenia adb backup .

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

-f <filename> określ nazwę domyślną: tworzy kopię zapasową.ab w bieżącym katalogu

-apk|noapk włącza / wyłącza tworzenie kopii zapasowych .apks się domyślnie: -noapk

-obb|noobb włącza / wyłącza tworzenie kopii zapasowych dodatkowych plików domyślnie: -noobb

-shared|noshared współdzielona pamięć / zawartość karty SD domyślnie: -noshared

-all kopie zapasowe wszystkich zainstalowanych aplikacji

-system|nosystem zawiera domyślne aplikacje systemowe : -system

<packages> lista pakietów, których kopie zapasowe należy wykonać (np. com.example.android.myapp) (niepotrzebne, jeśli podano -all )

---

Aby uzyskać pełną kopię zapasową urządzenia, w tym wszystko, użyj

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

Uwaga: wykonanie pełnej kopii zapasowej może zająć dużo czasu.

---

Aby przywrócić kopię zapasową, użyj

adb restore backup.ab

Zainstaluj ADB w systemie Linux

Jak zainstalować most debugujący Androida (ADB) w systemie Linux z terminalem za pomocą repozytoriów twojej dystrybucji.

Zainstaluj w systemie Ubuntu / Debian przez apt:

sudo apt-get update
sudo apt-get install adb

Zainstaluj w systemie Fedora / CentOS przez yum:

sudo yum check-update
sudo yum install android-tools

Zainstaluj w systemie Gentoo z portage:

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

Zainstaluj w systemie openSUSE z programem zypper:

sudo zypper refresh
sudo zypper install android-tools 

Zainstaluj w systemie Arch za pomocą Pacmana:

sudo pacman -Syyu
sudo pacman -S android-tools

Wyświetl wszystkie uprawnienia, które wymagają przyznania środowiska wykonawczego od użytkowników w systemie Android 6.0

adb shell pm list permissions -g -d 

Wyświetl wewnętrzne dane aplikacji (data / data / ) na urządzeniu

Po pierwsze, upewnij się, że twoja aplikacja może zostać utworzona kopia zapasowa w AndroidManifest.xml , tj. android:allowBackup nie jest false .

Polecenie kopii zapasowej:

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

Utwórz tar za pomocą polecenia dd:

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

Wyodrębnij smołę:

tar -xvf backup.tar

Następnie możesz wyświetlić wyodrębnioną treść.

Zobacz stos aktywności

adb -s <serialNumber> shell dumpsys activity activities

Bardzo przydatny w połączeniu z poleceniem watch unix:

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

Przeglądaj i pobieraj pliki pamięci podręcznej aplikacji

Możesz użyć tego polecenia, aby wyświetlić listę plików dla własnej debkowanej aplikacji:

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

A ten skrypt do pobierania z pamięci podręcznej, najpierw skopiuj zawartość do sdcard, wyciągnij, a następnie usuń na końcu:

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

Następnie możesz pobrać plik z pamięci podręcznej w następujący sposób:

./pull.sh cache/someCachedData.txt

Pobierz plik bazy danych przez ADB

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