Wszystkie zadania kompilacji dostępne w Twoim projekcie Androida możesz wykonywać za pomocą narzędzia wiersza poleceń Opakowanie Gradle. Jest on dostępny w postaci pliku wsadowego dla systemu Windows (gradlew.bat
) oraz skryptu powłoki na systemy Linux i Mac (gradlew.sh
). Można go uzyskać z katalogu głównego każdego projektu utworzonego w Android Studio.
Aby uruchomić zadanie z otoką, użyj jednego z tych poleceń w oknie terminala (w Android Studio wybierz Widok > Narzędzia Okna > Terminal):
- W systemie Windows:
gradlew task-name
- W systemie Mac lub Linux:
./gradlew task-name
Aby wyświetlić listę wszystkich zadań kompilacji dostępnych w Twoim projekcie, uruchom polecenie tasks
:
gradlew tasks
Pozostała część tej strony zawiera podstawowe informacje o tworzeniu i uruchamianiu aplikacji za pomocą otoki Gradle. Więcej informacji o konfigurowaniu kompilacji na Androida znajdziesz w artykule o konfigurowaniu kompilacji.
Jeśli wolisz korzystać z narzędzi Android Studio zamiast narzędzi wiersza poleceń, przeczytaj artykuł Tworzenie i uruchamianie aplikacji.
Informacje o typach kompilacji
Domyślnie dla każdej aplikacji na Androida dostępne są 2 typy kompilacji: kompilacja debugująca i do udostępniania aplikacji użytkownikom (release). Wynikowe dane wyjściowe każdej kompilacji muszą być podpisane certyfikatem, zanim będzie można wdrożyć aplikację na urządzeniu. Kompilacja do debugowania jest automatycznie podpisana kluczem debugowania dostarczonym przez narzędzia pakietu SDK (jest niezabezpieczona i nie można jej użyć do publikowania w Sklepie Google Play), a kompilacja musi być podpisana Twoim własnym kluczem prywatnym.
Jeśli chcesz skompilować aplikację do opublikowania, musisz ją też podpisać odpowiednim kluczem podpisywania. Jeśli jednak dopiero zaczynasz, możesz szybko uruchamiać aplikacje w emulatorze lub na połączonym urządzeniu, tworząc pakiet APK do debugowania.
Możesz też zdefiniować niestandardowy typ kompilacji w pliku build.gradle.kts
i skonfigurować go pod kątem podpisania jako kompilacji do debugowania. W tym celu dodaj parametr debuggable true
. Więcej informacji znajdziesz w artykule o konfigurowaniu wariantów kompilacji.
Tworzenie i wdrażanie pakietu APK
Utworzenie pakietu aplikacji to najlepszy sposób na utworzenie pakietu aplikacji i przesłanie go do Konsoli Play, ale taki plik jest lepszym rozwiązaniem, gdy chcesz szybko przetestować kompilację do debugowania lub udostępnić aplikację jako artefakt do wdrożenia innym użytkownikom.
Tworzenie pakietu APK do debugowania
Aby od razu testować i debugować aplikacje, możesz utworzyć pakiet APK do debugowania.
Plik APK do debugowania jest podpisany kluczem debugowania dostarczonym przez narzędzia pakietu SDK. Umożliwia on debugowanie za pomocą narzędzia adb
.
Aby utworzyć pakiet APK do debugowania, otwórz wiersz poleceń i przejdź do głównego katalogu swojego katalogu projektu. Aby zainicjować kompilację do debugowania, wywołaj zadanie assembleDebug
:
gradlew assembleDebug
Spowoduje to utworzenie pliku APK o nazwie module_name-debug.apk
w regionie project_name/module_name/build/outputs/apk/
.
Plik jest już podpisany kluczem debugowania i dopasowany do wartości zipalign
, dzięki czemu możesz od razu zainstalować go na urządzeniu.
Aby utworzyć plik APK i od razu zainstalować go w uruchomionym emulatorze lub na połączonym urządzeniu, wywołaj installDebug
:
gradlew installDebug
Część „Debugowanie” w powyższych nazwach zadań to tylko wersja wariantu kompilacji zapisana z użyciem wielkich liter, więc można ją zastąpić dowolnym typem kompilacji lub wariantem, który chcesz utworzyć lub zainstalować. Jeśli na przykład masz rodzaj produktu w wersji demonstracyjnej, możesz utworzyć wersję do debugowania za pomocą zadania assembleDemoDebug
.
Aby wyświetlić wszystkie zadania kompilacji i instalacji dostępne dla każdego wariantu (w tym zadania odinstalowywania), uruchom zadanie tasks
.
Zapoznaj się też z sekcją dotyczącą uruchamiania aplikacji w emulatorze i uruchamiania aplikacji na urządzeniu.
Tworzenie pakietu wersji lub pliku APK
Aby opublikować i rozpowszechnić aplikację, musisz utworzyć pakiet wersji lub plik APK podpisany Twoim kluczem prywatnym. Więcej informacji znajdziesz w sekcji dotyczącej podpisywania aplikacji za pomocą wiersza poleceń.
Wdrażanie aplikacji w emulatorze
Aby używać emulatora Androida, musisz utworzyć wirtualne urządzenie z Androidem (AVD) w Android Studio.
Gdy zainstalujesz narzędzie AR, uruchom emulator Androida i zainstaluj aplikację, wykonując te kroki:
W wierszu poleceń przejdź do
android_sdk/tools/
i uruchom emulator, podając AVD:emulator -avd avd_name
Jeśli nie masz pewności, jaka jest nazwa AVD, uruchom
emulator -list-avds
.- Teraz możesz zainstalować aplikację, korzystając z jednego z zadań instalacji Gradle wymienionych w sekcji dotyczącej tworzenia pakietu APK do debugowania lub za pomocą narzędzia
adb
.Jeśli plik APK został utworzony za pomocą pakietu SDK z podglądem dla programistów (jeśli
targetSdkVersion
to litera, a nie cyfra), musisz dodać opcję-t
do poleceniainstall
, by zainstalować testowy plik APK.adb install path/to/your_app.apk
Wszystkie utworzone przez Ciebie pliki APK są zapisywane w
project_name/module_name/build/outputs/apk/
.
Więcej informacji znajdziesz w artykule Uruchamianie aplikacji przy użyciu emulatora Androida.
Wdrażanie aplikacji na urządzeniu fizycznym
Aby móc uruchomić aplikację na urządzeniu, musisz włączyć na nim debugowanie USB. Tę opcję znajdziesz w sekcji Ustawienia > Opcje programisty.
Uwaga: w Androidzie 4.2 i nowszych Opcje programisty są domyślnie ukryte. Aby go udostępnić, wybierz Ustawienia > Informacje o telefonie i 7 razy kliknij Numer kompilacji. Wróć na poprzedni ekran, aby znaleźć Opcje programisty.
Po skonfigurowaniu i połączeniu urządzenia przez USB możesz zainstalować aplikację, korzystając z zadań instalacji Gradle wymienionych w sekcji dotyczącej tworzenia pakietu APK do debugowania lub za pomocą narzędzia adb
:
adb -d install path/to/your_app.apk
Wszystkie utworzone przez Ciebie pliki APK są zapisywane w project_name/module_name/build/outputs/apk/
.
Więcej informacji znajdziesz w artykule Uruchamianie aplikacji na urządzeniu sprzętowym.
Tworzenie pakietu aplikacji
Pakiety aplikacji na Androida zawierają cały skompilowany kod i zasoby aplikacji, ale opóźniają generowanie i podpisywanie plików APK w Google Play. W przeciwieństwie do plików APK nie można wdrożyć pakietu aplikacji bezpośrednio na urządzeniu. Jeśli więc chcesz szybko przetestować lub udostępnić plik APK innej osobie, utwórz go.
Najłatwiejszym sposobem utworzenia pakietu aplikacji jest użycie Android Studio. Jeśli jednak chcesz utworzyć pakiet aplikacji z poziomu wiersza poleceń, możesz to zrobić za pomocą Gradle lub bundletool
zgodnie z opisem w sekcjach poniżej.
Tworzenie pakietu aplikacji za pomocą Gradle
Jeśli wolisz wygenerować pakiet aplikacji z poziomu wiersza poleceń, uruchom zadanie bundleVariant
Gradle w module podstawowym aplikacji.
Na przykład to polecenie tworzy pakiet aplikacji na potrzeby wersji debugowania modułu podstawowego:
./gradlew :base:bundleDebug
Jeśli chcesz utworzyć podpisany pakiet do przesłania do Konsoli Play, musisz najpierw skonfigurować plik build.gradle.kts
modułu podstawowego z informacjami o podpisywania aplikacji. Więcej informacji znajdziesz w sekcji dotyczącej konfigurowania Gradle w celu podpisania aplikacji. Możesz na przykład utworzyć wersję do publikacji aplikacji, a Gradle automatycznie wygeneruje pakiet aplikacji i podpisze go danymi podpisywania podanymi w pliku build.gradle.kts
.
Jeśli zamiast tego chcesz podpisać pakiet aplikacji w oddzielnym kroku, możesz podpisać go za pomocą wiersza poleceń jarsigner
. Polecenie do utworzenia pakietu aplikacji:
jarsigner -keystore pathToKeystore app-release.aab keyAlias
Tworzenie pakietu aplikacji za pomocą narzędzia pakietu
bundletool
to narzędzie wiersza poleceń, za pomocą którego Android Studio, wtyczka Androida do obsługi Gradle i Google Play konwertują skompilowany kod i zasoby aplikacji na pakiety aplikacji oraz generują możliwe do wdrożenia pliki APK na podstawie tych pakietów.
Chociaż warto przetestować pakiety aplikacji za pomocą bundletool
i lokalnie odtworzyć sposób, w jaki Google Play generuje pliki APK, zazwyczaj nie musisz wywoływać funkcji bundletool
podczas tworzenia pakietu aplikacji. Zamiast tego użyj zadań Android Studio lub Gradle, jak opisano we wcześniejszych sekcjach.
Jeśli jednak nie chcesz używać zadań Android Studio lub Gradle do tworzenia pakietów (np. niestandardowego łańcucha narzędzi do kompilacji), możesz użyć polecenia bundletool
z poziomu wiersza poleceń, aby utworzyć pakiet aplikacji na podstawie już skompilowanego kodu i zasobów.
Pobierz plik bundletool
z repozytorium GitHub, jeśli jeszcze go nie masz.
W tej sekcji dowiesz się, jak spakować skompilowany kod i zasoby aplikacji oraz jak użyć bundletool
z poziomu wiersza poleceń do przekonwertowania ich na pakiet Android App Bundle.
Wygeneruj plik manifestu i zasoby w formacie proto
bundletool
wymaga określonych informacji o projekcie aplikacji, takich jak plik manifestu i zasoby aplikacji, w formacie bufora protokołu Google, który jest nazywany również „protobuf” i korzysta z rozszerzenia pliku *.pb
. Protobufy zapewniają neutralny pod względem języka, neutralny dla platformy i rozszerzony mechanizm serializacji uporządkowanych danych. Jest podobny do XML, ale mniejszy, szybszy i prostszy.
Pobierz AAPT2
Plik manifestu i tabelę zasobów aplikacji możesz wygenerować w formacie protokołu protobuf przy użyciu najnowszej wersji AAPT2 z repozytorium Google Maven.
Aby pobrać AAPT2 z repozytorium Google Maven, wykonaj te czynności:
- Przejdź do com.android.tools.build > aapt2 w indeksie repozytorium.
- Skopiuj nazwę najnowszej wersji AAPT2.
Wstaw skopiowaną nazwę wersji w tym adresie URL i określ docelowy system operacyjny: https://dl.google.com/dl/android/maven2/com/android/tools/build/aapt2/aapt2-version/aapt2-aapt2-version-[windows | linux | osx].jar
Aby na przykład pobrać wersję 3.2.0-alpha18-4804415 dla systemu Windows, użyj następującego kodu: https://dl.google.com/dl/android/maven2/com/android/tools/build/aapt2/3.2.0-alpha18-4804415/aapt2-3.2.0-alpha418-43.2.0-alpha418-4
Otwórz adres URL w przeglądarce – wkrótce powinno rozpocząć się pobieranie AAPT2.
Rozpakuj pobrany przed chwilą plik JAR.
Kompilowanie i łączenie zasobów aplikacji
Użyj AAPT2, aby skompilować zasoby aplikacji za pomocą tego polecenia:
aapt2 compile \ project_root/module_root/src/main/res/drawable/Image1.png \ project_root/module_root/src/main/res/drawable/Image2.png \ -o compiled_resources/
Na etapie łączenia, gdy AAPT2 łączy różne skompilowane zasoby w jeden plik APK, poproś AAPT2 o skonwertowanie pliku manifestu i zasobów skompilowanych na format protobuf przez dodanie flagi --proto-format
, jak pokazano poniżej:
aapt2 link --proto-format -o output.apk \ -I android_sdk/platforms/android_version/android.jar \ --manifest project_root/module_root/src/main/AndroidManifest.xml \ -R compiled_resources/*.flat \ --auto-add-overlay
Następnie możesz wyodrębnić zawartość z wyjściowego pakietu APK, np. AndroidManifest.xml
czy resources.pb
oraz inne pliki zasobów aplikacji – teraz w formacie protobuf. Potrzebujesz tych plików podczas przygotowywania danych wejściowych wymaganych przez bundletool
do utworzenia pakietu aplikacji w sposób opisany w sekcji poniżej.
Wstępnie skompilowany kod i zasoby pakietu
Zanim użyjesz bundletool
do wygenerowania pakietu aplikacji, musisz najpierw udostępnić pliki ZIP, które zawierają kod skompilowany i zasoby danego modułu aplikacji. Zawartość i układ pliku ZIP każdego modułu są bardzo podobne do formatu pakietu Android App Bundle.
Utwórz np. plik base.zip
dla podstawowego modułu aplikacji i uporządkuj jego zawartość w ten sposób:
Plik lub katalog | Opis |
---|---|
manifest/AndroidManifest.xml
|
Plik manifestu modułu w formacie protobuf. |
dex/...
|
Katalog, w którym co najmniej 1 skompilowany plik DEX aplikacji. Powinny one mieć następujące nazwy: classes.dex , classes2.dex , classes3.dex itd.
|
res/...
|
Zawiera zasoby modułu w formacie protobuf na potrzeby wszystkich konfiguracji urządzeń. Podkatalogi i pliki powinny być uporządkowane podobnie do typowych plików APK. |
root/... , assets/... i lib/...
|
Te katalogi są identyczne z opisanymi w sekcji dotyczącej formatu pakietów aplikacji na Androida. |
resources.pb
|
Tabela zasobów aplikacji w formacie protobuf. |
Po przygotowaniu pliku ZIP dla każdego modułu aplikacji możesz go przekazać do bundletool
, aby utworzyć pakiet aplikacji w sposób opisany w kolejnej sekcji.
Tworzenie pakietu aplikacji za pomocą narzędzia pakietu
Aby utworzyć pakiet aplikacji, użyj polecenia bundletool build-bundle
, jak pokazano poniżej:
bundletool build-bundle --modules=base.zip --output=mybundle.aab
W tabeli poniżej znajdziesz bardziej szczegółowe informacje o flagach polecenia build-bundle
:
Zgłoś | Opis |
---|---|
--modules=path-to-base.zip, path-to-module2.zip,path-to-module3.zip
|
Określa listę plików ZIP modułu, których bundletool ma używać do skompilowania pakietu aplikacji.
|
--output=path-to-output.aab
|
Określa ścieżkę i nazwę pliku wyjściowego pliku *.aab .
|
--config=path-to-BundleConfig.json
|
Określa ścieżkę do opcjonalnego pliku konfiguracji, którego możesz użyć, aby dostosować proces kompilacji. Więcej informacji znajdziesz w sekcji poświęconej dostosowywaniu generowania plików APK na potrzeby dalszych etapów. |
--metadata-file=target-bundle-path:local-file-path
|
Instruuje bundletool , aby opcjonalny plik metadanych znalazł się w pakiecie aplikacji. W tym pliku możesz umieścić dane, takie jak mapowania ProGuard lub pełną listę plików DEX aplikacji, które mogą być przydatne na innych etapach łańcucha narzędzi lub sklepu z aplikacjami.
target-bundle-path określa ścieżkę względną do katalogu głównego pakietu aplikacji, w którym ma zostać spakowany plik metadanych, a local-file-path określa ścieżkę do samego lokalnego pliku metadanych. |
Dostosuj generowanie dalszych plików APK
Pakiety aplikacji zawierają plik BundleConfig.pb
zawierający metadane, które są wymagane przez sklepy z aplikacjami, np. Google Play podczas generowania plików APK z pakietu.
Chociaż bundletool
tworzy ten plik za Ciebie, niektóre aspekty metadanych w pliku BundleConfig.json
możesz skonfigurować i przekazać do polecenia bundletool build-bundle
. bundletool
później konwertuje i scala ten plik z wersją protokołu zawartej w każdym pakiecie aplikacji.
Możesz na przykład określić, które kategorie plików APK konfiguracji mają być włączone lub wyłączone. Ten przykładowy plik BundleConfig.json
wyłącza pliki APK konfiguracji, które są kierowane na inny język (tzn. zasoby we wszystkich językach są uwzględnione w odpowiednich pakietach APK podstawowych lub funkcji):
{
"optimizations": {
"splitsConfig": {
"splitDimension": [{
"value": "LANGUAGE",
"negate": true
}]
}
}
}
W pliku BundleConfig.json
możesz też określić, które typy plików mają pozostać nieskompresowane podczas pakowania plików APK z wykorzystaniem
wzorców glob. Służą do tego:
{
"compression": {
"uncompressedGlob": ["res/raw/**", "assets/**.uncompressed"]
}
}
Pamiętaj, że bundletool
domyślnie nie kompresuje bibliotek natywnych aplikacji (w Androidzie 6.0 lub nowszym) ani tabeli zasobów (resources.arsc
). Pełny opis elementów, które można skonfigurować w BundleConfig.json
, znajdziesz w pliku bundletool
config.proto
napisanym z użyciem składni Proto3.
Wdrażanie aplikacji z poziomu pakietu aplikacji
Jeśli masz utworzony i podpisany pakiet aplikacji, użyj bundletool
do wygenerowania plików APK i wdrożenia ich na urządzeniu.
Podpisywanie aplikacji z poziomu wiersza poleceń
Do podpisania aplikacji nie potrzebujesz Android Studio. Możesz podpisać aplikację z poziomu wiersza poleceń, używając apksigner
w przypadku plików APK lub jarsigner
w przypadku pakietów aplikacji. Możesz też skonfigurować Gradle podpisywanie jej za Ciebie podczas kompilacji. W obu przypadkach musisz najpierw wygenerować klucz prywatny za pomocą keytool
, jak pokazano poniżej:
keytool -genkey -v -keystore my-release-key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias my-alias
Powyższy przykład wymaga podania haseł do magazynu kluczy i klucza oraz do pól „Nazwa wyróżniająca” klucza. Następnie generuje magazyn kluczy jako plik o nazwie my-release-key.jks
i zapisuje go w bieżącym katalogu (możesz go przenieść w dowolne miejsce). Magazyn kluczy zawiera jeden klucz ważny przez 10 000 dni.
Teraz możesz ręcznie podpisać plik APK lub pakiet aplikacji albo skonfigurować Gradle pod kątem podpisywania aplikacji podczas procesu kompilacji w sposób opisany w sekcjach poniżej.
Podpisywanie aplikacji ręcznie z poziomu wiersza poleceń
Jeśli chcesz podpisać pakiet aplikacji za pomocą wiersza poleceń, możesz użyć jarsigner
.
Jeśli zamiast tego chcesz podpisać pakiet APK, musisz użyć zipalign
i apksigner
, jak opisano poniżej.
- Otwórz wiersz poleceń – w Android Studio wybierz Widok > Okna narzędzi > Terminal i przejdź do katalogu, w którym znajduje się niepodpisany plik APK.
-
Dopasuj niepodpisany plik APK, używając
zipalign
:zipalign -v -p 4 my-app-unsigned.apk my-app-unsigned-aligned.apk
zipalign
dba o to, aby wszystkie nieskompresowane dane rozpoczynały się od określonego wyrównania bajtów w stosunku do początku pliku, co może zmniejszyć ilość pamięci RAM zużywanej przez aplikację. -
Podpisz plik APK kluczem prywatnym za pomocą
apksigner
:apksigner sign --ks my-release-key.jks --out my-app-release.apk my-app-unsigned-aligned.apk
W tym przykładzie podpisany pakiet APK jest generowany pod adresem
my-app-release.apk
po podpisaniu go kluczem prywatnym i certyfikatem przechowywanych w jednym pliku KeyStore:my-release-key.jks
.Narzędzie
apksigner
obsługuje inne opcje podpisywania, m.in. podpisywanie pliku APK za pomocą osobnych plików klucza prywatnego i certyfikatu oraz podpisywanie pakietu APK wieloma osobami podpisującymi. Więcej informacji znajdziesz w dokumentacjiapksigner
.Uwaga: aby korzystać z narzędzia
apksigner
, musisz mieć zainstalowane narzędzia Android SDK Build Tools w wersji 24.0.3 lub nowszej. Możesz zaktualizować ten pakiet za pomocą Menedżera SDK. -
Sprawdź, czy plik APK jest podpisany:
apksigner verify my-app-release.apk
Konfigurowanie Gradle w celu podpisania aplikacji
Otwórz plik build.gradle.kts
na poziomie modułu i dodaj blok signingConfigs {}
z wpisami storeFile
, storePassword
, keyAlias
i keyPassword
, a następnie przekaż ten obiekt do właściwości signingConfig
w typie kompilacji. Na przykład:
Kotlin
android { ... defaultConfig { ... } signingConfigs { create("release") { // You need to specify either an absolute path or include the // keystore file in the same directory as the build.gradle file. storeFile = file("my-release-key.jks") storePassword = "password" keyAlias = "my-alias" keyPassword = "password" } } buildTypes { getByName("release") { signingConfig = signingConfigs.getByName("release") ... } } }
Odlotowy
android { ... defaultConfig { ... } signingConfigs { release { // You need to specify either an absolute path or include the // keystore file in the same directory as the build.gradle file. storeFile file("my-release-key.jks") storePassword "password" keyAlias "my-alias" keyPassword "password" } } buildTypes { release { signingConfig signingConfigs.release ... } } }
Teraz, gdy tworzysz aplikację, wywołując zadanie Gradle, Gradle podpisuje ją (i uruchamia zipalign) za Ciebie.
Poza tym, ponieważ kompilacja wersji została skonfigurowana z Twoim kluczem podpisywania, w przypadku tego typu kompilacji dostępne jest zadanie „instalacji”. Możesz więc kompilować, wyrównywać, podpisywać i instalować pakiet APK wersji w emulatorze lub na urządzeniu, a wszystko to za pomocą zadania installRelease
.
Aplikacja podpisana Twoim kluczem prywatnym jest gotowa do dystrybucji, ale najpierw zapoznaj się z informacjami na temat publikowania aplikacji i zapoznaj się z listą kontrolną wprowadzenia na rynek w Google Play.