Jak używać artifactoryPublish do publikowania i debugowania artefaktów

Spróbuj tego:-

def runTasks = gradle.startParameter.taskNames

artifactory {
    contextUrl = "${artifactory_contextUrl}"
    publish {
        repository {
            if ('assembleRelease' in runTasks)
                repoKey = "${artifactory_repository_release}"
            else if ('assembleDebug' in runTasks)
                repoKey = "${artifactory_repository_debug}"

            username = "${artifactory_user}"
            password = "${artifactory_password}"
            maven = true
        }
        defaults {
            publishArtifacts = true
            if ('assembleRelease' in runTasks)
                publications("${artifactory_publication_release}")
            else if ('assembleDebug' in runTasks)
                publications("${artifactory_publication_debug}")
            publishPom = true
            publishIvy = false
        }
    }
}

Gdzie artifactory_repository_release=libs-release-local i artifactory_repository_debug=libs-debug-local

Artifactory repo, na którym chcesz opublikować swoją bibliotekę arr.

Dla migawek + wersji release, można użyć sonatype (aka mavencentral). Kilka tygodni temu zrobiłem krótki przewodnik, który może się przydać. Jak opublikować Android Aars-snapshoty / release to mavencentral

Nie mogę dostać pracy wydawniczej z @ cooperok odpowiedz inaczej to mi pomóc alots.

Oto Mój kod:

apply plugin: 'com.android.library'
apply plugin: 'com.jfrog.artifactory'
apply plugin: 'maven-publish'

android {
    compileSdkVersion 23
    buildToolsVersion "23.0.2"

    defaultConfig {
        minSdkVersion 9
        targetSdkVersion 23
        versionCode 1
        versionName "0.0.1"
    }

    publishNonDefault true

    buildTypes {
        debug {
            minifyEnabled false
            debuggable true
        }
        release {
            minifyEnabled false
            debuggable false
        }
        snapshot {
            minifyEnabled false
            debuggable false
        }
    }

}

task androidJavadocs(type: Javadoc) {
    source = android.sourceSets.main.java.srcDirs
    classpath +=    project.files(android.getBootClasspath().join(File.pathSeparator))
}

task androidJavadocsJar(type: Jar, dependsOn: androidJavadocs) {
    classifier = 'javadoc'
    from androidJavadocs.destinationDir
}

task androidSourcesJar(type: Jar) {
    classifier = 'sources'
    from android.sourceSets.main.java.srcDirs
}

artifacts {
    archives androidSourcesJar
    archives androidJavadocsJar
}

publishing {
    publications {
        android.buildTypes.all { variant ->
            "${variant.name}"(MavenPublication) {
                def manifestParser = new com.android.builder.core.DefaultManifestParser()
                groupId manifestParser.getPackage(android.sourceSets.main.manifest.srcFile)
                if("${variant.name}".equalsIgnoreCase("release")){
                    version = manifestParser.getVersionName(android.sourceSets.main.manifest.srcFile)
                }else if ("${variant.name}".equalsIgnoreCase("debug")){
                    version = manifestParser.getVersionName(android.sourceSets.main.manifest.srcFile).concat("-${variant.name}".toUpperCase().concat("-SNAPSHOT"))
                }else{
                    version = manifestParser.getVersionName(android.sourceSets.main.manifest.srcFile).concat("-${variant.name}".toUpperCase())
                }

                artifactId project.getName()

                artifact("$buildDir/outputs/aar/${project.getName()}-${variant.name}.aar")
                artifact androidJavadocsJar

                pom.withXml {
                    def dependencies = asNode().appendNode('dependencies')
                    configurations.getByName("_releaseCompile").getResolvedConfiguration().getFirstLevelModuleDependencies().each {
                        def dependency = dependencies.appendNode('dependency')
                        dependency.appendNode('groupId', it.moduleGroup)
                        dependency.appendNode('artifactId', it.moduleName)
                        dependency.appendNode('version', it.moduleVersion)
                    }
                }
            }
        }
    }
}

android.buildTypes.all { variant ->

    model {
        tasks."generatePomFileFor${variant.name.capitalize()}Publication" {
            destination = file("$buildDir/publications/${variant.name}/generated-pom.xml")
        }
    }

    def publicationName = "${variant.name}"

    def taskName = "${variant.name}Publication"

    task "$taskName"() << {
        artifactoryPublish {
            doFirst {
                tasks."generatePomFileFor${variant.name.capitalize()}Publication".execute()
                publications(publicationName)
                clientConfig.publisher.repoKey = "${variant.name}".equalsIgnoreCase("release") ? "libs-release-local" :
                        "libs-snapshot-local"
            }
        }
    }


    tasks."assemble${variant.name.capitalize()}".dependsOn(tasks."$taskName")

}


artifactory {
    contextUrl = 'http://172.16.32.220:8081/artifactory'
    publish {
        repository {
            username = "admin"
            password = "password"
        }
        defaults {
            publishPom = true
            publishArtifacts = true
            properties = ['qa.level': 'basic', 'dev.team': 'core']
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    testCompile 'junit:junit:4.12'
    compile 'com.android.support:appcompat-v7:23.1.1'
}

Po aktualizacji gradle do 'com.android.narzędzia.Budowa: gradle:3.x. x " To już nie działa.

Moim ostatecznym rozwiązaniem było:

artifactory {
    contextUrl = ARTIFACTORY_URL
    //The base Artifactory URL if not overridden by the publisher/resolver
    publish {
        repository {
            File debugFile = new File("$buildDir/outputs/aar/${SDK_NAME}-debug.aar");
            if ( debugFile.isFile() )
                repoKey = 'libs-snapshot-local'
            else
                repoKey = 'libs-release-local'

            username = ARTIFACTORY_USER
            password = ARTIFACTORY_PWD
            maven = true
        }
        defaults {
            File debugFile = new File("$buildDir/outputs/aar/${SDK_NAME}-debug.aar");
            if ( debugFile.isFile() )
                publications("debugAar")
            else
                publications("releaseAar")

            publishArtifacts = true
            // Properties to be attached to the published artifacts.
            properties = ['qa.level': 'basic', 'dev.team': 'core']
            // Is this even necessary since it's TRUE by default?
            // Publish generated POM files to Artifactory (true by default)
            publishPom = true
        }
    }
}

publishing {
    publications {
        //Iterate all build types to make specific
        //artifact for every build type
        android.buildTypes.all {variant ->
            //it will create different
            //publications ('debugAar' and 'releaseAar')
            "${variant.name}Aar"(MavenPublication) {
                writeNewPom(variant.name)
                groupId GROUP_NAME
                artifactId SDK_NAME
                version variant.name.endsWith('debug') ? VERSION_NAME + "-SNAPSHOT" : VERSION_NAME
                // Tell maven to prepare the generated "*.aar" file for publishing
                artifact("$buildDir/outputs/aar/${SDK_NAME}-${variant.name}.aar")
            }
        }
    }
}

def writeNewPom(def variant) {
    pom {
        project {
            groupId GROUP_NAME
            artifactId SDK_NAME
            version variant.endsWith('debug') ? VERSION_NAME + "-SNAPSHOT" : VERSION_NAME
            packaging 'aar'

            licenses {
                license {
                    name 'The Apache Software License, Version 2.0'
                    url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                    distribution 'repo'
                }
            }
        }
    }.withXml {
        def dependenciesNode = asNode().appendNode('dependencies')

        configurations.api.allDependencies.each {dependency ->
            if (dependency.group != null) {
                def dependencyNode = dependenciesNode.appendNode('dependency')
                dependencyNode.appendNode('groupId', dependency.group)
                dependencyNode.appendNode('artifactId', dependency.name)
                dependencyNode.appendNode('version', dependency.version)
            }
        }
    }.writeTo("$buildDir/publications/${variant}Aar/pom-default.xml")
}