build.gradle

/*
 * Copyright (c) 2014 Mohit Kanwal.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this
 * software and associated documentation files (the "Software"), to deal in the Software
 * without restriction, including without limitation the rights to use, copy, modify,
 * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 */

import org.gradle.internal.os.OperatingSystem

apply plugin: 'com.android.application'
def BUILD_TOOLS_VERSION = "19.1.0"
android {
    compileSdkVersion 19
    buildToolsVersion BUILD_TOOLS_VERSION

    defaultConfig {
        minSdkVersion 10
        targetSdkVersion 19
        versionCode 1
        versionName "1.0"
    }

    // Need to disable pre dexing to be able to build properly
    // Otherwise we need to add more tasks to the libraries
    // This is a small penalty to keep the house in order!
    dexOptions {
        incremental false
        preDexLibraries = false
        jumboMode = false
    }
    enforceUniquePackageName false

    buildTypes {
        release {
            runProguard true
            minifyEnabled true
            debuggable false
            zipAlign true
            proguardFiles 'proguard-rules.txt'
            signingConfig debug.signingConfig
        }
    }
}
/**
 * Relies on the Bash Script to manipulate the Dexing of the correct classes.
 */
afterEvaluate { project ->
    android.applicationVariants.each {
        variant ->
            String SDK_DIR = System.getenv("ANDROID_HOME")
            if (SDK_DIR == null) {
                Properties props = new Properties()
                props.load(new FileInputStream(project.rootProject.file("local.properties")))
                SDK_DIR = props.get('sdk.dir');
            }
            String FLAVOR = "${variant.flavorName}"
            String BUILD_TYPE = "${variant.buildType.name}"
            String ASSET_DIR = "${variant.mergeAssets.outputDir}"
            String DEX = "${SDK_DIR}/build-tools/${BUILD_TOOLS_VERSION}/dx"
            String BUILD_TOOL_DX = OperatingSystem.current().windows ? "${DEX}.bat" : "${DEX}"
            String EX_DIR = "classes"

            String LIB_NAME = ""
            if ("$FLAVOR" != "")
                LIB_NAME = "app-${FLAVOR}-${BUILD_TYPE}"
            else
                LIB_NAME = "app-${BUILD_TYPE}"

            String taskDexSplit = "dex${variant.name.capitalize()}Split"
            String taskDexSplit2 = taskDexSplit + "2"

            if (variant.buildType.minifyEnabled) {

                task("$taskDexSplit") << {

                    String WORKDIR
                    if ("$FLAVOR" != "")
                        WORKDIR = "build/intermediates/classes-proguard/${FLAVOR}/${BUILD_TYPE}"
                    else
                        WORKDIR = "build/intermediates/classes-proguard/${BUILD_TYPE}"

                    task("unzipAndDeleteClassesJar", type: Copy) {
                        def zipFile = file("${WORKDIR}/classes.jar")
                        def outputDir = file("${WORKDIR}/${EX_DIR}")
                        from zipTree(zipFile)
                        into outputDir
                        doFirst {
                            outputDir.deleteDir()
                        }
                        doLast {
                            zipFile.delete()
                        }
                    }.execute()

                    task("extractLibraryClasses", type: Copy) {
                        String PACKAGE = "com/github/creativepsyco/secondarydex/bigmodule/lib"
                        def source = file("${WORKDIR}/${EX_DIR}/${PACKAGE}/")
                        from source
                        into file("${WORKDIR}/OUTPACKAGE/${PACKAGE}/")
                        doLast {
                            source.deleteDir()
                        }
                    }.execute()

                    task("extractGuavaLibrary", type: Copy) {
                        String PACKAGE = "com/google"
                        def source = file("${WORKDIR}/${EX_DIR}/${PACKAGE}/")
                        from source
                        into file("${WORKDIR}/OUTPACKAGE/${PACKAGE}/")
                        doLast {
                            source.deleteDir()
                        }
                    }.execute()

                    task("rebuildClassesJar", type: Exec) {
                        commandLine "jar", "cvf", "${WORKDIR}/classes.jar", "-C", "${WORKDIR}/${EX_DIR}/", "."
                    }.execute()

                    task("dexLibraries", type: Exec) {
                        commandLine "${BUILD_TOOL_DX}", "--dex", "--output=${ASSET_DIR}", "${WORKDIR}/OUTPACKAGE"
                    }.execute()
                }

                if (variant.variantData.obfuscationTask != null) {
                    println "[Dexing] Adding Task to run after proguard"
                    tasks.findByName(taskDexSplit).dependsOn variant.variantData.obfuscationTask
                } else {
                    println "[Dexing] Obfuscation task is null ${variant.variantData}"
                }

            } else {

                // For Debug simply remove the library from getting dex and create it
                //----------------------- Extra Debug Step ----------------//
                def libraryFiles = new ArrayList<?>()
                def secondaryFile = new ArrayList<?>()

                variant.dex.libraries.each {
                    File file ->
                        if (!file.absolutePath.contains("lib${File.separator}unspecified${File.separator}classes.jar")
                                && !file.absolutePath.contains("guava")) {
                            libraryFiles.add(file)
                        } else {
                            secondaryFile.add(file)
                        }
                }
                variant.dex.libraries = libraryFiles
                //----------------------- Extra Debug Step ----------------//

                task("$taskDexSplit") << {
                    def arguments = new ArrayList<?>()
                    arguments.add("--dex")
                    arguments.add("--output=${ASSET_DIR}")
                    arguments.addAll(secondaryFile)

                    task("dexLibraries", type: Exec) {
                        executable "${BUILD_TOOL_DX}"
                        args arguments
//                        commandLine "${BUILD_TOOL_DX}", "--dex", "--output=${ASSET_DIR}"
//                        commandLine.addAll(secondaryFile)
                    }.execute()
                }

                tasks.findByName(taskDexSplit).dependsOn variant.javaCompile
            }

            task("$taskDexSplit2") << {

                task("zipDexedLibraries", type: Zip) {
                    destinationDir new File("${ASSET_DIR}")
                    archiveName 'game.zip'
                    from "${ASSET_DIR}"
                    include '*.dex'
                    doLast {
                        file("${ASSET_DIR}/classes.dex").delete()
                    }
                }.execute()


                task("copyDexedLibrariesToApp", type: Copy) {
                    from "${ASSET_DIR}/game.zip"
                    into "build/intermediates/libs/${LIB_NAME}/assets/"
                }.execute()
            }
/*
            tasks.findByName(taskDexSplit).onlyIf(new Spec<Task>() {
                boolean isSatisfiedBy(Task task) {
                    return task.dependsOnTaskDidWork();
                }
            })

            tasks.findByName(taskDexSplit2).onlyIf(new Spec<Task>() {
                boolean isSatisfiedBy(Task task) {
                    return task.dependsOnTaskDidWork();
                }
            })
*/

            // Finally Depend on Dex Task
            String dexTaskName = "dex${variant.variantData.name.capitalize()}"
            Task dexTask = tasks.findByName(dexTaskName)
            dexTask.dependsOn taskDexSplit2
            tasks.findByName(taskDexSplit2).dependsOn taskDexSplit
    }
}
dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:19.+'
    compile project(':lib')
    compile 'com.google.guava:guava:18.0'
}