Jak dodać projekt biblioteki do Android Studio?

Oto wizualny przewodnik:

Aktualizacja Dla Android Studio 0.8.2:

W Android Studio 0.8.2 przejdź do struktura projektu - > Pod Moduły po prostu naciśnij przycisk plus i wybierz Importuj istniejący projekt i importuj actionbarsherlock. Następnie zsynchronizuj pliki Gradle.

Jeśli napotkasz błąd

Błąd: wersja SDK Build Tools (xx. x. x) jest zbyt niska. Minimum wymagane jest yy.y. y

Po prostu otwórz plik build.gradle w actionbarsherlock katalog i zaktualizuj buildToolsVersion do sugerowanego.

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

Menu Plik -> Struktura Projektu...:

Moduł -> Moduł Importu

Po zaimportowaniu modułu biblioteki wybierz Twój moduł projektu i dodaj zależność:

A następnie wybierz zaimportowany moduł :

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

Zacząłem go używać dzisiaj. Jest trochę inaczej.

Dla Sherlocka, może chcesz usunąć ich katalog testowy lub dodać plik junit.jar do ścieżki klasowej.

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

Np.

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

Istnieje sekcja o nazwie "Open ustawienia modułu " jeśli kliknij prawym przyciskiem myszy folder modułu w sekcji Projekt systemu Android Studio (używam wersji 0.2.10).

Rozważyłbym zależności, Biblioteki Androida i konfigurację wielu projektów niezbędną lekturę. Poświęć na to kilka minut.

Szczególnie, w przypadku projektu biblioteki nie-jar, przeczytaj poniższy fragment z powyższego źródła:

Projekty Gradle mogą również zależeć od innych projektów gradle, używając konfiguracji wielu projektów. Konfiguracja wielu projektów zwykle działa poprzez posiadanie wszystkich projektów jako podfolderów danego projektu głównego.

Dla przykład, podany następującej strukturze:

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

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

:app
:libraries:lib1
:libraries:lib2

Każdy projekt będzie miał swoją własną budowę./ align = "left" / Dodatkowo pojawi się plik o nazwie settings.gradle u podstaw deklarowania projektów. Daje to następującą strukturę:

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

Zawartość ustawień.gradle jest bardzo proste:

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

To określa, który folder jest rzeczywiście projektem Gradle.

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

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

Należy pamiętać, że nie było lub nie było wykorzystanie interfejsu graficznego Android Studio, aby to się stało.

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

Właśnie znalazłem łatwiejszy sposób (zamiast pisać bezpośrednio do .pliki gradle).

To jest dla Android Studio 1.1.0.

1. Menu Plik -> Nowy Moduł...:

   

   Kliknij "Importuj istniejący projekt".

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

3. Kliknij przycisk Zakończ. Android Studio zaimportuje bibliotekę do twojego projektu. Zsynchronizuje pliki gradle.

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

   Kliknij prawym przyciskiem myszy na folderze aplikacji - > Otwórz Ustawienia modułu - > przejdź do zakładki zależności -> kliknij przycisk " + " - > Kliknij Na zależności modułu.

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

   

5. ???

6. Zysk

Najprostszym sposobem, jaki znalazłem, aby dołączyć zewnętrzny projekt biblioteki jest (na przykład, aby dołączyć bibliotekę Facebook, która jest przechowywana jeden katalog w folderze zależności):

1. W Ustawieniach.gradle add

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

2. W budowie.gradle dependencies section, add

   compile project ('facebook')
   

Pozostaje tylko zsynchronizować projekt z plikami gradle.

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

A) skopiuj swoje *.pliki jar

B) wklej do katalogu libs pod swoimi projektami:

C) Dodaj do budowania."gradle": {]}

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

B) Jeśli twój projekt z przykładowego com.przykład.MYProject i biblioteki com.przykład.ScanAPI ma tę samą przestrzeń nazw com.przykład, Android Studio sprawdzi twoją kompilację i stworzy wszystkie niezbędne zmiany w Twoim projekcie. Potem możesz przejrzeć te ustawienia w menu Plik -> struktura projektu .

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

Pamiętaj, że opcja "struktura projektu" nie powoduje żadnych automatycznych zmian w " build.gradle " w aktualnej wersji Android Studio (0.2.3). Być może ta funkcja będzie dostępna w kolejnych wersjach.

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

Odpowiednia budowa.plik gradle zostanie zaktualizowany automatycznie.

Opcja 2: Modify build.gradle File Manually

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 projekcie panel, Control + kliknij moduł, do którego chcesz dodać zależność i wybierz Otwórz Ustawienia modułu.

Wybierz zakładkę zależności, a następnie przycisk + w lewym dolnym rogu. Możesz wybrać z poniższej listy opcji:

• Zależność Biblioteki
• Zależność Pliku
• Zależność Modułu

Możesz następnie wprowadzić więcej informacji o zależności, którą chcesz dodać do swojego projektu. Na przykład, jeśli wybierz zależność biblioteki, Android Studio wyświetla listę bibliotek do wyboru.

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

Źródło

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

W projekcie, w którym chcesz dodać zewnętrzny projekt biblioteki, przejdź do menu Plik -> Nowy - > * Importuj nowy moduł**, przejdź do projektu biblioteki, który chcesz dodać do projektu, wybierz, aby dodać moduł 'Biblioteka' w projekcie. Otrzymasz Ustawienia.gradle w twoich projektach, obok aplikacji, dołączona biblioteka, coś w tym stylu:

include ':app', ':library'

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

Compile project ( ': biblioteka')

Odbudować projekt, i to wszystko.

* możesz dodać dowolną liczbę bibliotek (modułów). W takim przypadku w Ustawieniach.gradle będziesz miał:

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

I w budowie.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 (tak jak w przypadku ABS), upewnij się, że dodajesz projekt/moduł biblioteki jako "zależność od modułu" zamiast "Biblioteki".

1. Naciśnij F4 aby wyświetlić strukturę projektu, Kliknij biblioteki lub biblioteki globalne i kliknij + aby dodać plik JAR.
2. Kliknij Moduły co chcesz dodać, wybierz zakładkę zależności, Kliknij +, i dodaj bibliotekę.

Możesz to zrobić łatwo. Przejdź do menu Plik -> Nowe -> moduł importu...:

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

Przejdź do Struktura projektu i dodaj zależność modułu :

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

Aby dodać do odpowiedzi: jeśli IDE nie pokazuje żadnego błędu, ale gdy próbujesz skompilować, dostajesz coś w stylu:

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:

Menu Plik -> struktura projektu -> Facets - >[nazwa biblioteki] - > zaznacz "moduł Biblioteki".

Edytowanie zależności bibliotek za pomocą GUI nie jest wskazane, ponieważ nie zapisuje to tych zmian w Twojej kompilacji.plik gradle. Więc twój projekt nie będzie budowany z wiersza poleceń. Powinniśmy edytować kompilację.gradle plik bezpośrednio w następujący sposób.

Na przykład dla następującej struktury:

MyProject /

• app /
• biblioteki/
  • lib1 /
  • lib2/

Możemy zidentyfikować trzy projekty. Gradle będzie odwoływał się do nich z następujące nazwy:

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

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

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

Po zaimportowaniu modułu ABS (Z plik > struktura projektu) i upewnieniu się, że ma Android 2.2 i obsługuje bibliotekę v4 jako zależności, nadal otrzymywałem następujący błąd, jak @ 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 naprawiło problem.

Pierwszy sposób to działa dla Macbooka.

Najpierw wybierz swojego budowniczego.gradle file as given screen:

Dodaj zależności jak na wybranym ekranie:

Wybierz projekt synchronizacji.

Jeśli pojawi się błąd, taki jak "projekt ze ścieżką':signature-pad 'nie można znaleźć w projekcie': app'", użyj drugiej metody:

Wybierz menu plik -> nowe -> Import Moduł...:

Po kliknięciu na moduł importu,

Podaj ścieżkę biblioteki jak w moim MacBooku:

Kliknij na Zakończ. Teraz Twoja biblioteka zostanie dodana.

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

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

Więc ponownie kompiluję bez żadnych błędów.

Jeśli masz Android Studio .0.4.0, możesz utworzyć nowy folder w swojej ścieżce budowania, YourApp/libraries. Skopiuj plik JAR. Tam, kliknij prawym przyciskiem myszy na nim i "Dodaj jako bibliotekę". Teraz masz wyskakujące okienko. Po prostu wybierz katalog i naciśnij OK, i to wszystko.

Android Studio 3.0

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

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

Zauważ, że powinieneś używać implementation zamiast compile Teraz. Jest to nowość w Android Studio 3.0. Zobacz to Q & A dla wyjaśnienia różnicy.

Znalazłem rozwiązanie. To takie proste. Wykonaj instrukcje froger_mcs.

Upewnij się, że folder src jest katalogiem źródłowym w Project Structure -> Modules (Sources).

Przykład udanego dodania kolejnej biblioteki (PullToRefresh). Działa również dla ABS libproject.

To pytanie

Ten post

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

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

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

Mam nadzieję, że to pomoże.

Otwórz plik aplikacji buildle module i dodaj swoją zależność. Jeśli pobierasz bibliotekę, po prostu zaimportuj i zbuduj jako gradle.

W Przeciwnym Razie dodaj repozytoria w aplikacji side Gradle module:

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

Pierwsze repozytoria pobierają bibliotekę za Ciebie.

I skompilować 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.

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

Apply plugin: 'com.android.biblioteka "

Następnie wykonaj następujące kroki:

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

Https://www.dropbox.com/s/1e3eteu3h0pmkf7/Android%20studio%20_doc.doc?dl=0 jest łączem Dropbox do dodawania pliku JAR i projektu biblioteki w najnowszej wersji Android Studio 1.0.1.

Proszę zapoznać się z dokumentacją z zrzutami ekranu. To bardzo proste dla nowego użytkownika.

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

Dla Android Studio:

Kliknij na Zbuduj.gradle (module: app) .

I dodaj dla

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

I w katalogu "app" utwórz katalog "libs". Dodaj plik yourfile."jar": {]}

Na koniec skompiluj pliki Gradle:

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

repositories {
    mavenCentral()
}

Zmień mavenCentral () na jcenter () i dodaj

allprojects {
    repositories {
        jcenter()
    }
}

Również napotkałem ten sam problem, a następnie zrobiłem następujące rzeczy.

1. Projekt biblioteki importuję do AndroidStudio IDE jako moduł używając menu File - > Import module menus

2. Następnie udałem się do mojego głównego modułu, w którym chcę projekt biblioteki jako projekt zależny

3. Kliknij prawym przyciskiem myszy na głównym module (w moim przypadku jego nazwa to app ) - > otwórz ustawienie modułu - > przejdź do zakładki zależności - > kliknij przycisk + (otrzymasz to po prawej stronie okna) - > kliknij na moduł zależności - > wybierz swój projekt biblioteki z listy

Zastosuj zmiany i kliknij przycisk OK.

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

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

1. Za pomocą myszki Wybierz projekt na poziomie głównym (tutaj wyświetla się nazwa Twojej aplikacji).

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

3. Po utworzeniu majątku folder, wklej lub skopiuj w nim dowolny plik JAR, którego potrzebujesz do swojej biblioteki.

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

5. Następnie wybierz nazwę projektu i przejdź do zakładki Dependencies .

6. Kliknij na znak plusa(+) w lewym dolnym rogu okna dialogowego Wybierz zależność od Pliku.

7. Na koniec otwórz niedawno utworzony folder zasoby, wybierz Skopiowane pliki JAR, a następnie kliknij Zastosuj i OK .

Wyczyść i Przebuduj swój projekt.