[OFFEN] Gradle: maven-publish abhängigkeiten

[DagobertDokate]

Guten Morgen,

ich weis nicht mehr wonach ich noch googlen soll, deswegen hier mal mein Problem:

Ich baue gerade eine Android-App, welche aus verschiedenen Modulen besteht.
Jetzt möchte ich jedes Modul als jar/aar im mavenLocal ablegen. Dazu habe ich das "maven-publish"-Plugin gefunden.
Dabei stellt sich mir die Frage, wie ich Abhängigkeiten richtig angebe.
Ich habe ein Demo-Projekt, bestehend aus den Modulen pr1, pr2. Wenn ich jetzt in pr2 als dependencie pr1 angebe

 compile ('de.test:project1:1.0.0')

ist alles super.
Wenn ich jetzt aber aus pr2, apr2 mache kann die Abhängigkeit nicht mehr aufgelöst werden. Wie mache ich nun gradle klar, in welcher Reihenfolge die Module abgearbeitet werden sollen?
Hier mal einer der beiden build.gradle, die andere sieht ziemlich gleich aus:

plugins {
    id 'java'
    id 'maven-publish'
}

dependencies {
//    compile project(':project1')
    compile ('de.test:project1:1.0.0')
    testCompile 'junit:junit:4.12'
}

sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8

publishing {
    publications {
        publish(MavenPublication) {
            groupId 'de.test'
            artifactId 'project2'
            version '1.0.0'

            from components.java
        }
    }
}

lg. Dagobert

 

[StefMa]

Ich weiß nicht genau was dein Problem ist.
Du kannst dir aber sehr viel mühe sparen, wenn du zum Beispiel dieses Plugin benutzt.

Einfach in die build.gradle von projekte 1 und 2 folgenden zeile hinzufügen

androidArtifacts {
   groupId = 'de.test'
   artifactId = 'project1' // bzw. project2
   publishVersion = '0.1'
}

Danach einfach mit `gradlew publishToMavenLocal` ins locale maven publishen...

Die Projekte kannst du dann in deinem richtigen Projekt mit

compile 'de.test:project1:0.1'

einbinden...

 

[DagobertDokate]

Hallo StefMa,

danke für eine Antwort, leider hilft mir das nur bedingt weiter, ich versuche mein Problem nochmal anders zu schildern, mehr im text.
Mein Problem ist quasi die Abhängigkeit von einem Build-Prozess zum anderen. Ich referenziere im ersten Projekt quasi ein Artefakt, was noch nicht gebaut ist. Jetzt mecker gradle das nicht gebaut werden kann die benötigten Abhängigkeiten nicht vorhanden sind. Ist ja auch logisch.
Jetzt hätte ich gerne nen Task der das ganze in der richtigen Reihenfolge baut und veröffentlicht, so das alle Anhängigkeiten aufgelöst werden könne (später sind es 4-6).
der Standard publishToMavenLocal() scheint die Projekte mehr Alphabetisch durchzuarbeiten, was zum Erfolg führen kann, wenn man die Projekte richtig benennt. Ich hätte aber lieber ein Sinnvolles Build-cript.S

 

[StefMa]

Achso... Jetzt verstehe ich.
Das heißt du willst dein Module publishen bevor du dein projekt baust?!
1. Das ist keine gute Idee, weil es jedesmal passiert, wenn du dein Projekt bauen willst.
2. Das hat erstmal nichts mit "maven und publishing" zu tun. Das ist gradle behaviour

Du kannst folgendes machen (keine Ahnung ob das geht):

task("publishProj2ToMavenLocal", type: Exec) {
    commandLine './gradlew assemble :proj2:publishToMavenLocal'
}

compile.dependsOn "publishProj2ToMavenLocal"
compile.mustRunAfter "publishProj2ToMavenLocal"

Es kann sein, dass schon der `compile` task zu spät ist.. Das da schon die dependencies abgearbeitet sind. Das könnte das problem sein.

€dit:
Aber im großen und ganzen empfehle ich dir so ein vorgehen nicht.
Baue und publishe deine "library" lieber komplett unabhängig von deinem richtigen projekt.
Für demo/sample module kannst du deine library einfach mit compile ("roject2) einbinden...

 

[DagobertDokate]

Ja ich möchte die Lib/SDK auch seperat publishen.
Jedoch besteht die Lib aus mehreren Modulen. Quasi "core", "core-android", "network", "network-android"....
Ich dachte ich packe ganz viele kleine jars/aars und kann so in der app fein granularer hinzufügen was ich möchte.
So wie es die play-services quasi machen.

lg.

 

[DagobertDokate]

Aber ich muss doch die einzelnen Module jeweils als Artefakt publishen, oder kann ich iwie die mehrere Module in eine aar kompilieren?
Wenn ich einfach compile project(':core') angebe, kann das Modul später in anderen Projekte nicht aufgelöst werden.

Hier mal mein Projektbaum um das ganze zu verdeutlichen:

-Project
---- android-core // basiert auf core (compile project(':core'))
---- android-network // basiert auf network (compile project(':network')) & android-core (compile project(':android-core'))
---- android-storage // basiert auf android-network & storage
---- core
---- network // basiert auf core
---- storage // basiert auf network
---- android-lib // basiert auf android-storage

Wenn ich jetzt (auch mit deinem Plugin) nur android-lib publishe kann später compile project(':core') nicht mehr aufgelöst werden.
Änder ich compile project zu compile 'xyz:zxy:1' dann kann später alle aufgelöst werden, ist aber unschön zu bauen da ich 7 Publish-Tasks die ich in einer bestimmten Reihenfolge durchlaufen muss.

Ich hätte nie gedacht das dies so kompliziert ist Jetzt weiß ich warum jedes Artefakt immer ein einzelnes Project ist

lg. Dagobert

 

[StefMa]

Hey,

das ist alles gar nicht so kompliziert
Du kannst dir mal ThirtyInch anschauen -> GitHub - grandcentrix/ThirtyInch: a MVP library for Android favoring a stateful Presenter
Speziell die build.gradle des plugins.
Das ist ebenfalls ein selbstständiges module, brauch aber thirtyinch selbst als dependency. Was wir mit compile('thirtyinch') einbauen.

Wenn wir also nun
$ ./gradlew assemble luginublishToMavenLocal
aufrufen. Wird erst thirtyinch selbst und dann plugin in *ein* aar gepackt...

.... Das war meine annahme. Die ist fasch (Danke - wieder was gelernt )

Fakt ist:
gradle included *keine dependencies* in deine aar/jar.
Du musst diese dann local bereitstellen und EXTRA in deine aar/jar packen.
Siehe Gradle: how to include dependencies from repositories to output aar file und How to include dependencies in jar?.

D.h. wenn du - wie du schreibst - nur android-lib published. Dann funktioert das. Aber die dependencies von ihr können nicht gefunden werden.
Heißt also (Lösung):
Include jede dependency mit compile 'xyz:xyz:VERSION'.
Das published du *jede* library *gleichzeitig*.

ODER (denke ich ist eine schlechtere lösung):
Packe/Kopiere die dependecies in deine aar/jar.

In deinem richtigen projekt kannst du nun deine android-lib ganz normal einbinden.
Die schaut dann nach ihrem dependencies und findet diese auch im mavenLocal.. etc. etc.