bintray.gradle

//
// This script must be applied after android app/lib plugin.
//

/*
 * 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.
 */

apply plugin: 'maven'
apply plugin: 'signing'
apply plugin: 'com.jfrog.bintray'

version = VERSION_NAME
group = GROUP

def setup() {
  println("Checking environment variables setup for ${project.name}...")
  def resultOk = true

  ["BINTRAY_USER", "BINTRAY_USER_ORG", "BINTRAY_PASSWORD", "BINTRAY_API_KEY", "DA_OSS_USERNAME",
   "DA_OSS_PWD", "DA_SIGN_SECRET_RING_FILE"].each {
    if (!project.hasProperty(it)) {
      println("-> Property '$it' not found.")
      resultOk = false
    }
  }

  if (resultOk) {
    println("Relax, it's fine.\n")
  } else {
    println("Opps, it's incomplete.\n")
  }

  return resultOk
}

def getVariableOrEmpty(String name) {
  if (project.hasProperty(name)) {
    return project.property(name)
  } else {
    return ""
  }
}

if (!setup()) {
  println("bintray.gradle script can't continue without all the needed variables.\n")
  return
}

def isReleaseBuild() {
  return VERSION_NAME.contains("SNAPSHOT") == false
}

def getReleaseRepositoryUrl() {
  hasProperty('RELEASE_REPOSITORY_URL') ? getVariableOrEmpty("RELEASE_REPOSITORY_URL") :
      "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
}

def getSnapshotRepositoryUrl() {
  return hasProperty('SNAPSHOT_REPOSITORY_URL') ? getVariableOrEmpty("SNAPSHOT_REPOSITORY_URL") :
      "https://oss.sonatype.org/content/repositories/snapshots/"
  //      "https://oss.jfrog.org/artifactory/oss-snapshot-local"
  //      "https://oss.jfrog.org"
}

def getRepositoryUsername() {
  return hasProperty('BINTRAY_USER') ? getVariableOrEmpty("BINTRAY_USER") : ""
}

def getRepositoryPassword() {
  return hasProperty('BINTRAY_PASSWORD') ? getVariableOrEmpty("BINTRAY_PASSWORD") : ""
}

def pomProperties = {
  packaging "aar"
  groupId = GROUP
  artifactId = POM_ARTIFACT_ID
  version = VERSION_NAME
  name POM_NAME
  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
      email POM_DEVELOPER_EMAIL
    }
  }
}

afterEvaluate { project ->
  uploadArchives {
    repositories {
      mavenDeployer {
        beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }

        repository(url: getReleaseRepositoryUrl()) {
          authentication(userName: getRepositoryUsername(), password: getRepositoryPassword())
        }
        snapshotRepository(url: getSnapshotRepositoryUrl()) {
          authentication(userName: getRepositoryUsername(), password: getRepositoryPassword())
        }

        pom.project(pomProperties)
      }
    }
  }
}

signing {
  required { isReleaseBuild() && project.hasProperty("signPackage") }
  sign configurations.archives
}

task install(type: Upload, dependsOn: assemble) {
  repositories.mavenInstaller {
    configuration = configurations.archives

    pom.groupId = GROUP
    pom.artifactId = POM_ARTIFACT_ID
    pom.version = VERSION_NAME

    pom.project(pomProperties)

    // Append library dependencies to the pom
    pom.withXml {
      def dependenciesNode = asNode().appendNode('dependencies')

      configurations.compile.allDependencies.each {
        if (it.name != "lib") {
          def dependencyNode = dependenciesNode.appendNode('dependency')

          dependencyNode.appendNode('groupId', it.group)
          dependencyNode.appendNode('artifactId', it.name)
          dependencyNode.appendNode('version', it.version)
        }
      }
    }
  }
}

task androidJavadocs(type: Javadoc) {
  source = android.sourceSets.main.kotlin.source
  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 {
  archives androidSourcesJar
  archives androidJavadocsJar
}

bintray {
  if (!setup()) {
    println("-> bintray: No bintray properties found")
    return
  }

  user = getVariableOrEmpty("BINTRAY_USER")
  key = getVariableOrEmpty("BINTRAY_API_KEY")

  configurations = ['archives']

  override = true
  publish = true
  dryRun = project.hasProperty("dryRun")

  pkg {
    repo = "maven"
    name = POM_ARTIFACT_ID
    userOrg = getVariableOrEmpty("BINTRAY_USER_ORG")
    desc = POM_DESCRIPTION
    websiteUrl = POM_URL
    issueTrackerUrl = POM_URL + '/issues'

    vcsUrl = POM_SCM_CONNECTION
    licenses = [POM_LICENCE_NAME]

    githubRepo = POM_SCM_URL
    githubReleaseNotesFile = 'README.md'

    version {
      desc = POM_DESCRIPTION
      name = VERSION_NAME

      gpg {
        sign = false
      }

      mavenCentralSync {
        sync = true
        user = getVariableOrEmpty("DA_OSS_USERNAME")
        password = getVariableOrEmpty("DA_OSS_PWD")
        close = '1'
        //Optional property. By default the staging repository is closed and artifacts are released to Maven Central. You can optionally turn this behaviour off (by puting 0 as value) and release the version manually.
      }
    }
  }
}