build.gradle

import groovy.io.FileType

buildscript {
    apply from: 'gradle/versions.gradle'
    apply from: 'gradle/dependencies.gradle'

    repositories {
        jcenter()
        google()
        maven { url 'https://plugins.gradle.org/m2/' }
        maven { url 'https://dl.bintray.com/kotlin/kotlin-eap' }
    }

    dependencies {
        classpathDependencies.values().each { classpath it }
    }
}

apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-kapt'

apply plugin: 'com.github.ben-manes.versions'
apply plugin: 'io.gitlab.arturbosch.detekt'
apply plugin: 'com.novoda.android-command'

android {
    compileSdkVersion project.ext.compileSdkVersion

    dexOptions {
        preDexLibraries !isCI()
    }

    compileOptions {
        sourceCompatibility project.ext.javaVersion
        targetCompatibility project.ext.javaVersion
    }

    defaultConfig {
        applicationId 'me.proxer.app'
        minSdkVersion project.ext.minSdkVersion
        targetSdkVersion project.ext.targetSdkVersion
        versionCode project.ext.appVersionMajor * 1000000 + project.ext.appVersionMinor * 10000 + project.ext.appVersionPatch * 100
        versionName "${project.ext.appVersionMajor}.${project.ext.appVersionMinor}.${project.ext.appVersionPatch}"

        vectorDrawables.useSupportLibrary true
        resConfigs 'de'
    }

    signingConfigs {
        if (shouldSign()) {
            release {
                storeFile file(getFromSecrets('RELEASE_STORE_FILE'))
                storePassword getFromSecrets('RELEASE_STORE_PASSWORD')
                keyAlias getFromSecrets('RELEASE_KEY_ALIAS')
                keyPassword getFromSecrets('RELEASE_KEY_PASSWORD')
            }
        }
    }

    buildTypes {
        boolean shouldSign = shouldSign() && !isCI()

        if (!shouldSign) {
            logger.warn('This build will not be signed because it is missing the keystore info. Please add ' +
                    'values for "RELEASE_STORE_FILE", "RELEASE_STORE_PASSWORD", "RELEASE_KEY_ALIAS" and ' +
                    '"RELEASE_KEY_PASSWORD" to your secrets.properties file if you want the apk to be signed.')
        }

        debug {
            multiDexEnabled true
            multiDexKeepProguard file('config/multidex/multidex-config.pro')

            archivesBaseName = "app-${defaultConfig.versionName}"
            buildConfigField 'String', 'PROXER_API_KEY', "\"${getFromSecrets('PROXER_API_KEY')}\""
            buildConfigField 'boolean', 'STORE', "false"
        }

        release {
            postprocessing {
                removeUnusedCode true
                removeUnusedResources true
                obfuscate true
                optimizeCode true
                getProguardFiles().add(0, file('config/proguard/proguard-rules.pro'))
            }

            archivesBaseName = "app-${defaultConfig.versionName}"
            buildConfigField 'String', 'PROXER_API_KEY', "\"${getFromSecrets('PROXER_API_KEY')}\""
            buildConfigField 'boolean', 'STORE', "false"

            if (shouldSign) {
                signingConfig signingConfigs.release
            }
        }

        storeRelease {
            postprocessing {
                removeUnusedCode true
                removeUnusedResources true
                obfuscate true
                optimizeCode true
                getProguardFiles().add(0, file('config/proguard/proguard-rules.pro'))
            }

            archivesBaseName = "app-${defaultConfig.versionName}"
            buildConfigField 'String', 'PROXER_API_KEY', "\"${getFromSecrets('PROXER_API_KEY')}\""
            buildConfigField 'boolean', 'STORE', "true"

            if (shouldSign) {
                signingConfig signingConfigs.release
            }
        }
    }

    lintOptions {
        warningsAsErrors = true

        lintConfig new File(rootDir, 'config/lint/lint.xml')
    }

    packagingOptions {
        exclude '**/*.kotlin_builtins'
        exclude '**/*.kotlin_module'
        exclude '**/rxkotlin.properties'
        exclude '**/*.pro'
    }

    sourceSets {
        main {
            main.java.srcDirs += 'src/main/kotlin'
            debug.java.srcDirs += 'src/debug/kotlin'
            res.srcDirs += getResSrcDirs()
        }
    }
}

configurations {
    ktlint
}

repositories {
    jcenter()
    google()
    maven { url 'https://jitpack.io' }
    maven { url 'https://dl.bintray.com/kotlin/kotlin-eap' }
    maven { url 'https://oss.sonatype.org/content/repositories/snapshots' }
}

dependencies {
    implementationDependencies.values().each { implementation it }
    debugImplementationDependencies.values().each { debugImplementation it }
    releaseImplementationDependencies.values().each { releaseImplementation it }
    releaseImplementationDependencies.values().each { storeReleaseImplementation it }
    compileOnlyDependencies.values().each { compileOnly it }
    kaptDependencies.values().each { kapt it }
    ktlintDependencies.values().each { ktlint it }

    transitiveImplementationDependencies.values().each {
        implementation(it) {
            transitive = true
        }
    }

    excludingImplementationDependencies.values().each { dependency ->
        implementation(dependency.dependency) {
            dependency.exclusions.each {
                exclude module: it
            }
        }
    }
}

task ktlintCheck(type: Exec) {
    group 'Verification'
    description 'Analyze your kotlin code with ktlint.'

    commandLine 'java', '-cp', configurations.ktlint.join(System.getProperty('path.separator')),
            'com.github.shyiko.ktlint.Main', '--reporter=checkstyle', 'src/**/*.kt'

    ignoreExitValue = true

    doFirst {
        File outputFile = new File(buildDir, 'reports/ktlint/ktlint-checkstyle.xml')

        outputFile.parentFile.mkdirs()
        outputFile.createNewFile()

        standardOutput = new FileOutputStream(outputFile)
    }

    doLast {
        standardOutput.close()

        if (execResult.exitValue != 0) {
            throw new GradleException("ktlint finished with non-zero exit value ${execResult.exitValue}")
        }
    }
}

task ktlintFormat(type: Exec) {
    group 'Formatting'
    description = "Fix Kotlin code style deviations."

    commandLine 'java', '-cp', configurations.ktlint.join(System.getProperty('path.separator')),
            'com.github.shyiko.ktlint.Main', '-F', 'src/**/*.kt'
}

task wrapper(type: Wrapper) {
    gradleVersion project.ext.gradleVersion
}

kapt {
    useBuildCache = true
}

detekt {
    version = detektPluginVersion

    profile('main') {
        config = "$projectDir/config/detekt/detekt.yml"
        output = "$buildDir/reports/detekt"
        parallel = true
    }
}

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
    kotlinOptions {
        freeCompilerArgs = ["-Xjsr305=strict"]
    }
}

gradle.projectsEvaluated {
    check.dependsOn detektCheck
    check.dependsOn ktlintCheck
}

static getResSrcDirs() {
    String layoutsPath = 'src/main/res/layouts'
    Set<String> result = []

    new File(layoutsPath).eachFile(FileType.DIRECTORIES) {
        result.add("${layoutsPath}/${it.name}")
    }

    return result
}

static String getFromSecrets(String key) {
    if (isCI()) {
        return 'dummy'
    }

    Properties result = new Properties()

    try {
        result.load(new FileInputStream(new File('secrets.properties')))
    } catch (Exception ignored) {
        throw new GradleException("Please add a secrets.properties file with a value for $key to perform this action.")
    }

    if (!result.containsKey(key)) {
        throw new GradleException("Please include a value for $key in your secrets.properties file to perform this action.")
    }

    return result[key]
}

static boolean shouldSign() {
    Properties result = new Properties()

    try {
        result.load(new FileInputStream(new File('secrets.properties')))
    } catch (Exception ignored) {
        return false
    }

    return result.containsKey('RELEASE_STORE_FILE') && result.containsKey('RELEASE_STORE_PASSWORD') &&
            result.containsKey('RELEASE_KEY_ALIAS') && result.containsKey('RELEASE_KEY_PASSWORD')
}

static boolean isCI() {
    Object isCI = System.getenv('CI')

    return isCI != null && isCI.toBoolean()
}