gradle-mvn-push.gradle

/*
 * Copyright 2013 Chris Banes
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
if (project.rootProject.file('local.properties').exists()) {
    apply plugin: 'com.jfrog.bintray'
    apply plugin: 'com.github.dcendents.android-maven'
    apply plugin: 'maven-publish'

    version = VERSION_NAME
    group = GROUP

// Bintray
    bintray {
        Properties properties = new Properties()
        println("starting bintray")
        properties.load(project.rootProject.file('local.properties').newDataInputStream())
        user = properties.getProperty("bintray.user")
        key = properties.getProperty("bintray.apikey")

        configurations = ['archives']
        dryRun = false
        pkg {
            repo = BINTRAY_REPO_NAME
            name = POM_ARTIFACT_ID
            desc = POM_DESCRIPTION
            websiteUrl = POM_URL
            issueTrackerUrl = POM_ISSUE_URL
            vcsUrl = POM_SCM_URL
            licenses = ["Apache-2.0"]
            publish = true

            publicDownloadNumbers = true
            version {
                desc = POM_DESCRIPTION
                gpg {
                    sign = true //Determines whether to GPG sign the files. The default is false
                    passphrase = properties.getProperty("bintray.gpg.password")
                    //Optional. The passphrase for GPG signing'
                }

                mavenCentralSync {
                    sync = true
                    user = properties.getProperty("bintray.oss.user")
                    password = properties.getProperty("bintray.oss.password")
                    close = '1'
                }
            }
        }

        publications= ['mavenAar']
    }

        install {
            repositories.mavenInstaller {
                customizePom(pom, project)
                configuration = configurations.archives

            }
        }

        task androidJavadocs(type: Javadoc) {
            source = android.sourceSets.main.java.source
            options.addStringOption('Xdoclint:none', '-quiet')
            options.addStringOption('encoding', 'UTF-8')
            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.source
        }


    if (JavaVersion.current().isJava8Compatible()) {
        allprojects {
            tasks.withType(Javadoc) {
                options.addStringOption('Xdoclint:none', '-quiet')
            }
        }
    }

    artifacts {
        if (project.getPlugins().hasPlugin('com.android.application') ||
                project.getPlugins().hasPlugin('com.android.library')) {
            archives androidSourcesJar
        }
    }


}
def customizePom(pom, gradleProject) {
    publishing {
        publications {
            mavenAar(MavenPublication) {
                artifact("$buildDir/outputs/aar/app-release.aar")
                groupId = GROUP
                artifactId = POM_ARTIFACT_ID
                version = VERSION_NAME
                pom.withXml {
                    def dependenciesNode = asNode().appendNode('dependencies')

                    // Iterate over the implementation dependencies (we don't want the test ones), adding a <dependency> node for each
                    configurations.implementation.allDependencies.each {
                        // Ensure dependencies such as fileTree are not included in the pom.
                        if (it.name != 'unspecified') {
                            def dependencyNode = dependenciesNode.appendNode('dependency')
                            dependencyNode.appendNode('groupId', GROUP)
                            dependencyNode.appendNode('artifactId', POM_ARTIFACT_ID)
                            dependencyNode.appendNode('version', VERSION_NAME)
                        }
                    }
                    groupId = GROUP
                    artifactId = POM_ARTIFACT_ID
                    version = VERSION_NAME
                    gradleProject {
                        name POM_NAME
                        packaging POM_PACKAGING
                        description POM_DESCRIPTION
                        url POM_URL

                        scm {
                            url POM_SCM_URL
                            connection POM_SCM_CONNECTION
                            developerConnection POM_SCM_DEV_CONNECTION
                        }

                        licenses {
                            license {
                                name POM_LICENCE_NAME
                                url POM_LICENCE_URL
                                distribution POM_LICENCE_DIST
                            }
                        }

                        developers {
                            developer {
                                id POM_DEVELOPER_ID
                                name POM_DEVELOPER_NAME
                            }
                        }
                    }
                }

            }
        }
    }

    pom.whenConfigured { generatedPom ->
        // eliminate test-scoped dependencies (no need in maven central poms)
        generatedPom.dependencies.removeAll { dep ->
            dep.scope == "test"
        }

        // sort to make pom dependencies order consistent to ease comparison of older poms
        generatedPom.dependencies = generatedPom.dependencies.sort { dep ->
            "$dep.scope:$dep.groupId:$dep.artifactId"
        }

        // add all items necessary for maven central publication
        generatedPom.project {
            groupId = GROUP
            artifactId = POM_ARTIFACT_ID
            version = VERSION_NAME
            gradleProject {
                name POM_NAME
                packaging POM_PACKAGING
                description POM_DESCRIPTION
                url POM_URL

                scm {
                    url POM_SCM_URL
                    connection POM_SCM_CONNECTION
                    developerConnection POM_SCM_DEV_CONNECTION
                }

                licenses {
                    license {
                        name POM_LICENCE_NAME
                        url POM_LICENCE_URL
                        distribution POM_LICENCE_DIST
                    }
                }

                developers {
                    developer {
                        id POM_DEVELOPER_ID
                        name POM_DEVELOPER_NAME
                    }
                }
            }
        }


    }
}


task copyPom(type: Copy) {
    from rootProject.file("/lives/build/publications/mavenAar/pom-default.xml")
    into rootProject.file("/lives/build/poms/")
}

task  releaseOnAdibBintray(type: GradleBuild) {
    tasks = ['assembleRelease', 'androidSourcesJar', 'generatePomFileForMavenAarPublication', 'copyPom', 'bintrayUpload']
}