Android Studio aggiunge un progetto esterno a build.gradle

140

Ho un progetto di esempio, con la seguente configurazione:

/root
  + Pure Java Lib
  + Android Test Lib
  + Android Test Project

Laddove il " Progetto test " dipende dal " Test Lib " e l'ultimo dipende dal " Lib Java puro " La compilazione del progetto e l'avvio di questa configurazione funzionano perfettamente.

Sto pensando di importare il mio precedente spazio di lavoro Eclipse e lavorare con Android Studio, il problema è che l'impostazione del progetto è diversa e vorrei mantenerlo così.

per esempio se usare l'esempio precedente:

/root
  + Android Test Lib
  + Android Test Project

/Some Other folder (another repository for example)
  + Pure Java Lib

Ho provato molte configurazioni, ma non ho trovato un modo per fare riferimento a un progetto al di fuori dell'ambito della cartella principale (" root " nel caso di esempio).

In molte piattaforme / moduli puoi usare '..' per spostarti verso l'alto nelle cartelle ma questo non ha funzionato per me, forse l'ho usato male.

Qualcuno sa come raggiungere questo obiettivo con Gradle?

AGGIORNARE

Proverò ad essere più generico:

/C:/

  /Project A
    + Module 1 - Pure Java
    + Module 2 - Android Test Lib
    + Module 3 - Android Test Project

  /Project B
    + Module 1 - Pure Java
    + Module 2 - Pure Java
    + Module 3 - Pure Java

Vorrei utilizzare il modulo 1 del progetto B , nel progetto A .

AGGIORNAMENTO: 09-03-19

L'ho visto ora e devo aggiornare ... dopo quasi 6 anni, oggi sono più saggio, e posso sicuramente dire che il problema era che ho frainteso il concetto di "Fonte della verità".

Mentre avere un riferimento a una biblioteca è un concetto piacevole da avere .. e può sembrare una "Fonte di verità", la "Fonte di verità" REALE sarebbe la versione del codice che ogni progetto utilizza di quella biblioteca, perché la libreria ha di per sé delle versioni .. molte versioni e la "Fonte della verità" è relativa al progetto che sta utilizzando la libreria.

Il modo corretto sarebbe quello di usare ciò che non piace alla maggior parte degli sviluppatori, e cioè i sottomoduli git, e sì duplicare le fonti in ciascun progetto, poiché la maggior parte delle probabilità che ogni progetto usi una versione diversa del codice.

Dovresti comunque puntare a tutti i tuoi progetti per utilizzare l'ultima e la più grande versione di tutte le tue librerie .. che è una sfida da sola

La ragione per cui questo è il modo giusto di sviluppare un progetto con fonti di biblioteche è che questa scala ... puoi avere centinaia di progetti ciascuno con la sua configurazione di biblioteche.

— TacB0sS
fonte

4

Vedo che questa domanda attira l'attenzione ... Dopo aver provato davvero molto, ho rinunciato allo studio Android per ora, poiché la complessità dell'installazione che stavo cercando di costruire era troppo, e costruire il mio progetto finale era fattibile, ma altamente instabile. ad ogni avvio di Android Studio ho dovuto impostare nuovamente alcuni parametri e far funzionare manualmente la build. sono passati circa due mesi da quando ho rinunciato, e spero che le cose vadano meglio ora!

— TacB0sS,

L'approccio 2 qui spiega come farlo molto facilmente: stackoverflow.com/questions/25610727/…

— Doron Ben-Ari

222

Supponendo che Some Other Folder sia un progetto gradle, è possibile aggiungere qualcosa di simile al seguente file settings.gradle:

include ':module1'
project(':module1').projectDir = new File(settingsDir, '../Project B/Module 1')

— Ethan
fonte

1

SomeOtherFolder punta a una cartella di progetto e in essa ci sono moduli, che sono interessato ad aggiungere come moduli al progetto Lib Android

— TacB0sS

Le impostazioni dir puntano a "root" Ho bisogno di salire di livello, ad un altro modulo in un altro progetto.

— TacB0sS,

dopo potresti aggiungere i sottomoduli? include ': someOtherFolder: proj1'

— Ethan,

1

aggiornato con alcuni dettagli. settings.gradle dovrebbe essere in / Project A

— Ethan,

5

Bella risposta. In AS 1.0.2, avevo anche bisogno di fare quanto segue: Tasto destro del mouse sul modulo -> Apri le impostazioni del modulo -> Dipendenze -> + (in basso), seleziona Dipendenza del modulo, seleziona la tua libreria dall'elenco, fai clic su OK :)

— T. Coutlakis,

49

Devi inserire le impostazioni del tuo file. Aggiorna queste righe:

include ':module2'
project(':module2').projectDir = new File(settingsDir, '../Project 2/Module2')

Quindi devi aggiungere il tuo builde.gradle (Modulo: app) nella struttura delle dipendenze , questa riga:

implementation project(':module2')

oppure vai nella Struttura del progetto > app > Dipendenze , fai clic su Aggiungi , scegli 3 Dipendenze del modulo e seleziona il modulo

— Dario Brux
fonte

1

Se hai problemi con il riferimento alle classi della libreria dall'app principale, ciò è dovuto al fatto che la libreria è probabilmente disponibile in diverse varianti. Quindi, basta specificare la dipendenza in modo corretto: compile project(path: ':library', configuration: 'variant'). Qui, è variantcostituito da flavore buildTypecome definito dal build.gradlefile della libreria . Ad esempio, se si desidera releasecostruire il tipo di libreria in un developsapore, allora lo variantè developRelease.

— Sevastyan Savanyuk il

9

Con Gradle 1.10 (non so per quali altre versioni questo sarà valido) questo è quello che mi è venuto in mente in base a una risposta data qui http://forums.gradle.org/gradle/topics/reference_external_project_as_dependancy

Ho un progetto di libreria API, un progetto di libreria comune e il progetto dell'app principale. Ognuno è un progetto di sviluppo autonomo e le due librerie sono pensate per essere condivise tra più app.

In settings.gradle per il progetto comune:

def apiLibDir = file('../android-api/android-api-lib')
def rootProjectDescriptor = settings.rootProject
settings.createProjectDescriptor(rootProjectDescriptor, 'android-api-lib', apiLibDir)
include ':android-api-lib'

Quindi nelle impostazioni principali del progetto app.gradle:

def apiLibDir = file('../android-libs/android-api/android-api-lib')
def rootProjectDescriptor = settings.rootProject
settings.createProjectDescriptor(rootProjectDescriptor, 'android-api-lib', apiLibDir)
include ':android-api-lib'

def commonLibDir = file('../android-libs/android-common/android-common-lib')
settings.createProjectDescriptor(rootProjectDescriptor, 'android-common-lib', commonLibDir)
include ':android-common-lib'

In ciascuno dei rispettivi file build.gradle li fai semplicemente riferimento al nome che hai dato loro in settings.createProjectDescriptor come faresti con qualsiasi altra dipendenza del progetto:

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile project(':android-api-lib')
    compile project(':android-common-lib')
}

Questo sembra funzionare. Non ho nemmeno generato un errore per più file DEX che definiscono la libreria di API, sospetto perché faceva tutto parte dello stesso processo di compilazione e Gradle era abbastanza intelligente da capire tutto.

— alphonzo79
fonte

2

Continuo a provare questo, ma il problema è che le dipendenze nella rispettiva libreria sembrano non essere mai caricate. Quindi, se ho solo la libreria aperta, sembra che vada bene, ma quando la provo dall'app principale, dice che mancano tutte le librerie importate.

— Czechnology,

@Czechnology ha avuto lo stesso problema. Risolto Vedere il mio commento a questa risposta: stackoverflow.com/a/29603354/7408927

— Sevastyan Savanyuk

9

Fare clic destro sul progetto - Selezionare "Apri le impostazioni del modulo" - Selezionare "Moduli" nel riquadro a sinistra - Fare clic sul simbolo "+" in alto - Scegliere "Importa modulo".

Dopo aver importato il modulo. Devi aggiungerlo come dipendenza per il tuo progetto attuale.

Mantieni "Moduli" selezionati nel riquadro a sinistra e fai clic sul tuo progetto - Ora vai nella scheda Dipendenze e fai clic sul simbolo "+" che si trova in fondo - Scegli la terza opzione "Dipendenze del modulo" e se hai importato correttamente il tuo progetto, lo farà mostra tutto il modulo disponibile che può essere aggiunto come dipendenza al tuo progetto attuale.

— Varundroid
fonte

Questo funziona quasi ... il progetto non può essere compilato perché l'output del modulo di dipendenza non viene aggiunto al file build.gradle, che è esattamente il mio problema originale.

— TacB0sS,

Penso che con Gradle, devi mettere tutti i progetti nella stessa cartella radice. Prova questo. Inserisci il progetto che desideri aggiungere come dipendenza nella stessa cartella del progetto corrente.

— Varundroid,

Questo è ciò che nessuno vuole fare se non ATM se si desidera lavorare con Android Studio, questo è il modo per far funzionare le cose. Un altro modo alternativo che sto seguendo è che creo un progetto in Intellij per configurare tutte le dipendenze e quindi importare quel progetto in Android Studio, facendo questo costringo Android Studio a utilizzare il sistema di generazione di formiche anziché Gradle. Spero che sia d'aiuto. Saluti!!

— Varundroid

1

@Varundroid, la soluzione è innanzitutto importare un riferimento alla libreria autonoma usando la risposta di Ethan. Quindi aggiungi il modulo alle dipendenze dell'app principale usando la tua risposta. Ciò consente di fare riferimento alla stessa libreria in più app senza dover duplicare il codice della libreria.

— bcorso,

1

Richiamo nuovamente questa domanda in un modo che implica le intenzioni dei poster originali in Come possiamo fare riferimento a librerie Android e Java personalizzate che vivono al di fuori della directory del nostro principale progetto Android?

Lì rispondo alla mia domanda. Fondamentalmente la mia risposta usa la comprensione del codice di @ Ethan (l'autore della risposta scelta nel thread corrente). Ma la mia risposta esplora anche alcuni altri gotcha e fornisce un esempio dettagliato passo dopo passo.

— John Bentley
fonte

-1

Come ha detto Ethan, se lo aggiungi al tuo settings.gradle, aggiungerà un progetto esterno ad Android Studio (in questo esempio, si trova nella cartella principale):

project(':../ProjectB/:module1')

Quindi, per aggiungerlo come dipendenza di uno dei tuoi progetti, basta aggiungerlo nel build.gradle di quel progetto come un'altra dipendenza come questa (puoi anche farlo graficamente come qui ):

compile project(':../ProjectB/:module1')

— Yair Kukielka
fonte