Jak dodać projekt biblioteki do Android Studio?

Jak dodać projekt biblioteki (np. Sherlock ABS) do Android Studio ?

(Nie do starego pakietu opartego na ADT Eclipse, ale do nowego Android Studio .)

Aktualizacja dla Androida Studio 1.0

Od czasu wydania Android Studio 1.0 (i wielu wersji między wersją 1.0 a jedną z pierwszych od czasu mojej poprzedniej odpowiedzi) niektóre rzeczy się zmieniły.

Mój opis koncentruje się na ręcznym dodawaniu zewnętrznego projektu biblioteki za pomocą plików Gradle (dla lepszego zrozumienia procesu). Jeśli chcesz dodać bibliotekę za pomocą kreatora Android Studio, po prostu sprawdź odpowiedź poniżej za pomocą wizualnego przewodnika (istnieją pewne różnice między Android Studio 1.0 a tymi ze zrzutów ekranu, ale proces jest bardzo podobny).

Zanim zaczniesz ręcznie dodawać bibliotekę do swojego projektu, rozważ dodanie zależności zewnętrznej. Nie będzie bałaganu w strukturze twojego projektu. Prawie każda dobrze znana biblioteka Androida jest dostępna w repozytorium Maven, a jego instalacja zajmuje tylko jeden wiersz kodu w app/build.gradlepliku:

dependencies {
     compile 'com.jakewharton:butterknife:6.0.0'
}

Dodawanie biblioteki

Oto pełny proces dodawania zewnętrznej biblioteki Androida do naszego projektu:

1. Utwórz nowy projekt za pomocą kreatora Android Studio. Nazwałem to HelloWorld .
2. Oto oryginalna struktura projektu stworzona przez Android Studio:

HelloWorld/
      app/
           - build.gradle  // local Gradle configuration (for app only)
           ...
      - build.gradle // Global Gradle configuration (for whole project)
      - settings.gradle
      - gradle.properties
      ...

3. W katalogu głównym ( HelloWorld/) utwórz nowy folder: /libsw którym umieścimy nasze biblioteki zewnętrzne (ten krok nie jest wymagany - tylko dla utrzymania bardziej przejrzystej struktury projektu).
4. Wklej swoją bibliotekę do nowo utworzonego /libsfolderu. W tym przykładzie użyłem biblioteki PagerSlidingTabStrip (wystarczy pobrać plik ZIP z GitHub, zmienić nazwę katalogu biblioteki na „PagerSlidingTabStrip” i skopiować go). Oto nowa struktura naszego projektu:

HelloWorld/
      app/
           - build.gradle  // Local Gradle configuration (for app only)
           ...
      libs/
           PagerSlidingTabStrip/
                - build.gradle // Local Gradle configuration (for library only)
      - build.gradle // Global Gradle configuration (for whole project)
      - settings.gradle
      - gradle.properties
      ...

5. Edytuj settings.gradle, dodając swoją bibliotekę do include. Jeśli używasz niestandardowej ścieżki, tak jak ja, musisz także zdefiniować katalog projektu dla naszej biblioteki. Cały settings.gradle powinien wyglądać jak poniżej:

   include ':app', ':PagerSlidingTabStrip'
   project(':PagerSlidingTabStrip').projectDir = new File('libs/PagerSlidingTabStrip')

5.1 Jeśli napotkasz błąd „Konfiguracja domyślna”, spróbuj tego zamiast kroku 5,

    include ':app'
    include ':libs:PagerSlidingTabStrip'

6. Na app/build.gradledodatek nasz projekt biblioteki jako zależność:

   dependencies {
       compile fileTree(dir: 'libs', include: ['*.jar'])
       compile 'com.android.support:appcompat-v7:21.0.3'
       compile project(":PagerSlidingTabStrip")
   }

6.1 Jeśli wykonałeś krok 5.1, to wykonaj to zamiast 6,

    dependencies {
        compile fileTree(dir: 'libs', include: ['*.jar'])
        compile 'com.android.support:appcompat-v7:21.0.3'

        compile project(":libs:PagerSlidingTabStrip")
    }

7. Jeśli twój projekt biblioteki nie ma build.gradlepliku, musisz go utworzyć ręcznie. Oto przykład tego pliku:

       apply plugin: 'com.android.library'
   
       dependencies {
           compile 'com.android.support:support-v4:21.0.3'
       }
   
       android {
           compileSdkVersion 21
           buildToolsVersion "21.1.2"
   
           defaultConfig {
               minSdkVersion 14
               targetSdkVersion 21
           }
   
           sourceSets {
               main {
                   manifest.srcFile 'AndroidManifest.xml'
                   java.srcDirs = ['src']
                   res.srcDirs = ['res']
               }
           }
       }

8. Dodatkowo możesz stworzyć globalną konfigurację dla swojego projektu, która będzie zawierać wersje SDK i budować wersję narzędzi dla każdego modułu, aby zachować spójność. Po prostu edytuj gradle.propertiesplik i dodaj linie:

   ANDROID_BUILD_MIN_SDK_VERSION=14
   ANDROID_BUILD_TARGET_SDK_VERSION=21
   ANDROID_BUILD_TOOLS_VERSION=21.1.3
   ANDROID_BUILD_SDK_VERSION=21

   Teraz możesz go używać w swoich build.gradleplikach (w modułach aplikacji i bibliotek), jak poniżej:

   //...
   android {
       compileSdkVersion Integer.parseInt(project.ANDROID_BUILD_SDK_VERSION)
       buildToolsVersion project.ANDROID_BUILD_TOOLS_VERSION
   
       defaultConfig {
           minSdkVersion Integer.parseInt(project.ANDROID_BUILD_MIN_SDK_VERSION)
           targetSdkVersion Integer.parseInt(project.ANDROID_BUILD_TARGET_SDK_VERSION)
       }
   }
   //...

9. To wszystko. Wystarczy kliknąć „zsynchronizuj projekt z ikoną Gradle” . Twoja biblioteka powinna być dostępna w twoim projekcie.

Google I / O 2013 - nowy system kompilacji SDK systemu Android to świetna prezentacja na temat tworzenia aplikacji na Androida za pomocą systemu Gradle Build System: Jak powiedział Xavier Ducrohet:

Android Studio to przede wszystkim edycja, debugowanie i profilowanie. Nie chodzi już o budowanie.

Na początku może to być nieco mylące (szczególnie dla tych, którzy pracują z Eclipse i nigdy nie widzieli mrówki - jak ja;)), ale na końcu Gradle daje nam wspaniałe możliwości i warto nauczyć się tego systemu budowania.

Oto wizualny przewodnik:

Aktualizacja dla Androida Studio 0.8.2:

W Android Studio 0.8.2, przejdź do struktury projektu -> pod moduły wystarczy nacisnąć przycisk plus i wybierz Importuj istniejący projekt i import actionbarsherlock. Następnie zsynchronizuj pliki Gradle.

Jeśli napotkasz błąd

Błąd: Wersja narzędzi kompilacji zestawu SDK (xx.xx) jest zbyt niska. Wymagane minimum to rrrr

po prostu otwórz build.gradleplik w actionbarsherlockkatalogu i zaktualizuj go buildToolsVersiondo sugerowanego.

android {
  compileSdkVersion 19
  buildToolsVersion 'yy.y.y'

Plik menu -> Struktura projektu ... :

Moduł -> Moduł importu

Po zaimportowaniu modułu biblioteki, wybierz swój moduł projektu i dodać zależność:

A następnie wybierz importowany moduł :

Użyj menu Plik -> Struktura projektu -> Moduły .

Zacząłem go dzisiaj używać. To jest trochę inne.

W przypadku Sherlocka może chcesz usunąć ich katalog testowy lub dodać junit.jarplik do ścieżki klasy.

Aby zaimportować bibliotekę za pomocą gradle, możesz dodać ją do dependenciessekcji build.gradle(modułu).

Na przykład

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:22.1.0'
    compile 'com.actionbarsherlock:actionbarsherlock:4.4.0@aar'
}

Android Studio się zmienia.

Istnieje sekcja o nazwie „Otwórz ustawienia modułu”, jeśli klikniesz prawym przyciskiem myszy folder modułu w sekcji projektu Android Studio (używam wersji 0.2.10).

Uważam, że konieczne są lektury Zależności, Biblioteki Androida i Konfiguracja wielu projektów . Poświęć kilka minut, aby to zrobić.

W szczególności, w przypadku projektu biblioteki innej niż jar, przeczytaj poniższy fragment z powyższego źródła:

Projekty stopniowe mogą również zależeć od innych projektów stopniowych przy użyciu konfiguracji obejmującej wiele projektów. Konfiguracja wielu projektów zwykle działa, ponieważ wszystkie projekty są podfolderami danego projektu głównego.

Na przykład, biorąc pod uwagę następującą strukturę:

MyProject/
 + app/
 + libraries/
    + lib1/
    + lib2/

Możemy zidentyfikować 3 projekty. Gradle będzie odwoływał się do nich następującą nazwą:

:app
:libraries:lib1
:libraries:lib2

Każdy projekt będzie miał swoją własną wersję build.gradle z informacją o tym, jak zostanie zbudowany. Dodatkowo w katalogu głównym będzie plik o nazwie settings.gradle, który deklaruje projekty. Daje to następującą strukturę:

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

Zawartość settings.gradle jest bardzo prosta:

include ':app', ':libraries:lib1', ':libraries:lib2'

Określa, który folder jest faktycznie projektem Gradle.

Projekt: app prawdopodobnie zależeć będzie od bibliotek, a odbywa się to poprzez zadeklarowanie następujących zależności:

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

Uprzejmie informujemy, że interfejs GUI Android Studio był w niewielkim stopniu lub nie był używany do tego celu.

Obecnie używam podmodułów git do łączenia zagnieżdżonej biblioteki z rzeczywistym repozytorium git biblioteki, aby uniknąć bałaganu zależności.

Właśnie znalazłem prostszy sposób (zamiast pisać bezpośrednio w plikach .gradle).

To jest dla Androida Studio 1.1.0.

1. Plik menu -> Nowy moduł ... :

   

   Kliknij „Importuj istniejący projekt”.

2. Wybierz żądaną bibliotekę i żądany moduł.

3. Kliknij koniec. Android Studio zaimportuje bibliotekę do twojego projektu. Będzie synchronizować pliki stopni.

4. Dodaj zaimportowany moduł do zależności projektu.

   Kliknij prawym przyciskiem myszy folder aplikacji -> Otwórz ustawienia modułu -> przejdź do zakładki zależności -> kliknij przycisk „+” -> kliknij opcję Zależność modułu.

   Moduł biblioteki zostanie następnie dodany do zależności projektu.

   

5. ???

6. Zysk

Najłatwiejszy sposób na włączenie projektu biblioteki zewnętrznej jest (na przykład włączenie biblioteki Facebooka, która jest zapisana o jeden katalog w folderze zależności):

1. W settings.gradle dodaj

   include ':facebook'
   
   project(':facebook').projectDir = new File(settingsDir, '../dependencies/FacebookSDK')

2. W sekcji zależności build.gradle dodaj

   compile project ('facebook')

Pozostaje tylko zsynchronizować projekt z plikami stopni.

Prosty sposób dodania pliku JAR jako biblioteki do projektu Android Studio:

a) Skopiuj pliki * .jar

b) Wklej do katalogu libs w swoich projektach:

c) Dodaj do build.gradle:

dependencies {
    ...
    compile files('libs/ScanAPIAndroid.jar', 'libs/ScanAPIFactoryAndroid.jar', .., ..)
}

b) Jeśli Twój projekt z przykładowego com.example.MYProject i bibliotek com.example.ScanAPI ma tę samą przestrzeń nazw com.example , Android Studio sprawdzi twoją kompilację i wprowadzi wszystkie niezbędne zmiany w projekcie. Następnie możesz przejrzeć te ustawienia w menu Plik -> Struktura projektu .

c) Jeśli twój projekt i biblioteki mają inną przestrzeń nazw , musisz kliknąć bibliotekę prawym przyciskiem myszy i wybrać opcję „Dodaj jako bibliotekę” i wybrać typ, którego potrzebujesz.

Pamiętaj, że opcja „Struktura projektu” nie wprowadza żadnych automatycznych zmian w „build.gradle” w bieżącej wersji Androida Studio (0.2.3). Być może ta funkcja będzie dostępna w następnych wersjach.

Opcja 1: upuść pliki do katalogu libs / projektu

Odpowiedni plik build.gradle zostanie następnie zaktualizowany automatycznie.

Opcja 2: Ręcznie zmodyfikuj plik build.gradle

Otwórz plik build.gradle i dodaj nową regułę kompilacji do zamknięcia zależności. Na przykład, jeśli chcesz dodać Usługi Google Play, sekcja zależności Twojego projektu wyglądałaby mniej więcej tak:

dependencies {
     compile fileTree(dir: 'libs', include: ['*.jar'])
     compile 'com.google.android.gms:play-services:6.5.+'
   }

Opcja 3: Użyj interfejsu użytkownika Android Studio

W panelu Projekt Controlkliknij + moduł, do którego chcesz dodać zależność, i wybierz Otwórz ustawienia modułu.

Wybierz kartę Zależności, a następnie przycisk + w lewym dolnym rogu. Możesz wybrać z następującej listy opcji:

• Zależność biblioteki
• Zależność pliku
• Zależność modułu

Następnie możesz wprowadzić więcej informacji o zależności, którą chcesz dodać do swojego projektu. Na przykład, jeśli wybierzesz Zależność bibliotek, Android Studio wyświetli listę bibliotek do wyboru.

Po dodaniu zależności sprawdź plik build.gradle na poziomie modułu. Powinien był zostać automatycznie zaktualizowany, aby uwzględnić nową zależność.

Źródło

Tak to działa dla mnie w Android Studio 1.5+

W projekcie, w którym chcesz dodać projekt biblioteki zewnętrznej, przejdź do menu Plik -> Nowy -> * Importuj nowy moduł **, przejdź do projektu biblioteki, który chcesz dodać do projektu, wybierz, aby dodać moduł „biblioteki” w Twój projekt. Dostaniesz settings.gradle w swoich projektach, oprócz aplikacji, dołączonej biblioteki, coś takiego:

include ':app', ':library'

Dodaj w build.gradle (Module: app) w sekcji zależności:

Skompiluj projekt („: biblioteka”)

Odbuduj projekt i to wszystko.

* Możesz dodać tyle bibliotek (modułów), ile chcesz. W takim przypadku w settings.gradle będziesz mieć:

 include ':app', ':lib1', ':lib2', ...

W build.gradle musisz mieć:

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])

    // Some other dependencies...

    compile project(':lib1')
    compile project(':lib2')
    ...
}

Jeśli potrzebujesz dostępu do zasobów projektu bibliotecznego (jak w przypadku ABS), upewnij się, że dodajesz projekt / moduł biblioteczny jako „Zależność modułu” zamiast „Biblioteka”.

Możesz to zrobić z łatwością. Przejdź do menu Plik -> Nowy -> Importuj moduł ... :

Wyszukaj katalog zawierający moduł. Kliknij Zakończ:

Przejdź do struktury projektu i dodaj Zależność modułu :

Uwaga: Jeśli pojawi się błąd SDK, zaktualizuj go.

1. Naciśnij, F4aby wyświetlić Struktura projektu , kliknij biblioteki lub Biblioteki globalne, a następnie kliknij, +aby dodać plik JAR.
2. Kliknij Moduły, które chcesz dodać jar, wybierz kartę Zależności , kliknij +i dodaj bibliotekę.

Edycja zależności bibliotek przez GUI nie jest wskazana, ponieważ nie zapisuje tych zmian w pliku build.gradle. Twój projekt nie będzie budowany z wiersza poleceń. Powinniśmy edytować plik build.gradle bezpośrednio w następujący sposób.

Na przykład, biorąc pod uwagę następującą strukturę:

Mój projekt/

• aplikacja /
• biblioteki /
  • lib1 /
  • lib2 /

Możemy zidentyfikować trzy projekty. Gradle odniesie je do następujących nazw:

1. : app
2. : biblioteki: lib1
3. : biblioteki: lib2

Projekt: app prawdopodobnie zależeć będzie od bibliotek, a odbywa się to poprzez zadeklarowanie następujących zależności:

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

Aby dodać do odpowiedzi: Jeśli IDE nie pokazuje żadnego błędu, ale podczas próby kompilacji, otrzymujesz coś takiego:

No resource found that matches the given name 'Theme.Sherlock.Light'

Twój projekt biblioteki jest prawdopodobnie skompilowany jako projekt aplikacji. Aby to zmienić, przejdź do:

Plik menu -> Struktura projektu -> Aspekty -> [Nazwa biblioteki] -> Zaznacz „Moduł biblioteki”.

Pierwszy sposób Działa to na MacBooku.

Najpierw wybierz plik builder.gradle jako dany ekran:

Dodaj zależności, jak na wybranym ekranie:

Wybierz projekt synchronizacji.

Jeśli pojawia się błąd typu „Projekt ze ścieżką”: pad-podpisu nie został znaleziony w projekcie „: aplikacja” ”, skorzystaj z drugiego sposobu:

Wybierz menu Plik -> Nowy -> Importuj moduł ... :

Po kliknięciu na import module ,

podaj ścieżkę biblioteki jak moja ścieżka do MacBooka:

Kliknij Zakończ . Teraz twoja biblioteka została dodana.

Po zaimportowaniu modułu ABS (z menu Plik> Struktura projektu) i upewnieniu się, że ma on Android 2.2 i bibliotekę wsparcia v4 jako zależności, wciąż pojawiał się następujący błąd, gdy ty @Alex

Error retrieving parent for item: No resource found that matches the given name 'Theme.Sherlock.Light.DarkActionBar'

Dodałem nowo zaimportowany moduł jako zależność do mojego głównego modułu aplikacji i to rozwiązało problem.

Android Studio 3.0

Wystarczy dodać nazwę biblioteki do bloku zależności w pliku build.gradle aplikacji.

dependencies {
    // ...
    implementation 'com.example:some-library:1.0.0'
}

Pamiętaj, że powinieneś używać implementationraczej niż compileteraz. To nowość w Android Studio 3.0. Zobacz te pytania i wyjaśnienia różnicy.

Aby rozwiązać ten problem, wystarczy dodać ścieżkę zasobów abs do pliku kompilacji projektu, tak jak poniżej:

sourceSets {
    main {
        res.srcDirs = ['src/main/res','../../ActionBarSherlock/actionbarsherlock/res']
    }
}

Ponownie kompiluję bez żadnych błędów.

Jeśli masz Androida Studio .0.4.0, można utworzyć nowy folder w ścieżce kompilacji YourApp/libraries. Skopiuj plik JAR. Tam kliknij prawym przyciskiem myszy i „Dodaj jako bibliotekę”. Teraz masz wyskakujące okienko. Po prostu wybierz swój katalog i naciśnij OK, i to wszystko.

Wystarczy zaimportować projekt biblioteki Androida jako moduł i w Build.gradle .

Zastosuj wtyczkę: „com.android.library”

Następnie wykonaj następujące kroki:

1. Kliknij moduł prawym przyciskiem myszy i wybierz otwórz ustawienia modułu
2. Wybierz zależności, kliknij +, wybierz zależności biblioteki i dodaj wcześniej zaimportowany moduł.

https://www.dropbox.com/s/1e3eteu3h0pmkf7/Android%20studio%20_doc.doc?dl=0 to łącze Dropbox dotyczące dodawania pliku JAR i projektu biblioteki w najnowszej wersji Androida Studio 1.0.1.

Zobacz dokumentację ze zrzutami ekranu. Dla nowego użytkownika jest to bardzo łatwe.

Znalazłem rozwiązanie. To takie proste. Postępuj zgodnie z instrukcjami froger_mcs .

Upewnij się, że folder src jest folderem źródłowym w strukturze projektu -> Moduły (źródła).

Zasadniczo możesz dołączyć swoje pliki JAR na trzy różne sposoby. Ostatnia to zdalna biblioteka korzystająca z internetowego repozytorium https://bintray.com/ jcenter. Ale jeśli zrobisz to na jeden z dwóch innych sposobów, plik JAR zostanie fizycznie dołączony do twojego projektu. Przeczytaj ten link https://stackoverflow.com/a/35369267/5475941, aby uzyskać więcej informacji. W tym poście wyjaśniłem, jak zaimportować plik JAR do studia Android i wyjaśniłem wszystkie możliwe sposoby.

Podsumowując, jeśli tak jest (adres lokalny), są one pobierane, a te pliki JAR są fizycznie w projekcie:

Ale jeśli jest to taki adres internetowy, to są to biblioteki zdalne (część bintray.com jcenter) i będą używane zdalnie:

Mam nadzieję, że to pomoże.

Otwórz plik aplikacji modułu oceny wersji i dodaj swoją zależność. Jeśli pobierzesz bibliotekę, po prostu zaimportuj i skompiluj jako wersję.

W przeciwnym razie dodaj repozytoria w aplikacji modułu stopni bocznych:

repositories {
        maven { url 'http://clinker.47deg.com/nexus/content/groups/public' }
}

Pierwsze repozytoria pobiorą bibliotekę dla Ciebie.

I skompiluj pobraną bibliotekę:

 compile ('com.fortysevendeg.swipelistview:swipelistview:1.0-SNAPSHOT@aar') {
        transitive = true
    }

Jeśli tworzysz bibliotekę, wystarczy zaimportować projekt jako import nowego modułu.

Miałem inną przyczynę problemu, więc dla ludzi:

repositories {
    mavenCentral()
}

zmień mavenCentral () na jcenter () i dodaj

allprojects {
    repositories {
        jcenter()
    }
}

W Android Studio przejdź do wewnętrznego folderu aplikacji i otwórz plik build.gradle. Tutaj zobaczysz zależności {}. Wewnątrz możesz dodać projekt biblioteki i zsynchronizować. Teraz po zsynchronizowaniu biblioteki zostanie ona dodana do twojego projektu i możesz używać jej funkcji i klas w swoim projekcie.

Dla Androida Studio:

Kliknij Build.gradle (moduł: aplikacja) .

I dodaj za

dependencies {
    compile fileTree(include: ['*.jar'], dir: 'libs')
    compile files('libs/commons-io-2.4.jar')
}

a w katalogu „app” utwórz katalog „libs”. Dodaj plik twoj_plik.jar:

Na koniec skompiluj pliki Gradle:

Zetknąłem się z tym samym problemem, a potem robiłem następujące rzeczy.

1. Importuję projekt biblioteki do mojego AndroidStudio IDE jako moduł, używając menu Plik -> Importuj menu modułów

2. Potem poszedłem do mojego głównego modułu, w którym chcę projekt biblioteki jako projekt zależny

3. Kliknij prawym przyciskiem myszy główny moduł (w moim przypadku jest to aplikacja ) -> otwórz ustawienia modułu -> przejdź do zakładki zależności -> kliknij przycisk + (dostaniesz go po prawej stronie okna) -> kliknij zależność modułu - > wybierz projekt biblioteki z listy

Zastosuj zmiany i kliknij OKprzycisk.

To zadziałało dla mnie. Mam nadzieję, że pomoże to również innym.

Dodaj to do pliku oceny kompilacji:

 dependencies {
     implementation 'com.jakewharton:butterknife:9.0.0'
}

Rzeczywiście, gdy zmieniają się wersje, zmienia się także interfejs użytkownika i opcje dostępne w menu. Po przeczytaniu większości odpowiedzi na te pytania musiałem odgadnąć, co zadziała w Android Studio 1.1.0 .

1. Za pomocą myszy wybierz projekt na głównym poziomie (tutaj pokazuje nazwę Twojej aplikacji).

2. Kliknij prawym przyciskiem myszy i wybierz opcje menu Nowy, Folder, Folder zasobów .

3. Po utworzeniu folderu zasobów wklej lub skopiuj do niego dowolny plik JAR potrzebny do biblioteki.

4. Z głównego menu Android Studio (u góry ekranu) wybierz Plik -> Struktura projektu .

5. Następnie wybierz nazwę projektu i przejdź do zakładki Zależności .

6. Kliknij znak plus ( +) w lewym dolnym rogu okna dialogowego i wybierz zależność pliku.

7. Na koniec otwórz niedawno utworzony folder zasobów, wybierz skopiowane pliki JAR, a następnie kliknij przycisk Zastosuj i OK.

Oczyść i odbuduj swój projekt.