Publicación de Android Library (aar) a Bintray con sabores elegidos

Me enfrenté al mismo desafío, y aquí está lo mejor que pude hacer todavía:{[26]]}

Usando mavenPublications y el complemento gradle maven-publish junto con el complemento bintray, puedes publicar cualquier variante en mavenLocal y bintray.

Aquí está el publish.gradle archivo que aplico al final de todos los módulos de la biblioteca de mi proyecto que quiero publicar:

def pomConfig = {
    licenses {
        license {
            name 'The Apache Software License, Version 2.0'
            url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
        }
    }
    developers {
        developer {
            id 'louiscad'
            name 'Louis CAD'
            email '[email protected]'
        }
    }
    scm {
        connection 'https://github.com/LouisCAD/Splitties.git'
        developerConnection 'https://github.com/LouisCAD/Splitties.git'
        url siteUrl
    }
}

def publicationNames = []
publishing.publications {
    android.libraryVariants.all { variant ->
        if (variant.buildType.name == "debug") return // Prevents publishing debug library

        def flavored = !variant.flavorName.isEmpty()

        /**
         * Translates "_" in flavor names to "-" for artifactIds, because "-" in flavor name is an
         * illegal character, but is well used in artifactId names.
         */
        def variantArtifactId = flavored ? variant.flavorName.replace('_', '-') : project.name

        /**
         * If the javadoc destinationDir wasn't changed per flavor, the libraryVariants would
         * overwrite the javaDoc as all variants would write in the same directory
         * before the last javadoc jar would have been built, which would cause the last javadoc
         * jar to include classes from other flavors that it doesn't include.
         *
         * Yes, tricky.
         *
         * Note that "${buildDir}/docs/javadoc" is the default javadoc destinationDir.
         */
        def javaDocDestDir = file("${buildDir}/docs/javadoc ${flavored ? variantArtifactId : ""}")

        /**
         * Includes
         */
        def sourceDirs = variant.sourceSets.collect {
            it.javaDirectories // Also includes kotlin sources if any.
        }
        def javadoc = task("${variant.name}Javadoc", type: Javadoc) {
            description "Generates Javadoc for ${variant.name}."
            source = variant.javaCompile.source // Yes, javaCompile is deprecated,
            // but I didn't find any working alternative. Please, tweet @Louis_CAD if you find one.
            destinationDir = javaDocDestDir
            classpath += files(android.getBootClasspath().join(File.pathSeparator))
            classpath += files(configurations.compile)
            options.links("http://docs.oracle.com/javase/7/docs/api/");
            options.links("http://d.android.com/reference/");
            exclude '**/BuildConfig.java'
            exclude '**/R.java'
            failOnError false
        }
        def javadocJar = task("${variant.name}JavadocJar", type: Jar, dependsOn: javadoc) {
            description "Puts Javadoc for ${variant.name} in a jar."
            classifier = 'javadoc'
            from javadoc.destinationDir
        }
        def sourcesJar = task("${variant.name}SourcesJar", type: Jar) {
            description "Puts sources for ${variant.name} in a jar."
            from sourceDirs
            classifier = 'sources'
        }

        def publicationName = "splitties${variant.name.capitalize()}Library"
        publicationNames.add(publicationName)

        "$publicationName"(MavenPublication) {
            artifactId variantArtifactId
            group groupId
            version libraryVersion

            artifact variant.outputs[0].packageLibrary // This is the aar library
            artifact sourcesJar
            artifact javadocJar

            pom {
                packaging 'aar'
                withXml {
                    def root = asNode()
                    root.appendNode("name", 'Splitties')
                    root.appendNode("url", siteUrl)
                    root.children().last() + pomConfig
                    def depsNode = root["dependencies"][0] ?: root.appendNode("dependencies")

                    def addDep = {
                        if (it.group == null) return // Avoid empty dependency nodes
                        def dependencyNode = depsNode.appendNode('dependency')
                        dependencyNode.appendNode('groupId', it.group)
                        dependencyNode.appendNode('artifactId', it.name)
                        dependencyNode.appendNode('version', it.version)
                        if (it.hasProperty('optional') && it.optional) {
                            dependencyNode.appendNode('optional', 'true')
                        }
                    }

                    // Add deps that everyone has
                    configurations.compile.allDependencies.each addDep
                    // Add flavor specific deps
                    if (flavored) {
                        configurations["${variant.flavorName}Compile"].allDependencies.each addDep
                    }
                    // NOTE: This library doesn't use builtTypes specific dependencies, so no need to add them.
                }
            }
        }
    }
}

group = groupId
version = libraryVersion

afterEvaluate {
    bintray {
        user = bintray_user
        key = bintray_api_key
        publications = publicationNames

        override = true
        pkg {
            repo = 'splitties'
            name = project.name
            desc = libraryDesc
            websiteUrl = siteUrl
            issueTrackerUrl = 'https://github.com/LouisCAD/Splitties/issues'
            vcsUrl = gitUrl
            licenses = ['Apache-2.0']
            labels = ['aar', 'android']
            publicDownloadNumbers = true
            githubRepo = 'LouisCAD/Splitties'
        }
    }
}

Para que esto funcione, necesito tener definidas las propiedades bintray_user y bintray_api_key. Personalmente solo los tengo en mi archivo ~/.gradle/gradle.properties como esto:

bintray_user=my_bintray_user_name
bintray_api_key=my_private_bintray_api_key

También necesito definir las siguientes propiedades ext que utilicé en el publish.gradle archivo en mi proyecto raíz build.gradle archivo:

allprojects {
    ...
    ext {
        ...
        // Libraries
        groupId = "xyz.louiscad.splitties"
        libraryVersion = "1.2.1"
        siteUrl = 'https://github.com/LouisCAD/Splitties'
        gitUrl = 'https://github.com/LouisCAD/Splitties.git'
    }
}

Y ahora, finalmente puedo usarlo en mi módulo de biblioteca de Android, donde tengo múltiples productFlavors. Aquí hay un fragmento de un módulo de biblioteca publicablebuild.gradle archivo:

plugins {
    id "com.jfrog.bintray" version "1.7.3" // Enables publishing to bintray
    id "com.github.dcendents.android-maven" version "1.5" // Allows aar in mavenPublications
}

apply plugin: 'com.android.library'
apply plugin: 'maven-publish' // Used for mavenPublications

android {
    ...
    defaultPublishConfig "myLibraryDebug" // Allows using this library in another
    // module in this project without publishing to mavenLocal or Bintray.
    // Useful for debug purposes, or for your library's sample app.
    defaultConfig {
        ...
        versionName libraryVersion
        ...
    }
    ...
    productFlavors {
        myLibrary
        myLibrary_logged // Here, the "_" will be replaced "-" in artifactId when publishing.
        myOtherLibraryFlavor
    }
    ...
}

dependencies {
    ...
    // Timber, a log utility.
    myLibrary_loggedCompile "com.jakewharton.timber:timber:${timberVersion}"; // Just an example
}
...

ext {
    libraryDesc = "Delegates for kotlin on android that check UI thread"
}

apply from: '../publish.gradle' // Makes this library publishable

Cuando tenga toda esta configuración correctamente, con el nombre de su biblioteca en lugar de la mía (que puede usar como un ejemplo), puede intentar publicar una versión de su biblioteca saborizada al intentar publicar primero en mavenLocal. Para hacerlo, ejecute este comando:

myLibrary $ ../gradlew publishToMavenLocal

Luego puede intentar agregar mavenLocal en los repositorios de su aplicación (ejemplo aquí) e intentar agregar su biblioteca como una dependencia (artifactId debe ser el nombre del tipo, con "_" reemplazado por "-") y compilarlo. También puede verificar con su explorador de archivos (use cmd+shift+G en Mac en Finder para acceder a la carpeta oculta) el directorio ~/.m2 y busca tu biblioteca.

Cuando llegue el momento de publicar en bintray / jcenter, solo tiene que ejecutar este comando:

myLibrary $ ../gradlew bintrayUpload

Importante:

Antes de publicar su biblioteca en mavenLocal, Bintray u otro repositorio maven, normalmente querrá probar su biblioteca con una aplicación de ejemplo que use la biblioteca. Esta aplicación de ejemplo, que debería ser otro módulo en el mismo proyecto solo necesita tener la dependencia del proyecto, que debería tener este aspecto: compile project(':myLibrary'). Sin embargo, dado que su biblioteca tiene varios sabores de productos, querrá probarlos todos. Desafortunadamente, actualmente es imposible especificar qué configuración desea usar del archivo build.gradle de su aplicación de ejemplo (a menos que use publishNonDefault true en el archivo build.gradle de su biblioteca, que rompe las publicaciones maven y bintray), pero puede especificar la configuración predeterminada (es decir, buildVariant) en el módulo de su biblioteca como tal: defaultPublishConfig "myLibraryDebug" en el cierre android. Puedes ver las variantes de compilación disponibles para tu biblioteca en las Ventanas de la herramienta" Construir variantes " en Android Studio.

, Siéntase libre de explorar mi biblioteca "Splitties" aquí si necesita un ejemplo. El módulo con sabor se llama concurrency, pero también uso mi script para módulos de biblioteca sin sabor, y lo probé completamente en todos los módulos de biblioteca de mi proyecto.

Puede ponerse en contacto conmigo si necesita ayuda para configurarlo para usted.