Jestem nowy w systemie kompilacji Gradle i IntelliJ.

Jak więc utworzyć projekt biblioteki systemu Android (np. Com.myapp.lib1) i projekt aplikacji (np. Com.myapp.app) i sprawić, by system kompilacji obejmował com.myapp.lib1 w projekcie aplikacji?

Poszedłem do projektu Struktura projektu -> Moduły -> Moja aplikacja i dodałem zależność do projektu lib. IntelliJ może teraz rozpoznawać klasy z projektu lib, gdy są używane w projekcie aplikacji, ale kiedy uruchamiam projekt aplikacji, pojawiają się błędy, takie jak:

Gradle: error: package com.myapp.lib1 does not exist

Aby utworzyć bibliotekę:

Plik> Nowy moduł

wybierz Android Library

Aby skorzystać z biblioteki, dodaj ją jako zależność:

Plik> Struktura projektu> Moduły> Zależności

Następnie dodaj moduł (bibliotekę systemu Android) jako zależność modułu.

Uruchom swój projekt. To będzie działać.

Zastanawiam się, dlaczego nie ma przykładu samodzielnego projektu słoika.

W eclipse po prostu zaznaczamy pole „Is Library” w oknie dialogowym ustawień projektu.
W Android Studio wykonałem te kroki i otrzymałem plik jar.

1. Utwórz projekt.

2. otwórz plik w lewym menu projektu. (app / build.gradle): Gradle Scripts> build.gradle (Moduł: XXX)

3. zmień jedną linię: apply plugin: 'com.android.application' ->'apply plugin: com.android.library'

4. usuń applicationId w pliku: applicationId "com.mycompany.testproject"

5. projekt budowy: Kompiluj> Przebuduj projekt

6. wtedy możesz pobrać plik aar: app> build> output> aar folder

7. zmiana aar nazwę rozszerzenia pliku nazip

8. rozpakuj i możesz zobaczyć classes.jar w folderze. zmień nazwę i użyj go!

W każdym razie nie wiem, dlaczego Google sprawia, że ​​tworzenie słoików jest tak kłopotliwe w Android Studio.

Google Gradle Plugin zalecany sposób konfigurowania plików gradle do budowania wielu projektów ma pewne wady Jeśli masz wiele projektów zależnych od jednego projektu biblioteki, ten post pokrótce wyjaśnia zalecaną konfigurację Google, jej niedociągnięcia i zaleca inny sposób konfiguracji plików gradle, aby obsługuje konfiguracje wielu projektów w Android Studio:

Alternatywna konfiguracja wielu projektów dla studia Android

Inny sposób:

Okazuje się, że istnieje lepszy sposób zarządzania wieloma projektami w Android Studio. Sztuczka polega na utworzeniu oddzielnych projektów Android Studio dla swoich bibliotek i poinformowaniu gradle, że moduł biblioteki, od której zależy Twoja aplikacja, znajduje się w katalogu projektu biblioteki. Jeśli chcesz użyć tej metody z opisaną powyżej strukturą projektu, wykonaj następujące czynności:

1. Utwórz projekt Android Studio dla biblioteki StickyListHeaders
2. Utwórz projekt Android Studio dla App2
3. Utwórz projekt Android Studio dla App1
4. Skonfiguruj App1 i App2, aby skompilować moduły w projekcie StickyListHeaders.

Czwarty krok to najtrudniejsza część, więc to jedyny krok, który opiszę szczegółowo. Możesz odwoływać się do modułów, które są zewnętrzne w stosunku do katalogu projektu, dodając instrukcję projektu w pliku settings.gradle i ustawiając właściwość projectDir w obiekcie ProjectDescriptor, który jest zwracany przez tę instrukcję projektu:

Kod, który trzeba wpisać settings.gradle:

include ':library1'
project(':library1').projectDir = new File('../StickyListHeader/library1')

Jeśli zrobiłeś to poprawnie, zauważysz, że moduły, do których odwołuje się Twój projekt, pojawią się w nawigatorze projektu, nawet jeśli te moduły są zewnętrzne w stosunku do katalogu projektu:

Umożliwia to jednoczesną pracę nad kodem biblioteki i kodem aplikacji. Integracja kontroli wersji działa również dobrze, gdy w ten sposób odwołujesz się do modułów zewnętrznie. Możesz zatwierdzać i wypychać modyfikacje do kodu biblioteki, tak jak możesz zatwierdzać i wypychać modyfikacje do kodu aplikacji.

Ten sposób tworzenia wielu projektów pozwala uniknąć trudności, które są plagą zalecanej przez Google konfiguracji. Ponieważ odwołujemy się do modułu, który znajduje się poza katalogiem projektu, nie musimy tworzyć dodatkowych kopii modułu biblioteki dla każdej aplikacji, która jest od niego zależna, i możemy wersjonować nasze biblioteki bez żadnych bzdur podrzędnych git.

Niestety, ten inny sposób tworzenia wielu projektów jest bardzo trudny do znalezienia. Oczywiście nie jest to coś, czego się dowiesz, patrząc na przewodnik Google, iw tym momencie nie ma sposobu, aby skonfigurować swoje projekty w ten sposób za pomocą interfejsu użytkownika Android Studio.

Sprawdź ten link o konfiguracjach wielu projektów .

Warto zwrócić uwagę, upewnij się, że plik settings.gradle został zaktualizowany, aby odnosił się zarówno do modułów aplikacji, jak i biblioteki.

settings.gradle: include ':app', ':libraries:lib1', ':libraries:lib2'

Upewnij się również, że plik build.gradle aplikacji zawiera następujący tekst:

dependencies {
     compile project(':libraries:lib1')
}

Powinieneś mieć następującą strukturę:

 MyProject/
  | settings.gradle
  + app/
    | build.gradle
  + libraries/
    + lib1/
       | build.gradle
    + lib2/
       | build.gradle

Plik build.gradle aplikacji powinien używać rozszerzenia com.android.application wtyczki, a plik build.gradle wszystkich bibliotek powinien korzystać z com.android.librarywtyczki.

IDE Android Studio powinno zostać zaktualizowane, jeśli możesz budować z wiersza poleceń z tą konfiguracją.

W przypadku Intellij IDEA (i Android Studio) każda biblioteka jest modułem. Pomyśl o module w Android Studio jako o ekwiwalencie projektu w Eclipse. Projekt w Android Studio to zbiór modułów. Moduły mogą być uruchamianymi aplikacjami lub modułami bibliotek.

Tak więc, aby dodać nowy projekt biblioteki dla systemu Android, musisz utworzyć moduł typu „biblioteka Androida”. Następnie dodaj ten moduł biblioteki do listy zależności modułu głównego (moduł aplikacji).

Najprostszy sposób, w jaki mogę utworzyć i ponownie wykorzystać projekt biblioteki:

1. W otwartym projekcie file > new > new module(i odpowiedz na pytania dotyczące interfejsu użytkownika)

2. sprawdź / lub dodaj if w pliku settings.gradle :include ':myLibrary'

3. sprawdź / lub dodaj if w pliku build.gradle :

   dependencies { ... compile project(':myLibrary') }

4. Aby ponownie użyć tego modułu biblioteki w innym projekcie, skopiuj jego folder w projekcie zamiast kroku 1 i wykonaj kroki 2 i 3.

Możesz także utworzyć nowy projekt aplikacji studyjnej. Możesz łatwo zmienić istniejący moduł aplikacji na moduł biblioteki, zmieniając przypisanie wtyczki w pliku build.gradle na com.android.library.

apply plugin: 'com.android.application'

android {...}

do

apply plugin: 'com.android.library'

android {...}

więcej tutaj

Możesz dodać nowy moduł do dowolnej aplikacji, jak mówi Blundell w swojej odpowiedzi, a następnie odwołać się do niego z dowolnej innej aplikacji.

Jeśli chcesz przenieść moduł w dowolne miejsce na komputerze, po prostu przenieś folder modułów (moduły są całkowicie niezależne), wtedy będziesz musiał odwołać się do modułu.

Aby odwołać się do tego modułu, należy:

• W pliku build.gradle aplikacji dodaj:

  dependencies {
  ...
  compile project(':myandroidlib')
  }
  

• W pliku settings.gradle dodaj następujące informacje:

   include ':app', ':myandroidlib'
   project(':myandroidlib').projectDir = new File(PATH_TO_YOUR_MODULE)
  

Nie zapomnij użyć apply plugin: 'com.android.library'w twojej build.gradlezamiast stosować wtyczki:'com.android.application'

Sposób dokumentacji

Jest to zalecany sposób, zgodnie z poradami zawartymi w dokumentacji Android Studio.

Utwórz moduł biblioteki

Utwórz nowy projekt, w którym chcesz umieścić swoją bibliotekę. Kliknij opcję Plik> Nowy> Nowy moduł> Biblioteka systemu Android> Dalej> (wybierz nazwę)> Zakończ . Następnie dodaj wybrane klasy i zasoby do swojej biblioteki.

Podczas budowania modułu zostanie utworzony plik AAR. Możesz go znaleźć w project-name/module-name/build/outputs/aar/.

Dodaj swoją bibliotekę jako zależność

Możesz dodać swoją bibliotekę jako zależność do innego projektu w następujący sposób:

1. Zaimportuj plik AAR biblioteki za pomocą opcji Plik> Nowy moduł> Importuj pakiet .JAR / .AAR> Dalej> (wybierz lokalizację pliku)> Zakończ . (Nie importuj kodu, w przeciwnym razie będzie można go edytować w zbyt wielu miejscach).

2. Upewnij się, że w pliku settings.gradle znajduje się nazwa Twojej biblioteki.

   include ':app', ':my-library-module'
   

3. W pliku build.gradle aplikacji dodaj wiersz kompilacji do sekcji zależności:

   dependencies {
       compile project(":my-library-module")
   }
   

4. Zostaniesz poproszony o zsynchronizowanie projektu z Gradle. Zrób to.

Otóż ​​to. Teraz powinieneś móc korzystać ze swojej biblioteki.

Uwagi

Jeśli chcesz, aby Twoja biblioteka była łatwo dostępna dla większej liczby odbiorców, rozważ użycie JitPac lub JCenter .

Miałem to samo pytanie i rozwiązałem je w następujący sposób:

Sytuacja początkowa :

FrigoShare (root)
|-Modules:    frigoshare,   frigoShare-backend

Cel : chcesz dodać moduł o nazwiedataformats

1. Dodaj nowy moduł (np .: Java Library :)

2. Upewnij się, że settings.gradlewyglądasz tak (zwykle automatycznie):

   include ':frigoshare', ':frigoShare-backend', ':dataformats'

3. Upewnij się ( ręcznie ), że build.gradlepliki modułów, które muszą używać Twojej biblioteki, mają następującą zależność:

   dependencies { ... compile project(':dataformats') }

Cel: biblioteka Androida w jednym miejscu - udostępnianie w wielu projektach http://raevilman.blogspot.com/2016/02/android-library-project-using-android.html

Jako komentarz theczechsensation powyżej, próbuję poszukać informacji o Gradle Build Varians i znalazłem ten link: http://code.tutsplus.com/tutorials/using-gradle-build-variants--cms-25005 To bardzo proste rozwiązanie. Oto, co zrobiłem: - W build.gradle:

flavorDimensions "version"

productFlavors {
    trial{
        applicationId "org.de_studio.recentappswitcher.trial"
        flavorDimension "version"
    }
    pro{
        applicationId "org.de_studio.recentappswitcher.pro"
        flavorDimension "version"
    }

}

Następnie mam jeszcze 2 wersje mojej aplikacji: pro i trial z 2 różnymi nazwami pakietu, czyli 2 identyfikatorami applicationId w powyższym kodzie, więc mogę przesłać obie do Google Play. Nadal koduję w sekcji „main” i używam getpackageName do przełączania się między wersjami. Po prostu przejdź do linku, który podałem, aby uzyskać szczegółowe informacje.

Są dwa najprostsze sposoby, jeśli jeden nie działa, spróbuj drugiego.

1. Dodaj zależność biblioteki do zależności wewnątrz pliku build.gradle biblioteki, której używasz, i wklej bibliotekę ur do bibliotek zewnętrznych.

LUB

2. Po prostu przejdź do folderu libs w folderze aplikacji i wklej wszystkie swoje pliki .jar, np. Pliki biblioteki. Teraz sztuczka polega na tym, że teraz przejdź do pliku settings.gradle i dodaj tę linię „include ': app: libs'" po "include": app '"To na pewno zadziała ........... :)

W moim przypadku używając MAC OS X 10.11 i Androida 2.0 i robiąc dokładnie to, co wyjaśnił Aqib Mumtaz.

Ale za każdym razem otrzymywałem ten komunikat: „ Wystąpił problem podczas konfigurowania projektu„: aplikacja ”.> Nie można ocenić modułu xxx: Nie znaleziono konfiguracji o nazwie„ domyślna ” .”

Odkryłem, że powodem tego komunikatu jest to, że Android 2.0 nie pozwala na bezpośrednie tworzenie biblioteki. Postanowiłem więc najpierw utworzyć projekt aplikacji, a następnie zmodyfikować plik build.gradle, aby przekształcić go w bibliotekę.

To rozwiązanie nie działa, ponieważ projekt biblioteki bardzo różni się od projektu aplikacji.

Więc rozwiązałem mój problem w następujący sposób:

• Najpierw utwórz standardową aplikację (w razie potrzeby);
• Następnie wybierz „Plik / Utwórz moduł”
• Przejdź do wyszukiwarki i przenieś folder świeżo utworzonego modułu do katalogu frameworka

Następnie przejdź do rozwiązania zaproponowanego przez Aqib Mumtaz.

W rezultacie źródło Twojej biblioteki będzie udostępniane bez konieczności powielania plików źródłowych za każdym razem (była to dla mnie herezja!)

Mam nadzieję, że to ci pomoże.