build.gradle

import de.undercouch.gradle.tasks.download.Download
import org.apache.tools.ant.taskdefs.condition.Os

// Top-level build file where you can add configuration options common to all sub-projects/modules.

buildscript {
    repositories {
        google()
        jcenter()
    }
    dependencies {
        classpath "com.android.tools.build:gradle:${ANDROID_GRADLE_PLUGIN_VERSION}"
        classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:${GRADLE_BINTRAY_PLUGIN_VERSION}"
        classpath "com.github.dcendents:android-maven-gradle-plugin:${ANDROID_MAVEN_GRADLE_PLUGIN_VERSION}"

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

plugins {
    id "de.undercouch.download" version "3.1.2"
}

project.ext {
    buildToolsVersion = "${BUILD_TOOLS_VERSION}"
    compileSdkVersion = COMPILE_SDK_VERSION.toInteger()
    minSdkVersion = MIN_SDK_VERSION
    samplesMinSdkVersion = SAMPLES_MIN_SDK_VERSION
    targetSdkVersion = TARGET_SDK_VERSION
    preDexLibs = !project.hasProperty('disablePreDex')
}

subprojects {

    repositories {
        google()
        jcenter()
    }

    task allclean {
    }

    afterEvaluate { project ->
      allclean.dependsOn(project.tasks.matching {it.name == 'clean'})

        if (project.tasks.matching { it.name == 'assembleRelease'}) {
            def jarList = new ArrayList()
            task setJarList(dependsOn: assembleRelease) << {
                configurations.compile.each {
                    jarList.add(it)
                }
            }

            task copyDeps(dependsOn: setJarList, type: Copy) {
                from jarList
                into 'build/external'
            }
        }
    }

    project.plugins.whenPluginAdded { plugin ->
        if ("com.android.build.gradle.AppPlugin".equals(plugin.class.name)) {
            project.android.dexOptions.preDexLibraries = rootProject.ext.preDexLibs
        } else if ("com.android.build.gradle.LibraryPlugin".equals(plugin.class.name)) {
            project.android.dexOptions.preDexLibraries = rootProject.ext.preDexLibs
        }
    }

    apply plugin: 'de.undercouch.download'

    ext.makeNdkTasks = { name, deps ->
        task "ndk_build_${name}"(dependsOn: deps, type: Exec) {
            inputs.file("src/main/jni/${name}")
            outputs.dir("$buildDir/${name}")
            commandLine getNdkBuildFullPath(project),
                    'NDK_PROJECT_PATH=null',
                    'NDK_APPLICATION_MK=../Application.mk',
                    'NDK_OUT=' + temporaryDir,
                    "NDK_LIBS_OUT=$buildDir/${name}",
                    '-C', file("src/main/jni/${name}").absolutePath,
                    '--jobs', Runtime.getRuntime().availableProcessors()
        }

        task "ndk_clean_$name"(type: Exec) {
            ignoreExitValue true
            commandLine getNdkBuildFullPath(project),
                    'NDK_PROJECT_PATH=null',
                    'NDK_APPLICATION_MK=../Application.mk',
                    'NDK_OUT=' + temporaryDir,
                    "NDK_LIBS_OUT=$buildDir/${name}",
                    '-C', file("src/main/jni/${name}").absolutePath,
                    'clean'
        }

        tasks.withType(JavaCompile) {
            compileTask -> compileTask.dependsOn "ndk_build_$name"
        }
        clean.dependsOn "ndk_clean_$name"
    }

    ext.getNdkBuildName =  {
        if (Os.isFamily(Os.FAMILY_WINDOWS)) {
            return "ndk-build.cmd"
        } else {
            return "ndk-build"
        }
    }

    ext.getNdkBuildFullPath = { Project project ->
        File propFile = project.rootProject.file('local.properties')
        if (!propFile.exists()) {
            return getNdkBuildName()
        }
        Properties properties = new Properties()
        properties.load(propFile.newDataInputStream())
        def ndkCommand = properties.getProperty('ndk.command')
        if (ndkCommand != null) {
            return ndkCommand
        }
        def path = null
        def ndkPath = properties.getProperty('ndk.path')
        if (ndkPath != null) {
            path = ndkPath
        } else {
            def ndkDir = properties.getProperty('ndk.dir')
            if (ndkDir != null) {
                path = ndkDir
            }
        }
        if (path != null) {
            if (!path.endsWith(File.separator)) {
                path += File.separator
            }
            return path + getNdkBuildName()
        } else {
            // if none of above is provided, we assume ndk-build is already in $PATH
            return getNdkBuildName()
        }
    }

    ext.nativeDepsDir = new File("${projectDir}/nativedeps")
    ext.downloadsDir = new File("${nativeDepsDir}/downloads")
    ext.mergeDir = new File("${nativeDepsDir}/merge")

    task removeNativeDeps(type: Delete) {
        delete nativeDepsDir
    }
    allclean.dependsOn removeNativeDeps

    task createNativeDepsDirectories {
        nativeDepsDir.mkdirs()
        downloadsDir.mkdirs()
        mergeDir.mkdirs()
    }

    ext.createNativeLibrariesTasks = {name, libraryUrl, libraryFileName, libraryDestinationDir, sourceDir, includePaths, destinationDir ->
        // We create the DownloadTask
        tasks.create("download${name}", Download) {
            src libraryUrl
            onlyIfNewer true
            overwrite false
            dest downloadsDir
            dependsOn createNativeDepsDirectories
        }
        // The unpack task
        tasks.create("unpack${name}", Copy) {
            String filePath = "${downloadLibjpeg.dest}/${libraryFileName}"
            ReadableResource resource
            if (filePath.endsWith("gz")) {
                resource = resources.gzip(filePath)
            } else if (filePath.endsWith("bz2")) {
                resource = resources.bzip2(filePath)
            } else {
                throw new GradleException("Could not unpack library " + filePath)
            }
            from tarTree(resource)
            into "${downloadsDir}/${libraryDestinationDir}"
            dependsOn "download${name}"
        }
        // The copy task
        Task unpackTask = tasks.getByName("unpack${name}")
        tasks.create("copy${name}", Copy) {
            from "${unpackTask.destinationDir}/${sourceDir}"
            from "src/main/jni/third-party/${destinationDir}"
            include(includePaths)
            into "${mergeDir}/${destinationDir}"
            dependsOn "unpack${name}"
        }

    }

    // Libjpeg-turbo
    createNativeLibrariesTasks(
            'Libjpeg',      // Name for the tasks
            "https://github.com/libjpeg-turbo/libjpeg-turbo/archive/${LIBJPEG_TURBO_VERSION}.tar.gz", // The Url for download
            "${LIBJPEG_TURBO_VERSION}.tar.gz", // The downloaded file
            'libjpeg', // The folder where the file is downloaded
            "libjpeg-turbo-${LIBJPEG_TURBO_VERSION}", // The first dir where we have put our customisation
            ['**/*.c', '**/*.h','**/*.S', '**/*.asm', '**/*.inc', '*.mk'], // Files to compile
            "libjpeg-turbo-${LIBJPEG_TURBO_VERSION}" // Final destination dir
    )

    // Libpng
    createNativeLibrariesTasks(
            'Libpng',      // Name for the tasks
            "https://github.com/glennrp/libpng/archive/v${LIBPNG_VERSION}.tar.gz", // The Url for download
            "v${LIBPNG_VERSION}.tar.gz", // The downloaded file
            'libpng', // The folder where the file is downloaded
            "libpng-${LIBPNG_VERSION}", // The first dir where we have put our customisation
            ['**/*.c', '**/*.h', '**/*.S', '*.mk'], // Files to compile
            "libpng-${LIBPNG_VERSION}" // Final destination dir
    )

    // Gif
    createNativeLibrariesTasks(
            'Giflib',      // Name for the tasks
            "https://launchpad.net/ubuntu/+archive/primary/+files/giflib_${GIFLIB_VERSION}.orig.tar.bz2", // The Url for download
            "giflib_${GIFLIB_VERSION}.orig.tar.bz2", // The downloaded file
            'giflib', // The folder where the file is downloaded
            "giflib-${GIFLIB_VERSION}/lib", // The first dir where we have put our customisation
            ['*.c', '*.h', '*.mk'], // Files to compile
            "giflib" // Final destination dir
    )

    // Webp
    createNativeLibrariesTasks(
            'Libwebp',      // Name for the tasks
            "https://github.com/webmproject/libwebp/archive/v${LIBWEBP_VERSION}.tar.gz", // The Url for download
            "v${LIBWEBP_VERSION}.tar.gz", // The downloaded file
            'libwebp', // The folder where the file is downloaded
            "libwebp-${LIBWEBP_VERSION}", // The first dir where we have put our customisation
            ['src/**/*.c', 'src/**/*.h', '*.mk'], // Files to compile
            "libwebp-${LIBWEBP_VERSION}" // Final destination dir
    )
}