Od 27 marca 2025 r. zalecamy używanie android-latest-release zamiast aosp-main do kompilowania i wspołtworzenia AOSP. Więcej informacji znajdziesz w artykule o zmianach w AOSP.

Ta strona została przetłumaczona przez Cloud Translation API.

Urządzenie wirtualne z Androidem jako platforma programistyczna

Aby korzystać z wirtualnych urządzeń z Androidem (AVD), emulator Androida obsługuje graficzny interfejs użytkownika (GUI) i interfejs wiersza poleceń (CLI). Wybierz optymalny przepływ pracy dla swojego środowiska.

Tworzenie wirtualnych urządzeń i zarządzanie nimi GUI to proste narzędzie dostępne dla większości deweloperów i użytkowników aplikacji.
Uruchamianie emulatora z poziomu wiersza poleceń to elastyczny sposób dla zaawansowanych użytkowników i automatyzacji. Może to być na przykład używanie wielu AVD lub skonfigurowanie ciągłego testowania i ciągłej integracji. Na początek zapoznaj się z przykładami w narzędziach.

Tworzenie wirtualnego urządzenia z AOSP Car

Proces tworzenia AVD AOSP Car jest podobny do tworzenia obrazów AVD na telefon (np. aosp_car_x86_64):

Aby skonfigurować środowisko programistyczne i określić gałąź, zapoznaj się z narzędziami do kontroli źródła. Następnie zapoznaj się z sekcją Pobieranie źródła:

ANDROID_BRANCH="android12L-release"

REPO_URL="https://android.googlesource.com/platform/manifest"

mkdir $ANDROID_BRANCH && cd $ANDROID_BRANCH && repo init -u $REPO_URL -b
$ANDROID_BRANCH --partial-clone &&  repo sync -c -j8

Utwórz obraz AVD:

. build/envsetup.sh && lunch sdk_car_x86_64-userdebug && m -j32

Uruchom obraz AVD (w razie potrzeby dodaj dodatkowe opcje uruchamiania w wierszu poleceń):
```
emulator &
```
Na przykład:

Rysunek 1. Ekran wirtualnego emulatora Androida

Uwagi dotyczące tego procesu:
- Proces kompilacji jest taki sam jak w przypadku kompilacji Androida na urządzenie fizyczne, więc pobranie źródła i jego skompilowanie zajmie trochę czasu.
- Aby pracować nad innymi gałęziami, ustaw $ANDROID_BRANCH na inną gałąź lub tag.
- Obrazy AVD, takie jak system.img, są tworzone w $ANDROID_PRODUCT_OUT. Więcej informacji o kluczowych obrazach znajdziesz w katalogu systemowym AVD.
- W pliku README znajdziesz informacje o tym, jak wstępnie skompilowane pliki binarne emulatora w drzewie Androida są używane do uruchamiania emulatora.

Tworzenie AVD w samochodzie

Dodawanie nowego AVD do samochodu jest niemal identyczne z dodawaniem nowego urządzenia. Na przykład 1660554 tworzy nowy avd_car AVD.

Aby utworzyć AVD samochodu:

W razie potrzeby utwórz firmę i folder urządzenia. W tym przykładzie użyto elementu $ANDROID_BUILD_TOP/device/google_car/avd_car.
Utwórz plik makefile produktu avd_car.mk, który określa sposób tworzenia AVD.
Utwórz folder urządzenia avd_car_device, w którym będą przechowywane pliki BoardConfig.mk i source.properties.
Dodaj nowe pole makefile i nową opcję lunch do AndroidProducts.mk.

Aby skompilować i uruchomić nowy avd_carAVD:

. build/envsetup.sh && lunch acar-userdebug && m -j32 && emulator &

Możesz teraz tworzyć prototypy większości funkcji HMI i aplikacji na nowym AVD.

Pakowanie pliku ZIP z obrazem AVD

Możesz spakować i udostępnić AVD innym osobom lub używać go na innym komputerze. Aby wygenerować plik ZIP obrazu AVD, użyj polecenia emu_img_zip.mk:

Po utworzeniu AVD ustaw go jako emu_img_zip docelowy:
```
m emu_img_zip
```
Plik ZIP obrazu AVD z prefiksem sdk-repo-linux-system-images zostanie utworzony w folderze o nazwie $ANDROID_PRODUCT_OUT.
Uwaga: funkcja emu_img_zip.mk została dodana po Androidzie 11, ale możesz dostosować plik makefile do poprzedniej wersji. Na przykład 1661582 działa na Androidzie 11.

Kompilowanie jądra AVD

Jądra AVD są podobne do innych jąder Androida, ponieważ wszystkie są wstępnie skompilowanymi obrazami. Zwykle możesz używać gotowych obrazów jądra goldfish w standardowej postaci z każdej wersji Androida.

Aby eksperymentować ze zmianami w jądrze:

Wykonaj te instrukcje:

mkdir goldfish-kernel-54
cd goldfish-kernel-54
repo init -u https://android.googlesource.com/kernel/manifest -b
common-android11-5.4
repo sync
BUILD_CONFIG=common/build.config.gki.x86_64 build/build.sh
BUILD_CONFIG=common-modules/virtual-device/build.config.goldfish.x86_64
build/build.sh
ls -l ./out/android11-5.4/dist/

Zastąp plik binarny jądra w bazie kodu zgodnie z plikiem makefile AVD. Na przykład device/generic/goldfish/board/emu64x/details.mk zawiera device/generic/goldfish/board/kernel/x86_64.mk.

Kod i konfiguracja jądra znajdują się w tych lokalizacjach:

Produkt	Wartość
Oddział	`common-android11-5.4` (używany w Androidzie 11)
Plik manifestu	`kernel/manifest/common-android11-5.4`
common-modules/virtual-device	`kernel/common-modules/virtual-device/android11-5.4`
Bąbelki	`kernel/common/android11-5.4`

Tworzenie nowego profilu urządzenia

Aby umożliwić użytkownikom tworzenie określonego urządzenia wirtualnego w Menedżerze urządzeń wirtualnych w Android Studio, zapoznaj się z artykułem Tworzenie urządzeń wirtualnych i zarządzanie nimi. Producenci urządzeń mogą definiować własne specyfikacje sprzętowe, np. rozmiar ekranu i DPI, za pomocą devices.xml pliku dołączonego do obrazu AVD.

Na przykład profile urządzeń samochodowych znajdziesz w automotive.xml.
W przypadku tworzenia lub prototypowania interfejsu HMI do pliku można dodać wiele urządzeń dla tego samego obrazu AVD.
Umieść plik w pliku ZIP z obrazem AVD OEM w folderze [ABI]. Na przykład x86_64.
Producenci urządzeń mogą też utworzyć skórkę emulatora. Na przykład w celu zdefiniowania dodatkowych przycisków sprzętowych, które zapewnią większą wierność interfejsu. Jest to przydatne nie tylko w przypadku procesów deweloperskich, ale też innych zadań, takich jak badania i weryfikacja UX.

Tworzenie pliku XML obrazu AVD

Producenci urządzeń mogą utworzyć plik XML obrazu AVD, aby Android Studio mogło go pobrać.

Na przykład zobacz plik XML obrazu AVD AAOS, sys-img2-1.xml.
Producenci urządzeń mogą określić własną umowę licencyjną OEM AVD dla swoich użytkowników docelowych (z zastosowaniem systemu honorowego) z licencją na emulator Androida. Android Studio uzyskuje zgodę użytkownika, gdy taka licencja jest uwzględniona.

Aby utworzyć obraz:

Przygotuj plik ZIP z obrazem AVD.
Rozpakuj ${ANDROID_PRODUCT_OUT}/sdk-repo-linux-system-images-*.zip.
Dodaj plik devices.xml do folderu x86_64, a następnie skompresuj go do pliku ZIP. Na przykład oem_avd_img_x86_64.zip.
Zaktualizuj urządzenie oem-sys-img2-1.xml.
Zaktualizuj nazwę, rozmiar i sumę kontrolną SHA pliku ZIP (przykładowe pliki XML znajdziesz w tools).

Jeśli na przykład chcesz hostować AVD w Google Cloud Storage, zapoznaj się z artykułem Tworzenie zasobników pamięci.

Aby przesłać AVD i udostępnić go publicznie, zapoznaj się z sekcją Udostępnianie danych publicznie:

BUCKET_NAME="aaos-avd"
gsutil mb gs://$BUCKET_NAME
gsutil cp oem_avd_img_x86_64.zip gs://$BUCKET_NAME
gsutil cp oem-sys-img2-1.xml gs://$BUCKET_NAME
gsutil iam ch allUsers:objectViewer gs://$BUCKET_NAME

Format adresu URL dodatku SDK obrazu AVD to: https://storage.googleapis.com/$BUCKET_NAME/oem-sys-img2-1.xml. Jeśli na przykład BUCKET_NAME to aaos-avd, adres URL to: https://storage.googleapis.com/aaos-avd/oem-sys-img2-1.xml.

Aby użytkownicy mogli pobierać obrazy AVD i używać AVD w Android Studio, możesz udostępnić plik XML dodatku SDK. Więcej informacji znajdziesz w artykule Aktualizowanie IDE i narzędzi pakietu SDK.

Aby pobrać AVD z sieci:

Umieść plik ZIP z obrazem i pliki XML na serwerze.
Podaj adres URL użytkownikom docelowym.
(Opcjonalnie) Ogranicz dostęp za pomocą nazwy użytkownika i hasła.

Aby przyspieszyć proces programowania, możesz też pobrać AVD do katalogu lokalnego:

Zapisz pliki XML i wszystkie artefakty określone w pliku XML w folderze (np. wszystkie pliki ZIP z obrazami AVD) o nazwie ADDON_DIR.
Określ adres URL jako file://$ADDON_DIR/oem-sys-img2-1.xml.