Tworzenie aplikacji z poziomu wiersza poleceń

Za pomocą narzędzia wiersza poleceń Gradle Wrapper możesz wykonywać wszystkie zadania kompilacji dostępne w projekcie na Androida. Jest on dostępny jako plik wsadowy w Windows (gradlew.bat) i skrypt powłoki w Linuxie i na Macu (gradlew.sh). Można go otworzyć w katalogu głównym każdego projektu utworzonego w Android Studio.

Aby wykonać zadanie za pomocą oprogramowania zamykającego, użyj jednego z tych poleceń w oknie terminala (w Android Studio kliknij Widok > Okna narzędzia > Terminal):

• W wierszu poleceń w systemie Windows:

  gradlew task-name

• W systemie Mac, Linux lub Windows PowerShell:

  ./gradlew task-name

Aby zobaczyć listę wszystkich dostępnych zadań kompilacji w projekcie, wykonaj tę czynność: tasks

gradlew tasks

Pozostała część tej strony zawiera podstawowe informacje o tworzeniu i uruchamianiu aplikacji za pomocą owijarki Gradle. Więcej informacji o konfigurowaniu kompilacji Androida znajdziesz w artykule Konfigurowanie kompilacji.

Jeśli wolisz używać narzędzi Android Studio zamiast narzędzi wiersza poleceń, zapoznaj się z artykułem Kompilowanie i uruchamianie aplikacji.

Typy kompilacji

Domyślnie w przypadku każdej aplikacji na Androida dostępne są 2 typy wersji: jedna do debugowania – wersja debugowa – i jedna do wydania dla użytkowników – wersja wydana. Zanim wdrożesz aplikację na urządzeniu, wynik każdego procesu kompilacji musi zostać podpisany certyfikatem. Kompilacja debugowania jest automatycznie podpisywana kluczem debugowania udostępnianym przez narzędzia pakietu SDK (jest on niezabezpieczony i nie można opublikować go w Google Play Store), a kompilacja wersji produkcyjnej musi być podpisana własnym kluczem prywatnym.

Jeśli chcesz skompilować aplikację na potrzeby wydania, musisz też podpisać ją odpowiednim kluczem podpisywania. Jeśli dopiero zaczynasz, możesz szybko uruchomić aplikacje na emulatorze lub połączonym urządzeniu, tworząc plik APK do debugowania.

Możesz też zdefiniować niestandardowy typ kompilacji w pliku build.gradle.ktsi skonfigurować go tak, aby był podpisany jako kompilacja debugowania, dodając debuggable true. Więcej informacji znajdziesz w artykule Konfigurowanie wariantów kompilacji.

Tworzenie i wdrażanie pliku APK

Chociaż skompilowanie pakietu aplikacji to najlepszy sposób na spakowanie aplikacji i przesłanie jej do Konsoli Play, kompilowanie pliku APK jest lepszym rozwiązaniem, gdy chcesz szybko przetestować wersję debugującą lub udostępnić aplikację innym jako artefakt do wdrożenia.

Tworzenie pliku APK debugowania

Aby od razu przetestować aplikację i przeprowadzić debugowanie, możesz utworzyć plik APK do debugowania. Plik APK debugowania jest podpisany kluczem debugowania udostępnianym przez narzędzia pakietu SDK i umożliwia debugowanie za pomocą adb.

Aby utworzyć plik APK debugowania, otwórz wiersz poleceń i przejdź do głównego katalogu projektu. Aby rozpocząć kompilację debugowania, wywołaj zadanie assembleDebug:

gradlew assembleDebug

Spowoduje to utworzenie pliku APK o nazwie module_name-debug.apk w folderze project_name/module_name/build/outputs/apk/. Plik jest już podpisany kluczem debugowania i zgodny z zipalign, więc możesz go od razu zainstalować na urządzeniu.

Aby utworzyć pakiet APK i natychmiast zainstalować go na działającym emulatorze lub połączonym urządzeniu, wywołaj polecenie installDebug:

gradlew installDebug

Część „Debug” w wymienionych wyżej nazwach zadań to po prostu nazwa wariantu kompilacji w wersji z wielkimi literami na początku wyrazów. Można ją zastąpić dowolnym typem kompilacji lub wariantem, który chcesz z niego skorzystać. Jeśli na przykład masz wersję „demo” produktu, możesz utworzyć wersję debugującą za pomocą zadania assembleDemoDebug.

Aby zobaczyć wszystkie zadania kompilacji i instalacji dostępne dla poszczególnych wariantów (w tym zadania odinstalowywania), uruchom zadanie tasks.

Zapoznaj się też z sekcją dotyczącą uruchamiania aplikacji na emulatorze i uruchamiania aplikacji na urządzeniu.

Kompilowanie pakietu wersji lub pliku APK

Gdy aplikacja będzie gotowa do wydania i rozpowszechniania, musisz utworzyć pakiet wersji lub plik APK podpisany kluczem prywatnym. Więcej informacji znajdziesz w sekcji o podpisywaniu aplikacji z wiersza poleceń.

Wdrażanie aplikacji w emulatorze

Aby korzystać z emulatora Androida, musisz utworzyć urządzenie wirtualne z Androidem (AVD) za pomocą Android Studio.

Po utworzeniu AVD uruchom emulator Androida i zainstaluj aplikację w ten sposób:

1. W wierszu poleceń przejdź do android_sdk/tools/ i uruchom emulator, podając swój AVD:

   emulator -avd avd_name

   Jeśli nie masz pewności, jaka jest nazwa AVD, wykonaj tę komendę: emulator -list-avds.

2. Teraz możesz zainstalować aplikację, korzystając z jednego z zadań instalacji Gradle wymienionych w sekcji o generowaniu pliku APK na potrzeby debugowania lub z narzędzia adb.

   Jeśli plik APK został skompilowany za pomocą pakietu SDK w wersji dla deweloperów (jeśli targetSdkVersion jest literą, a nie cyfrą), musisz użyć opcji -t w komandze install, aby zainstalować testowy plik APK.

   adb install path/to/your_app.apk
   

   Wszystkie utworzone przez Ciebie pliki APK są zapisywane w folderze project_name/module_name/build/outputs/apk/.

Więcej informacji znajdziesz w artykule Uruchamianie aplikacji na emulatorze Androida.

Wdrażanie aplikacji na urządzeniu fizycznym

Zanim uruchomisz aplikację na urządzeniu, musisz włączyć na nim debugowanie przez USB. Opcję znajdziesz w sekcji Ustawienia > Opcje programisty.

Uwaga: w Androidzie 4.2 i nowszych opcja Opcje programisty jest domyślnie ukryta. Aby go udostępnić, otwórz Ustawienia > Informacje o telefonie i kliknij Numer kompilacji 7 razy. Wróć do poprzedniego ekranu, aby znaleźć Opcje programisty.

Po skonfigurowaniu urządzenia i podłączeniu go przez USB możesz zainstalować aplikację, korzystając z zadań instalacji Gradle wymienionych w sekcji Tworzenie pliku 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 folderze project_name/module_name/build/outputs/apk/.

Więcej informacji znajdziesz w artykule Uruchamianie aplikacji na sprzęcie.

Tworzenie pakietu aplikacji

Pakiety aplikacji na Androida zawierają cały skompilowany kod i zasoby aplikacji, ale generowanie i podpisywanie pliku APK jest odkładane na później w Google Play. W przeciwieństwie do pliku APK pakietu aplikacji nie można wdrożyć bezpośrednio na urządzeniu. Jeśli chcesz szybko przetestować plik APK lub udostępnić go innej osobie, skompiluj go.

Najłatwiej utworzyć pakiet aplikacji, korzystając z Android Studio. Jeśli jednak chcesz utworzyć pakiet aplikacji z wiersza poleceń, możesz to zrobić za pomocą Gradle lub bundletool, jak opisano w następnych sekcjach.

Tworzenie pakietu aplikacji za pomocą Gradle

Jeśli wolisz wygenerować pakiet aplikacji z wiersza poleceń, uruchom zadanie Gradle bundleVariant w module podstawowym aplikacji. Na przykład to polecenie tworzy pakiet aplikacji dla 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, podając w nim informacje o podpisywaniu aplikacji. Więcej informacji znajdziesz w sekcji Konfigurowanie Gradle do podpisywania aplikacji. Możesz na przykład skompilować wersję aplikacji przeznaczoną do opublikowania. Gradle automatycznie wygeneruje pakiet aplikacji i podpisze go przy użyciu informacji o podpisywaniu, które podasz w pliku build.gradle.kts.

Jeśli chcesz podpisać pakiet aplikacji jako osobny krok, możesz użyć jarsigner, aby podpisać pakiet aplikacji z poziomu wiersza poleceń. Polecenie do kompilowania pakietu aplikacji:

jarsigner -keystore pathToKeystore app-release.aab keyAlias

Tworzenie pakietu aplikacji za pomocą narzędzia bundletool

bundletool to narzędzie wiersza poleceń, którego Android Studio, wtyczka Gradle dla Androida i Google Play używają do konwertowania skompilowanego kodu i zasobów aplikacji na pakiety aplikacji oraz do generowania z tych pakietów plików APK do wdrożenia.

Chociaż testowanie pakietów aplikacji za pomocą narzędzia bundletool i lokalne odtwarzanie sposobu generowania plików APK przez Google Play jest przydatne, zwykle nie musisz wywoływać narzędzia bundletool, aby skompilować sam pakiet aplikacji. Zamiast tego użyj zadań w Android Studio lub Gradle, jak opisano w poprzednich sekcjach.

Jeśli jednak nie chcesz używać Android Studio ani zadań Gradle do kompilowania pakietów (np. jeśli używasz niestandardowego zestawu narzędzi do kompilowania), możesz użyć bundletoolna linii poleceń, aby skompilować pakiet aplikacji z za pomocą wstępnie skompilowanego kodu i zasobów. Jeśli nie masz jeszcze zainstalowanego pakietu, pobierz gobundletool z repozytorium GitHub.

Z tej sekcji dowiesz się, jak spakować skompilowany kod i zasoby aplikacji oraz jak użyć bundletool na linii poleceń, aby przekonwertować je na pakiet Android App Bundle.

wygenerować plik manifestu i zasobów w formacie proto.

bundletool wymaga, aby pewne informacje o projekcie aplikacji, takie jak plik manifestu i zasoby aplikacji, były w formacie Google Protocol Buffer (znanym też jako „protobuf”), który ma rozszerzenie *.pb. Protobufs zapewniają neutralny pod względem języka i platformy rozszerzalny mechanizm serializacji uporządkowanych danych. Są podobne do XML, ale mniejsze, szybsze i prostsze.

Pobieranie AAPT2

Plik manifestu i tabelę zasobów aplikacji możesz wygenerować w formacie protobuf za pomocą najnowszej wersji AAPT2 z repozytorium Google Maven.

Aby pobrać AAPT2 z repozytorium Maven firmy Google, wykonaj te czynności:

1. W indeksie repozytorium kliknij com.android.tools.build > aapt2.
2. Skopiuj nazwę najnowszej wersji AAPT2.

3. Wklej skopiowaną nazwę wersji w tym adresie URL i wskaż 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 na system Windows, użyj adresu: https://dl.google.com/dl/android/maven2/com/android/tools/build/aapt2/3.2.0-alpha18-4804415/aapt2-3.2.0-alpha18-4804415-windows.jar

4. Otwórz adres URL w przeglądarce – AAPT2 powinno zacząć się pobierać.

5. Rozpakuj pobrany przed chwilą plik JAR.

Kompilowanie i linkowanie zasobów aplikacji

Aby skompilować zasoby aplikacji, użyj AAPT2 i wykonaj to polecenie:

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/

W fazie łączenia, w której AAPT2 łączy różne skompilowane zasoby w jeden plik APK, zleć AAPT2 konwersję pliku manifestu i skompilowanych zasobów aplikacji na format protobuf, podając flagę --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 pliku APK wyjściowego, np. pliki AndroidManifest.xml i resources.pb aplikacji oraz inne pliki zasobów – teraz w formacie protobuf. Potrzebujesz tych plików do przygotowania danych wejściowych, których bundletool wymaga do utworzenia pakietu aplikacji, jak opisano w sekcji poniżej.

Pakowanie wstępnie skompilowanego kodu i zasobów

Zanim użyjesz bundletool do wygenerowania pakietu aplikacji, musisz najpierw przesłać pliki ZIP zawierające skompilowany kod i zasoby danego modułu aplikacji. Treść i organizacja pliku ZIP każdego modułu są bardzo podobne do formatu pakietu aplikacji na Androida. Na przykład dla podstawowego modułu aplikacji utwórz plik base.zip i uporządkuj jego zawartość w ten sposób:

Po przygotowaniu pliku ZIP dla każdego modułu aplikacji możesz go przekazać do bundletool, aby utworzyć pakiet aplikacji, jak opisano w następnej sekcji.

Tworzenie pakietu aplikacji za pomocą narzędzia bundletool

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 szczegółowe informacje o flagach polecenia build-bundle:

Dostosowywanie generowania plików APK na dalszych etapach

Pakiety aplikacji zawierają plik BundleConfig.pb, który zawiera metadane wymagane przez sklepy z aplikacjami, takie jak Google Play, do generowania plików APK z pakietu. Chociaż bundletool tworzy ten plik za Ciebie, możesz skonfigurować niektóre aspekty metadanych w pliku BundleConfig.json i przekazać go do polecenia bundletool build-bundle. bundletool później konwertuje i zgrywa ten plik z wersją protobuf zawartą 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. Przykład pliku BundleConfig.json, który wyłącza pliki APK konfiguracji przeznaczone na różne języki (czyli zasoby dla wszystkich języków są uwzględnione w odpowiednich plikach APK bazowych 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 za pomocą wzorców glob. Aby to zrobić, wykonaj te czynności:

{
  "compression": {
    "uncompressedGlob": ["res/raw/**", "assets/**.uncompressed"]
  }
}

Pamiętaj, że domyślnie bundletool nie kompresuje natywnych bibliotek aplikacji (w Androidzie 6.0 lub nowszym) ani tabeli zasobów (resources.arsc). Pełny opis tego, co możesz skonfigurować w pliku BundleConfig.json, znajdziesz w pliku bundletool config.proto, który jest napisany w składni Proto3.

Wdrażanie aplikacji z pakietu aplikacji

Jeśli masz już utworzony i podpisany pakiet aplikacji, użyj narzędzia bundletool do wygenerowania plików APK i wdrożenia ich na urządzenie.

Podpisywanie aplikacji z poziomu wiersza poleceń

Aby podpisać aplikację, nie musisz używać Android Studio. Możesz to zrobić w wierszu poleceń, używając polecenia apksigner w przypadku plików APK lub jarsigner w przypadku pakietów aplikacji, albo skonfigurować Gradle, aby podpisywało aplikację podczas kompilacji. W obu przypadkach musisz najpierw wygenerować klucz prywatny za pomocą funkcji keytool, jak pokazano poniżej:

keytool -genkey -v -keystore my-release-key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias my-alias

W tym przykładzie pojawi się prośba o podanie haseł do magazynu kluczy i klucza oraz do pól „Nazwa wyróżniona” 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). Sklep kluczy zawiera 1 klucz,który jest ważny przez 10 tys. dni.

Teraz możesz podpisać plik APK lub pakiet aplikacji ręcznie albo skonfigurować Gradle tak, aby podpisywał aplikację podczas procesu kompilacji. Aby to zrobić, postępuj zgodnie z instrukcjami w sekcjach poniżej.

Ręczne podpisywanie aplikacji w wierszu poleceń

Jeśli chcesz podpisać pakiet aplikacji z poziomu wiersza poleceń, możesz użyć narzędzia jarsigner. Jeśli zamiast tego chcesz podpisać plik APK, musisz użyć zipalign i apksigner w sposób opisany poniżej.

1. Otwórz wiersz polecenia. W Android Studio kliknij Widok > Okna narzędzia > Terminal i otwórz katalog z niepodpisanym pakietem APK.

2. Wyrównaj niezaszyfrowany plik APK za pomocą:zipalign

   zipalign -v -p 4 my-app-unsigned.apk my-app-unsigned-aligned.apk
   

   zipalign zapewnia, że wszystkie niezdekompresowane dane zaczynają się od określonego bajtu względem początku pliku, co może zmniejszyć ilość pamięci RAM zużywanej przez aplikację.

3. Podpisz plik APK za pomocą klucza prywatnego, korzystając z apksigner:

   apksigner sign --ks my-release-key.jks --out my-app-release.apk my-app-unsigned-aligned.apk
   

   W tym przykładzie podpisany plik APK jest zapisywany w pliku my-app-release.apk po podpisaniu go kluczem prywatnym i certyfikatem przechowywanymi w pojedynczym pliku KeyStore: my-release-key.jks.

   Narzędzie apksigner obsługuje inne opcje podpisywania, w tym: podpisywanie pliku APK za pomocą oddzielnych plików klucza prywatnego i certyfikatu oraz podpisywanie pliku APK za pomocą wielu podpisujących. Więcej informacji znajdziesz w dokumentacji apksigner.

   Uwaga: aby używać narzędzia apksigner, musisz mieć zainstalowany pakiet Android SDK Build Tools w wersji 24.0.3 lub nowszej. Możesz zaktualizować ten pakiet za pomocą Menedżera pakietu SDK.

4. Sprawdź, czy plik APK jest podpisany:

   apksigner verify my-app-release.apk
   

Konfigurowanie Gradle do podpisywania aplikacji

Otwórz plik build.gradle.kts na poziomie modułu i dodaj blok signingConfigs {} z rekordami storeFile, storePassword, keyAlias i keyPassword, a następnie przekaż ten obiekt do właściwości signingConfig w typie kompilacji. Może to obejmować np. te funkcje:

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")
            ...
        }
    }
}

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
            ...
        }
    }
}

Gdy teraz skompilujesz aplikację, wywołując zadanie Gradle, Gradle podpisze ją za Ciebie (i uruchomi zipalign).

Ponieważ skompilowana wersja została skonfigurowana za pomocą klucza podpisywania, zadanie „instalacja” jest dostępne dla tego typu kompilacji. Dzięki zadaniu installRelease możesz skompilować, dopasować, podpisać i zainstalować wersję APK na urządzeniu lub w emulatorze.

Aplikacja podpisana Twoim kluczem prywatnym jest gotowa do dystrybucji, ale najpierw zapoznaj się z informacjami na temat publikowania aplikacji i sprawdź listę kontrolną przed opublikowaniem w Google Play.