How to use artifactoryPublish to publish release and debug artifacts

I configured my android library build.gradle file that compiled aar file could be uploaded in different repos, dependent on build type.
For example you want to publish debug artifats to 'libs-debug-local' repository and release artifacts to 'libs-release-local' repository.

//First you should configure all artifacts you want to publish
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) {
                def manifestParser = new com.android.builder.core.DefaultManifestParser()

                //Set values from Android manifest file
                groupId manifestParser.getPackage(android.sourceSets.main.manifest.srcFile)
                version = manifestParser.getVersionName(android.sourceSets.main.manifest.srcFile)
                artifactId project.getName()

                // Tell maven to prepare the generated "*.aar" file for publishing
                artifact("$buildDir/outputs/aar/${project.getName()}-${variant.name}.aar")
            }
        }
    }
}

//After configuring publications you should
//create tasks to set correct repo key
android.buildTypes.all { variant ->

    //same publication name as we created above
    def publicationName = "${variant.name}Aar"

    //new task name
    def taskName = "${variant.name}Publication"

    //in execution time setting publications and repo key, dependent on build type
    tasks."$taskName" << {
        artifactoryPublish {
            doFirst {
                publications(publicationName)
                clientConfig.publisher.repoKey = "libs-${variant.name}-local"
            }
        }
    }

    //make tasks assembleDebug and assembleRelease dependent on our new tasks
    //it helps to set corrent values for every task
    tasks."assemble${variant.name.capitalize()}".dependsOn(tasks."$taskName")
}

//Inside artifactory block just set url and credential, without setting repo key and publications
artifactory {
    contextUrl = 'http://artifactory.cooperok.com:8081/artifactory'
    publish {
        repository {
            username = "username"
            password = "password"
        }
        defaults {
            publishArtifacts = true

            // Properties to be attached to the published artifacts.
            properties = ['qa.level': 'basic', 'dev.team': 'core']
        }
    }
}

That's all. Now if you run command

Win : gradlew assembleRelease artifactoryPublish Mac : ./gradlew assembleRelease artifactoryPublish

aar file will be uploaded to 'libs-release-local' repository.
And if you ran

Win : gradlew assembleDebug artifactoryPublish Mac : ./gradlew assembleDebug artifactoryPublish

it will be uploaded to 'libs-debug-local' repository

One minus of this configuration is that you should always run artifactoryPublish task with assembleDebug/Release tasks

try this:-

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
        }
    }
}

where artifactory_repository_release=libs-release-local and artifactory_repository_debug=libs-debug-local

artifactory repo on which you want to publish your library arr.

After a gradle update to 'com.android.tools.build:gradle:3.x.x' this no longer works for me.

My final solution was:

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")
}