Pratica per garantire progetti di Android costruire subito dopo SVN checkout in Eclipse

Question

Problema:

Quando un progetto viene controllato in SVN, e qualcun altro controlli fuori, c'è un punto esclamativo su di esso e costruire gli errori di percorso ha bisogno di essere risolto. Come sistemarlo?

Per fare un esempio, ho un progetto e che segue è la sua struttura:

Ha 3 librerie nella cartella libs:

* android-support-v4.jar 
* bugsense3.2.2.jar 
* gcm.jar 

cartella

Dipendenze Android ha:

* annotations.jar 

referenziati biblioteche ha:

* gcm.jar 

Android biblioteche private è:

* bugsense3.2.2.jar 
* gcm.jar 
* android-support-v4.jar 

API di Google [Android 2.2] ha:

* android.jar 
* maps.jar 

Così sembra che tutto ciò che abbiamo posto nella cartella libs viene automaticamente aggiunto ai Android private Biblioteche, è esatto? In modo che possano essere controllati a quando qualcuno controlli fuori e costruisce, le .jars in Android private Biblioteche sarà semplicemente puntare al suo spazio di lavoro locale in modo che non è un problema e SVN.

Tuttavia, annotations.jar in Android Dipendenze e android.jar e maps.jar nelle API di Google fanno riferimento alla cartella di Android-sdk sul mio C :. Quindi, quando qualcun altro controlla tutto il mio progetto, hanno creato problemi che devono risolvere tramite il percorso di costruzione Java.

Qual è la prassi standard per memorizzare tutte le librerie in SVN in modo tale che quando un nuovo sviluppatore entra e controlla il progetto, semplicemente costruisce senza manipolare le impostazioni? Sospetto che stiamo entrando nel territorio dell'utilizzo di un sistema di gestione build, integrazione continua, server di creazione, ecc. Quindi ne so un po 'ma non l'ho mai effettivamente utilizzato nella praticità dato che non ho mai lavorato in una squadra abbastanza grande . Se qualcuno sarebbe così gentile da darmi esattamente quello che usano (gli strumenti attuali, come Maven, Gradle, ecc), allora sarebbe molto molto apprezzato!

Grazie,

-V

Answer 1

Non c'è niente di speciale le librerie che ADK aggiunge al percorso di classe. Se si vuole essere in grado di controllare in tutte le dipendenze del progetto, è possibile copiare i vasi si fa riferimento ad una directory locale e quindi puntare il percorso di classe a quelli invece di utilizzare i gruppi di librerie fornite. Perché il plugin di Android ha quel nuovo sistema di stravagante che aggiunge automaticamente roba nella directory libs al percorso e alla vostra apk, non mi consiglia di mettere questi altri vasi in là. Normalmente ciò che faremo qui è creare una cartella separata in svn nome di terze parti o qualcosa del genere, e quindi utilizzare svn:externals per fare riferimento i vasi necessari. Avere uno spazio comune per conservare i jar di terze parti semplifica la gestione delle versioni e della configurazione.

Per illustrare le cose un po 'più chiaramente, questo è ciò che un repository di esempio subversion sarà simile:

repo 
    -android_project 
     -trunk 
      -your other project stuff (src, etc) 
      -libs 
       -android-support-v4.jar 
       -bugsense3.2.2.jar 
       -gcm.jar 
      -third-party 
       -annotations.jar (external) 
       -android.jar (external) 
       -maps.jar (external) 
third-party 
    -android 
     -v_X.XX 
      -annotations.jar 
      -android.jar 
      -maps.jar 

Nel progetto attuale Eclipse, si dovrebbe aggiungere la roba in di terze parti per il percorso manualmente, e l'adk aggiungerà automaticamente le cose in libs al percorso.

EDIT

Sul tema di questo metodo rispetto Maven, la prima cosa che devo ammettere è che non ho una quantità enorme di esperienza con Maven. Da quello che so a questo proposito, non credo che soddisfi abbastanza i tuoi criteri. Quando usavo Maven, per impostazione predefinita scaricava le tue dipendenze su una posizione specifica della macchina, invece che sul tuo spazio di lavoro. Per ottenere Eclipse per raccogliere queste dipendenze, è stato quindi necessario aggiungere una proprietà M2_HOME al proprio spazio di lavoro in modo che potesse risolvere correttamente tutti i percorsi. È stato abbastanza semplice impostare tutte queste cose perché c'erano comandi mvn per automatizzare il processo, ma a qualcuno che non ha familiarità con il sistema potrebbe causare molta confusione e rallentare le cose quando un nuovo sviluppatore sta iniziando su un progetto. Inoltre, un grosso problema che abbiamo riscontrato è che richiede che le dipendenze siano archiviate su una sorta di repository centrale che ha reso molto difficile il lavoro nelle aree non connesse.

Anche in questo caso, io non sono esperto Maven quindi prendete quello che ho detto con un grano di sale, ma dalla mia esperienza Maven grandi opere in un ambiente open-source dove la connettività è accolto e quasi garantito, ma non tanto in un ambiente closed-source. Sembra che abbia causato più problemi di quanti ne abbia risolti per noi, e quindi non è mai stato preso veramente in considerazione. La cosa bella del sistema che ho descritto sopra è che dopo il checkout, hai una singola cartella che contiene tutto (tranne eclissi) che è necessario per sviluppare e costruire il progetto. Ciò rende le cose molto facili da installare e utilizzare su una nuova macchina o su un ambiente non familiare.

Dirò che un grande vantaggio fornito da Maven è la coerenza. Con il sistema che ho descritto, lo sviluppatore è responsabile di ogni aspetto della creazione di un progetto. Ciò significa che tra sviluppatori e progetti è possibile ottenere variazioni sul modo in cui il repository svn è disposto. Uno sviluppatore potrebbe nominare una directory "di terze parti" mentre un'altra potrebbe chiamarla "open-source", oppure alcuni sviluppatori potrebbero non utilizzare un trunk nei loro progetti. Con il passare del tempo queste piccole cose possono accumularsi e lasciare il tuo deposito in disordine. Poiché Maven è responsabile del layout del progetto, puoi essere certo che il tuo repository rimarrà coerente.