Added JSON support to APK sizing (#101)

* Modified the APK size tooling to produce a JSON file

* Enabled linting for APK size tooling

* Added tests for ApkSize*Builder classes.

* Added Gradle integration tests

Author: allisonbm92

buildSrc/build.gradle

@@ -14,6 +14,7 @@
 
 plugins {
     id 'java-gradle-plugin'
+    id 'groovy'
 }
 
 repositories {
@@ -39,6 +40,7 @@ dependencies {
 
     implementation 'com.android.tools.build:gradle:3.2.1'
     testImplementation 'junit:junit:4.12'
+    testImplementation 'org.json:json:20180813'
     testImplementation('org.spockframework:spock-core:1.1-groovy-2.4') {
         exclude group: 'org.codehaus.groovy'
     }
@@ -65,4 +67,4 @@ test {
         showStandardStreams = true
     }
     enabled = rootProject.properties.get('enablePluginTests', false).toBoolean()
-}
+}

buildSrc/src/main/groovy/com/google/firebase/gradle/plugins/measurement/ApkSizeJsonBuilder.groovy

@@ -0,0 +1,68 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+package com.google.firebase.gradle.plugins.measurement
+
+/** A helper class that generates the APK size measurement JSON report. */
+class ApkSizeJsonBuilder {
+
+    private static final String PULL_REQUEST_TABLE = "PullRequests"
+    private static final String PULL_REQUEST_COLUMN = "pull_request_id"
+    private static final String APK_SIZE_TABLE = "ApkSizes"
+    private static final String SDK_COLUMN = "sdk_id"
+    private static final String APK_SIZE_COLUMN = "apk_size"
+
+    // This comes in as a String and goes out as a String, so we might as well keep it a String
+    private final String pullRequestNumber
+    private final List<Tuple2<Integer, Integer>> sdkSizes
+
+    ApkSizeJsonBuilder(pullRequestNumber) {
+        this.pullRequestNumber = pullRequestNumber
+        this.sdkSizes = []
+    }
+
+    def addApkSize(sdkId, size) {
+        sdkSizes.add(new Tuple2(sdkId, size))
+    }
+
+    def toJsonString() {
+        if (sdkSizes.isEmpty()) {
+            throw new IllegalStateException("No sizes were added")
+        }
+
+        def sizes = sdkSizes.collect {
+            "[$pullRequestNumber, $it.first, $it.second]"
+        }.join(", ")
+
+        def json = """
+            {
+                tables: [
+                    {
+                        table_name: "$PULL_REQUEST_TABLE",
+                        column_names: ["$PULL_REQUEST_COLUMN"],
+                        replace_measurements: [[$pullRequestNumber]],
+                    },
+                    {
+                        table_name: "$APK_SIZE_TABLE",
+                        column_names: ["$PULL_REQUEST_COLUMN", "$SDK_COLUMN", "$APK_SIZE_COLUMN"],
+                        replace_measurements: [$sizes],
+                    },
+                ],
+            }
+        """
+
+        return json
+    }
+}

buildSrc/src/main/groovy/com/google/firebase/gradle/plugins/measurement/ApkSizeTableBuilder.groovy

@@ -0,0 +1,41 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+package com.google.firebase.gradle.plugins.measurement
+
+/** A helper class that generates the human-readable, APK size measurement table. */
+class ApkSizeTableBuilder {
+
+    private final List<Tuple> sdkSizes = []
+
+    def addApkSize(projectName, buildType, size) {
+        sdkSizes.add(new Tuple(projectName, buildType, size))
+    }
+
+    def toTableString() {
+        if (sdkSizes.isEmpty()) {
+          throw new IllegalStateException("No sizes added")
+        }
+
+        def table = "|------------------        APK Sizes        ------------------|\n"
+        table +=    "|--    project    --|--  build type   --|--  size in bytes  --|\n"
+
+        table += sdkSizes.collect {
+            sprintf("|%-19s|%-19s|%-21s|", it.get(0), it.get(1), it.get(2))
+        }.join("\n")
+
+        return table
+    }
+}

buildSrc/src/main/groovy/com/google/firebase/gradle/plugins/measurement/GenerateMeasurementsTask.groovy

@@ -22,14 +22,18 @@ import org.gradle.api.tasks.OutputFile
 import org.gradle.api.tasks.TaskAction
 
 /**
- * Generates size measurements after building the test apps and outputs them as a text-format
- * protocol buffer report.
+ * Generates size measurements after building the test apps.
+ *
+ * <p>This task can run in two modes. The first mode, is a dependency for {@link
+ * UploadMeasurementsTask} and generates a JSON file with measurement information. This file
+ * references database IDs, and is not considered to be human-friendly. The second mode outputs a
+ * table to standard out with more useful information. These modes can be toggled by adding the
+ * {@code pull_request} flag to the task. See the README for more details.
  *
  * <p>This task requires two properties, an SDK map, as input, and the report, as output. The map is
  * used to convert project names and build variants into the SDK identifiers used by the database.
- * The report path is where the output should be stored. Additionally, a project property, {@code
- * pull_request} is used in the report. Excluding this value will send a human-readable version
- * to standard out.
+ * The report path is where the output should be stored. These properties are not used when the task
+ * is run in the second, humna-friendly mode. However, they are still required to be specified.
  */
 public class GenerateMeasurementsTask extends DefaultTask {
 
@@ -76,59 +80,58 @@ public class GenerateMeasurementsTask extends DefaultTask {
 
     @TaskAction
     def generate() {
-        // Check if we need to run human-readable or upload mode.
+        def variants = project.android.applicationVariants
+
+        // Check if we need to run human-readable table or JSON upload mode.
         if (project.hasProperty("pull_request")) {
             def pullRequestNumber = project.properties["pull_request"]
-            def sdkMap = createSdkMap()
-            def sizes = calculateSizesForUpload(sdkMap, project.android.applicationVariants)
-            def report = createReportForUpload(pullRequestNumber, sizes)
-
-            reportFile.withWriter {
-                it.write(report)
-            }
+            generateJson(pullRequestNumber, variants)
         } else {
-            def sizes = calculateHumanReadableSizes(project.android.applicationVariants)
-            printHumanReadableReport(sizes)
+            generateTable(variants)
         }
     }
 
-    private def calculateHumanReadableSizes(variants) {
-        def sizes = [:]
-        def processor = {flavor, build, size ->
-            sizes[new Tuple2(flavor, build)] = size
+    private def generateJson(pullRequestNumber, variants) {
+        def sdkMap = createSdkMap()
+        def builder = new ApkSizeJsonBuilder(pullRequestNumber)
+        def variantProcessor = {projectName, buildType, apkSize ->
+            def name = "$projectName-$buildType"
+            def sdkId = sdkMap[name]
+
+            if (sdkId == null) {
+                throw new IllegalStateException("$name not included in SDK map")
+            }
+
+            builder.addApkSize(sdkId, apkSize)
         }
 
-        calculateSizesFor(variants, processor)
-        return sizes
+        calculateSizes(variants, variantProcessor)
+        reportFile.withWriter {
+            it.write(builder.toJsonString())
+        }
     }
 
-    private def calculateSizesForUpload(sdkMap, variants) {
-        def sizes = [:]
-        def processor = { flavor, build, size ->
-            def name = "${flavor}-${build}"
-            def sdk = sdkMap[name];
-
-            if (sdk == null) {
-                throw new IllegalStateException("$name not included in SDK map")
-            }
-            sizes[sdk] = size
+    private def generateTable(variants) {
+        def builder = new ApkSizeTableBuilder()
+        def variantProcessor = {projectName, buildType, apkSize ->
+            builder.addApkSize(projectName, buildType, apkSize)
         }
 
-        calculateSizesFor(variants, processor)
-        return sizes
+        calculateSizes(variants, variantProcessor)
+        project.logger.quiet(builder.toTableString())
     }
 
-    private def calculateSizesFor(variants, processor) {
+    private def calculateSizes(variants, processor) {
         // Each variant should have exactly one APK. If there are multiple APKs, then this file is
-	// out of sync with our Gradle configuration, and this task fails. If an APK is missing, it
-	// is silently ignored, and the APKs from the other variants will be used to build the
-	// report.
+        // out of sync with our Gradle configuration, and this task fails. If an APK is missing, it
+        // is silently ignored, and the APKs from the other variants will be used to build the
+        // report.
         variants.each { variant ->
             def flavorName = variant.flavorName
             def buildType = variant.buildType.name
             def apks = variant.outputs.findAll { it.outputFile.name.endsWith(".apk") }
             if (apks.size() > 1) {
-	        def msg = "${flavorName}-${buildType} produced more than one APK"
+                def msg = "${flavorName}-${buildType} produced more than one APK"
                 throw new IllegalStateException(msg)
             }
 
@@ -140,77 +143,6 @@ public class GenerateMeasurementsTask extends DefaultTask {
         }
     }
 
-    private def printHumanReadableReport(sizes) {
-        project.logger.quiet("|------------------        APK Sizes        ------------------|")
-        project.logger.quiet("|--    project    --|--  build type   --|--  size in bytes  --|")
-
-        sizes.each { key, value ->
-            def line = sprintf("|%-19s|%-19s|%-21s|", key.first, key.second, value)
-            project.logger.quiet(line)
-        }
-    }
-
-    // TODO(allisonbm): Remove hard-coding protocol buffers. This code manually generates the
-    // text-format protocol buffer report. This eliminates requiring buildSrc to depend on the
-    // uploader (or simply, the protocol buffer library), but this isn't the most scalable option.
-    private def createReportForUpload(pullRequestNumber, sizes) {
-        def sdkId = 0
-        def apkSize = 0
-
-        def pullRequestGroup = """
-            groups {
-                table_name: "PullRequests"
-                column_names: "pull_request_id"
-                measurements {
-                    values {
-                        int_value: ${pullRequestNumber}
-                    }
-                }
-            }
-        """
-
-        def sizeGroupHeader = """
-            groups {
-                table_name: "ApkSizes"
-                column_names: "sdk_id"
-                column_names: "pull_request_id"
-                column_names: "apk_size"
-        """
-
-        def sizeGroupEntry = """
-                measurements {
-                    values {
-                        int_value: ${->sdkId}
-                    }
-                    values {
-                        int_value: ${pullRequestNumber}
-                    }
-                    values {
-                        int_value: ${->apkSize}
-                    }
-                }
-        """
-
-        def sizeGroupFooter = """
-            }
-        """
-
-
-        def builder = new StringBuilder()
-        builder.append(pullRequestGroup)
-        builder.append(sizeGroupHeader)
-
-        sizes.each { key, value ->
-            // sdkId and apkSize are lazily interpolated into sizeGroupEntry.
-            sdkId = key
-            apkSize = value
-            builder.append(sizeGroupEntry)
-        }
-
-        builder.append(sizeGroupFooter)
-        return builder.toString()
-    }
-
     private def createSdkMap() {
         def map = [:]
 

buildSrc/src/main/groovy/com/google/firebase/gradle/plugins/measurement/UploadMeasurementsTask.groovy

@@ -72,7 +72,7 @@ public class UploadMeasurementsTask extends DefaultTask {
                     "-jar",
                     jar,
                     "--config_path=${configuration}",
-                    "--proto_path=${reportFile}",
+                    "--json_path=${reportFile}",
                 )
             }.rethrowFailure()
         }