Android Studio: aggiungi jar come libreria?

Sto cercando di utilizzare il nuovo Android Studio ma non riesco a farlo funzionare correttamente.

Sto usando la libreria Gson per serializzare / deserializzare gli oggetti JSON. Ma la libreria in qualche modo non è inclusa nella build.

Avevo creato un nuovo progetto con solo una MainActivity . Copiato gson-2.2.3.jar nella cartella / libs e aggiunto come dipendenza della libreria (clic destro-> Aggiungi come libreria). Ciò include il jar in Android Studio in modo che possa essere referenziato dai file di origine.

Quando provo a eseguire il progetto, non può essere compilato, quindi ho aggiunto:

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

alle dipendenze nel file de .gradle. Dopodiché si compila correttamente ma quando eseguo l'applicazione ottengo un ClassDefNotFoundException.

Qualcuno sa cosa sto facendo di sbagliato?

Ho lottato con la stessa cosa per molte ore, cercando di far funzionare il vaso Gson non meno. Alla fine l'ho risolto: ecco i passaggi che ho preso:

1. Metti il ​​vaso Gson (nel mio caso gson-2.2.4.jar) nella libscartella
2. Fai clic destro e premi 'Aggiungi come libreria'

3. Assicurati che compile files('libs/gson-2.2.4.jar')sia nel tuo build.gradlefile (o compile fileTree(dir: 'libs', include: '*.jar')se stai usando molti file jar)

   Modifica: usa implementation files('libs/gson-2.2.4.jar')(o implementation fileTree(dir: 'libs', include: '*.jar')) in Android Studio 3.0+

4. Fai una build pulita (probabilmente puoi farlo bene in Android Studio, ma per assicurarti che ho navigato in un terminale nella cartella principale della mia app e gradlew cleanho digitato . Sono su Mac OS X, il comando potrebbe essere diverso sul tuo sistema

Dopo aver fatto quanto sopra quattro, ha iniziato a funzionare bene. Penso che il passaggio "Aggiungi come libreria" fosse quello che avevo perso in precedenza e non ha funzionato fino a quando non l'ho pulito.

[Modifica - aggiunto il build.gradlepassaggio necessario anche come altri hanno sottolineato]

Ecco le istruzioni per aggiungere un file jar locale come libreria a un modulo:

1. Creare una cartella 'libs' nel livello superiore della directory del modulo (la stessa directory che contiene la directory 'src')

   

2. Nel build.gradle fileaggiungere quanto segue in modo che la chiusura delle dipendenze abbia:

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

3. Android Studio dovrebbe aver già installato un wrapper gradlew. Dalla riga di comando, vai al livello superiore del tuo progetto (la directory che ha un gradlewfile).

   Corri ./gradlew assemble. Questo dovrebbe compilare il progetto con la libreria. Potrebbe essere necessario correggere gli errori nel file build.gradle, se necessario.

4. Affinché Android Studio riconosca i file jar locali come librerie per il supporto durante la codifica nell'IDE, è necessario eseguire alcuni altri passaggi:

   4.1. Fai clic con il pulsante destro del mouse sul modulo nel riquadro di sinistra e scegli Open Library Settings.

   

   4.2. Nel riquadro sinistro della finestra di dialogo, selezionare Libraries.

   4.3. Fare clic sul +segno sopra il secondo pannello da sinistra ->Java

   

   4.4. Seleziona il tuo vaso locale e aggiungilo al progetto.

5. Potrebbe essere necessario eseguire il ./gradlewcomando sopra ancora una volta

Nel progetto fare clic con il tasto destro

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

Segui le schermate seguenti:

1:

2:

3:

Vedrai questo:

In Android Stuido, mi piace usare Gradle per gestire la libreria Gson.

Aggiungi la dipendenza seguente nel tuo file build.gradle.

repositories {mavenCentral()}

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

Va tutto bene.

Puoi anche vedere questo post. Il modo migliore per integrare la libreria di terze parti in Android Studio

IIRC, semplicemente usando "Aggiungi come libreria" non è sufficiente per la compilazione con il progetto.

Controlla l'aiuto di Intellij sull'aggiunta di librerie a un progetto

La parte che dovrebbe interessarti di più è questa:

(In File > Project Structure) Apri le impostazioni del modulo e seleziona la scheda Dipendenze.

Nella scheda Dipendenze, fare clic su Aggiungi e selezionare Libreria.

Nella finestra di dialogo Scegli librerie, selezionare una o più librerie e fare clic su Aggiungi selezionati.

Se la libreria non viene visualizzata nella finestra di dialogo, aggiungila nelle impostazioni Librerie, proprio sotto Moduli.

Non dovresti aggiungere compile files()altro e la libreria dovrebbe essere correttamente aggiunta al tuo progetto.

Tutte queste soluzioni sono obsolete. È davvero facile ora in Android Studio:

File> Nuovo modulo ...

La schermata successiva sembra strana, come se stessi selezionando un widget o qualcosa del genere, ma tienilo nella prima immagine e sotto scorri e trova "Importa JAR o .AAR Package"

Quindi prendere Project Structuredal menu File. Selezionare appdalla finestra aperta, quindi selezionare dependencies, quindi premere green plus button, selezionare, module dependencyquindi selezionare il modulo importato, quindi premereOK

Semplici passaggi per aggiungere una libreria esterna in Android Studio

1. Se sei in Visualizzazione Android in Esplora progetti, modificalo in Visualizzazione progetto come di seguito

2. Fare clic con il tasto destro del mouse sul modulo desiderato in cui si desidera aggiungere la libreria esterna, quindi selezionare Nuovo> Directroy e denominarlo come " libs "
3. Ora copia blah_blah.jar nella cartella ' libs '
4. Fai clic con il pulsante destro del mouse su blah_blah.jar, quindi seleziona " Aggiungi come libreria ... ". Questo aggiungerà e inserirà automaticamente in build.gradle come file di compilazione ('libs / blah_blah.jar') e sincronizzerà il gradle. E il gioco è fatto

Nota: se si utilizzano librerie di terze parti, è preferibile utilizzare le dipendenze in cui lo script Gradle scarica automaticamente il JAR e il JAR delle dipendenze quando viene eseguito lo script gradle.

Esempio: compila "com.google.android.gms: play-services-ads: 9.4.0"

Ulteriori informazioni su Gradle Dependency Mangement

"compilare file ..." funzionava per me, ma non più. dopo molto dolore, ho scoperto che l'utilizzo di questo invece funziona:

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

Non ho idea del perché ciò abbia fatto la differenza, ma almeno la dannata cosa sta funzionando ora.

1. Scarica il file della libreria dal sito Web
2. Copia da windows esplora
3. Incolla nella cartella lib da Esplora progetti
4. Ctrl+ Alt+ Shift+ Sapri la struttura del progetto
5. Selezionare la scheda Dipendenze, aggiungere il file utilizzando +
6. Barra degli strumenti Sincronizza il progetto con il file gradle utilizzando il pulsante

Ciò ha risolto il mio problema. Prova, se qualcuno vuole maggiori dettagli fammelo sapere.

L'ho fatto funzionare semplicemente aggiungendo una riga a 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
}

Non dimenticare di fare clic Sync nownell'angolo in alto a destra.

Sto usando Android Studio 1.0.1.

Ho trovato Dependency Manager di Android Studio abbastanza utile e potente per la gestione delle dipendenze di terze parti (come gson menzionato qui). Fornire una guida passo passo che ha funzionato per me (NOTA: questi passaggi sono testati per Android Studio 1.6 e versioni successive sulla piattaforma Windows).

Step-1: Vai a "Costruisci> Modifica librerie e dipendenze ..." si aprirà la finestra di dialogo "Struttura del progetto"

Passaggio 2: selezionare "app", quindi selezionare la scheda "Dipendenze". Quindi selezionare "Aggiungi> 1 Dipendenza dalla libreria"

Passaggio 3: verrà visualizzata la finestra di dialogo "Scegli dipendenza libreria", specificare "gson" nella ricerca e premere il "pulsante Cerca"

Passaggio 4: la dipendenza desiderata verrà visualizzata nell'elenco di ricerca, selezionare com.google.code.gson: gson: 2.7 (questa è l'ultima versione al momento in cui ho scritto la risposta), premere OK

Premere OK sulla finestra di dialogo "Struttura del progetto". Gradle aggiorna di conseguenza gli script di compilazione.

Spero che questo possa aiutare :)

1. Metti il ​​vaso (nel mio caso, gson-2.2.4.jar) nella cartella libs.

2. Assicurarsi che compile files ( libs/gson-2.2.4.jar) sia nel file build.gradle.

3. Ora fai clic su "Sincronizza progetto con file Gradle" (pulsante da sinistra a AVD manager sulla barra superiore).

Dopo aver fatto i tre precedenti, ha iniziato a funzionare bene.

Scarica e copia il tuo .jarfile nella libscartella quindi aggiungi queste righe a build.gradle:

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

Non dimenticare di fare clic su "Sincronizza ora"

Puoi farlo con due opzioni.

primo modo semplice.

Copia il file .jar negli appunti, quindi aggiungilo alla cartella libs. Per vedere la cartella libs nel progetto, scegli il progetto dalla casella combinata sopra le cartelle.

quindi fai clic con il pulsante destro del mouse sul file .jar e fai clic su Aggiungi come libreria, quindi scegli un modulo e poi ok. Puoi vedere il file .jar nel file build.gradle nel blocco delle dipendenze.

 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'
    }

Il secondo modo è che: possiamo aggiungere un file .jar a un modulo importando questo file .jar come modulo .jar, quindi aggiungere questo modulo a qualsiasi modulo desideriamo.

modulo di importazione ---> scegli il tuo file .jar -> di importare come .jar -

Quindi CTRL + ALT + MAIUSC + S -> progetto sturure -> scegli il modulo che vuoi aggiungere un barattolo -> Dipendenze -> Dipendenza del modulo. build.gradle del modulo verrà aggiornato automaticamente.

Ho fatto sopra 3 passaggi e il suo fascino del lavoro per me.

(Sto usando Android Studio 2.1.2)

Passo 1

• Aggiungi il nome del tuo pacchetto jar (come esempio compile 'com.squareup.okhttp3:okhttp:3.3.1') nello script build gradle sotto build.gradle (Modulo: app) .

Passaggio 2: fare clic con il tasto destro sulla cartella dell'app -> Nuovo -> Modulo

Passaggio 3: fare clic su Importa pacchetto JAR / .AAR Quindi sfogliare il pacchetto. come esempio: OkHttp.jar

Con Android Studio 3+:

Dovresti semplicemente essere in grado di copiare semplicemente il file jar nella cartella libs proprio sotto la cartella dell'app.

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

Quindi selezionare File di progetto dall'elenco a discesa nella finestra Progetti, fare clic con il pulsante destro del mouse sul progetto, selezionare Sincronizza per visualizzare il file in File di progetto. Aggiungerà automaticamente le dipendenze nel file gradle (Modulo: app).

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

Ecco un'altra soluzione:

Vai alla vista File di progetto (seleziona File di progetto dal menu a discesa).

Seleziona Nuova ... Directory, crea una cartella chiamata libs proprio sotto l'app.

Apri File Explorer, copia e incolla il tuo file jar nella cartella libs.

In Android Studio, fai clic con il pulsante destro del mouse sul file jar e seleziona Aggiungi come libreria ... dal menu popup.

Dovresti vedere il file elencato nell'elenco delle dipendenze nel file gradle:

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

Apri il tuo file java e aggiungi la dichiarazione di importazione lì:

import com.xxx.xxx;

Metti i .jarfile nella libscartella del progetto Android.

Quindi aggiungi questa riga di codice nel file gradle dell'app:

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

Per Android Gradle Plugin 3.0 e versioni successive, è preferibile utilizzare questo invece:

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

A differenza di Eclipse non è necessario scaricare jar e inserirlo nella cartella / libs. Gradle gestisce queste cose di cui abbiamo solo bisogno per aggiungere dipendenze Gradle, Gradle la scarica e inserisce la cache gradle.

Dobbiamo aggiungere dipendenze come:

dipendenze {implementazione 'com.google.code.gson: gson: 2.2.4'}

questo è tutto Tuttavia, possiamo anche scaricare jar e aggiungerlo come libreria, ma la migliore pratica è quella di aggiungere dipendenze Gradle.

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

Passaggio 1: ora sotto a app folderte dovresti vedere libs, se non lo vedi, quindi crealo .

Passaggio 2: Drag & Drop the .jar file hereè possibile che ti venga richiesto "This file does not belong to the project", fai clic su OKPulsante.

Passo 3: Ora dovresti vedere il file jar nella cartella libs , fai clic destro sul file jar e seleziona"Add as library", Click OK for prompt "Create Library"

Passaggio 4: ora questo vaso è stato aggiunto.

Crea una cartella libs. Aggiungi il tuo file .jar. Fai clic destro su di esso e troverai aggiungi jar come dipendenza. Cliccaci sopra. È tutto ciò che devi fare. Puoi trovare le dipendenze aggiunte al tuo file build.gradle.

1) crea una cartella 'your_libs' all'interno della cartella Project / app / src.

2) Copia il tuo file jar in questa cartella 'your_libs'

3) In Android Studio, vai su File -> Struttura del progetto -> Dipendenze -> Aggiungi -> Dipendenza del file e vai al tuo file jar, che dovrebbe essere sotto 'src / your_libs'

3) Seleziona il tuo file jar e fai clic su "Ok"

e quindi puoi vedere sul tuo build.gradle in questo modo: compile files ('src / your_libs / your.jar')

In Android Studio 1.1.0. Ho risolto questa domanda seguendo i seguenti passaggi:

1: Metti il ​​file jar nella directory libs. (nel Finder)

2: Apri le impostazioni del modulo, vai su Dipendenze, nell'angolo in basso a sinistra c'è un pulsante più. Fai clic sul pulsante più, quindi seleziona "Dipendenza file". Qui puoi vedere il tuo file jar. Selezionalo ed è risolto.

Ho letto tutte le risposte qui e sembrano coprire tutte le vecchie versioni di Android Studio!

Con un progetto creato con Android Studio 2.2.3 avevo solo bisogno di creare una libsdirectory sotto appe posizionare lì il mio vaso. L'ho fatto con il mio file manager, non è necessario fare clic o modificare nulla in Android Studio.

Perché funziona Apri Crea / Modifica librerie e dipendenze e vedrai:

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

Su Mac OS X:

1. Aggiungi jar come libreria (trascina jar su libs, fai clic con il pulsante destro del mouse aggiungi come lib)

2. Aggiungi istruzione di compilazione a build.grade

3. Installa gradle v1.6(usa homebrew)

   • brew install gradle
   • gradle -v
   • se non v1.6, aggiorna homebrew

4. gradle clean (ricostruire android non ha funzionato)

Questo mi ha risolto.

Come molti altri hanno sottolineato, è necessario aggiungere

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

nel tuo file build.gradle.

Tuttavia ho un progetto in Android Studio che è stato migrato da Eclipse e in questo caso la cartella "libs" si chiama "lib", quindi per me la rimozione della "s" ha risolto il problema.

1. Aggiunta la libscartella a livello di app.
2. Aggiunto tutto jarsin questo progetto.
3. Successivamente, selezionato tutti i barattoli, nella libscartella,
4. fare clic con il tasto destro del mouse sugli elementi selezionati e dire add library
5. poi troverai l'opzione di espansione dei vasetti, all'interno del project explorer stesso.

Ho osservato CTRL+ ALT+ SHIFT+ S-> struttura del progetto -> modulo-app -> Dipendenze "aveva già una voce come (dir: 'libs', include: '*.jar')sotto compile-option, inizialmente. E dopo aver aggiunto il vaso secondo i passaggi sopra indicati, build.gradleho ottenuto le voci per il nuovo aggiunto Jar's, stesso.

In Android Studio 2.1 seguo questa strada,

Vai all'app -> src-> main -> cartella delle risorse (se non disponibile creala ) -> inserisci i tuoi file JAR

Nel tuo build.gradle aggiungi dipendenza in questo modo,

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')

Sincronizza ora. Ora i tuoi file JAR sono pronti per l'uso.

Per Android 1.0.2 più recente, nel file build.gradle è già presente quanto segue

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

Aggiungi il jar della libreria alla cartella libs -> fai clic con il pulsante destro del mouse sulla libreria -> fai clic su aggiungi come libreria -> ti chiede per il progetto per aggiungerlo per -> seleziona il tuo progetto-> fai clic su ok La seguente riga viene aggiunta automaticamente per compilare .gradle

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

Che ha fatto per me. non era necessario altro. ho mostrato questo per Android Aquery un'altra libreria di terze parti per Android.

La mia risposta sta fondamentalmente raccogliendo alcune delle risposte giuste ma incomplete fornite sopra.

1. Apri build.gradle

2. Aggiungi quanto segue:

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

   Ciò consentirà il supporto per due diversi modi di aggiungere dipendenze. Il compile fileTree(dir: 'libs', include: ['*.jar'])(come menzionato @Binod) dice al compilatore di cercare sotto le librerie delle cartelle QUALSIASI jar. È buona norma creare una 'libs' di tale cartella che conterrà i pacchetti jar che la nostra applicazione deve usare.

Ma ciò consentirà anche il supporto per la dipendenza Maven. La compilazione 'com.google.code.gson:gson:2.3'(come menzionato da @saneryee) è un altro modo consigliato per aggiungere dipendenze che si trovano in un repository remoto centrale e non nel nostro "repository locale" / libs. Fondamentalmente sta dicendo a Gradle di cercare quella versione di quel pacchetto e sta dicendo al compilatore di considerarlo durante la compilazione del progetto (avendolo nel percorso di classe)

PS: io uso entrambi