build.gradle

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

def downloadUrl = 'https://www.apkmirror.com/wp-content/themes/APKMirror/download.php?id=289495'
// NOTE WHEN UPGRADING:
// - update Play Services version in maven dependencies below

def apkFile = new File(buildDir, 'in.apk')
def apkDir = new File(buildDir, 'apk')
def outDir = new File(buildDir, 'out')
def smaliDir = new File(outDir, 'smali')

// Detect Android SDK location using Android Studio-generated
// local.properties in the root project.
def rootSdkDir
def rootLocalProperties = new File(rootProject.projectDir, 'local.properties')
if (rootLocalProperties.exists()) {
    Properties properties = new Properties()
    rootLocalProperties.withInputStream { instr ->
        properties.load(instr)
    }
    rootSdkDir = properties.getProperty('sdk.dir')
}

def sdkDir = new File(rootSdkDir ?: System.getProperty('sdk.dir') ?: System.getenv("ANDROID_SDK")
        ?: System.getenv("SDK_ROOT") ?: System.getenv("ANDROID_HOME"))

import de.undercouch.gradle.tasks.download.Download
import java.util.regex.Pattern

apply plugin: "maven-publish"

task downloadApk(type: Download) {
    src downloadUrl
    dest apkFile
    onlyIfNewer true
}

// This is a Gradle incremental task which means that it won't
// be re-executed if the inputFile did not change.
class JavaExecExtract extends JavaExec {
    @Input
    File inputFile

    @OutputDirectory
    File outputDir
}

task extractApk(dependsOn: downloadApk, type: JavaExecExtract) {
    classpath = files('libs/apktool_2.3.0.jar')
    main = 'brut.apktool.Main'
    args 'decode', '-o', apkDir, '-f', apkFile
    inputFile = apkFile
    outputDir = apkDir
}

task collectResources(dependsOn: extractApk) {
    doLast {
        def KEEP_EXTRA_RES = [
                '@style/Base.CardView',
            ]

        // Extract symbols
        def symbols = [:]
        fileTree(dir: apkDir)
                .include('smali*/com/google/android/apps/auto/sdk/ui/R$*.smali')
                .each { File file ->
            def filesyms = [:];
            file.eachLine { String line ->
                if (!line.startsWith('.field public static final '))
                    return
                def tokens = line.split()
                def namesig = tokens[4].split(':')
                if (namesig[1] != 'I')
                    return
                filesyms[namesig[0]] = Integer.decode(tokens[6])
            }
            def basename = file.name.take(file.name.lastIndexOf('.')).split('\\$')[1]
            symbols[basename] = filesyms
        }
        println symbols

        // Process value resources
        fileTree(dir: apkDir)
                .include('res/values*/*')
                .exclude('res/values/public.xml')
                .each { File file ->
            def relpath = file.absolutePath - apkDir.absolutePath
            println relpath
            def xml = new XmlParser().parse(file)
            assert xml.name() == 'resources'
            println xml.children().size()
            def toremove = []
            xml.each { child ->
                def category = child.name()
                def name = child.@name
                if (category == 'item' || category == 'public')
                    category = child.@type
                if (!(symbols.get(category) ?: [:]).containsKey(name)
                        && !KEEP_EXTRA_RES.contains('@' + category + '/' + name)) {
                    toremove.add(child)
                }
            }
            toremove.each { child ->
                xml.remove(child)
            }
            println xml.children().size()
            if (xml.children().size() > 0) {
                def outfile = new File(outDir, relpath)
                outfile.getParentFile().mkdirs()
                new XmlNodePrinter(new PrintWriter(new FileWriter(outfile))).print(xml)
            }
        }

        // Process remaining resources
        fileTree(dir: apkDir)
                .include('res/*/*')
                .exclude('res/values*/*')
                .each { File file ->
            def category = file.getParentFile().getName().split('-')[0]
            def name = file.name.take(file.name.lastIndexOf('.'))
            if (!(symbols.get(category) ?: [:]).containsKey(name))
                return
            def relpath = file.absolutePath - apkDir.absolutePath
            println relpath
            def outfile = new File(outDir, relpath)
            outfile.getParentFile().mkdirs()
            outfile.setBytes(file.getBytes())
        }

        // Fixup attrs
        def attrsFile = new File(outDir, 'res/values/attrs.xml')
        def xml = new XmlParser().parse(attrsFile)
        def attrsDone = [] as Set
        symbols.styleable.each { k, v ->
            def s = k.split('_')[0]
            if (attrsDone.contains(s))
                return
            attrsDone.add(s)
            def items = symbols.styleable.findAll { it.key.startsWith(s + '_') }.collect { it.key }
            items.sort { symbols.styleable[it] }
            def decl = xml.appendNode('declare-styleable', ['name': s])
            items.each { item ->
                def name = item.split('_', 2)[1].replace('_', ':')
                def node = xml.attr.find { attr -> attr.@name == name }
                if (node) {
                    xml.remove(node)
                    decl.append(node)
                } else {
                    decl.appendNode('attr', ['name': name])
                }
            }
        }
        new XmlNodePrinter(new PrintWriter(new FileWriter(attrsFile))).print(xml)

        // Fixup layouts
        fileTree(dir: outDir)
                .include('res/layout*/*')
                .each { File file ->
            def relpath = file.absolutePath - outDir.absolutePath
            println relpath
            def content = file.text.replaceAll('@id/', '@+id/')
            file.text = content
        }

        // Write manifest
        new File(outDir, 'AndroidManifest.xml').text =
            """<?xml version="1.0" encoding="utf-8"?>
            <manifest xmlns:android="http://schemas.android.com/apk/res/android"
                    package="com.google.android.apps.auto.sdk.ui">
                <uses-sdk
                    android:minSdkVersion="21"
                    android:targetSdkVersion="25" />
                <application />
            </manifest>"""
    }
}

task aaptResources(dependsOn: collectResources, type: Exec) {
    def aaptDir = new File(outDir, 'aapt')

    doFirst {
        aaptDir.mkdirs()
    }

    executable new File(sdkDir, 'build-tools/25.0.1/aapt')
    args 'p',
        '-M', new File(outDir, 'AndroidManifest.xml'),
        '-S', new File(outDir, 'res'),
        '-S', new File(projectDir, 'res-extra'),
        '-I', new File(sdkDir, 'platforms/android-25/android.jar'),
        '-J', aaptDir,
        '--output-text-symbols', outDir,
        '--auto-add-overlay'
}

task makePublicTxt(dependsOn: aaptResources, type: Copy) {
    from new File(outDir, 'R.txt')
    into outDir
    rename { 'public.txt' }
}

task collectSmali(dependsOn: extractApk) {
    doLast {
        def PACKAGES_TO_EXTRACT = [
                'com.google.android.apps.auto.sdk',
                'com.google.android.gms.car',
                'com.google.android.a',
                'com.google.android.b',
                'com.google.a',
                'android.support.car',
            ]

        smaliDir.mkdirs()
        fileTree(dir: apkDir)
                .include('smali*/**/*.smali')
                .each { File file ->
            def relpath = file.absolutePath - apkDir.absolutePath
            relpath = relpath.split(Pattern.quote(File.separator), 3)[2]
            def classname = relpath.split('\\.')[0].replaceAll(Pattern.quote(File.separator), '.')
            if (classname.split('\\$')[0] == 'com.google.android.apps.auto.sdk.ui.R')
                return
            def found = false
            PACKAGES_TO_EXTRACT.each { pkg ->
                if (classname.startsWith(pkg + '.'))
                    found = true
            }
            if (!found)
                return
            println classname
            def text = file.text
            // HACK: This is not strictly needed, but it confuses Android
            // Studio, which thinks that CarActivity is not a ContextManager.
            text = text.replaceAll('L(com/google/android/./.);', 'L$1gizmo;')

            def outfile = new File(smaliDir, relpath)
            outfile.getParentFile().mkdirs()
            outfile.text = text
        }
        fileTree(dir: smaliDir)
                .include('com/google/android/?/?.smali')
                .each { File file ->
            file.renameTo new File(file.getParentFile(),
                    file.getName().split('\\.')[0] + 'gizmo.smali')
        }
    }
}

task buildDex(dependsOn: collectSmali, type: JavaExec) {
    classpath = files('libs/smali-2.2.1.jar')
    main = 'org.jf.smali.Main'
    args 'a', '-o', new File(outDir, 'classes.dex'), smaliDir
}

task buildJar(dependsOn: buildDex, type: JavaExec) {
    classpath = fileTree(dir: 'libs/dex2jar-2.0')
    main = 'com.googlecode.dex2jar.tools.Dex2jarCmd'
    args '-d', '-o', new File(outDir, 'classes.jar'), '--force',
            new File(outDir, 'classes.dex')
}

task makeProguardTxt(type: Copy) {
    from new File(projectDir, 'proguard.txt')
    into outDir
}

task buildAar(dependsOn: [collectResources, makePublicTxt, buildJar,
        makeProguardTxt], type: Zip) {
    from outDir
    include 'AndroidManifest.xml', 'R.txt', 'public.txt', 'proguard.txt',
            'classes.jar', 'res/**'
    archiveName 'aauto.aar'
    destinationDir buildDir
}

task clean {
    doLast {
        delete buildDir
    }
}

task build(dependsOn: buildAar)

publishing {
    publications {
		maven(MavenPublication) {
            groupId System.getenv('GROUP') ?: 'com.github.martoreto'
            artifactId System.getenv('ARTIFACT') ?: 'aauto-sdk'
            version System.getenv('VERSION') ?: 'master-SNAPSHOT'

			artifact new File(buildDir, 'aauto.aar')

            pom.withXml {
                def deps = asNode().appendNode('dependencies')
                def dep

                // The final product support libraries version should be the
                // same as its compileSdk, and we don't know what compileSdk
                // the final app will have. Threfore I leave the oldest
                // possible versions of support libraries here, and if the app
                // uses the newer ones, Gradle will resolve it so that these
                // newer versions will be used.

                dep = deps.appendNode('dependency')
                dep.appendNode('groupId', 'com.android.support')
                dep.appendNode('artifactId', 'support-v4')
                dep.appendNode('version', '21.0.3')

                dep = deps.appendNode('dependency')
                dep.appendNode('groupId', 'com.android.support')
                dep.appendNode('artifactId', 'appcompat-v7')
                dep.appendNode('version', '21.0.3')

                dep = deps.appendNode('dependency')
                dep.appendNode('groupId', 'com.android.support')
                dep.appendNode('artifactId', 'recyclerview-v7')
                dep.appendNode('version', '21.0.3')

                // The Play Services version here should be the same as used in
                // the source APK. I'm not sure what happens when the app uses
                // the newer version, though.

                dep = deps.appendNode('dependency')
                dep.appendNode('groupId', 'com.google.android.gms')
                dep.appendNode('artifactId', 'play-services-base')
                dep.appendNode('version', '11.4.0')
            }
		}
	}
}