Tworzenie aplikacji z poziomu wiersza poleceń

Wszystkie zadania kompilacji dostępne w projekcie aplikacji na Androida możesz wykonywać za pomocą narzędzia wiersza poleceń Gradle wrapper. Jest dostępny jako plik wsadowy dla systemu Windows (gradlew.bat) i skrypt powłoki dla systemów Linux i Mac (gradlew.sh). Można go otworzyć z poziomu katalogu głównego każdego projektu utworzonego w Android Studio.

Aby uruchomić zadanie za pomocą kodu, użyj jednego z tych poleceń w oknie terminala (w Android Studio wybierz Widok > Okna narzędzi > Terminal):

  • W powłoce poleceń systemu Windows:

    gradlew task-name
    
  • Na Macu, Linuksie lub w Windows PowerShell:

    ./gradlew task-name
    

Aby wyświetlić listę wszystkich dostępnych zadań kompilacji dla projektu, wykonaj polecenie tasks:

gradlew tasks

W dalszej części tej strony opisujemy podstawy tworzenia i uruchamiania aplikacji za pomocą Gradle wrappera. Więcej informacji o konfigurowaniu kompilacji na Androida znajdziesz w artykule o konfigurowaniu kompilacji.

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

Typy kompilacji

Domyślnie dla każdej aplikacji na Androida dostępne są 2 typy kompilacji: jedna do debugowania aplikacji (kompilacja do debugowania) i jedna do udostępniania aplikacji użytkownikom (kompilacja do publikacji). Zanim wdrożysz aplikację na urządzeniu, musisz podpisać certyfikatem dane wyjściowe każdej kompilacji. Kompilacja do debugowania jest automatycznie podpisywana kluczem debugowania dostarczonym przez narzędzia SDK (jest on niezabezpieczony i nie można go używać do publikowania w Sklepie Google Play), a kompilacja do publikacji musi być podpisana własnym kluczem prywatnym.

Jeśli chcesz skompilować aplikację do opublikowania, musisz ją też podpisać 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.kts i skonfigurować go tak, aby był podpisywany jako kompilacja do debugowania, dodając debuggable true. Więcej informacji znajdziesz w artykule o konfigurowaniu wariantów kompilacji.

Tworzenie i wdrażanie pakietu APK

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

Tworzenie pakietu APK do debugowania

Aby natychmiast przetestować i zdebugować aplikację, możesz utworzyć plik APK do debugowania. Plik APK do debugowania jest podpisany kluczem debugowania dostarczonym przez narzędzia SDK i umożliwia debugowanie za pomocą adb.

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

gradlew assembleDebug

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

Aby utworzyć plik APK i natychmiast zainstalować go na uruchomionym emulatorze lub połączonym urządzeniu, wywołaj installDebug:

gradlew installDebug

Część „Debug” w nazwach zadań to po prostu wersja nazwy wariantu kompilacji w formacie camelCase, więc można ją zastąpić dowolnym typem lub wariantem kompilacji, który chcesz utworzyć lub zainstalować. Jeśli na przykład masz wariant usługi „demo”, możesz utworzyć wersję do debugowania za pomocą zadania assembleDemoDebug.

Aby zobaczyć wszystkie zadania kompilacji i instalacji dostępne dla każdego wariantu (w tym zadania odinstalowywania), uruchom zadanie tasks.

Zobacz też sekcje dotyczące uruchamiania aplikacji w emulatorze i na urządzeniu.

Tworzenie pakietu lub pliku APK wersji

Gdy będziesz gotowy(-a) do opublikowania i rozpowszechniania aplikacji, musisz utworzyć pakiet wersji lub plik APK podpisany kluczem prywatnym. Więcej informacji znajdziesz w sekcji o podpisywaniu aplikacji z poziomu wiersza poleceń.

Wdrażanie aplikacji w emulatorze

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

Gdy masz już AVD, uruchom Android Emulator i zainstaluj aplikację w ten sposób:

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

    emulator -avd <var>avd_name</var>
    

    Jeśli nie masz pewności co do nazwy AVD, wykonaj polecenie emulator -list-avds.

  2. Teraz możesz zainstalować aplikację, korzystając z jednego z zadań instalacji Gradle wymienionych w sekcji dotyczącej tworzenia debugowanego pliku APK lub narzędzia adb.

    Jeśli plik APK został utworzony przy użyciu pakietu SDK w wersji przedpremierowej dla programistów (jeśli targetSdkVersion jest literą, a nie cyfrą), musisz dołączyć opcję -t do polecenia install, aby zainstalować testowy plik APK.

    adb install <var>path/to/your_app</var>.apk
    

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

Więcej informacji znajdziesz w artykule Uruchamianie aplikacji w Android Emulator.

Wdrażanie aplikacji na urządzeniu fizycznym

Zanim uruchomisz aplikację na urządzeniu, musisz włączyć na nim debugowanie USB. Tę opcję znajdziesz w sekcji Ustawienia > 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 dotyczącej tworzenia debugowanego pliku APK lub narzędzia adb:

adb -d install path/to/your_app.apk

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

Więcej informacji znajdziesz w artykule Uruchamianie aplikacji na urządzeniu.

Tworzenie pakietu aplikacji

Pakiety Android App Bundle zawierają cały skompilowany kod i wszystkie zasoby aplikacji, ale generowanie i podpisywanie plików APK jest odroczone do momentu przesłania do Google Play. W przeciwieństwie do pliku APK pakietu aplikacji nie można wdrożyć bezpośrednio na urządzeniu. Jeśli więc chcesz szybko przetestować lub udostępnić komuś plik APK, utwórz go.

Najłatwiejszym sposobem na utworzenie pakietu aplikacji jest użycie Android Studio. Jeśli jednak musisz utworzyć pakiet aplikacji z poziomu wiersza poleceń, możesz to zrobić za pomocą Gradle lub bundletool, jak opisano w sekcjach poniżej.

Tworzenie pakietu aplikacji za pomocą Gradle

Jeśli wolisz wygenerować pakiet aplikacji z wiersza poleceń, uruchom zadanie bundleVariant Gradle 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 informacje o podpisywaniu aplikacji. Więcej informacji znajdziesz w sekcji o konfigurowaniu Gradle do podpisywania aplikacji. Następnie możesz na przykład utworzyć wersję aplikacji do publikacji, a Gradle automatycznie wygeneruje pakiet aplikacji i podpisze go za pomocą informacji o podpisywaniu podanych w pliku build.gradle.kts.

Jeśli chcesz podpisać pakiet aplikacji w osobnym kroku, możesz użyć narzędzia jarsigner, aby podpisać pakiet aplikacji z poziomu wiersza poleceń. Polecenie do utworzenia pakietu aplikacji to:

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 Androida do Gradle 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 pakietów APK przez Google Play jest przydatne, zwykle nie trzeba wywoływać narzędzia bundletool, aby utworzyć sam pakiet aplikacji. Zamiast tego należy użyć Android Studio lub zadań Gradle, jak opisano w poprzednich sekcjach.

Jeśli jednak nie chcesz używać Android Studio ani zadań Gradle do tworzenia pakietów – na przykład jeśli używasz niestandardowego łańcucha narzędzi do kompilacji – możesz użyć bundletool w wierszu poleceń, aby utworzyć pakiet aplikacji ze wstępnie skompilowanego kodu i zasobów. Jeśli jeszcze nie masz pliku bundletool, pobierz go z repozytorium GitHub.

W tej sekcji opisujemy, jak spakować skompilowany kod i zasoby aplikacji oraz jak użyć narzędzia bundletool z poziomu wiersza poleceń, aby przekonwertować je na pakiet Android App Bundle.

Wygeneruj plik manifestu i zasoby w formacie proto

bundletool wymaga, aby pewne informacje o projekcie aplikacji, takie jak jej plik manifestu i zasoby, były w formacie bufora protokołu Google, który jest też nazywany „protobuf” i ma rozszerzenie pliku *.pb. Protobufs to niezależny od języka i platformy rozszerzalny mechanizm serializacji uporządkowanych danych. Jest podobny do XML, ale mniejszy, szybszy i prostszy.

Pobieranie AAPT2

Możesz wygenerować plik manifestu aplikacji i tabelę zasobów w formacie protobuf, używając najnowszej wersji AAPT2 z repozytorium Maven Google.

Aby pobrać AAPT2 z repozytorium Maven Google:

  1. W indeksie repozytorium przejdź do com.android.tools.build > aapt2.
  2. Skopiuj nazwę najnowszej wersji AAPT2.
  3. Wstaw skopiowaną nazwę wersji do tego adresu 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 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 – pobieranie AAPT2 powinno rozpocząć się wkrótce.

  5. Rozpakuj pobrany plik JAR.

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/

Podczas fazy łączenia, w której AAPT2 łączy różne skompilowane zasoby w jeden plik APK, poinstruuj AAPT2, aby przekonwertował plik manifestu aplikacji i skompilowane zasoby na format protobuf, dodając flagę --proto-format, jak w tym przykładzie:

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 pliku APK, np. pliki AndroidManifest.xml, resources.pb i inne pliki zasobów aplikacji – teraz w formacie protobuf. Te pliki są potrzebne podczas przygotowywania danych wejściowych, których bundletool wymaga do utworzenia pakietu aplikacji, jak opisano w następnej sekcji.

Pakowanie wstępnie skompilowanego kodu i zasobów

Zanim użyjesz narzędzia bundletool do wygenerowania pakietu aplikacji, musisz najpierw przesłać pliki ZIP, z których każdy zawiera skompilowany kod i zasoby danego modułu aplikacji. Zawartość i struktura pliku ZIP każdego modułu są bardzo podobne do formatu pakietu Android App Bundle. Na przykład utwórz plik base.zip dla modułu podstawowego 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 z co najmniej 1 skompilowanym plikiem DEX aplikacji. Pliki te powinny mieć nazwy: classes.dex, classes2.dex, classes3.dex itd.
res/... Zawiera zasoby modułu w formacie protobuf dla wszystkich konfiguracji urządzeń. Podkatalogi i pliki powinny być uporządkowane podobnie jak w przypadku typowego pliku APK.
root/..., assets/... i lib/... Te katalogi są identyczne z tymi opisanymi w sekcji dotyczącej formatu pakietu Android App Bundle.
resources.pb Tabela zasobów aplikacji w formacie protobuf.

Po przygotowaniu pliku ZIP dla każdego modułu aplikacji możesz przekazać je 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 w tym przykładzie:

bundletool build-bundle --modules=base.zip --output=mybundle.aab

W tabeli poniżej znajdziesz więcej informacji o flagach polecenia build-bundle:

Flaga Opis
--modules=path-to-base.zip, path-to-module2.zip,path-to-module3.zip Określa listę plików ZIP modułów, których bundletool ma używać do tworzenia pakietu aplikacji.
--output=path-to-output.aab Określa ścieżkę i nazwę pliku wyjściowego *.aab.
--config=path-to-BundleConfig.json Określa ścieżkę do opcjonalnego pliku konfiguracji, którego możesz użyć do dostosowania procesu kompilacji. Więcej informacji znajdziesz w sekcji dotyczącej dostosowywania generowania pakietów APK na dalszych etapach.
--metadata-file=target-bundle-path:local-file-path Instruuje bundletool, aby spakować opcjonalny plik metadanych w pakiecie aplikacji. Możesz użyć tego pliku, aby dołączyć dane, takie jak mapowania ProGuard lub pełną listę plików DEX aplikacji, które mogą być przydatne w innych krokach łańcucha narzędzi lub w sklepie z aplikacjami.

target-bundle-path określa ścieżkę względną do katalogu głównego pakietu aplikacji, w którym ma zostać umieszczony plik metadanych, a local-file-path określa ścieżkę do lokalnego pliku metadanych.

Dostosowywanie generowania plików APK na dalszych etapach

Pakiety aplikacji zawierają plik BundleConfig.pb, który dostarcza metadane wymagane przez sklepy z aplikacjami, takie jak Google Play, podczas 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 przekonwertuje i scali ten plik z wersją protobuf dołączoną do każdego pakietu aplikacji.

Możesz na przykład określić, które kategorie pakietów APK konfiguracji mają być włączone, a które wyłączone. Poniższy przykład pliku BundleConfig.json wyłącza pliki APK konfiguracji, z których każdy jest kierowany na inny język (czyli zasoby dla wszystkich języków są zawarte w odpowiednich podstawowych lub funkcjonalnych plikach APK):

{
  "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, używając wzorców glob w ten sposób:

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

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

Wdrażanie aplikacji z pakietu aplikacji

Jeśli masz już skompilowany i podpisany pakiet aplikacji, użyj narzędzia bundletool, aby wygenerować pliki APK i wdrożyć je na urządzeniu.

Podpisywanie aplikacji z poziomu wiersza poleceń

Do podpisania aplikacji nie potrzebujesz Android Studio. Możesz podpisać aplikację z wiersza poleceń, używając apksigner w przypadku plików APK lub jarsigner w przypadku pakietów aplikacji, albo skonfigurować Gradle, aby podpisywał ją podczas kompilacji. W obu przypadkach musisz najpierw wygenerować klucz prywatny za pomocą keytool, jak w tym przykładzie:

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 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 1 klucz,który jest ważny przez 10 000 dni.

Teraz możesz ręcznie podpisać pakiet APK lub pakiet aplikacji albo skonfigurować Gradle, aby podpisywał aplikację podczas procesu kompilacji, jak opisano w sekcjach poniżej.

Ręczne podpisywanie aplikacji z poziomu wiersza poleceń

Jeśli chcesz podpisać pakiet aplikacji z poziomu wiersza poleceń, możesz użyć narzędzia jarsigner. Jeśli chcesz podpisać pakiet APK, musisz użyć zipalign i apksigner:

  1. Otwórz wiersz poleceń – w Android Studio kliknij Widok > Okna narzędzi > Terminal – i przejdź do katalogu, w którym znajduje się niepodpisany plik APK.

  2. Wyrównaj niepodpisany plik APK za pomocą narzędzia zipalign:

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

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

  3. Podpisz plik APK kluczem prywatnym za pomocą narzędzia 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 wyprowadzany w my-app-release.apk po podpisaniu go kluczem prywatnym i certyfikatem, które są przechowywane w jednym pliku KeyStore: my-release-key.jks.

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

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

Dynamiczny

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 kompilujesz aplikację, wywołując zadanie Gradle, Gradle podpisuje aplikację (i uruchamia zipalign).

Dodatkowo, ponieważ kompilacja do publikacji została skonfigurowana z użyciem klucza podpisywania, zadanie „install” jest dostępne dla tego typu kompilacji. Dzięki temu możesz utworzyć, wyrównać, podpisać i zainstalować plik APK wersji w emulatorze lub na urządzeniu za pomocą zadania installRelease.

Aplikacja podpisana kluczem prywatnym jest gotowa do dystrybucji, ale najpierw dowiedz się więcej o publikowaniu aplikacji i zapoznaj się z listą kontrolną dotyczącą publikowania w Google Play.