Tworzenie aplikacji z poziomu wiersza poleceń

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:

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

2. 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 polecenia install, 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:

1. Przejdź do com.android.tools.build > aapt2 w indeksie repozytorium.
2. Skopiuj nazwę najnowszej wersji AAPT2.

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

4. Otwórz adres URL w przeglądarce – wkrótce powinno rozpocząć się pobieranie AAPT2.

5. 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:

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:

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.

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

2. 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ę.

3. 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 dokumentacji apksigner.

   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.

4. 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:

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

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.