Android Studio: dodać jar jako bibliotekę?

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

1. Utwórz folder 'libs' na najwyższym poziomie katalogu modułu (tego samego katalogu, który zawiera katalog 'src')

   

2. W build.gradle file Dodaj tak aby Twoje zależności miały:

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

3. Android Studio powinno już skonfigurować okładkę gradlew. Z wiersza poleceń Przejdź na najwyższy poziom swojego project (katalog zawierający plik gradlew).

   Run ./gradlew assemble. To powinno skompilować projekt z biblioteką. Może być konieczne naprawienie błędów w kompilacji.plik gradle w razie potrzeby.

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

   4.1. Kliknij prawym przyciskiem myszy na module w lewym panelu i wybierz Open Library Settings.

   

   4.2. Na lewym panelu w oknie dialogowym Wybierz Libraries.

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

   

   4.4. Wybierz swój lokalny jar i dodaj go do projektu.

5. Może być konieczne uruchomienie powyższej komendy ./gradlew Jeszcze raz

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:

IIRC, samo użycie "Add as library" nie wystarcza do kompilacji z projektem.

Sprawdź pomoc Intellij o dodawaniu bibliotek do projektu

Część, która powinna cię najbardziej zainteresować jest taka:

(W File > Project Structure) Otwórz Ustawienia modułu i wybierz zakładkę zależności.

Na karcie zależności kliknij przycisk Dodaj i wybierz opcję 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, tuż pod modułami.

Nie powinieneś już dodawać compile files(), A biblioteka powinna być odpowiednio dodana do twojego projektu.

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

Dodaj poniżej zależności w swojej kompilacji.plik gradle.

repositories {mavenCentral()}

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

Możesz również zobaczyć ten post. najlepszy sposób na integrację biblioteki innych firm w Android studio

Wszystkie te rozwiązania są przestarzałe. To naprawdę proste teraz w Android Studio:

Plik > Nowy Moduł...

Następny ekran wygląda dziwnie, jakbyś wybierał jakiś widget lub coś, ale zachowaj go na pierwszym zdjęciu i poniżej Przewiń i znajdź " Importuj JAR lub .Pakiet AAR "

Następnie wybierz Project Structure z menu Plik.Wybierz app z otwartego okna wybierz dependencies, następnie naciśnij green plus button, Wybierz module dependency Następnie wybierz importowany moduł, a następnie naciśnij OK

' kompilować pliki... kiedyś dla mnie pracował, ale już nie. po wielu bólach stwierdziłem, że używanie tego zamiast tego działa:

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

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

1. Jeśli jesteś w widoku Android w Eksploratorze projektu, zmień go na Project widok jak poniżej

1. Kliknij prawym przyciskiem myszy odpowiedni moduł, do którego chcesz dodać bibliotekę zewnętrzną, a następnie wybierz New > Directroy i nazwij go jako "libs "
2. skopiuj blah_blah.jar do " libs " folder
3. Kliknij prawym przyciskiem myszy na blah_blah.jar, następnie wybierz ' Dodaj jako bibliotekę..'. Spowoduje to automatyczne dodanie i wpisanie w build.gradle as compile files ('libs / blah_blah.jar') i zsynchronizować gradle. I jesteś skończony

Uwaga: Jeśli korzystasz z bibliotek innych firm, lepiej jest użyć dependencies gdzie Gradle script automatycznie pobiera JAR i Jar zależności, gdy gradle uruchom skrypt.

Ex: compile ' com.google.android.gms: play-usługi-ogłoszenia:9.4.0'

Read more about Gradle Dependency Mangement

1. Pobierz plik biblioteki ze strony internetowej
2. Kopiowanie z Windows explore
3. Wklej do folderu Lib z Project Explorer
4. Ctrl+Alt+Shift+S otwarta struktura projektu
5. wybierz zakładkę zależności, Dodaj plik za pomocą +
6. projekt synchronizacji paska narzędzi z plikiem gradle za pomocą przycisku

Udało mi się to poprzez dodanie jednej linii do budowania."gradle": {]}

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

Nie zapomnij kliknąć "Synchronizuj teraz" w prawym górnym rogu.

Znalazłem Menedżera zależności Android Studio dość poręczny i potężny do zarządzania 3rd party zależności (jak gson wspomniano tutaj). Zapewnienie przewodnika krok po kroku, który działał dla mnie (uwaga: te kroki są testowane dla Android Studio 1.6 i nowszych wersji na platformie Windows).

Krok-1: Goto " Build > Edytuj Biblioteki i zależności..."otworzy okno dialogowe" struktura projektu "

Krok-2: Wybierz "app", a następnie wybierz Zakładka "zależności". Następnie wybierz "dodaj > 1 zależność od Biblioteki"

Krok-3: Zostanie wyświetlone okno dialogowe "wybierz zależność Biblioteki", określ" gson " w wyszukiwaniu i naciśnij przycisk "Szukaj"

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

Naciśnij OK w oknie dialogowym "struktura projektu". Gradle zaktualizowałby odpowiednio Twoje Skrypty budowania.

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

1. włóż słoik (w moim przypadku gson-2.2.4.jar) do folderu libs.

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

3. Teraz kliknij "Synchronizuj Projekt z plikami Gradle"(po lewej stronie do przycisku AVD manager na górnym pasku).

Po wykonaniu powyższych trzech, zaczęło działać dobrze.

Pobierz i skopiuj swój plik {[1] } do folderu libs, a następnie dodaj te linie do budowania."gradle": {]}

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

Nie zapomnij kliknąć "Synchronizuj teraz"

Android Studio 1.1.0

W przeciwieństwie do Eclipse nie musimy pobierać Jara i umieszczać go w folderze / libs. Gradle zajmuje się tymi rzeczami musimy tylko dodać zależności Gradle, Gradle pobiera je i umieszcza w gradle cache.

Musimy dodać zależności jako:

Dependencies {compile ' com.google.kod.gson: gson:2.2.4'}

Thats it Możemy jednak również pobrać jar i dodać go jako bibliotekę, ale najlepszą praktyką jest dodanie zależności Gradle.

Możesz to zrobić z dwoma opcjami.

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

Następnie kliknij prawym przyciskiem myszy na .plik jar i kliknij Dodaj jako bibliotekę, a następnie wybierz moduł, a następnie ok. Możesz zobaczyć .plik jar w build.plik gradle w bloku zależności.

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

Drugi sposób jest taki: możemy dodać .plik jar do modułu poprzez import to .plik jar jako .moduł jar następnie dodaj ten moduł do dowolnego modułu, który chcemy.

Moduł importu - - - > wybierz swój.plik jar -- > niż import jako .jar --

Następnie CTRL + ALT+SHIFT + S --> project sturure -->wybierz moduł, który chcesz dodać jar -->Dependencendies -- > Dependency Module. buduj.gradle modułu będzie aktualizowany automatycznie.

Po prostu umieść pliki .jar w folderze libs projektu Android.

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

Ta linia kodu w pliku apps graddle zrobi resztę.

Happy Coding :)

Zrobiłem powyżej 3 kroki i jego pracy urok dla mnie.

(używam Android Studio 2.1.2)

Krok 1

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

Krok 2: Kliknij prawym przyciskiem myszy na app folder -> New - > Moduł

Krok 3: Kliknij Importuj JAR/.Pakiet AAR następnie przejrzyj pakiet. jako przykład: OkHttp.jar

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

Na Mac OS X:

1. Dodaj jar jako bibliotekę (przeciągnij jar do libs, kliknij prawym przyciskiem myszy Dodaj jako lib)

2. Dodaj instrukcję kompilacji do build.grade

3. Install gradle v1.6 (Użyj homebrew)

   • brew install gradle
   • gradle-v
   • jeśli nie v1.6, upgrade homebrew

4. Gradle clean (rebuild android nie działa)

Utwórz katalog libs. Dodaj swój .plik jar. Kliknij prawym przyciskiem myszy na nim, a znajdziesz add jar jako zależność. / Align = "left" / To wszystko, co musisz zrobić. Możesz znaleźć zależności dodane do Twojej kompilacji.plik gradle.

1) Utwórz folder 'your_libs' wewnątrz folderu Project/app / src.

2) Skopiuj plik jar do folderu 'your_libs'

3) W Android Studio przejdź do File - > project Structure -> Dependencies -> Add - > File Dependency i przejdź do pliku jar, który powinien znajdować się pod 'src/your_libs'

3) Wybierz plik jar i kliknij ' Ok '

I wtedy możesz zobaczyć na swojej budowie.gradle like this: compile files ('src / your_libs / your.jar')

W android Studio 1.1.0 . Rozwiązałem to pytanie, wykonując następujące kroki:

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ść od Pliku".Tutaj możesz zobaczyć plik jar. Wybierz go i zostanie rozwiązany.

Krok 1: teraz pod twoim app folder powinieneś zobaczyć libs, jeśli go nie widzisz, utwórz go.

Krok 2 : Drag & Drop the .jar file here, możesz uzyskać monit "This file does not belong to the project", wystarczy kliknąć OK guzik .

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

Krok 4: Teraz to jar został dodano.

Z Android Studio 3+:

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

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

Następnie wybierz pliki projektów z listy rozwijanej w oknie projekty, kliknij prawym przyciskiem myszy projekt, wybierz Synchronizuj, aby zobaczyć plik w plikach projektów. Automatycznie doda zależności w pliku gradle (moduł: app).

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

Oto inne rozwiązanie:

Przejdź do projektu Widok plików (z listy rozwijanej wybierz pliki projektów).

Wybierz Nowy... Katalog, utwórz folder o nazwie libs tuż pod aplikacją.

Otwórz Eksplorator 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.

Powinieneś zobaczyć Plik z listy zależności w plik gradle:

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

Otwórz plik java i dodaj tam instrukcję import:

import com.xxx.xxx;

Jak wielu wcześniej wskazało, należy dodać

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

Do twojej budowy.plik gradle.

Mam jednak projekt w Android Studio, który został przeniesiony z Eclipse i w tym przypadku folder "libs" nazywa się "lib", więc dla mnie usunięcie " s " rozwiązało problem.

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

W projekcie stworzonym z Androidem Studio 2.2.3 potrzebowałem tylko utworzyć libs katalog pod app i umieścić tam mój jar. Zrobiłem to z moim menedżerem plików, nie trzeba klikać ani edytować niczego w Android Studio.

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

compile fileTree(dir: 'libs', include: '*.jar') działa dobrze, ale nie compile files(...) zostały przetestowane z Studio Beta 0.8.1

Moja odpowiedź polega zasadniczo na zebraniu niektórych właściwych, ale niekompletnych odpowiedzi podanych powyżej.

1. Open build.gradle

2. Dodać:

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

   Pozwoli to na obsługę dwóch różnych sposobów dodawania zależności. compile fileTree(dir: 'libs', include: ['*.jar']) (jak wspomniał @Binod) mówi kompilatorowi, aby szukał pod katalogami libs dowolnego jar. Dobrą praktyką jest utworzenie takiego folderu 'libs', który będzie zawierał Pakiety jar, które nasza aplikacja musi użyj.

Ale pozwoli to również na obsługę zależności Mavena. Kompilacja 'com.google.code.gson:gson:2.3' (jak wspomniał @saneryee) jest kolejnym zalecanym sposobem dodawania zależności, które znajdują się w centralnym zdalnym repozytorium, a nie w naszym /libs "repozytorium lokalnym". W zasadzie mówi gradle, aby szukał tej wersji pakietu i mówi kompilatorowi, aby wziął to pod uwagę podczas kompilacji projektu (mając go w classpath)

PS: używam obu

Dla nowszego Androida 1.0.2 poniżej znajduje się już w Twojej kompilacji.gradle file

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

Dodaj słoik biblioteki do folderu libs - > kliknij prawym przyciskiem myszy bibliotekę - > kliknij przycisk Dodaj jako bibliotekę- > poprosi o dodanie projektu - > wybierz swój projekt - > kliknij ok Następująca linia jest automatycznie dodawana do budowania.gradle

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

To mi pomogło. nic więcej nie było wymagane. pokazałem to dla Androida aquery kolejna biblioteka innej firmy dla Androida.

1. Dodano folder " libs "na poziomie"app".
2. Dodano wszystkie "słoiki" w tym projekcie.
3. następnie zaznaczono wszystkie słoiki, w folderze "libs",
4. Kliknij prawym przyciskiem myszy wybrane elementy i powiedz "dodaj bibliotekę"
5. następnie znajdziesz opcję Rozszerzenia jars w samym Eksploratorze projektu.

Zauważyłem "CTRL + ALT + SHIFT + s -- > struktura projektu -- >app-module -- > zależności" już miał wpis jako "(dir: 'libs', include: '*.jar') " pod "compile-option", początkowo. I po dodaniu słoika zgodnie z krokami podanymi powyżej, " build.gradle " otrzymał wpisy do nowego dodanego Jara.