Sono nuovo del sistema di costruzione gradle e IntelliJ.

Quindi, come faccio a creare un Progetto libreria Android (ad esempio com.myapp.lib1) e il progetto dell'applicazione (ad esempio com.myapp.app) e fare in modo che il sistema di compilazione includa com.myapp.lib1 nel progetto dell'applicazione?

Sono andato alla Struttura del progetto -> Moduli -> Il mio progetto App e ho aggiunto una dipendenza al progetto lib. IntelliJ ora è in grado di riconoscere le classi dal progetto lib quando viene utilizzato nel progetto app, ma quando eseguo il progetto app, ci sono errori come:

Gradle: error: package com.myapp.lib1 does not exist

Per creare una libreria:

File> Nuovo modulo

seleziona Libreria Android

Per usare la libreria aggiungila come dipendenza:

File> Struttura del progetto> Moduli> Dipendenze

Quindi aggiungere il modulo (libreria Android) come dipendenza del modulo.

Esegui il tuo progetto. Esso sarà funzionerà.

Mi chiedo perché non esiste un esempio di progetto di vaso autonomo.

In eclipse, selezioniamo semplicemente la casella "Is Library" nella finestra di dialogo delle impostazioni del progetto.
In Android Studio, ho seguito questi passaggi e ho ottenuto un file jar.

1. Crea un progetto.

2. apri il file nel menu di progetto a sinistra. (app / build.gradle): Gradle Scripts> build.gradle (Modulo: XXX)

3. cambia una riga: apply plugin: 'com.android.application'->'apply plugin: com.android.library'

4. rimuovere applicationId nel file: applicationId "com.mycompany.testproject"

5. build project: Build> Rebuild Project

6. allora puoi ottenere il file aar: app> build> output> cartella aar

7. cambia aaril nome dell'estensione del file inzip

8. decomprimere e puoi vedere classes.jarnella cartella. rinominalo e usalo!

Comunque, non so perché Google rende la creazione di jar così problematica in Android Studio.

Il modo raccomandato da Google Gradle Plugin per la configurazione dei file Gradle per la creazione di più progetti presenta alcune carenze Se si dispone di più progetti in base a un progetto di libreria, questo post spiega brevemente la configurazione consigliata di Google, le sue carenze e consiglia un modo diverso di configurare i file Gradle per supporta configurazioni multi-progetto in Android Studio:

Una configurazione multiproject alternativa per Android Studio

Un modo diverso:

Si scopre che esiste un modo migliore per gestire più progetti in Android Studio. Il trucco è creare progetti Android Studio separati per le tue librerie e dire a gradle che il modulo per la libreria da cui dipende la tua app si trova nella directory di progetto della libreria. Se si desidera utilizzare questo metodo con la struttura del progetto che ho descritto sopra, si dovrebbe fare quanto segue:

1. Crea un progetto Android Studio per la libreria StickyListHeaders
2. Crea un progetto Android Studio per App2
3. Crea un progetto Android Studio per App1
4. Configura App1 e App2 per creare i moduli nel progetto StickyListHeaders.

Il quarto passo è la parte difficile, quindi è l'unico passo che descriverò in dettaglio. È possibile fare riferimento a moduli esterni alla directory del progetto aggiungendo un'istruzione di progetto nel file settings.gradle e impostando la proprietà projectDir sull'oggetto ProjectDescriptor restituito dall'istruzione di progetto:

Il codice uno deve inserire settings.gradle:

include ':library1'
project(':library1').projectDir = new File('../StickyListHeader/library1')

Se lo hai fatto correttamente, noterai che i moduli a cui fa riferimento il tuo progetto appariranno nel navigatore del progetto, anche se quei moduli sono esterni alla directory del progetto:

Ciò ti consente di lavorare contemporaneamente sul codice della libreria e sul codice dell'app. Anche l'integrazione del controllo versione funziona bene quando si fa riferimento ai moduli esternamente in questo modo. È possibile eseguire il commit e il push delle modifiche al codice della libreria proprio come è possibile eseguire il commit e il push delle modifiche al codice dell'app.

Questo modo di creare più progetti evita le difficoltà che affliggono la configurazione consigliata da Google. Poiché stiamo facendo riferimento a un modulo esterno alla directory del progetto, non è necessario creare copie extra del modulo della libreria per ogni app che dipende da esso e possiamo eseguire la versione delle nostre librerie senza alcun tipo di assurdità del sottomodulo git.

Sfortunatamente, questo altro modo di creare più progetti è molto difficile da trovare. Ovviamente, non è qualcosa che capirai guardando la guida di Google e, a questo punto, non c'è modo di configurare i tuoi progetti in questo modo utilizzando l'interfaccia utente di Android Studio.

Dai un'occhiata a questo link sulle configurazioni multi-progetto .

Alcune cose da sottolineare, assicurati di aver aggiornato settings.gradle per fare riferimento sia ai moduli dell'app che della libreria.

settings.gradle: include ':app', ':libraries:lib1', ':libraries:lib2'

Assicurati anche che build.gradle dell'app abbia il seguenteng:

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

Dovresti avere la seguente struttura:

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

Build.gradle dell'app dovrebbe usare il com.android.applicationplug-in mentre build.gradle di qualsiasi libreria dovrebbe usare il com.android.libraryplug-in.

L'IDE di Android Studio dovrebbe essere aggiornato se riesci a creare dalla riga di comando con questa configurazione.

Per Intellij IDEA (e Android Studio) ogni libreria è un modulo. Pensa a un modulo in Android Studio come equivalente al progetto in Eclipse. Project in Android Studio è una raccolta di moduli. I moduli possono essere applicazioni eseguibili o moduli di libreria.

Quindi, per aggiungere un nuovo progetto di libreria Android è necessario creare un modulo di tipo "Libreria Android". Quindi aggiungere questo modulo della libreria all'elenco delle dipendenze del modulo principale (modulo dell'applicazione).

Il modo più semplice per me di creare e riutilizzare un progetto di biblioteca:

1. Su un progetto aperto file > new > new module(e rispondi alle domande dell'interfaccia utente)

2. controlla / o aggiungi se nel file settings.gradle :include ':myLibrary'

3. controlla / o aggiungi se nel file build.gradle :

   dependencies { ... compile project(':myLibrary') }

4. Per riutilizzare questo modulo di libreria in un altro progetto, copia la relativa cartella nel progetto anziché il passaggio 1 ed esegui i passaggi 2 e 3.

È inoltre possibile creare un nuovo progetto di applicazione in studio. È possibile modificare facilmente un modulo di applicazione esistente in un modulo di libreria modificando l'assegnazione del plug-in nel file build.gradle in com.android.library.

apply plugin: 'com.android.application'

android {...}

per

apply plugin: 'com.android.library'

android {...}

di più qui

Puoi aggiungere un nuovo modulo a qualsiasi applicazione come Blundell dice sulla sua risposta e quindi fare riferimento a esso da qualsiasi altra applicazione.

Se si desidera spostare il modulo in qualsiasi punto del computer, basta spostare la cartella del modulo (i moduli sono completamente indipendenti), quindi sarà necessario fare riferimento al modulo.

Per fare riferimento a questo modulo dovresti:

• Nel file build.gradle della tua app aggiungi:

  dependencies {
  ...
  compile project(':myandroidlib')
  }
  

• Nel file settings.gradle aggiungi quanto segue:

   include ':app', ':myandroidlib'
   project(':myandroidlib').projectDir = new File(PATH_TO_YOUR_MODULE)
  

Non dimenticare di utilizzare il apply plugin: 'com.android.library'tuo build.gradleplugin invece di applicare:'com.android.application'

Modo di documentazione

Questo è il modo raccomandato secondo i consigli forniti nella documentazione di Android Studio.

Crea un modulo di libreria

Crea un nuovo progetto in cui inserire la tua libreria. Fai clic su File> Nuovo> Nuovo modulo> Libreria Android> Avanti> (scegli il nome)> Fine . Quindi aggiungi le classi e le risorse che desideri alla tua libreria.

Quando compili il modulo verrà creato un file AAR. Puoi trovarlo in project-name/module-name/build/outputs/aar/.

Aggiungi la tua libreria come dipendenza

Puoi aggiungere la tua libreria come dipendenza a un altro progetto come questo:

1. Importa il file AAR della libreria con File> Nuovo modulo> Importa pacchetto .JAR / .AAR> Avanti> (scegli la posizione del file)> Fine . (Non importare il codice, altrimenti sarà modificabile in troppi punti.)

2. Nel file settings.gradle, assicurati che il nome della tua libreria sia presente.

   include ':app', ':my-library-module'
   

3. Nel file build.gradle dell'app, aggiungi la riga di compilazione alla sezione delle dipendenze:

   dependencies {
       compile project(":my-library-module")
   }
   

4. Ti verrà richiesto di sincronizzare il tuo progetto con Gradle. Fallo.

Questo è tutto. Dovresti essere in grado di utilizzare la tua libreria ora.

Appunti

Se vuoi rendere la tua libreria facilmente disponibile per un pubblico più ampio, prendi in considerazione l'utilizzo di JitPac o JCenter .

Aveva la stessa domanda e risolta nel modo seguente:

Inizia situazione :

FrigoShare (root)
|-Modules:    frigoshare,   frigoShare-backend

Target : desidera aggiungere un modulo denominatodataformats

1. Aggiungi un nuovo modulo (ad es . Java Library:)

2. Assicurati che il tuo settings.gradleaspetto sia simile (normalmente automaticamente):

   include ':frigoshare', ':frigoShare-backend', ':dataformats'

3. Assicurarsi ( manualmente ) che i build.gradlefile dei moduli che devono utilizzare la libreria abbiano la seguente dipendenza:

   dependencies { ... compile project(':dataformats') }

Scopo: libreria Android in un unico posto - Condividi su più progetti http://raevilman.blogspot.com/2016/02/android-library-project-using-android.html

Come ho già detto nel commento di CzechSensation, provo a cercare Varian Build Gradle e ho trovato questo link: http://code.tutsplus.com/tutorials/using-gradle-build-variants--cms-25005 Questa è una soluzione molto semplice. Questo è quello che ho fatto: - In build.gradle:

flavorDimensions "version"

productFlavors {
    trial{
        applicationId "org.de_studio.recentappswitcher.trial"
        flavorDimension "version"
    }
    pro{
        applicationId "org.de_studio.recentappswitcher.pro"
        flavorDimension "version"
    }

}

Quindi ho altre 2 versioni della mia app: pro e trial con 2 differenti packageName che è 2 applicationId nel codice sopra in modo da poter caricare entrambi su Google Play. Ho ancora il codice nella sezione "principale" e uso getpackageName per passare alla versione. Basta andare al link che ho dato per i dettagli.

Esistono due modi più semplici se uno non funziona, provare l'altro.

1. Aggiungi la dipendenza della libreria all'interno della dipendenza all'interno del file build.gradle della tua libreria usando e incolla la tua libreria in Librerie esterne.

O

2. Basta andare nella cartella libs all'interno della cartella dell'app e incollare tutti i file .jar, ad esempio i file della libreria lì Ora il trucco qui è che ora vai all'interno del file settings.gradle ora aggiungi questa riga "include ': app: libs'" dopo "include ': app "" Funzionerà sicuramente ........... :)

Nel mio caso, usando MAC OS X 10.11 e Android 2.0 e facendo esattamente ciò che ha spiegato Aqib Mumtaz.

Ma ogni volta ho ricevuto questo messaggio: " Si è verificato un problema durante la configurazione del progetto ': app'.> Impossibile valutare il modulo xxx: la configurazione con il nome 'default' non è stata trovata ."

Ho scoperto che la ragione di questo messaggio è che Android 2.0 non consente di creare direttamente una libreria. Quindi, ho deciso prima di creare un progetto di app e poi di modificare build.gradle per trasformarlo in libreria.

Questa soluzione non funziona, perché un progetto di libreria è molto diverso da un progetto di app.

Quindi, ho risolto il mio problema in questo modo:

• Innanzitutto crea un'app standard (se necessario);
• Quindi selezionare "File / Crea modulo"
• Vai al finder e sposta la cartella del modulo appena creata nella directory del tuo framework

Quindi continua con la soluzione proposta da Aqib Mumtaz.

Di conseguenza, la tua sorgente della libreria verrà condivisa senza la necessità di duplicare i file sorgente ogni volta (è stata un'eresia per me!)

Spero che questo ti aiuti.