Co to jest Gradle w Android Studio?

Gradle jest dla mnie trochę mylący, a także dla każdego nowego programisty Androida. Czy ktoś może wyjaśnić, czym jest Gradle w Android Studio i do czego służy? Dlaczego jest zawarty w Android Studio?

Krótka odpowiedź

Gradle to system kompilacji.

Długa odpowiedź

Przed Android Studio korzystałeś z Eclipse do celów programistycznych i, prawdopodobnie nie wiesz, jak zbudować APK dla Androida bez Eclipse.

Możesz to zrobić w wierszu polecenia, ale musisz nauczyć się, co każde narzędzie (dx, aapt) robi w zestawie SDK. Eclipse uratowało nas wszystkich przed tymi niskimi poziomami, ale ważnymi, fundamentalnymi szczegółami, dając nam własny system kompilacji.

Czy zastanawiałeś się kiedyś, dlaczego resfolder znajduje się w tym samym katalogu, co srcfolder?

W tym miejscu pojawia się system kompilacji. System kompilacji automatycznie pobiera wszystkie pliki źródłowe ( .javalub .xml), a następnie stosuje odpowiednie narzędzie (np. Pobiera javapliki klas i konwertuje je na dexpliki) i grupuje je wszystkie w jeden skompresowany plik, nasz ukochany APK.

Ten system kompilacji wykorzystuje pewne konwencje: przykładem może być określenie katalogu zawierającego pliki źródłowe (w Eclipse jest to \srcfolder) lub pliki zasobów (w Eclipse jest to \resfolder).

Teraz, aby zautomatyzować wszystkie te zadania, musi istnieć skrypt; możesz napisać własny system kompilacji za pomocą skryptów powłoki w systemie Linux lub składni plików wsadowych w systemie Windows. Rozumiem?

Gradle to kolejny system kompilacji, który bierze najlepsze funkcje z innych systemów kompilacji i łączy je w jeden. Jest poprawiony w oparciu o ich niedociągnięcia. Jest to system kompilacji oparty na JVM , co oznacza, że ​​możesz pisać własny skrypt w Javie, z którego korzysta Android Studio.

Jedną fajną rzeczą w gradle jest to, że jest to system oparty na wtyczkach . Oznacza to, że jeśli masz swój własny język programowania i chcesz zautomatyzować zadanie zbudowania jakiegoś pakietu (wyjście takie jak JAR dla Javy) ze źródeł, możesz napisać kompletną wtyczkę w Javie lub Groovy (lub Kotlin, patrz tutaj ) i dystrybuuj to do reszty świata.

Dlaczego Google go użył?

Google zobaczył jeden z najbardziej zaawansowanych systemów kompilacji na rynku i zdał sobie sprawę, że możesz pisać własne skrypty z niewielką lub zerową krzywą uczenia się i bez nauki Groovy lub jakiegokolwiek innego nowego języka. Napisali więc wtyczkę do systemu Android dla Gradle.

Musisz zobaczyć build.gradlepliki w swoim projekcie. W tym miejscu możesz pisać skrypty automatyzujące zadania. Kod, który widziałeś w tych plikach, to kod Groovy. Jeśli napiszesz System.out.println("Hello Gradle!");, wydrukuje się na konsoli.

Co możesz zrobić w skrypcie kompilacji?

Prostym przykładem jest to, że musisz skopiować niektóre pliki z jednego katalogu do drugiego przed faktycznym procesem kompilacji. Skrypt kompilacji Gradle może to zrobić.

To nowe narzędzie do budowania, którego Google chce używać na Androida. Jest używany, ponieważ jest bardziej rozszerzalny i użyteczny niż mrówka. Ma to na celu poprawę doświadczenia programistów.

Można zobaczyć rozmowę Xavier Ducrohet z Zespołu Android Developer na Google I / O tutaj.

W Xavier i Tor Norbye odbyła się kolejna rozmowa na temat Android Studio, również podczas Google I / O tutaj .

Gradle to system kompilacji działający w systemie Android Studio .

Na przykład w innych językach:

• Ant and Maven of Java
• Rake of Ruby
• AAP z C.
• NAnt z .NET
• Twórz w systemie Linux

Oto szczegółowe wyjaśnienie, co to Gradlejest i jak go używać w Android Studio.

Eksplorowanie plików Gradle

1. Za każdym razem, gdy tworzysz projekt w Android Studio, system kompilacji automatycznie generuje wszystkie niezbędne pliki kompilacji Gradle.

Pliki kompilacji stopniowej

2. Pliki kompilacji Gradle używają a Domain Specific Language or DSLdo definiowania niestandardowej logiki kompilacji i interakcji z specyficznymi dla Androida elementami wtyczki Android dla Gradle.

3. Projekty Android Studio składają się z jednego lub więcej modułów, które są komponentami, które można budować, testować i debugować niezależnie. Każdy moduł ma własny plik kompilacji, więc każdy projekt Android Studio zawiera 2 rodzaje plików kompilacji Gradle.

4. Plik kompilacji najwyższego poziomu: w tym miejscu znajdują się opcje konfiguracji wspólne dla wszystkich modułów tworzących projekt.

5. Plik kompilacji na poziomie modułu : Każdy moduł ma własny plik kompilacji Gradle, który zawiera ustawienia kompilacji specyficzne dla modułu. Większość czasu spędzasz na edytowaniu plików kompilacji na poziomie modułu zamiast pliku kompilacji na najwyższym poziomie projektu.

Aby przejrzeć te build.gradlepliki, otwórz panel Projekt w Android Studio (wybierając kartę Projekt) i rozwiń folder Gradle Scripts. Pierwsze dwa elementy w folderze Skrypty Gradle to pliki kompilacji Gradle na poziomie projektu i modułu

Plik kompilacji gradientu najwyższego poziomu

Każdy projekt Android Studio zawiera jeden plik kompilacji Gradle najwyższego poziomu. Ten build.gradleplik jest pierwszym elementem, który pojawia się w folderze Gradle Scripts i jest wyraźnie oznaczony jako Projekt.

Przez większość czasu nie musisz wprowadzać żadnych zmian w tym pliku, ale nadal warto poznać jego zawartość i rolę, jaką odgrywa on w twoim projekcie.

Pliki kompilacji stopni na poziomie modułu

Oprócz pliku kompilacji Gradle na poziomie projektu, każdy moduł ma własny plik kompilacji Gradle. Poniżej znajduje się adnotowana wersja podstawowego pliku kompilacji Gradle na poziomie modułu.

Inne pliki stopniowania

Oprócz plików build.gradle twój folder Gradle Scripts zawiera także inne pliki Gradle. Przez większość czasu nie będziesz musiał ręcznie edytować tych plików, ponieważ będą one aktualizowane automatycznie po wprowadzeniu odpowiednich zmian w projekcie. Warto jednak zrozumieć rolę, jaką odgrywają te pliki w projekcie.

gradle-wrapper.properties (wersja Gradle)

Ten plik umożliwia innym osobom budowanie twojego kodu, nawet jeśli nie mają zainstalowanego Gradle na swoim komputerze. Ten plik sprawdza, czy zainstalowana jest prawidłowa wersja Gradle iw razie potrzeby pobiera niezbędną wersję.

settings.gradle

Ten plik odwołuje się do wszystkich modułów tworzących projekt.

gradle.properties (właściwości projektu)

Ten plik zawiera informacje o konfiguracji dla całego projektu. Domyślnie jest pusta, ale możesz zastosować do projektu szeroki zakres właściwości, dodając je do tego pliku.

local.properties (lokalizacja zestawu SDK)

Ten plik informuje wtyczkę Android Gradle, gdzie może znaleźć instalację zestawu Android SDK.

Uwaga: local.properties zawiera informacje specyficzne dla lokalnej instalacji zestawu Android SDK. Oznacza to, że nie powinieneś trzymać tego pliku pod kontrolą źródła.

Sugerowana lektura - samouczek Tutsplus

Z tego jasno zrozumiałem stopień.

Gradle to jeden rodzaj narzędzia do kompilacji, które buduje kod źródłowy programu. Jest to więc ważna część Androida Studio i musi zostać zainstalowana przed rozpoczęciem tworzenia aplikacji.

Nie musimy instalować go osobno, ponieważ Android Studio robi to za nas, kiedy wykonujemy nasz pierwszy projekt.

DEFINICJA :: Gradle można opisać zorganizowany mechanizm budynku, w którym dostarcza programiście narzędzia i elastyczność w zarządzaniu zasobami projektu stworzenia buduje się smaller in size, targeting specific requirementsna niektórych urządzeniach niektórych konfiguracjach

PODSTAWOWE KONFIGURACJE

1. minimumSdk
2. maximumSdk
3. targettedSdk
4. versionCode
5. versionName

BIBLIOTEKI :: Możemy dodatkowo dodawać biblioteki Androida lub inne biblioteki stron trzecich zgodnie z wymaganiami łatwymi, co wcześniej było uciążliwym zadaniem. Jeśli biblioteka nie pasuje do istniejącego projektu, programista wyświetla dziennik, w którym osoba może znaleźć odpowiednie rozwiązanie, aby wprowadzić zmiany w projekcie, aby można było dodać bibliotekę. To tylko jedna linia zależności

WYTWARZANIE ODMIAN BUDYNKÓW

Łączenie typów kompilacji ze smakami kompilacji, aby uzyskać różne warianty kompilacji

 ====================                         ====================
|     BuildTypes     |                       |   ProductFlavours  |
 --------------------  ====================== --------------------
|  Debug,Production  |      ||       ||      | Paid,Free,Demo,Mock|
 ====================       ||       ||       ==================== 
                            ||       ||
                            VV       VV
 =================================================================
|           DebugPaid, DebugFree, DebugDemo, DebugMock            |
|  ProductionPaid, ProductionFree, ProductionDemo, ProductionMock |
 =================================================================

ZMNIEJSZANIE ROZMIARU

Gradle pomaga zmniejszyć rozmiar generowanej kompilacji, usuwając nieużywane zasoby, a także nieużywane rzeczy ze zintegrowanych bibliotek

ZARZĄDZANIE POZWOLENIAMI

Możemy określić określone uprawnienia dla niektórych kompilacji, dodając określone uprawnienia w niektórych scenariuszach na podstawie wymagań

BUDYNKI NIEKTÓRYCH URZĄDZEŃ

Możemy zarządzać generowaniem kompilacji dla niektórych urządzeń, które zawierają pewne gęstości i pewne poziomy API. Pomaga to we wdrożeniach produktów w sklepie z aplikacjami zgodnie z wymaganiami na wielu typach urządzeń

DOBRA REFERENCJA

Poradniki Vogella

Tutaj znajdziesz wszystko, co musisz wiedzieć o Gradle: Podręcznik użytkownika wtyczki Gradle

Cele nowego systemu kompilacji

Cele nowego systemu kompilacji to:

• Ułatw ponowne użycie kodu i zasobów
• Ułatw tworzenie kilku wariantów aplikacji, zarówno do dystrybucji w wielu aplikacjach, jak i do różnych smaków aplikacji
• Ułatw konfigurację, rozszerzenie i dostosowanie procesu kompilacji
• Dobra integracja IDE

Dlaczego Gradle

Gradle to zaawansowany system kompilacji, a także zaawansowany zestaw narzędzi kompilacji umożliwiający tworzenie niestandardowej logiki kompilacji za pomocą wtyczek.

Oto niektóre z jego funkcji, które skłoniły nas do wyboru Gradle:

• DSL (Domain Specific Language) do opisywania i manipulowania logiką kompilacji
• Pliki kompilacji są oparte na Groovy i umożliwiają mieszanie elementów deklaratywnych przez DSL i używanie kodu do manipulowania elementami DSL w celu zapewnienia niestandardowej logiki.
• Wbudowane zarządzanie zależnościami za pośrednictwem Maven i / lub Ivy.
• Bardzo elastyczny. Pozwala na stosowanie najlepszych praktyk, ale nie narzuca własnego sposobu robienia rzeczy.
• Wtyczki mogą udostępniać własne DSL i własne API do użycia z kompilacjami.
• Dobry interfejs API do narzędzi umożliwiający integrację IDE

Odnoszę dwa samouczki, aby napisać Odpowiedź jeden , dwa

Gradle to deklaratywne narzędzie do budowania ogólnego przeznaczenia. Jest to cel ogólny, ponieważ można go użyć do zbudowania praktycznie wszystkiego, co chcesz zaimplementować w skrypcie kompilacji. Jest to deklaratywne, ponieważ nie chcesz widzieć dużej ilości kodu w pliku kompilacji, który jest nieczytelny i mniej konserwowalny. Tak więc, podczas gdy Gradle zapewnia ideę konwencji oraz prostą i deklaratywną kompilację, umożliwia także dostosowanie narzędzia, a programistom - możliwość rozszerzenia. Zapewnia również łatwy sposób dostosowania domyślnego zachowania i różnych zaczepów w celu dodania funkcji innych firm.

Gradle łączy dobre części obu narzędzi i zapewnia dodatkowe funkcje oraz używa Groovy jako DSL (Domain Specific Language). Ma moc i elastyczność narzędzia Ant z funkcjami Maven, takimi jak cykl życia kompilacji i łatwość użycia.

Dlaczego Gradle Dlaczego teraz?

Odpowiedzią narzędzia do budowania jest dodanie funkcji skryptowej za pomocą niestandardowych mechanizmów rozszerzeń. Kończysz mieszanie kodu skryptowego z XML lub wywoływanie zewnętrznych skryptów z logiki kompilacji. Łatwo sobie wyobrazić, że z czasem trzeba będzie dodawać coraz więcej niestandardowych kodów. W rezultacie nieuchronnie wprowadzisz przypadkową złożoność, a łatwość konserwacji zniknie za oknem.

Powiedzmy, że chcesz skopiować plik do określonej lokalizacji podczas budowania wersji projektu. Aby zidentyfikować wersję, sprawdzasz ciąg w metadanych opisujących Twój projekt. Jeśli pasuje do określonego schematu numeracji (na przykład 1.0-RELEASE), skopiujesz plik z punktu A do punktu B. Z perspektywy zewnętrznej może to brzmieć jak trywialne zadanie. Jeśli musisz polegać na XML, język kompilacji wielu tradycyjnych narzędzi, wyrażanie tej prostej logiki staje się dość trudne.

Ewolucja narzędzi do budowania Java

Logikę kompilacji Java należy opisać w XML. XML świetnie nadaje się do opisywania danych hierarchicznych, ale brakuje mu do wyrażenia przebiegu programu i logiki warunkowej. Gdy skrypt kompilacji staje się coraz bardziej złożony, utrzymanie kodu budynku staje się koszmarem.

W Ant można uzależnić cel JAR od celu kompilacji. Ant nie udziela żadnych wskazówek na temat struktury projektu. Chociaż zapewnia maksymalną elastyczność, Ant sprawia, że ​​każdy skrypt kompilacji jest unikalny i trudny do zrozumienia. Biblioteki zewnętrzne wymagane przez projekt są zwykle sprawdzane pod kątem kontroli wersji, ponieważ nie ma zautomatyzowanego mechanizmu wyciągania ich z centralnej lokalizacji.

Wydany w lipcu 2004 r. Maven 1 próbował ułatwić ten proces. Zapewnił znormalizowaną strukturę projektu i katalogu, a także zarządzanie zależnościami. Niestety niestandardowa logika jest trudna do wdrożenia

Gradle pasuje do tej generacji narzędzi do budowania i spełnia wiele wymagań współczesnych narzędzi do budowania (rysunek 1). Zapewnia ekspresyjny DSL, konwencję dotyczącą konfiguracji i potężne zarządzanie zależnościami. To właściwy krok do porzucenia XML i wprowadzenia dynamicznego języka Groovy do zdefiniowania logiki kompilacji. Brzmi zachęcająco, prawda?

Gradle łączy najlepsze cechy innych narzędzi do budowania.

Niezwykły zestaw funkcji Gradle'a

Dlaczego warto budować projekty Java za pomocą Gradle zamiast Ant lub Maven?

Domyślne narzędzie do budowania dla Androida (i nowa gwiazda narzędzi do budowania w JVM) zostało zaprojektowane w celu ułatwienia pisania skryptów złożonych, wielojęzycznych kompilacji. Czy jednak powinieneś to zmienić, jeśli używasz Anta lub Mavena?

Kluczem do odblokowania funkcji mocy Gradla w skrypcie kompilacji jest odkrycie i zastosowanie modelu domeny, jak pokazano na poniższym obrazku.

Gradle nie zna wszystkich wymagań specyficznych dla twojej kompilacji. Udostępniając haki w fazach cyklu życia, Gradle pozwala monitorować i konfigurować zachowanie wykonawcze skryptu kompilacji.

Gradle ustanawia słownictwo dla swojego modelu, ujawniając DSL zaimplementowany w Groovy. W przypadku złożonej domeny problemowej, w tym przypadku, zadanie tworzenia oprogramowania, możliwość użycia wspólnego języka do wyrażenia logiki może być potężnym narzędziem.

Innym przykładem jest sposób wyrażania zależności w bibliotekach zewnętrznych, bardzo częsty problem rozwiązywany przez narzędzia do budowania. Gotowy do użycia Gradle udostępnia dwa bloki konfiguracji dla skryptu kompilacji, które pozwalają zdefiniować zależności i repozytoria, z których chcesz je odzyskać. Jeśli standardowe elementy DSL nie pasują do twoich potrzeb, możesz nawet wprowadzić własne słownictwo za pomocą mechanizmu rozszerzenia Gradle.

Integracja z innymi narzędziami do budowania

Gradle dobrze gra z Antem, Mavenem i Bluszczem swoich poprzedników, jak pokazano na poniższym obrazku.

Automatyzacja projektu od kompilacji do wdrożenia

Na obrazie: etapy potoku wdrażania.

• Kompilowanie kodu

• Uruchamianie testów jednostkowych i integracyjnych

• Przeprowadzanie analizy kodu statycznego i generowanie pokrycia testowego

• Tworzenie dystrybucji

• Zaopatrywanie środowiska docelowego

• Wdrażanie rezultatu

• Wykonywanie dymu i zautomatyzowane testy funkcjonalne

Odnoszę dwa samouczki, aby napisać Odpowiedź jeden , dwa

Gradle to system kompilacji . Systemy kompilacji to narzędzia programowe zaprojektowane do automatyzacji procesu kompilacji programów. Systemy kompilacji mają różne formy i są używane do różnych zadań kompilacji oprogramowania. Podczas gdy ich głównym celem jest wydajne tworzenie plików wykonywalnych.

Innym powiązanym terminem jest automatyzacja kompilacji, czyli proces automatyzacji tworzenia kompilacji oprogramowania i powiązanych procesów, w tym: kompilowanie kodu źródłowego komputera w kod binarny, pakowanie kodu binarnego i przeprowadzanie automatycznych testów.

Kilka podobnych systemów kompilacji dla innych języków to (patrz pełna lista tutaj ):

1. Apache Ant & Apache Maven - Java
2. sbt (Simple Build Tool) - dla Scali (frameworka Play itp.)
3. AAP - narzędzie do budowania oparte na języku Python
4. Rake (Apache Builder) - Ruby
5. Leiningen dla Clojure

Ryzykując dyskursywność, myślę, że kryje się za tym pytanie, dlaczego Android Studio / Gradle jest tak zły.

Typowe doświadczenie Clojure:

• pobierz projekt z zależnościami wymienionymi w project.clj.
• Leiningen dostaje zależności dzięki Clojars i Maven.
• Projekt się kompiluje.

Typowe doświadczenie Android Studio / Gradle:

• „Zaimportuj mój projekt Eclipse”.
• Projekt OK został zaimportowany.
• Gradle robi to ... czekaj ... czekaj ... czekaj ... Gradle skończył.
• Kompiluj ... nie mogę skompilować, ponieważ nie wiem, co to jest X / nie mogę znaleźć biblioteki Y.

Nie jestem pewien, czy to dokładnie wina Gradle'a. Ale „import z projektu Eclipse” wydaje się dość niestabilny. Pomimo wszystkich rzekomych wyrafinowań i zalet systemu kompilacji Gradle, Android Studio po prostu nie wydaje się dobrze importować zależności kompilacji lub procesu kompilacji z Eclipse.

Nie informuje, kiedy nie udało się zaimportować pełnego wykresu zależności. Android Studio nie zawiera żadnej przydatnej pomocy ani wskazówek, jak rozwiązać problem. Nie mówi ci, gdzie możesz ręcznie szukać w folderach Eclipse. Nie mówi ci, której biblioteki brakuje. Lub pomóż im wyszukać Maven itp.

W 2016 r. Rzeczy takie jak Leiningen / Clojars, npm węzła, pip Pythona lub apkg Debiana (i jestem pewien, że wiele podobnych menedżerów pakietów dla innych języków i systemów) wszystko działa pięknie ... brakujące zależności należą już do przeszłości.

Z wyjątkiem Androida. Android Studio jest teraz jedynym miejscem, w którym wciąż wydaje mi się, że doświadczam piekła polegającego na braku zależności.

Skłaniam się do stwierdzenia, że ​​to wina Google. Złamali ekosystem Androida (i tysiące istniejących projektów / samouczków online na Androida), gdy kawalersko postanowili przejść z Eclipse na Android Studio / Gradle bez solidnego procesu konwersji. Ludzie, których projekty działają w środowisku Eclipse, nie dostosowują ich do AS (przypuszczalnie dlatego, że jest to dla nich uciążliwe). A ludzie próbujący korzystać z tych projektów w AS mają te same problemy.

W każdym razie, jeśli Gradle jest tym super-potężnym systemem kompilacji, dlaczego nadal zarządzam wieloma innymi zależnościami w menedżerze SDK? Dlaczego projekt, który potrzebuje, powiedzmy, ndk nie może tego określić w swoim pliku Gradle, aby był automatycznie instalowany i wbudowywany w razie potrzeby? Dlaczego NDK jest wyjątkowy? Podobnie w przypadku platform docelowych? Dlaczego instaluję je jawnie w IDE, a nie tylko sprawdzam mój projekt względem nich i mam wszystko posortowane za kulisami?

Gradle jest zaawansowanym systemem kompilacji, a także zaawansowanym zestawem narzędzi kompilacji umożliwiającym tworzenie niestandardowej logiki kompilacji za pomocą wtyczek!

Zalety:

• Dsl - język specyficzny dla domeny, oparty na groovy
• DAG - Directed Acyclic Graph
• Kompilacje przyrostowe
• Rozszerzalny model domeny
• Gradle jest zawsze aktualny
• Przed uruchomieniem zadania Gradle robi migawkę danych wejściowych i wyjściowych zadania.
• W przypadku zmiany migawki lub jej braku, Gralde ponownie wykona to zadanie.

Wpisy manifestowe

Za pomocą DSL można skonfigurować następujące wpisy manifestu:

Wariant budowy

Domyślnie wtyczka Androida automatycznie konfiguruje projekt w celu zbudowania zarówno debugowania, jak i wersji aplikacji.

Zależności

1. Lokalne zależności:

Jeśli masz lokalne archiwa binarne, od których zależy moduł, takie jak pliki JAR, możesz zadeklarować te zależności w pliku kompilacji dla tego modułu.

2. Zdalne zależności:

Najpierw należy dodać repozytorium do listy, a następnie zadeklarować zależność w sposób, w jaki Maven lub Ivy deklarują swoje artefakty.

Gradle jest dla języka Groovy JVM czym jest mrówka dla Java. Zasadniczo jest to narzędzie do budowania Groovy. W przeciwieństwie do Anta, oparty jest na pełnym języku Groovy. Możesz na przykład napisać kod skryptu Groovy w skrypcie Gradle, aby coś zrobić, zamiast polegać na określonym języku domeny.

Nie znam specyficznej integracji IntelliJ, ale wyobraź sobie, że możesz „rozszerzyć” Groovy tak, abyś mógł pisać określone prymitywy języka „build”, a one właśnie stały się częścią języka Groovy. (Metaprogramowanie Groovy to cała dyskusja sama w sobie). IntelliJ / Google może użyć Gradle do zbudowania języka kompilacji na wysokim poziomie, ale jest to kompilacja języka na rozszerzalnym, otwartym standardzie.

Gradle to zaawansowany zestaw narzędzi do budowania dla systemu Android, który zarządza zależnościami i pozwala zdefiniować niestandardową logikę kompilacji. funkcje są jak

• Dostosuj, skonfiguruj i rozszerz proces kompilacji.

• Utwórz wiele pakietów APK dla swojej aplikacji z różnymi funkcjami przy użyciu tego samego projektu.

• Ponownie użyj kodu i zasobów.

odnosić się

Gradle to zautomatyzowany zestaw narzędzi, który można zintegrować z wieloma różnymi środowiskami, nie tylko dla projektów na Androida.

Oto kilka rzeczy, które możesz zrobić z gradle.

• Minimalna konfiguracja wymagana dla nowych projektów, ponieważ Gradle ma domyślne konfiguracje dla twoich projektów Android studio.

• Deklaracja zależności. Można zadeklarować pliki jar lub pliki bibliotek zależności hostowane na serwerze lokalnym lub zdalnym.

• Gradle automatycznie generuje katalog testowy i testowy pakiet APK ze źródła projektu.

• Jeśli dodasz wszystkie niezbędne informacje, takie jak keyPasswordi keyAlias, do pliku kompilacji Gradle, możesz użyć Gradle do wygenerowania podpisanych plików APK.

• Gradle może generować wiele pakietów APK z różnymi pakietami i konfigurować kompilacje z jednego modułu.

W Android Studio Gradle jest niestandardowym narzędziem do budowania pakietów Androida (plików apk) poprzez zarządzanie zależnościami i zapewnienie niestandardowej logiki kompilacji.

Plik APK (pakiet aplikacji na Androida) to specjalnie sformatowany plik zip, który zawiera

• Kod bajtowy
• Zasoby (obrazy, interfejs użytkownika, XML itp.)
• Plik manifestu

Plik apk zostaje podpisany i przekazany do urządzenia za pomocą ADB (Android Debug Bridge), gdzie jest wykonywany.

Gradle to niestandardowe narzędzie do budowania i używane do budowania APK lub znane jako pakiet aplikacji.

autor: @Brian Gardner:

Gradle to rozbudowane narzędzie do tworzenia i zarządzania zależnościami do programowania projektów. Ma specyficzny dla domeny język oparty na Groovy. Gradle zapewnia również obsługę konwencyjną dla wielu typów projektów, w tym Java, Android i Scala.

Funkcja Gradle:

1. Zarządzanie zależnościami
2. Korzystanie z Ant z Gradle
3. Wtyczki Gradle
4. Wtyczka Java
5. Wtyczka na Androida
6. Kompilacje wielu projektów

Gradle pozwala zautomatyzować tworzenie złożonych projektów Androida, które obejmują 10 tysięcy tysięcy linii kodu z wielu źródeł, projektów, bibliotek itp. Może warunkowo generować wiele zoptymalizowanych pakietów APK na podstawie mnóstwa specyfikacji konfiguracyjnych - jeśli jesteś zainteresowani, pozostałe odpowiedzi podają więcej szczegółów na temat tego aspektu Gradle.

Jeśli jednak dopiero zaczynasz tworzyć Androida, Gradle w 99% przypadków powstrzymuje tworzenie projektu. Jest to nieodgadniony, złożony system, który skutecznie zaciemnia proces kompilacji Androida i zasadniczo uniemożliwia niedoświadczonym programistom, tj. W celu zbudowania prostej aplikacji dla systemu Android, niczego nie podejrzewający nowicjusz może potrzebować przestudiować i zrozumieć wiele rzeczy, na które się nie targowali Jak na przykład:

• Struktura i ekosystem APK Androida
• Android Studio
• Ścieżki klas Java i zależności
• Groovy
• Skrypty budowania stopniowego
• Wiele innych złożonych i interesujących technologii

Wszystkie te rzeczy są interesujące i przydatne dla programistów Androida, ale nie są łatwe i stanowią ogromną barierę wejścia. Podejrzewam, że tym, co zainspirowało OP do zadawania tego pytania, jest uczucie frustracji, które nieuchronnie uderza w programistę neofitów po zbyt długim spędzaniu czasu na próbach zbudowania prostej aplikacji i ciągłym udaremnianiu jej przez Gradle. Problem przewrotnie pogarsza przytłaczająca ilość wysoce technicznej dokumentacji dostępnej dla wszystkich tych technologii. Również w przypadku dużej liczby potrzeb rozwojowych Gradle jest przesadą.

Alternatywą jest napisanie skryptu powłoki, który buduje projekt poprzez zautomatyzowanie narzędzi dostępnych w zestawie Android SDK. Zalet tego podejścia jest wiele, na początek jest to prawdopodobnie najlepszy sposób na zbadanie i zrozumienie procesu kompilacji i ekosystemu Androida, i pozwala on całkowicie kontrolować sposób budowania aplikacji. Jednak takie podejście jest bardziej odpowiednie dla głęboko nierealnych szefów technologii niż dla niedoświadczonych noobów wypróbowujących Androida.

To, co rzuca się w oczy z powodu jego braku (proszę poinformuj mnie, jeśli coś takiego istnieje), to podstawowe, lekkie IDE ze zmniejszonym zestawem funkcji, który jednocześnie upraszcza proces kompilacji, nie zakrywając go (więc nie fasoli sieciowej ani zaćmienia). użyj Gradle (co było nie tak z Antem). Powinno to ułatwić generowanie pakietów APK, które są zgodne z kilkoma typowymi konfiguracjami, i korzystanie ze struktury projektu, która może przekształcić się w pełny projekt Android Studio, jeśli zdecydujesz się na takie podejście.

Mówiąc wprost, Gradle to narzędzie dostarczone przez Android Studio w celu wdrożenia dwóch ważnych procesów:

1. Buduj nasze projekty
2. Spakuj AndroidManifest.xml, folder res i kod binarny do specjalnie sformatowanego pliku zip o nazwie APK

Wyniki wyszukiwania Wyróżniony fragment z sieci Android | budować. stopień. Gradle to system kompilacji (open source), który służy do automatyzacji budowania, testowania, wdrażania itp. ... Na przykład proste zadanie skopiowania niektórych plików z jednego katalogu do drugiego może być wykonane przez skrypt kompilacji Gradle przed faktyczną kompilacją proces się dzieje.

W Android Studio Gradle służy do budowania naszych projektów aplikacji na Androida, dlatego pełni rolę systemu kompilacji. Przed Android Studio w Eclipse kompilowaliśmy i budowaliśmy aplikacje za pomocą narzędzia wiersza poleceń, które wkrótce zostało przejęte przez kroki oparte na GUI do budowania i uruchamiania aplikacji na Androida w środowisku eclipse przy użyciu ANT. Każde narzędzie do tworzenia aplikacji na Androida musi skompilować zasoby, kod źródłowy Java, biblioteki zewnętrzne i połączyć je w końcowy pakiet APK.

Gradle to system kompilacji, który jest odpowiedzialny za kompilację kodu, testowanie, wdrażanie i konwersję kodu do plików .dex, a tym samym uruchamianie aplikacji na urządzeniu.

Ponieważ Android Studio ma wstępnie zainstalowany system Gradle, nie ma potrzeby instalowania dodatkowego oprogramowania wykonawczego, aby zbudować nasz projekt. Za każdym razem, gdy klikniesz przycisk w Android Studio, zadanie gradacji automatycznie uruchamia się i rozpoczyna budowanie projektu, a po ukończeniu zadania gradate aplikacja zaczyna działać w AVD lub na podłączonym urządzeniu.

System kompilacji, taki jak Gradle, nie jest kompilatorem, konsolidatorem itp., Ale kontroluje i nadzoruje działanie kompilacji, łączenia plików, uruchamiania przypadków testowych i ewentualnego pakowania kodu w plik apk dla aplikacji na Androida.

Istnieją dwa pliki build.gradle dla każdego projektu studia Android, jeden dla aplikacji, a drugi dla plików kompilacji na poziomie projektu (na poziomie modułu) .

W procesie kompilacji kompilator pobiera kod źródłowy, zasoby, pliki JAR bibliotek zewnętrznych i plik AndroidManifest.xml (który zawiera metadane dotyczące aplikacji) i konwertuje je na pliki .dex (pliki wykonywalne Dalvik) , które zawierają kod bajtowy . Ten kod bajtowy jest obsługiwany przez wszystkie urządzenia z Androidem do uruchomienia Twojej aplikacji. Następnie Menedżer APK łączy pliki .dex i wszystkie inne zasoby w jeden plik apk. APK Packager podpisuje debugowanie lub wydanie apk przy użyciu odpowiedniego magazynu kluczy debugowania lub wydania.

Plik debugowania jest zwykle używany do celów testowych lub możemy powiedzieć, że jest używany tylko na etapie programowania. Gdy Twoja aplikacja będzie wyposażona w pożądane funkcje i będziesz gotowy do opublikowania aplikacji do użytku zewnętrznego, potrzebujesz apk wydania podpisanego przy użyciu magazynu kluczy wersji.

Teraz rzućmy trochę światła na pliki stopni.

setting.gradle Plik setting.gradle (ustawienie stopniowania) służy do określenia wszystkich modułów używanych w aplikacji.

build.gradle (poziom projektu) Plik build.gradle najwyższego poziomu (moduł) to plik kompilacji na poziomie projektu, który definiuje konfiguracje kompilacji na poziomie projektu. Ten plik dotyczy konfiguracji wszystkich modułów w projekcie aplikacji na Androida.

build.gradle (poziom aplikacji) Plik build.gradle na poziomie aplikacji znajduje się w każdym module projektu Android. Ten plik zawiera nazwę pakietu jako ID aplikacji, nazwę wersji (wersja apk), kod wersji, minimum i docelowy pakiet SDK dla określonego modułu aplikacji. Jeśli dołączasz biblioteki zewnętrzne (nie pliki jar), musisz wspomnieć o tym w pliku stopni na poziomie aplikacji, aby uwzględnić je w projekcie jako zależności aplikacji.

Uwaga: jeśli określona aplikacja jest opracowana w różnych wersjach dla poszczególnych modułów, takich jak smartfon, tablet lub telewizor, należy utworzyć osobne pliki ocen dla wszystkich. Możesz nawet uruchomić swój system ocen za pomocą narzędzia wiersza poleceń. Służą do tego następujące polecenia:

./gradlew build - (build project)
./gradlew clean build - (build project complete scratch)
./gradlew clean build - (uruchom test)
./gradlew wrapper - (aby zobaczyć wszystkie dostępne zadania)

Gradle = Groovy + Cradle Hans Dockter komentarz na forum

Zamieszanie jest nieco niepotrzebne, gdy można je było nazwać „Kompilacją” lub czymś w Android Studio.

Lubimy utrudniać sobie życie w społeczności programistów.