build.gradle

apply plugin: 'com.android.library'
apply plugin: 'kotlin-android'
apply plugin: "com.github.dcendents.android-maven"
apply plugin: "maven-publish"
apply plugin: "signing"

android {
    compileSdkVersion 29
    buildToolsVersion "29.0.3"

    defaultConfig {
        minSdkVersion 19
        targetSdkVersion 29
        versionCode 1
        versionName libraryVersion

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
        consumerProguardFiles "consumer-rules.pro"
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
    compileOptions {
        sourceCompatibility 1.8 /** Required for de-suraging */
        targetCompatibility 1.8 /** Required for de-suraging */
    }
    testOptions {
        unitTests.includeAndroidResources = true
    }
}

dependencies {
    implementation fileTree(dir: "libs", include: ["*.jar"])
    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
    implementation deps.ktx
    implementation deps.appcompat
    implementation deps.android_material
    api project(":design")
    api project(":base-viewmodel")
    api project(":base-viewmodel-impl")
    api(project(":base")) {
        exclude module: 'libsodium-jni'
    }
    implementation('com.github.joshjdevl.libsodiumjni:libsodium-jni-aar:2.0.1')

    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'androidx.test.ext:junit:1.1.1'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
}

task androidSourcesJar(type: Jar) {
    archiveClassifier.set('sources')
    from android.sourceSets.main.java.srcDirs
}

artifacts {
    archives androidSourcesJar
}

afterEvaluate {
    // ================================================================================
    // Built upon solutions presented here to build for multiple android flavors
    // https://stackoverflow.com/questions/34331713/publishing-android-library-aar-to-bintray-with-chosen-flavors
    // ================================================================================
    def publicationNames = []
    publishing {
        publications {
            android.libraryVariants.all { variant ->
                if (variant.buildType.name == "debug") return // Prevents publishing debug library

                def flavored = !variant.flavorName.isEmpty()

                /**
                 * Translates "_" in flavor names to "-" for artifactIds, because "-" in flavor name is an
                 * illegal character, but is well used in artifactId names.
                 */
                def variantArtifactId = flavored ? "${project.name}-${variant.flavorName.replace('_', '-')}".replace('-normal', '') : project.name

                /**
                 * If the javadoc destinationDir wasn't changed per flavor, the libraryVariants would
                 * overwrite the javaDoc as all variants would write in the same directory
                 * before the last javadoc jar would have been built, which would cause the last javadoc
                 * jar to include classes from other flavors that it doesn't include.
                 *
                 * Yes, tricky.
                 *
                 * Note that "${buildDir}/docs/javadoc" is the default javadoc destinationDir.
                 */
                def javaDocDestDir = file("${buildDir}/docs/javadoc ${flavored ? variantArtifactId : ""}")

                /**
                 * Includes
                 */
                def javadoc = task("${variant.name}Javadoc", type: Javadoc) {
                    description "Generates Javadoc for ${variant.name}."
                    source = variant.javaCompileProvider.get().source
                    //variant.javaCompile.source // Yes, javaCompile is deprecated,
                    // but I didn't find any working alternative. Please, tweet @Louis_CAD if you find one.
                    destinationDir = javaDocDestDir
                    classpath += files(android.getBootClasspath().join(File.pathSeparator))
                    classpath += files(configurations.compile)
                    options.links("http://docs.oracle.com/javase/7/docs/api/");
                    options.links("http://d.android.com/reference/");
                    exclude '**/BuildConfig.java'
                    exclude '**/R.java'
                    failOnError false
                }
                def javadocJar = task("${variant.name}JavadocJar", type: Jar, dependsOn: javadoc) {
                    description "Puts Javadoc for ${variant.name} in a jar."
                    classifier = 'javadoc'
                    from javadoc.destinationDir
                }

                def publicationName = "spend${variant.name.capitalize()}"
                publicationNames.add(publicationName)

                "$publicationName"(MavenPublication) {
                    artifactId variantArtifactId
                    group groupId
                    version libraryVersion

                    // This is the aar library
                    artifact variant.packageLibraryProvider.get().archivePath
                    artifact androidSourcesJar
                    artifact javadocJar

                    pom {
                        packaging 'aar'

                        name = 'spend'
                        description = "Kin Android SDK Spend"
                        url = 'https://github.com/kinecosystem/kin-android/tree/master/spend'
                        licenses {
                            license {
                                name = 'MIT License'
                                url = 'https://github.com/kinecosystem/kin-android/blob/master/LICENSE.md'
                            }
                        }

                        scm {
                            connection = 'scm:git:github.com/kinecosystem/kin-android.git'
                            developerConnection = 'scm:git:ssh://github.com/kinecosystem/kin-android.git'
                            url = 'https://github.com/kinecosystem/kin-android/tree/master/spend'
                        }

                        developers {
                            developer {
                                id = 'kin-ci'
                                name = 'Kin CI'
                                email = 'eng+ci@kin.org'
                            }
                        }

                        withXml {
                            def root = asNode()
//                            root.appendNode("name", 'spend')
//                            root.appendNode("url", siteUrl)
                            root.children().last() //+ pomConfig
                            def depsNode = root["dependencies"][0] ?: root.appendNode("dependencies")

                            def addDep = {
                                if (it.group == null) return // Avoid empty dependency nodes
                                def dependencyNode = depsNode.appendNode('dependency')
                                dependencyNode.appendNode('groupId', it.group)
                                if (it.hasProperty('targetConfiguration') && it.targetConfiguration != null) {
                                    dependencyNode.appendNode('artifactId', "${it.name}-${it.targetConfiguration}")
                                } else {
                                    dependencyNode.appendNode('artifactId', it.name)
                                }
                                dependencyNode.appendNode('version', it.version)
                                if (it.hasProperty('optional') && it.optional) {
                                    dependencyNode.appendNode('optional', 'true')
                                }
                                if (it.hasProperty("excludeRules")) {
                                    ArrayList<ExcludeRule> excludeRules = it.excludeRules
                                    if (excludeRules.size() > 0) {
                                        def exclusionsNode = dependencyNode.appendNode("exclusions")
                                        it.excludeRules.each { ExcludeRule rule ->
                                            def xmlExclusion = exclusionsNode.appendNode("exclusion")
                                            if (rule.group != null && !(rule.group as String).isEmpty()) {
                                                xmlExclusion.appendNode("groupId", rule.group)
                                            } else {
                                                xmlExclusion.appendNode("groupId", "*")
                                            }
                                            xmlExclusion.appendNode("artifactId", rule.module)
                                        }
                                    }
                                }
                                dependencyNode.appendNode("scope", "runtime")
                            }

                            // Add deps that everyone has
                            configurations.implementation.allDependencies.each addDep
                            // Add flavor specific deps
                            if (flavored) {
                                configurations["${variant.flavorName}Implementation"].allDependencies.each addDep
                            }
                            // NOTE: This library doesn't use builtTypes specific dependencies, so no need to add them.
                        }
                    }
                }
            }
        }
    }
}

ext["signing.keyId"] = rootProject.ext["signing.keyId"]
ext["signing.password"] = rootProject.ext["signing.password"]
ext["signing.secretKeyRingFile"] = rootProject.ext["signing.secretKeyRingFile"]

signing {
    sign publishing.publications
}