build.gradle

buildscript { scriptHandler ->
    apply from: "${projectDir}/gradle/versions.gradle"
    apply from: "${projectDir}/gradle/repositories.gradle", to: scriptHandler
}

plugins {
    id "com.android.application"
    id "org.jetbrains.kotlin.android"
    id "org.jetbrains.kotlin.kapt"

    id "com.mikepenz.aboutlibraries.plugin"

    id "com.github.ben-manes.versions"
    id "io.gitlab.arturbosch.detekt"
    id "org.jlleitschuh.gradle.ktlint"
}

apply from: "${projectDir}/gradle/utils.gradle"

android {
    compileSdkVersion rootProject.ext.compileSdkVersion
    ndkVersion rootProject.ext.ndkVersion

    dexOptions {
        preDexLibraries !isCI()
    }

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

        vectorDrawables.useSupportLibrary true
        resConfigs "de"

        javaCompileOptions {
            annotationProcessorOptions {
                if (project.property("kapt.incremental.apt").toBoolean() == true) {
                    arguments << ["room.incremental": "true"]
                }

                arguments << ["room.schemaLocation": "$projectDir/schemas".toString()]
            }
        }
    }

    sourceSets {
        main {
            java.srcDirs += "src/main/kotlin"
        }

        debug {
            java.srcDirs += "src/debug/kotlin"
        }

        release {
            java.srcDirs += "src/release/kotlin"
        }

        logRelease {
            java.srcDirs = release.java.srcDirs
            res.srcDirs = release.res.srcDirs
        }
    }

    compileOptions {
        sourceCompatibility javaVersion
        targetCompatibility javaVersion
    }

    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 {
        if (!shouldSign() && !isCI()) {
            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

            ndk { abiFilters "arm64-v8a", "armeabi-v7a", "x86_64", "x86" }

            versionNameSuffix = "-debug"
            buildConfigField "String", "PROXER_API_KEY", "\"${getFromSecrets("PROXER_API_KEY")}\""
            buildConfigField "boolean", "LOG", "Boolean.parseBoolean(\"true\")"
        }

        release {
            postprocessing {
                obfuscate true
                optimizeCode true
                removeUnusedCode true
                removeUnusedResources true
                proguardFile "config/shrinker/shrinker-rules.pro"
            }

            multiDexEnabled true

            ndk { abiFilters "arm64-v8a", "armeabi-v7a", "x86_64", "x86" }

            buildConfigField "String", "PROXER_API_KEY", "\"${getFromSecrets("PROXER_API_KEY")}\""
            buildConfigField "boolean", "LOG", "Boolean.parseBoolean(\"false\")"

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

        logRelease {
            postprocessing {
                obfuscate true
                optimizeCode true
                removeUnusedCode true
                removeUnusedResources true
                proguardFile "config/shrinker/shrinker-rules.pro"
            }

            multiDexEnabled true

            ndk { abiFilters "arm64-v8a", "armeabi-v7a", "x86_64", "x86" }

            versionNameSuffix = "-logRelease-${getGitHash()}"
            buildConfigField "String", "PROXER_API_KEY", "\"${getFromSecrets("PROXER_API_KEY")}\""
            buildConfigField "boolean", "LOG", "Boolean.parseBoolean(\"true\")"

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

    lintOptions {
        mkdir("$buildDir/reports/lint")

        warningsAsErrors = true
        checkReleaseBuilds = false

        lintConfig file("$rootDir/config/lint/lint.xml")
        xmlOutput file("$buildDir/reports/lint/lint-results.xml")
        htmlOutput file("$buildDir/reports/lint/lint-results.html")
    }

    packagingOptions {
        jniLibs {
            useLegacyPackaging false
        }

        exclude "META-INF/*.kotlin_module"
        exclude "META-INF/*.version"
        exclude "META-INF/rxkotlin.properties"
        exclude "META-INF/proguard/**"
        exclude "META-INF/README.md"
        exclude "META-INF/nanohttpd/**"
        exclude "kotlin/**"
        exclude "kotlinx/**"
        exclude "third_party/**"
        exclude "jsr305_annotations/**"
        exclude "error_prone/**"
        exclude "auto/**"
        exclude "build-data.properties"
        exclude "androidsupportmultidexversion.txt"
        exclude "play-services-*.properties"
    }

    bundle {
        language {
            enableSplit = false
        }
    }

    applicationVariants.all { variant ->
        def suffix = variant.buildType.name == "release" ? "-release" : ""

        variant.outputs.all {
            outputFileName = "app-${variant.versionName}${suffix}.apk"
        }
    }
}

apply from: "${projectDir}/gradle/repositories.gradle"
apply from: "${projectDir}/gradle/dependencies.gradle"

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
    kotlinOptions {
        allWarningsAsErrors = true
        jvmTarget = javaVersion.toString()
        freeCompilerArgs = ["-Xjsr305=strict", "-progressive", "-Xnew-inference"]
    }
}

kapt {
    useBuildCache = true
}

detekt {
    version = detektPluginVersion
    buildUponDefaultConfig = true

    config = files("$projectDir/config/detekt/detekt.yml")

    reports {
        xml.destination = file("$buildDir/reports/detekt/detekt.xml")
        html.destination = file("$buildDir/reports/detekt/detekt.html")
    }
}

ktlint {
    version = ktlintVersion
    disabledRules = ["import-ordering"]
    reporters {
        reporter org.jlleitschuh.gradle.ktlint.reporter.ReporterType.CHECKSTYLE
    }
}

tasks.named("dependencyUpdates").configure {
    rejectVersionIf {
        it.candidate.version.contains("alpha")
    }
}

wrapper {
    gradleVersion rootProject.ext.gradleVersion
}