Android Studio: dodać słoik jako bibliotekę?

Próbuję użyć nowego Androida Studio, ale wydaje mi się, że nie działa poprawnie.

Korzystam z biblioteki Gson do serializacji / deserializacji obiektów JSON. Ale biblioteka jakoś nie została uwzględniona w kompilacji.

Stworzyłem nowy projekt z funkcją MainActivity . Skopiowałem gson-2.2.3.jar do folderu / libs i dodałem go jako zależność od biblioteki (prawy przycisk myszy-> Dodaj jako bibliotekę). Obejmuje słoik w Android Studio, więc można się do niego odwoływać z plików źródłowych.

Kiedy próbuję uruchomić projekt, nie można go skompilować, więc dodałem:

compile files('libs/gson-2.2.3.jar')

do zależności w pliku de .gradle. Następnie kompiluje się poprawnie, ale po uruchomieniu aplikacji otrzymuję ClassDefNotFoundException.

Czy ktoś wie, co robię źle?

Walczyłem z tym samym od wielu godzin, próbując doprowadzić słoik Gson do działania. W końcu go złamałem - oto kroki, które podjąłem:

1. Umieść słoik Gson (w moim przypadku gson-2.2.4.jar) w libsfolderze
2. Kliknij go prawym przyciskiem myszy i kliknij „Dodaj jako bibliotekę”

3. Upewnij się, że compile files('libs/gson-2.2.4.jar')jest w twoim build.gradlepliku (lub compile fileTree(dir: 'libs', include: '*.jar')jeśli używasz wielu plików jar)

   Edycja: Użyj implementation files('libs/gson-2.2.4.jar')(lub implementation fileTree(dir: 'libs', include: '*.jar')) w Android Studio 3.0+

4. Wykonaj czystą kompilację (prawdopodobnie możesz to zrobić dobrze w Android Studio, ale aby upewnić się, że nawigowałem w terminalu do folderu głównego mojej aplikacji i gradlew cleanpisałem. Jestem w systemie Mac OS X, polecenie może być inne w twoim systemie

Po wykonaniu powyższych czterech czynności zaczęło działać dobrze. Myślę, że krok „Dodaj jako bibliotekę” był tym, za którym wcześniej tęskniłem i nie zadziałał, dopóki go nie wyczyściłem.

[Edytuj - dodano build.gradlekrok, który jest również konieczny, jak zauważyli inni]

Oto instrukcje dodawania lokalnego pliku jar jako biblioteki do modułu:

1. Utwórz folder „libs” na najwyższym poziomie katalogu modułu (ten sam katalog, który zawiera katalog „src”)

   

2. W build.gradle filedodatku następujących tak, że zamknięcie ma zależności:

   dependencies {
       // ... other dependencies
       compile files('libs/<your jar's name here>')
   }

3. Android Studio powinien już mieć skonfigurowane opakowanie gradlew. Z wiersza polecenia przejdź do najwyższego poziomu projektu (katalogu, w którym znajduje się gradlewplik).

   Uruchom ./gradlew assemble. To powinno skompilować projekt z biblioteką. W razie potrzeby może być konieczne naprawienie błędów w pliku build.gradle.

4. Aby Android Studio rozpoznał lokalne pliki jar jako biblioteki do obsługi podczas kodowania w IDE, musisz wykonać kilka dodatkowych kroków:

   4.1 Kliknij moduł prawym przyciskiem myszy i wybierz Open Library Settings.

   

   4.2 W lewym panelu okna dialogowego wybierz Libraries.

   4.3 Kliknij +znak nad panelem drugi od lewej ->Java

   

   4.4 Wybierz lokalny słoik i dodaj go do projektu.

5. Może być konieczne ponowne uruchomienie powyższego ./gradlewpolecenia

W projekcie kliknij prawym przyciskiem myszy

-> new -> module
-> import jar/AAR package
-> import select the jar file to import
-> click ok -> done

Wykonaj poniższe zrzuty ekranu:

1:

2:

3:

Zobaczysz to:

W Androidzie Stuido lubię używać Gradle do zarządzania biblioteką Gson.

Dodaj poniżej zależności w pliku build.gradle.

repositories {mavenCentral()}

dependencies {compile 'com.google.code.gson:gson:2.2.4'}

Wszystko w porządku.

Możesz także zobaczyć ten post. Najlepszy sposób na zintegrowanie biblioteki innej firmy w Android Studio

IIRC, samo użycie „Dodaj jako bibliotekę” nie wystarczy, aby skompilowało się z projektem.

Sprawdź pomoc firmy Intellij na temat dodawania bibliotek do projektu

To, co powinno Cię najbardziej zainteresować, to:

(W File > Project Structure) Otwórz ustawienia modułu i wybierz kartę Zależności.

Na karcie Zależności kliknij dodaj i wybierz Biblioteka.

W oknie dialogowym Wybierz biblioteki wybierz jedną lub więcej bibliotek i kliknij Dodaj wybrane.

Jeśli biblioteka nie pojawia się w oknie dialogowym, dodaj ją w ustawieniach bibliotek, bezpośrednio pod modułami.

Nie trzeba compile files()już dodawać , a biblioteka powinna zostać poprawnie dodana do projektu.

Wszystkie te rozwiązania są przestarzałe. Teraz w Android Studio jest to naprawdę łatwe:

Plik> Nowy moduł ...

Następny ekran wygląda dziwnie, jakbyś wybierał jakiś widżet lub coś, ale trzymaj go na pierwszym obrazku, a poniżej przewiń i znajdź „Importuj plik JAR lub .AAR”

Następnie weź Project Structurez menu Plik. Wybierz appw otwartym oknie, a następnie wybierz dependencies, a następnie naciśnij green plus button, wybierz, module dependencya następnie wybierz moduł zaimportowany, a następnie naciśnijOK

Proste kroki, aby dodać bibliotekę zewnętrzną w Android Studio

1. Jeśli korzystasz z widoku Android w Eksploratorze projektów, zmień go na Widok projektu, jak poniżej

2. Kliknij prawym przyciskiem myszy żądany moduł, do którego chcesz dodać bibliotekę zewnętrzną, a następnie wybierz Nowy> Directroy i nazwij go jako „ libs ”
3. Teraz skopiuj plik blah_blah.jar do folderu „ libs ”
4. Kliknij prawym przyciskiem myszy plik blah_blah.jar, a następnie wybierz opcję „ Dodaj jako bibliotekę .. ”. Spowoduje to automatyczne dodanie i wpisanie do pliku build.gradle jako plików kompilacji („libs / blah_blah.jar”) i synchronizację stopnia. I gotowe

Uwaga: Jeśli korzystasz z bibliotek stron trzecich, lepiej jest użyć zależności, w których skrypt Gradle automatycznie pobiera plik JAR i plik JAR zależności podczas uruchamiania skryptu gradle.

Przykład: kompiluj „com.google.android.gms: play-services-ads: 9.4.0”

Przeczytaj więcej o zarządzaniu stopniem zależności

„kompiluj pliki ...” działało dla mnie, ale już nie. po dużym bólu stwierdziłem, że zamiast tego działa to:

compile fileTree(dir: 'libs', include: '*.jar')

Nie mam pojęcia, dlaczego to miało znaczenie, ale przynajmniej ta cholerna rzecz działa teraz.

1. Pobierz plik biblioteki ze strony internetowej
2. Kopiuj z Eksploruj Windows
3. Wklej do folderu lib z Eksploratora projektu
4. Ctrl+ Alt+ Shift+ Sotwórz strukturę projektu
5. Wybierz kartę Zależności, dodaj plik za pomocą +
6. Pasek narzędzi Zsynchronizuj projekt z plikiem stopni za pomocą przycisku

To rozwiązało mój problem. Spróbuj, jeśli ktoś chce więcej szczegółów, daj mi znać.

Zrobiłem to, dodając tylko jedną linię do build.gradle:

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar']) ----> AS creates this
    implementation 'com.google.code.gson:gson:2.3.1'   ----------> I added this one
}

Nie zapomnij kliknąć Sync noww prawym górnym rogu.

Używam Androida Studio 1.0.1.

Uważam, że Dependency Manager z Android Studio jest dość przydatny i potężny do zarządzania zależnościami innych firm (jak wspomniany tutaj gson). Udostępnienie przewodnika krok po kroku, który działał dla mnie (UWAGA: te kroki są testowane dla Androida Studio 1.6 i nowszych wersji na platformie Windows).

Krok 1: Idź do „Kompiluj> Edytuj biblioteki i zależności ...” otworzy się okno dialogowe „Struktura projektu”

Krok 2: Wybierz „aplikację”, a następnie zakładkę „Zależności”. Następnie wybierz „Dodaj> 1 zależność biblioteki”

Krok 3: Zostanie wyświetlone okno dialogowe „Wybierz zależność biblioteki”, określ „gson” w wyszukiwaniu i naciśnij przycisk „Szukaj”

Krok 4: Pożądana zależność zostanie wyświetlona na liście wyszukiwania, wybierz com.google.code.gson: gson: 2.7 (jest to najnowsza wersja w momencie, gdy napisałem odpowiedź), naciśnij OK

Naciśnij OK w oknie dialogowym „Struktura projektu”. Gradle odpowiednio zaktualizuje skrypty kompilacji.

Mam nadzieję, że to pomoże :)

1. Umieść słoik (w moim przypadku gson-2.2.4.jar) w folderze libs.

2. Upewnij się, że pliki kompilacji ( libs/gson-2.2.4.jar) znajdują się w pliku build.gradle.

3. Teraz kliknij „Synchronizuj projekt z plikami Gradle” (od lewej do przycisku Menedżera AVD na górnym pasku).

Po wykonaniu powyższych trzech czynności zaczęło działać dobrze.

Pobierz i skopiuj swój .jarplik do libsfolderu, a następnie dodaj tę linię do build.gradle:

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.google.code.gson:gson:2.3.1'
}

Nie zapomnij kliknąć „Synchronizuj teraz”

Możesz to zrobić za pomocą dwóch opcji.

pierwszy prosty sposób.

Skopiuj plik .jar do schowka, a następnie dodaj go do folderu libs. Aby zobaczyć folder libs w projekcie, wybierz projekt z combobox nad folderami.

następnie kliknij prawym przyciskiem myszy plik .jar i kliknij dodaj jako bibliotekę, a następnie wybierz moduł, a następnie ok. Plik .jar można zobaczyć w pliku build.gradle w bloku zależności.

 dependencies {
        implementation fileTree(dir: 'libs', include: ['*.jar'])
        implementation 'com.android.support:appcompat-v7:21.0.3'
        implementation project(':okhttp-2.0.0')
        implementation 'com.google.code.gson:gson:2.3.1'
    }

Po drugie: możemy dodać plik .jar do modułu, importując ten plik .jar jako moduł .jar, a następnie dodaj ten moduł do dowolnego modułu, który chcemy.

moduł importu ---> wybierz plik .jar -> niż importuj jako .jar -

Następnie CTRL + ALT + SHIFT + S -> projektu wytrzymałość -> wybierz moduł, który chcesz, aby dodać słoik -> Zależności -> Zależność modułu. build.gradle modułu zostanie zaktualizowany automatycznie.

Zrobiłem ponad 3 kroki i jego urok pracy dla mnie.

(Używam Android Studio 2.1.2)

Krok 1

• Dodaj nazwę pakietu jar (jako przykład compile 'com.squareup.okhttp3:okhttp:3.3.1') do skryptu budowania stopni w build.gradle (Module: app) .

Krok 2: Kliknij prawym przyciskiem myszy folder aplikacji -> Nowy -> Moduł

Krok 3: Kliknij opcję Importuj pakiet JAR / .AAR, a następnie przejrzyj swój pakiet. jako przykład: OkHttp.jar

W systemie Android Studio 3+:

Powinieneś być w stanie po prostu skopiować plik jar do folderu libs bezpośrednio pod folderem aplikacji.

... myproject \ app \ libs \ myfile.jar

Następnie wybierz Pliki projektu z menu rozwijanego w oknie Projekty, kliknij prawym przyciskiem myszy projekt, wybierz Synchronizuj, aby zobaczyć plik w plikach projektu. Automatycznie doda zależności w pliku stopni (Moduł: aplikacja).

dependencies {
...
    implementation files('libs/myfile.jar')

Oto inne rozwiązanie:

Przejdź do widoku Pliki projektu (wybierz Pliki projektu z menu rozwijanego).

Wybierz Nowy ... Katalog, utwórz folder o nazwie libs bezpośrednio w aplikacji.

Otwórz Eksploratora plików, skopiuj i wklej plik jar do folderu libs.

W Android Studio kliknij prawym przyciskiem myszy plik jar i wybierz Dodaj jako bibliotekę ... z menu podręcznego.

Plik powinien zostać wyświetlony na liście zależności w pliku stopni:

dependencies {
...
    implementation files('libs/myfile.jar')
}

Otwórz plik Java i dodaj tam instrukcję importu:

import com.xxx.xxx;

Umieść .jarpliki w libsfolderze projektu Android.

Następnie dodaj ten wiersz kodu do pliku oceny aplikacji:

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

W przypadku wersji Androida 3.0 i nowszej wersji lepiej jest użyć tego:

    implementation fileTree(dir: 'libs', include: ['*.jar'])

W przeciwieństwie do Eclipse nie musimy pobierać słoika i umieszczać go w folderze / libs. Gradle obsługuje te rzeczy, musimy tylko dodać zależności Gradle, Gradle pobiera je i umieszcza w pamięci podręcznej gradle.

Musimy dodać zależności, ponieważ:

zależności {wdrożenie 'com.google.code.gson: gson: 2.2.4'}

to wszystko Jednak możemy również pobrać jar i dodać to jako bibliotekę, ale najlepszą praktyką jest dodanie zależności Gradle.

menu File -> project struct -> module select "app" -> dependencies tab -> + button 
-> File dependency -> PATH/myfile.jar

Krok 1: Teraz app folderpowinieneś zobaczyć libs, jeśli go nie widzisz, a następnie utwórz go .

Krok 2: Drag & Drop the .jar file heremoże pojawić się monit "This file does not belong to the project", wystarczy kliknąć OKprzycisk.

Krok 3: Teraz powinieneś zobaczyć plik jar w folderze libs , kliknij prawym przyciskiem myszy plik jar i wybierz"Add as library", Click OK for prompt "Create Library"

Krok 4: Teraz ten słoik został dodany.

Utwórz bibliotekę lib. Dodaj swój plik .jar. Kliknij go prawym przyciskiem myszy, a zobaczysz, że dodaj słoik jako zależność. Kliknij na to. To wszystko, co musisz zrobić. Można znaleźć zależności dodane do pliku build.gradle.

1) utwórz folder „your_libs” w folderze Project / app / src.

2) Skopiuj plik jar do tego folderu „your_libs”

3) W Android Studio przejdź do Plik -> Struktura projektu -> Zależności -> Dodaj -> Zależność pliku i przejdź do pliku jar, który powinien znajdować się w obszarze „src / your_libs”

3) Wybierz plik jar i kliknij „Ok”

a następnie możesz zobaczyć na swoim build.gradle w następujący sposób: skompiluj pliki ('src / your_libs / your.jar')

W Android Studio 1.1.0. Rozwiązałem to pytanie, wykonując następujące czynności:

1: Umieść plik jar w katalogu libs. (w Finderze)

2: Otwórz ustawienia modułu, przejdź do Zależności, w lewym dolnym rogu znajduje się przycisk plus. Kliknij przycisk plus, a następnie wybierz „Zależność pliku”. Tutaj możesz zobaczyć plik jar. Wybierz i zostanie rozwiązany.

Przeczytałem wszystkie odpowiedzi tutaj i wszystkie wydają się obejmować stare wersje Android Studio!

Dzięki projektowi utworzonemu w Android Studio 2.2.3 po prostu musiałem utworzyć libskatalog podapp i umieścić tam mój słoik. Zrobiłem to z moim menedżerem plików, nie trzeba klikać ani edytować niczego w Android Studio.

Dlaczego to działa? Otwórz Kompiluj / Edytuj biblioteki i zależności, a zobaczysz:

{include=[*.jar], dir=libs}

W systemie Mac OS X:

1. Dodaj słoik jako bibliotekę (przeciągnij słoik do bibliotek, kliknij prawym przyciskiem myszy dodaj jako lib)

2. Dodaj instrukcję kompilacji do build.grade

3. Zainstaluj gradle v1.6(użyj Homebrew)

   • stopień instalacji parzenia
   • stopień -v
   • jeśli nie v1.6, uaktualnij homebrew

4. gradle clean (odbudowa Androida nie działała)

To mnie załatwiło.

Jak wielu wcześniej wspomniałem, należy dodać

compile files('libs/gson-2.2.3.jar') 

do pliku build.gradle.

Mam jednak projekt w Android Studio, który został migrowany z Eclipse iw tym przypadku folder „libs” nosi nazwę „lib”, więc usunięcie „s” rozwiązało problem.

1. Dodano libsfolder na poziomie app.
2. Dodano wszystko jarsw tym projekcie.
3. Następnie zaznacz wszystkie słoiki w libsfolderze,
4. kliknij wybrane elementy prawym przyciskiem myszy i powiedz add library
5. wtedy znajdziesz opcję rozszerzenia słoików w samym eksploratorze projektu.

Zauważyłem CTRL+ ALT+ SHIFT+ S-> strukturę projektu -> moduł aplikacji -> Zależności " początkowo miałem wpis jak (dir: 'libs', include: '*.jar')poniżej compile-option. A po dodaniu słoika zgodnie z powyższymi krokami, build.gradleotrzymałem wpisy dla nowego dodanego sam słoik.

W Android Studio 2.1 postępuję w ten sposób,

Idź do aplikacji -> src-> main -> folder zasobów (jeśli nie jest dostępny, utwórz go) -> umieść pliki JAR

W swoim build.gradle dodaj taką zależność,

implementation files('src/main/assets/jsoup.jar')
implementation files('src/main/assets/org-apache-xmlrpc.jar')
implementation files('src/main/assets/org.apache.commons.httpclient.jar')
implementation files('src/main/assets/ws-commons-util-1.0.2.jar')

Synchronizuj teraz. Teraz Twoje pliki JAR są gotowe do użycia.

W przypadku nowszego Androida 1.0.2 w pliku build.gradle znajduje się już następujący element

implementation fileTree(include: ['*.jar'], dir: 'libs')

Dodaj słoik z biblioteką do folderu libs -> kliknij prawym przyciskiem myszy bibliotekę -> kliknij dodaj jako bibliotekę -> poprosi cię o dodanie projektu do - - wybierz projekt -> kliknij ok Następujący wiersz zostanie automatycznie dodany do kompilacji .gradle

implementation files('libs/android-query.jar')

To mi zrobiło. nic więcej nie było wymagane. Pokazałem to dla Androida Aquery innej biblioteki innej firmy dla Androida.

Moja odpowiedź polega w zasadzie na zebraniu niektórych poprawnych, ale niepełnych odpowiedzi podanych powyżej.

1. Otwórz build.gradle

2. Dodaj następujące:

   dependencies {
   compile 'com.android.support:appcompat-v7:19.+'
   compile fileTree(dir: 'libs', include: ['*.jar'])
   compile 'com.google.code.gson:gson:2.3'
   }

   Umożliwi to obsługę dwóch różnych sposobów dodawania zależności. compile fileTree(dir: 'libs', include: ['*.jar'])(Jak wspomniano @Binod) informuje kompilator, aby zajrzeć pod bibliotekami dla dowolnego folderu słoika. Dobrą praktyką jest tworzenie takiego folderu „libs”, który będzie zawierał pakiety jar, z których musi korzystać nasza aplikacja.

Pozwoli to również na obsługę zależności Maven. Kompilacji 'com.google.code.gson:gson:2.3'(jak wspomniano przez @saneryee) jest inny zalecany sposób, aby dodać zależności, które są w centrum zdalnego repozytorium, a nie w naszym / libs „lokalnym repozytorium”. Zasadniczo informuje gradla, aby szukał tej wersji tego pakietu, i informuje kompilator, aby wziął go pod uwagę podczas kompilowania projektu (umieszczenie go w ścieżce klas)

PS: Używam obu