android-multi-resolution/multires.gradle at master · freddyfang/android-multi-resolution · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
import groovy.xml.MarkupBuilder

final extraResourceDir = "$buildDir/generated/multires/res"

final shouldGenerateDefaultDimen = project.ext.has("generate_default_dimens") ? ext["generate_default_dimens"] : true
final defaultSpRange = project.ext.has("default_sp_range") ? ext["default_sp_range"] : [1, 30]
final defaultDpRange = project.ext.has("default_dp_range") ? ext["default_dp_range"] : [1, 800]

final base = project.ext.has("base_swdp") ? ext["base_swdp"] : 250
final min = project.ext.has("min_swdp") ? ext["min_swdp"] : 250
final max = project.ext.has("max_swdp") ? ext["max_swdp"] : 1000
final step = project.ext.has("res_step") ? ext["res_step"] : 10

static MarkupBuilder createNewDimensXml(FileWriter writer) {
    def dimensXml = new MarkupBuilder(writer)
    dimensXml.mkp.xmlDeclaration(version: '1.0', encoding: 'utf-8')
    return dimensXml
}

static def writeDimen(MarkupBuilder xml, int start, int end, String unit) {
    (start..end).each { val ->
        xml.dimen name: "${unit}_${val}", "${val}${unit}"
    }
}

static def generateDefaultDimensXml(File file, spRange, dpRange) {
    if (file.exists()) {
        return
    }

    file.createNewFile()

    def writer = new FileWriter(file)
    def dimensXml = createNewDimensXml(writer)

    dimensXml.resources {
        // Write sp
        writeDimen(dimensXml, spRange[0], spRange[1], 'sp')

        // Write blank line
        mkp.yield('\r\n')

        // Write dp
        writeDimen(dimensXml, dpRange[0], dpRange[1], 'dp')
    }

    writer.close()
}

task generateMultiRes() {
    def defaultDimensFile = new File(projectDir, 'src/main/res/values/dimens.xml')
    if (!defaultDimensFile.exists() && shouldGenerateDefaultDimen) {
        generateDefaultDimensXml(defaultDimensFile, defaultSpRange, defaultDpRange)
    }

    if (!defaultDimensFile.exists()) {
        return
    }

    def defaultDimensXml = new XmlParser()
            .parse(defaultDimensFile)

    def targetResourceDir = new File(extraResourceDir)
    if (targetResourceDir.exists()) {
        targetResourceDir.deleteDir()
    }
    targetResourceDir.mkdir()

    (min..max).step(step).each { n ->
        def dir = new File(targetResourceDir, sprintf('values-sw%ddp', n))
        dir.mkdirs()

        def target = new File(dir, 'dimens.xml')
        target.createNewFile()

        def writer = new FileWriter(target)
        def dimensXml = createNewDimensXml(writer)
        dimensXml.resources {
            defaultDimensXml.value().each { node ->
                def name = node.attribute('name')
                def defaultVal = node.text()
                def unit = defaultVal.contains('dp') ? 'dp' : 'sp'

                defaultVal = defaultVal.replace('dp', '')
                        .replace('sp', '')
                        .toFloat()
                def val = defaultVal * (n / base)

                dimen name: name, sprintf('%.2f%s', val, unit)
            }
        }

        writer.close()
    }
}

preBuild.dependsOn(generateMultiRes)
android.applicationVariants.all { variant ->
    def folders = files(extraResourceDir).builtBy('generateMultiRes')
    variant.registerGeneratedResFolders(folders)
}