build.gradle

group = 'com.strongloop';

logger.info('**JVM VERSION** ' + org.gradle.internal.jvm.Jvm.current())

buildscript {
  repositories {
      mavenCentral()
  }
  dependencies {
      classpath 'com.android.tools.build:gradle:1.0.1'
      classpath 'org.apache.commons:commons-io:1.3.2'
      classpath 'com.github.dcendents:android-maven-plugin:1.2'
  }
}

apply plugin: 'com.android.library'
apply plugin: 'android-maven'
apply plugin: 'signing'

import org.apache.commons.io.FilenameUtils;

def sonatypeRepositoryUrl = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
def isJenkinsBuild = System.getenv("BUILD_NUMBER")
def isReleaseBuild = !version.contains("SNAPSHOT")
def shouldPublishToMavenCentral = isReleaseBuild

repositories {
    mavenLocal()
    mavenCentral()
    maven {
        url "http://artifactory.strongloop.com:8081/artifactory/repo/"
    }
}

android {
    compileSdkVersion 21
    buildToolsVersion "21.0.2"

    defaultConfig {
        minSdkVersion 8
        targetSdkVersion 20
    }
}

dependencies {
    compile 'org.atteo:evo-inflector:1.2'
    compile 'com.google.guava:guava:17.0'
    compile 'com.loopj.android:android-async-http:1.4.5'
}

task unpackJavadocIncludes(type: Sync) {
    // unpack all source dependencies
    into 'build/javadoc-sources'
}

android.libraryVariants.all { variant ->
    def name = variant.buildType.name
    if (name.equals('DEBUG')) {
        return; // Skip debug builds.
    }

    // define androidReleaseJar task
    task("android${name.capitalize()}Jar", type: Jar) {
        dependsOn variant.javaCompile
        from variant.javaCompile.destinationDir
    }

    // define androidReleaseJavadoc task
    task("generate${name.capitalize()}Javadoc", type: Javadoc) {
        description "Generates Javadoc for $variant.name."
        dependsOn unpackJavadocIncludes
        source variant.javaCompile.source
        source fileTree('build/javadoc-sources').matching {
          include '**/*.java'
        }
        ext.androidJar = "${android.sdkDirectory}/platforms/${android.compileSdkVersion}/android.jar"
        classpath = files(variant.javaCompile.classpath.files) + files(ext.androidJar)

        logger.info('**JAVADOC CLASSPATH for ' + name + '**')
        classpath.each {
          logger.info '  ' + it.absolutePath
          if (!it.isFile() && !it.isDirectory()) {
            logger.error('INVALID CLASSPATH ITEM ' + it.absolutePath);
          }
        }

        verbose = logger.isEnabled(LogLevel.INFO)
    }
}

afterEvaluate { project ->
    task updateApiDocs(type: Sync, dependsOn: generateReleaseJavadoc) {
        from generateReleaseJavadoc.destinationDir
        into 'docs/api'
    }

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

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

    // Tasks for building dist.zip

    task distProperties() { doLast {
        new File(androidReleaseJar.archivePath.absolutePath + '.properties').withWriter { w ->
          w.println('src=src/' + androidSourcesJar.archiveName)
          w.println('doc=docs/' + androidJavadocsJar.archiveName)
        }

        // hack: create properties file for strong-remoting-android
        configurations.compile.resolve().each { dep ->
            if (dep.name.startsWith('strong-remoting-android')) {
                new File(dep.absolutePath + '.properties').withWriter { w ->
                    def baseName = FilenameUtils.getBaseName(dep.absolutePath)
                    w.println('src=src/' + baseName + '-sources.jar')
                    w.println('doc=docs/' + baseName + '-javadoc.jar')
                }
            }
        }
    } }

    // Structure based on
    // http://stackoverflow.com/questions/9873152/how-to-attach-javadoc-or-sources-to-jars-in-libs-folder
    task dist(type: Zip, dependsOn: [
      androidReleaseJar,
      androidJavadocsJar,
      androidSourcesJar,
      distProperties]) {
        classifier 'eclipse-bundle'

        def root = project.name + '-' + project.version;

        into(root + '/libs') {
            from(androidReleaseJar.archivePath)
            from(androidReleaseJar.archivePath.absolutePath + '.properties')
        }

        // bundle in dependencies
        configurations.compile.resolve().each { dep ->
            // exclude jars from Android SDK
            if (dep.absolutePath.contains('/com/android/')) return

            into(root + '/libs') {
                from (dep.absolutePath)

                // include -sources and -docs for strong-remoting-android
                if (dep.name.startsWith('strong-remoting-android')) {
                    def baseName = FilenameUtils.getBaseName(dep.absolutePath)
                    from(dep.absolutePath + '.properties')
                }
            }
        }

        into(root + '/libs/docs') {
            from(androidJavadocsJar.archivePath)
        }

        into(root + '/libs/src') {
            from(androidSourcesJar.archivePath)
        }

        into(root) {
            from('docs/README.dist') {
                rename 'README.dist', 'README'
            }
        }
    }

    artifacts {
        archives androidReleaseJar
        archives androidSourcesJar
        archives androidJavadocsJar
        archives dist
    }

    // Maven publishing

    uploadArchives {
        repositories {
            mavenDeployer {
                if (shouldPublishToMavenCentral) {
                    beforeDeployment { MavenDeployment deployment ->
                        signing.signPom(deployment)
                    }

                    repository(url: sonatypeRepositoryUrl) {
                        authentication(
                            userName: sonatypeUserName,
                            password: sonatypePassword);
                    }

                }

                pom.project {
                    name 'loopback-sdk-android'
                    description 'Android client for LoopBack'
                    url 'https://github.com/strongloop/loopback-sdk-android'

                    licenses {
                        license {
                            name 'The MIT License'
                            url 'http://opensource.org/licenses/mit-license.php'
                            distribution 'repo'
                        }
                    }

                    scm {
                        connection 'scm:git@github.com:strongloop/loopback-sdk-android.git'
                        developerConnection 'scm:git@github.com:strongloop/loopback-sdk-android.git'
                        url 'https://github.com/strongloop/loopback-sdk-android'
                    }

                    developers {
                        developer {
                            id 'bajtos'
                            name 'Miroslav Bajtos'
                            email 'miroslav@strongloop.com'
                            organization = 'StrongLoop, Inc.'
                            organizationUrl 'http://strongloop.com/'
                        }
                    }
                }

                pom.withXml {
                    def root = asNode()
                    root.appendNode('packaging', 'jar');
                }
            }
        }
    }

    // Task for Jenkins build that will conditionally
    // call uploadArchives, but only if there is something
    // to upload
    task publishToMavenCentral {
      if (shouldPublishToMavenCentral)
          dependsOn uploadArchives
    }

    if (shouldPublishToMavenCentral) {
        signing {
            required {
                gradle.taskGraph.hasTask("uploadArchives")
            }
            sign configurations.archives
        }
    }

    // debugging
    task printCompilerInput << {
      logger.info "**JAVAC INPUT FILES**"
      compileReleaseJava.source.each {
        logger.info '  ' + it.absolutePath
      }
      logger.info "**JAVAC CLASSPATH**"
      compileReleaseJava.classpath.each {
        logger.info '  ' + it.absolutePath
      }
    }
    compileReleaseJava.dependsOn printCompilerInput
}