Pubblicazione della libreria Android (aar) a Bintray con i sapori scelti

Ho giusto aggiunto alcuni flavors (o productFlavors se volete) al mio progetto.

Il fatto è che quando pubblico la biblioteca a bintray , tutti i sapori vengono caricati (che è grande), ma non sono in grado di utilizzarli. Il plugin utilizzato è quello ufficiale.

  • L'aiuto di OpenGL di Android ha bisogno
  • Come aggiungere il tempo al timer di conto alla rovescia?
  • come possiamo utilizzare startActivityforResult () per l'intento di posta elettronica?
  • non può call String.isEmpty () in android
  • Installazione del plugin ADT per Eclipse
  • Finestra di dialogo con EditText e Spinner
  • Il caricato aar:

      androidsdk-0.0.4-fullRelease.aar androidsdk-0.0.4-fullDebug.aar androidsdk-0.0.4-lightRelease.aar androidsdk-0.0.4-lightDebug.aar 

    Come notato, la fullRelease è denominata come classifier , vedere il capitolo doc 23.4.1.3 .

    Sto cercando una soluzione per scegliere i sapori che voglio caricare.

    Ho già esaminato bintray esempi ( qui e qui ) e questo , anche con altri esempi ma sono ancora bloccato.

    Ecco il mio script attuale:

     apply plugin: 'com.android.library' apply plugin: 'com.github.dcendents.android-maven' apply plugin: 'com.jfrog.bintray' buildscript { repositories { jcenter() } } android { compileSdkVersion 23 buildToolsVersion "23.0.1" defaultConfig { minSdkVersion 9 targetSdkVersion 23 versionCode 64 versionName "0.0.4" } publishNonDefault true productFlavors { full { } light { } } } dependencies { compile fileTree(dir: 'libs', include: ['*.jar']) compile 'com.android.support:appcompat-v7:23.1.1' compile 'com.android.support:recyclerview-v7:23.1.1' fullCompile 'com.squareup.picasso:picasso:2.5.0' } version = android.defaultConfig.versionName uploadArchives { repositories.mavenDeployer { pom.project { packaging 'aar' } } } //////////////////////////////// // Bintray Upload configuration Properties properties = new Properties() properties.load(project.rootProject.file('local.properties').newDataInputStream()) bintray { user = properties.getProperty("bintray.user") key = properties.getProperty("bintray.apikey") configurations = ['archives'] pkg { repo = "MyRepo" // repo name userOrg = 'hugo' name = "AndroidSDK" // Package name websiteUrl = siteUrl vcsUrl = gitUrl publish = true } } 

    Per importre la libreria che sto attualmente utilizzando questo:

     compile ('com.example.lib:sdk:0.0.8:fullRelease@aar') { transitive = true; } 

  • Android ExpandableListView Parent con il button
  • Inviare la richiesta HTTP tramite networking 3G senza utilizzare WiFi?
  • PhoneGap + JQuery Mobile + Google Maps v3: mappa mostra le piastre di sinistra più alte?
  • Perché ottengo "MismatchSenderId" dal lato server GCM?
  • Versioni multiple della stessa libreria
  • Notifica inviata posta in onActivityResult "Android"
  • 5 Solutions collect form web for “Pubblicazione della libreria Android (aar) a Bintray con i sapori scelti”

    Ho affrontato la stessa sfida, ecco il meglio che potrei fare ancora:

    Utilizzando mavenPublications e il plugin di gradle maven maven-publish lungo il plugin bintray, è ansible pubblicare qualsiasi variante in mavenLocal e bintray.

    Ecco il file publish.gradle che applico alla fine di tutti i moduli di libreria del mio progetto che voglio pubblicare:

     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 'louis.cognault@gmail.com' } } 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 classs 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' } } } 

    Per poter funzionare, devo avere le properties; bintray_user e bintray_api_key definite. Personalmente li ho solo nel file ~/.gradle/gradle.properties come questo:

     bintray_user=my_bintray_user_name bintray_api_key=my_private_bintray_api_key 

    Ho anche bisogno di definire le seguenti properties; ext utilizzate nel file publish.gradle nel file publish.gradle del mio progetto radice:

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

    Ed ora, posso finalmente utilizzarlo nel mio module di libreria Android, where ho più productFlavors . Di seguito è riportto un snippet di un file build.gradle di un module di libreria pubblicabile:

     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 

    Quando hai tutto questo setup correttamente, con il nome della tua libreria anziché i miei (che puoi utilizzare come esempio), puoi provare a pubblicare una versione della tua libreria aromatizzata cercando di pubblicare prima a mavenLocal. A tale scopo, eseguire questo command:

     myLibrary $ ../gradlew publishToMavenLocal 

    Puoi quindi provare ad aggiungere mavenLocal nei repository della tua app (esempio qui) e provare ad aggiungere la tua libreria come dipendenza (artifactId dovrebbe essere il nome del sapore, con "_" sostituito da "-") e costruirlo. Puoi anche controllare con il tuo file explorer (utilizzare cmd + shift + G su Mac nel Finder per accedere alla cartella nascosta) la directory ~/.m2 e cercare la tua libreria.

    Quando è il momento di pubblicare su bintray / jcenter, devi solo eseguire questo command:

     myLibrary $ ../gradlew bintrayUpload 

    Importnte:

    Prima di pubblicare la tua libreria in mavenLocal, Bintray o in un altro repository maven, di solito desideri provare la tua libreria su un'applicazione di esempio che utilizza la libreria. Questa applicazione di esempio, che dovrebbe essere un altro module nello stesso progetto, deve solo avere la dipendenza del progetto, che dovrebbe essere simile a questo: compile project(':myLibrary') . Tuttavia, poiché la tua biblioteca dispone di più productFlavors, vorrai testare tutti. Purtroppo adesso è imansible specificare la configuration da utilizzare dal file build.gradle dell'applicazione di build.gradle (a less che non si utilizzi il file build.gradle della libreria nella build.gradle di build.gradle della tua libreria), ma è ansible specificare il valore predefinito configuration (cioè buildVariant) nel module della tua libreria come tale: defaultPublishConfig "myLibraryDebug" nella chiusura android . Potete vedere le varianti di creazione disponibili per la tua libreria nel tool "Build Variants" di Windows in Android Studio.

    Sentiti libero di esplorare la mia biblioteca "Splitties" qui se hai bisogno di un esempio. Il module aromatizzato viene chiamato concurrency , ma utilizzo anche il mio script per i moduli bibliotecari unflavored e ho provato in modo approfondito su tutti i moduli di libreria del mio progetto.

    Potrai raggiungermi se hai bisogno di aiuto per impostarti per te.

    Il set up:

     buildTypes { debug { } release { } } publishNonDefault true 

    La correzione:

     defaultPublishConfig 'release' // Fix for defaultPublishConfig not working as expected // ref: https://github.com/dcendents/android-maven-gradle-plugin/issues/11 libraryVariants.all { variant -> if( publishNonDefault && variant.name == defaultPublishConfig ) { def bundleTask = tasks["bundle${variant.name.capitalize()}"] artifacts { archives(bundleTask.archivePath) { classifier null //necessary to get rid of the suffix in the artifact builtBy bundleTask name name.replace('-' + variant.name, '')//necessary to get rid of the suffix from the folder name } } } } 

    Questa correzione pubblica ancora tutti gli artefatti, ma pubblicherà un artefatto predefinito senza il suffisso del sapore, che è sufficiente per far funzionare tutto.

    La correzione per caricare solo l'artefatto predefinito sarebbe questo (se il plugin bintray sapeva quali sono i filtri POM):

     install { repositories.mavenInstaller { /* POM filters can be used to block artifacts from certain build variants. However, Bintray does not respect POM filters, therefore this only works for maven deploy plugin. Also, bintray crashes with named filters, since it always expects a /build/pom/pom-default.xml, which does not happen with named filters. */ filter { artifact, file -> // this how the default classifier is identified in case the defaultPublishConfig fix is applied artifact.attributes.classifier == null } } } 

    Non l'ho provata in modo da eliminare la risposta se non risolve il problema.

    È necessario submit un diverso artefatto per each sapore (o creare una variante se preferisci).
    In questo modo avrai in artefatti jcenter x, ognuno con un file pom.

    Qualcosa di simile a:

     groupId |--library-full |----.pom |----.aar |--library-light |----.pom |----.aar 

    Nel tuo file di livello superiore puoi definire

     allprojects { repositories { jcenter() } project.ext { groupId="xxx" libraryName = "" ...... } } 

    Quindi nel module della tua libreria:

     productFlavors { full { project.ext.set("libraryName", "library-full"); } light { project.ext.set("libraryName", "library-light"); } } bintray { //... pkg { //...Do the same for other variables name = project.ext.libraryName } } 

    Infine, assicurati di pubblicare solo il tipo di build release (perché anche la versione di debug?)

    Se qualcuno è ancora bloccato con questo problema ecco cosa ha funzionato per me –

    Diciamo che vuoi pubblicare la build di rilascio per il tuo flavour1 aggiungila questo al tuo build.gradle

     android { ... defaultPublishConfig "flavour1Release" } 

    Rimuovi il publishNonDefault true se è presente nel file gradle.

    Aggiungi questo all'interno del block bintray come questo

     bintray { ... archivesBaseName = 'YOUR_ARTIFACT_ID' ... } 

    Quindi eseguire semplicemente l'attività bintrayUpload come si farebbe.

    Il defaultPublishConfig dovrà essere modificato each volta che è necessario pubblicare un nuovo sapore.

    Sembra che tu non desideri che il classificatore sia nel nome del file. Sembra che il classificatore sia lo stesso del nome del file della libreria generato. Avete provato a dargli lo stesso nome di file, ma li hanno indirizzati a separare le directory? Ad esempio nell'ambito di android:

     libraryVariants.all { variant -> variant.outputs.each { output -> def outputFile = output.outputFile if (outputFile != null && outputFile.name.endsWith('.aar')) { def fileName = "same_name-${version}.aar" output.outputFile = new File(outputFile.parent+"/${archivesBaseName}", fileName) } } } 
    L'Android è un fan Android di Google, tutto su telefoni Android, Android Wear, Android Dev e applicazioni Android Games e così via.