Tworzenie aplikacji z poziomu wiersza poleceń

Wszystkie zadania kompilacji dostępne w Twoim projekcie Androida możesz wykonać za pomocą za pomocą narzędzia wiersza poleceń otoki Gradle. Jest dostępny jako plik wsadowy dla systemu Windows (gradlew.bat) i powłoki dla systemów Linux i Mac (gradlew.sh). w katalogu głównym każdego projektu tworzonego w Android Studio.

Aby uruchomić zadanie z kodem, użyj jednego z tych poleceń ze źródła Okno terminala (w Android Studio wybierz Widok > Okna narzędziowe > Terminal):

• W powłoce poleceń systemu Windows:

  gradlew task-name

• W systemie Mac, Linux lub Windows PowerShell:

  ./gradlew task-name

Aby wyświetlić listę wszystkich dostępnych zadań kompilacji dla Twój projekt, uruchom tasks:

gradlew tasks

W pozostałej części tej strony znajdziesz podstawowe informacje o tworzeniu i uruchamianiu aplikacji. za pomocą otoki Gradle. Więcej informacji o konfigurowaniu Kompilacja Androida, patrz Konfigurowanie i tworzenia.

Jeśli wolisz używać narzędzi Android Studio zamiast wiersza poleceń narzędzia dostępne w artykule Tworzenie i uruchamianie aplikacji.

Typy kompilacji

Domyślnie dla każdej aplikacji na Androida dostępne są 2 typy kompilacji: 1 do debugowania aplikacji (kompilacji do debugowania) i do publikowania aplikacji. dla użytkowników – kompilację wersji. Dane wyjściowe z każdego kompilacja musi być podpisana certyfikatem, zanim będzie można ją wdrożyć w urządzenia. Kompilacja do debugowania jest automatycznie podpisana za pomocą klucza debugowania podanego przez narzędzi pakietu SDK (nie jest on bezpieczny i nie można go używać do publikowania w Google Play, Store), a kompilacja wersji musi być podpisana Twoim kluczem prywatnym.

Jeśli chcesz utworzyć aplikację dla nowych użytkowników, podpisać aplikację odpowiednim kluczem podpisywania. Jeśli dopiero zaczynasz, możesz szybko uruchamiać aplikacje na za pomocą emulatora lub połączonego urządzenia, utwórz pakiet APK do debugowania.

Możesz też określić niestandardowy typ kompilacji w build.gradle.kts. i skonfiguruj go podpisać jako kompilację do debugowania, umieszczając w parametrze debuggable true Aby dowiedzieć się więcej, zobacz Konfigurowanie wariantów kompilacji.

Tworzenie i wdrażanie pakietu APK

Utworzenie pakietu aplikacji to najlepszy sposób spakuj aplikację i prześlij ją do Konsoli Play. Lepiej jest utworzyć plik APK. sprawdzi się, gdy chcesz szybko przetestować kompilację do debugowania lub udostępnić aplikację jako artefakt wdrażany w ramach innych rozwiązań.

Tworzenie pliku APK do debugowania

Aby przeprowadzić natychmiastowe testowanie i debugowanie aplikacji, możesz utworzyć pakiet APK do debugowania. Plik APK do debugowania jest podpisany kluczem debugowania dostarczonym przez narzędzia SDK. umożliwia debugowanie za pomocą narzędzia adb.

Aby utworzyć pakiet APK do debugowania, otwórz wiersz poleceń i przejdź do katalogu głównego katalogu projektu. Aby zainicjować kompilację do debugowania, wywołaj metodę 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 zgodny z zipalign, dzięki czemu możesz od razu zainstalować ją na urządzeniu.

Możesz też utworzyć pakiet APK i od razu zainstalować go w uruchomionym emulatorze. podłączone urządzenie, zamiast tego wywołaj installDebug:

gradlew installDebug

Pole „Debugowanie” jest częścią powyższych nazw zadań. w wersji na wielbłądach nazwy wersji kompilacji, którą można zastąpić dowolnym typem kompilacji lub wersji, którą chcesz zbudować lub zainstalować. Na przykład, jeśli masz „wersję demonstracyjną”, rodzaj produktu, możesz utworzyć wersję do debugowania za pomocą parametru assembleDemoDebug zadanie.

Aby zobaczyć wszystkie zadania kompilacji i instalacji dostępne w przypadku każdego wariantu (w tym odinstaluj zadania), 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

Gdy aplikacja jest gotowa do opublikowania i rozpowszechniania, musisz utworzyć opublikuj pakiet lub plik APK podpisany Twoim kluczem prywatnym. Aby dowiedzieć się więcej, przejdź do sekcji dotyczącej podpisywania aplikacji wiersza poleceń.

Wdrażanie aplikacji w emulatorze

Aby używać emulatora Androida, musisz utworzyć obiekt wirtualny Androida Urządzenie (AVD) korzystające z Android Studio.

Po zainstalowaniu programu AVD uruchom emulator Androida i zainstaluj aplikację w następujący sposób:

1. W wierszu poleceń przejdź do android_sdk/tools/ i uruchom emulator: określanie AVD:

   emulator -avd avd_name

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

2. Teraz możesz zainstalować aplikację, korzystając z jednego z zadań instalacyjnych Gradle wspomniane w sekcji dotyczącej tworzenia pakietu APK do debugowania. lub Narzędzie adb.

   Jeśli plik APK został utworzony z wykorzystaniem pakietu SDK w wersji deweloperskiej (jeśli targetSdkVersion to litery zamiast cyfry), musisz dodać Opcja -t za pomocą polecenia install, by zainstalować testowy pakiet APK.

   adb install path/to/your_app.apk
   

   Wszystkie utworzone pakiety APK są zapisywane 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 uruchomić aplikację na urządzeniu, musisz włączyć USB na urządzeniu. Znajdziesz ją w sekcji Ustawienia > Opcje programisty.

Uwaga: na Androidzie 4.2 i nowszych Opcje programisty są domyślnie ukryte. Aby ją udostępnić, wybierz Ustawienia > Informacje o telefonie i kliknij Utwórz siedem razy. Wróć na poprzedni ekran, aby znaleźć Opcje programisty.

Gdy urządzenie zostanie skonfigurowane i połączone przez USB, będzie można zainstalować aplikację przy użyciu wspomnianych zadań instalacji Gradle w sekcji dotyczącej tworzenia pakietu APK do debugowania lub Narzędzie adb:

adb -d install path/to/your_app.apk

Wszystkie utworzone pakiety APK są zapisywane project_name/module_name/build/outputs/apk/

Więcej informacji: Uruchamianie aplikacji na urządzeniu

Utwórz pakiet aplikacji

Pakiety Android App Bundle zawierają wszystkie skompilować kod i zasoby, ale opóźnić wygenerowanie i podpisanie pliku APK do Google. Graj. W przeciwieństwie do plików APK nie można wdrożyć pakietu aplikacji bezpośrednio na urządzeniu. Jeśli chcesz szybko przetestować lub udostępnić komuś pakiet APK, W przeciwnym razie utwórz pakiet APK.

Najłatwiejszym sposobem utworzenia pakietu aplikacji jest w Android Studio. Jeśli jednak musisz utworzyć pakietu aplikacji z wiersza poleceń, możesz użyć Gradle lub bundletool.

Tworzenie pakietu aplikacji za pomocą Gradle

Jeśli wolisz wygenerować pakiet aplikacji z poziomu wiersza poleceń, bundleVariant zadanie Gradle w podstawowym module aplikacji. Na przykład to polecenie tworzy pakiet aplikacji na potrzeby wersji do debugowania modułu podstawowego.

./gradlew :base:bundleDebug

Jeśli chcesz utworzyć podpisany pakiet do przesłania do Konsoli Play, aby najpierw skonfigurować plik build.gradle.kts modułu podstawowego przy użyciu pakietu podpisywanie danych. Więcej informacji znajdziesz w sekcji Skonfiguruj Gradle, aby podpisać aplikację. Następnie możesz na przykład utworzyć wersję premierową aplikacji i utworzyć Gradle automatycznie generuje pakiet aplikacji i podpisuje go podane w pliku build.gradle.kts.

Jeśli zamiast tego chcesz podpisać pakiet aplikacji w ramach osobnego kroku, możesz użyć jarsigner aby podpisać pakiet aplikacji z poziomu wiersza poleceń. Polecenie do utworzenia aplikacji pakiet to:

jarsigner -keystore pathToKeystore app-release.aab keyAlias

Tworzenie pakietu aplikacji za pomocą narzędzia bundletool

bundletool to narzędzie wiersza poleceń dostępne w Android Studio, czyli Android Gradle. i Google Play do konwertowania skompilowanego kodu aplikacji zasobów w pakiety aplikacji i wygenerować z nich pliki APK, które można wdrożyć.

Mimo że przydaje się to przetestuj pakiety aplikacji za pomocą bundletool i odtwórz je lokalnie jak Google Play generuje pliki APK, zwykle nie musisz wywołaj bundletool, by utworzyć własny pakiet aplikacji – zamiast tego używać zadań Android Studio lub Gradle zgodnie z opisem w poprzednich sekcjach.

Jeśli jednak nie chcesz używać zadań w Android Studio lub Gradle do tworzenia w pakietach (na przykład jeśli używasz niestandardowego łańcucha narzędzi do kompilacji), możesz za pomocą narzędzia bundletool w wierszu poleceń, by utworzyć pakiet aplikacji na podstawie wstępnie skompilowanego kodu i zasobami Google Cloud. Jeśli nie zostało to jeszcze zrobione, pobierz bundletool z repozytorium GitHub.

W tej sekcji dowiesz się, jak spakować skompilowany kod i zasoby aplikacji i jak używać w wierszu poleceń narzędzia bundletool do ich konwertowania na 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, Format bufora protokołów Google, który jest również nazywany „protobufem”. i ma rozszerzenie *.pb. Protobufsy pozwolą Ci opracować mechanizm neutralny dla języka i platformy, który będzie można rozszerzać; do serializacji uporządkowanych danych – jest podobna do XML, ale mniejsza, szybsza i prostsza.

Pobierz AAPT2

Plik manifestu i tabelę zasobów aplikacji możesz wygenerować tutaj: przy użyciu najnowszej wersji AAPT2 z Repozytorium Google Maven.

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

1. Otwórz com.android.tools.build > aapt2 w indeksie repozytorium.
2. Skopiuj nazwę najnowszej wersji AAPT2.

3. Wstaw skopiowaną nazwę wersji do poniższego 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 dla systemu Windows, użyjesz: 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 pliku AAPT2 powinno wkrótce się rozpocząć.

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 tworzenia linków, w którym AAPT2 łączy różne skompilowane zasoby w pojedynczy plik APK, instruuj AAPT2, aby przekonwertował plik manifestu aplikacji i skompilowane zasoby do formatu protobuf, dodając flagę --proto-format w ten sposób:

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. plik AndroidManifest.xml, resources.pb i inne pliki zasobów – teraz w formacie protokołu. Te pliki są potrzebne podczas przygotowywania danych wejściowych bundletool wymaga utworzenia pakietu aplikacji w sposób opisany w tym artykule .

Wstępnie skompilowany kod i zasoby w pakiecie

Zanim wygenerujesz pakiet aplikacji za pomocą narzędzia bundletool, musisz najpierw udostępnij pliki ZIP, w których każdy zawiera skompilowany kod i zasoby dla danego modułu aplikacji. Zawartość i układ plików ZIP każdego modułu są podobnie jak w formacie Android App Bundle. Na przykład należy utworzyć plik base.zip dla modułu podstawowego aplikacji i uporządkuj jego zawartość w taki sposób:

Po przygotowaniu pliku ZIP dla każdego modułu aplikacji możesz je przekazać do bundletool, aby utworzyć pakiet aplikacji w sposób opisany w sekcji poniżej.

Utwórz pakiet aplikacji za pomocą narzędzia bundletool

Aby utworzyć pakiet aplikacji, użyj polecenia bundletool build-bundle – poniżej:

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

W tabeli poniżej opisujemy flagi polecenia build-bundle w bardziej szczegóły:

Dostosuj generowanie kolejnych plików APK

Pakiety aplikacji zawierają plik BundleConfig.pb, który dostarcza metadane, sklepów, takich jak Google Play, są wymagane podczas generowania plików APK z pakietu. bundletool tworzy ten plik za Ciebie, ale możesz skonfigurować niektóre aspekty metadanych w pliku BundleConfig.json i przekazać do funkcji Polecenie bundletool build-bundle – bundletool później konwertuje i scala tę wartość z wersją protokołu dołączonego do każdego pakietu aplikacji.

Możesz na przykład określić, które kategorie plików APK konfiguracji włączyć lub wyłączyć. Poniższy przykład pliku BundleConfig.json wyłącza konfiguracyjne pliki APK, z których każdy jest kierowany na inny język (tzn. zasoby dla wszystkich języków są dołączone do odpowiednich baz lub pakiety APK funkcji):

{
  "optimizations": {
    "splitsConfig": {
      "splitDimension": [{
        "value": "LANGUAGE",
        "negate": true
      }]
    }
  }
}

W pliku BundleConfig.json możesz też określić, które typy plików pozostawisz bez zmian. nieskompresowane podczas pakowania plików APK za pomocą wzorców glob:

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

Pamiętaj, że domyślnie bundletool nie kompresuje kodu natywnego aplikacji biblioteki (na Androidzie 6.0 lub nowszym) i zasobach tabela (resources.arsc). Pełny opis elementów, które możesz skonfigurować BundleConfig.json, sprawdź bundletool config.proto , które jest napisane w języku Proto3. składni.

Wdrażanie aplikacji z poziomu pakietu aplikacji

Jeśli masz utworzony i podpisany pakiet aplikacji, Użyj usługi bundletool, aby wygenerować pliki APK i wdrożyć je w urządzenia.

Podpisywanie aplikacji z poziomu wiersza poleceń

Do podpisania aplikacji nie potrzebujesz Androida Studio. Aplikację możesz podpisać tutaj: w wierszu poleceń, używając apksigner w przypadku plików APK lub jarsigner w przypadku pakietów aplikacji, lub skonfigurować Gradle tak, aby podpisywała je za Ciebie podczas kompilacji. Tak czy inaczej, najpierw wygeneruj klucz prywatny za pomocą keytool jak poniżej:

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

W przykładzie powyżej musisz podać hasła do magazynu kluczy i klucza oraz „Nazwa wyróżniająca” na klucz. Następnie generuje jako plik o nazwie my-release-key.jks, zapisując go w bieżący katalog (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 do podpisywania aplikacji podczas kompilacji, jak opisano w sekcjach poniżej.

Podpisywanie aplikacji ręcznie z poziomu wiersza poleceń

Jeśli chcesz podpisać pakiet aplikacji za pomocą wiersza poleceń, możesz jarsigner Jeśli zamiast tego chcesz podpisać plik APK, musisz użyć plików zipalign i apksigner. jak opisano poniżej.

1. Otwórz wiersz poleceń – w Android Studio kliknij Widok > Okna narzędziowe > terminala – i przejdź do katalogu, w którym znajduje się niepodpisany plik APK. z siedzibą firmy.

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

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

   zipalign zapewnia, że wszystkie nieskompresowane dane zaczynają się od konkretne wyrównanie bajtów względem początku pliku, co może zmniejsz ilość pamięci RAM zużywaną 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
   

   Ten przykład wysyła podpisany pakiet APK pod adresem my-app-release.apk po podpisaniu go kluczem prywatnym i certyfikatem przechowywanym w pojedynczy plik KeyStore: my-release-key.jks.

   Narzędzie apksigner obsługuje inne opcje podpisywania, w tym podpisze plik APK przy użyciu osobnych plików klucza prywatnego i certyfikatu oraz podpisać plik APK przez wiele osób. Więcej informacji: apksigner odwołania.

   Uwaga: aby użyć narzędzia apksigner, musisz mieć zainstalowaną aplikację 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 do podpisania aplikacji

Otwórz plik build.gradle.kts na poziomie modułu i dodaj atrybut Blok signingConfigs {} z wpisami dla storeFile, storePassword, keyAlias i keyPassword, a następnie przekaż ten obiekt do funkcji signingConfig. 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
            ...
        }
    }
}

Jeśli tworzysz aplikację wywołując zadanie Gradle, Gradle podpisuje aplikację (i uruchamia polecenie zipalign).

Ponieważ kompilacja wersji została skonfigurowana za pomocą Twojego klucza podpisywania, „Zainstaluj” jest dostępne dla tego typu kompilacji. Możesz tworzyć, dostosowywać i zainstalować w emulatorze lub na urządzeniu plik APK wersji z installRelease zadanie.

Aplikacja podpisana Twoim kluczem prywatnym jest gotowa do dystrybucji, ale warto przeczytaj najpierw o tym, jak publikować treści aplikację i zapoznaj się z listą kontrolną wprowadzenia na rynek w Google Play.