app/build.gradle

apply plugin: 'com.android.application'
apply plugin: 'checkstyle'

/* gets the version name from the latest Git tag, stripping the leading v off */
def getVersionName = { ->
    def stdout = new ByteArrayOutputStream()
    exec {
        commandLine 'git', 'describe', '--tags', '--always'
        standardOutput = stdout
    }
    return stdout.toString().trim().substring(1)
}

repositories {
    jcenter()
}

dependencies {
    testCompile 'junit:junit:4.12'

    androidTestCompile 'com.android.support:support-annotations:24.1.1'
    androidTestCompile 'com.android.support.test:runner:0.5'
    androidTestCompile 'com.android.support.test:rules:0.5'
}

android {
    compileSdkVersion 24
    buildToolsVersion '24.0.1'

    defaultConfig {
        archivesBaseName = "FDroidPrivilegedExtension"

        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }

    compileOptions {
        compileOptions.encoding = "UTF-8"

        // Use Java 1.7, requires minSdk 8
        sourceCompatibility JavaVersion.VERSION_1_7
        targetCompatibility JavaVersion.VERSION_1_7
    }

    buildTypes {
        all {
            // Keep IPackageInstallObserver and IPackageDeleteObserver
            minifyEnabled false
            useProguard false
            shrinkResources false
        }
    }

    lintOptions {
        checkReleaseBuilds false
        abortOnError true

        htmlReport true
        xmlReport false
        textReport false

        // this is never going to be a real "app"
        disable 'GoogleAppIndexingWarning'
    }

    File signFile = rootProject.file('signing.properties')
    if (signFile.exists()) {
        Properties properties = new Properties()
        properties.load(new FileInputStream(signFile))
        signingConfigs {
            release {
                storeFile rootProject.file(properties['key.store'])
                storePassword properties['key.store.password']
                keyAlias properties['key.alias']
                keyPassword properties['key.alias.password']
            }
        }
        buildTypes.release.signingConfig signingConfigs.release
    }

    applicationVariants.all { variant ->
        def name = variant.buildType.name
        def zipBase = file("${buildDir}/intermediates/updateZip${name.capitalize()}")
        def zipWithFDroidBase = file("${buildDir}/intermediates/updateZipWithFDroid${name.capitalize()}")

        def apkToCopy
        variant.outputs.each { output ->
            if (output.zipAlign) {
                apkToCopy = output.outputFile
            }
        }
        if (apkToCopy == null) {
            return;
        }

        def copyApkTask = project.tasks.create("copyApk${name.capitalize()}", Copy) {
            dependsOn variant.assemble
            from apkToCopy
            into zipBase
            rename { String fileName ->
                fileName = "${archivesBaseName}.apk"
            }
        }

        def copyScriptTask = project.tasks.create("copyScript${name.capitalize()}", Copy) {
            from "src/main/scripts/update-binary"
            into "${zipBase}/META-INF/com/google/android/"
        }

        def zipTask = project.tasks.create("updateZip${name.capitalize()}", Zip) {
            dependsOn copyApkTask, copyScriptTask
            from zipBase
            archiveName "${archivesBaseName}-${getVersionName()}-${name}.zip"
        }

        def getFDroidApkTask = project.tasks.create("getFDroidApk${name.capitalize()}") {
            doLast {
                def downloadDir = "${buildDir}/intermediates"
                def f = new File("${downloadDir}/FDroid.apk")
                if (!f.exists()) {
                    def url = 'https://f-droid.org/FDroid.apk'
                    println "Downloading ${url}"
                    new URL(url).withInputStream { i -> f.withOutputStream { it << i } }
                }
                def asc = new File("${downloadDir}/FDroid.apk.asc")
                if (!asc.exists()) {
                    def url = 'https://f-droid.org/FDroid.apk.asc'
                    println "Downloading ${url}"
                    new URL(url).withInputStream { i -> asc.withOutputStream { it << i } }
                }
                println "Verifying using ${asc}"
                exec {
                    def keyring = new File(project.rootDir, '/f-droid.org-signing-key.gpg')
                    executable = 'gpg'
                    args '--keyring', keyring, '--no-default-keyring', '--verify', asc
                }
            }
        }

        def copyUpdateZipDirTask = project.tasks.create("copyUpdateZipDir${name.capitalize()}", Copy) {
            dependsOn copyApkTask, copyScriptTask
            from zipBase
            into zipWithFDroidBase
        }

        def copyFDroidApkTask = project.tasks.create("copyFDroidApk${name.capitalize()}", Copy) {
            dependsOn getFDroidApkTask, copyUpdateZipDirTask
            from "${buildDir}/intermediates/FDroid.apk"
            into zipWithFDroidBase
        }

        def zipWithFDroidTask = project.tasks.create("updateZipWithFDroid${name.capitalize()}", Zip) {
            dependsOn copyFDroidApkTask
            from zipWithFDroidBase
            archiveName "${archivesBaseName}WithFDroid-${getVersionName()}-${name}.zip"
        }

        project.tasks.build.dependsOn zipTask
    }
}

checkstyle {
    toolVersion = '7.1'
}

task checkstyle(type: Checkstyle) {
    configFile file("${project.rootDir}/config/checkstyle/checkstyle.xml")
    source 'src/main/java'
    include '**/*.java'

    classpath = files()
}