Added APK size analyzer

Author: pkpio

.gitignore

@@ -3,3 +3,7 @@ dist
 *.vsix
 .taskkey
 **/.taskkey
+.DS_Store
+**/.DS_Store
+test/assets/extracted/
+

downloadAndroidSdk.ts

@@ -4,18 +4,13 @@
     "description": "Azure DevOps task to measure the size in Android app size by looking at 2 given APKs and AABs",
     "main": "index.js",
     "scripts": {
-        "postinstall": "npm run download-sdk-all",
         "build": "npm run build-ts && npm run copy-files",
         "adoTask": "npm run build && node dist/src/ado-index.js",
         "build-ts": "tsc",
         "copy-files": "ts-node copyFiles.ts",
         "test": "npm run build && mocha dist/test/**/*.js",
         "bundle": "npm run build && npm run bundle-ado-task",
         "bundle-ado-task": "tfx extension create --manifest-globs ado-extension.json",
-        "download-sdk-windows": "ts-node downloadAndroidSdk.ts Windows_NT",
-        "download-sdk-linux": "ts-node downloadAndroidSdk.ts Linux",
-        "download-sdk-mac": "ts-node downloadAndroidSdk.ts Darwin",
-        "download-sdk-all": "npm run download-sdk-windows && npm run download-sdk-linux && npm run download-sdk-mac",
         "bump-major": "ts-node bumpVersion.ts major",
         "bump-minor": "ts-node bumpVersion.ts minor",
         "bump-patch": "ts-node bumpVersion.ts patch"
@@ -37,7 +32,11 @@
     },
     "homepage": "https://github.com/microsoft/android-app-size-ci#readme",
     "dependencies": {
-        "azure-pipelines-task-lib": "^2.9.3"
+        "@types/adm-zip": "^0.4.32",
+        "@types/line-reader": "0.0.28",
+        "adm-zip": "^0.4.13",
+        "azure-pipelines-task-lib": "^2.9.3",
+        "line-reader": "^0.4.0"
     },
     "devDependencies": {
         "@types/download": "^6.2.4",

package-lock.json

@@ -1,28 +1,28 @@
-import * as tl from 'azure-pipelines-task-lib/task';
-import * as shell from "shelljs";
-import * as os from 'os';
-import * as path from 'path';
+import * as adoTask from 'azure-pipelines-task-lib/task';
+import * as util from 'util';
+import ApkAnalyzer from '../apkAnalyzer/ApkAnalyzer';
 
 export default class AdoTaskRunner {
 
     public async run() {
-        const platform = os.type();
-
-        const apkanalyzerPath = path.join('dist', 'src', 'bin', platform, 'tools', 'bin', 'apkanalyzer');
-        const testApkPath = path.join('test', 'assets', 'test.apk');
-
-        shell.exec(apkanalyzerPath + ' apk download-size ' + testApkPath);
-
         try {
-            const inputString: string | undefined = tl.getInput('baseAppPath', true);
-            if (inputString == 'bad') {
-                tl.setResult(tl.TaskResult.Failed, 'Bad input was given');
+            const baseAppPath: string | undefined = adoTask.getInput('baseAppPath', true);
+            const targetAppPath: string | undefined = adoTask.getInput('targetAppPath', true);
+            const summaryOutputPath: string | undefined = adoTask.getInput('summaryOutputPath', false);
+
+            if (util.isUndefined(baseAppPath) || util.isUndefined(targetAppPath)) {
+                adoTask.setResult(adoTask.TaskResult.Failed, 'Invalid app paths supplied!');
                 return;
             }
-            console.log('Hello', inputString);
+
+            const baseSizeSummary = await new ApkAnalyzer().analyse(baseAppPath);
+            const targetSizeSummary = await new ApkAnalyzer().analyse(targetAppPath);
+
+            console.log(baseSizeSummary);
+            console.log(targetSizeSummary);
         }
         catch (err) {
-            tl.setResult(tl.TaskResult.Failed, err.message);
+            adoTask.setResult(adoTask.TaskResult.Failed, err.message);
         }
     }
 

package.json

@@ -0,0 +1,37 @@
+import AdmZip from 'adm-zip';
+import * as path from 'path'
+import * as util from 'util';
+import MetaMfParser from './MetaMfParser';
+import ApkSizeSummary from './ApkSizeSummary';
+import { FilesSizeCalculator } from './FilesSizeCalculator';
+
+export default class ApkAnalyzer {
+
+    public async analyse(apkPath: string, workingDir?: string) : Promise<ApkSizeSummary> {
+        if (util.isUndefined(workingDir)) {
+            workingDir = path.join(path.dirname(apkPath), 'extracted');
+        }
+
+        // Extract the apk file
+        const apkFile = new AdmZip(apkPath);
+        console.log('Extracting APK file to ' + workingDir);
+        apkFile.extractAllTo(workingDir, true);
+
+        // Parse the IMF file
+        const mfParser = new MetaMfParser(workingDir);
+        await mfParser.parse();
+
+        // Build Apk size summary
+        const fileSizeCalc = new FilesSizeCalculator();
+        const sizeSummary = new ApkSizeSummary();
+
+        sizeSummary.apkFile = fileSizeCalc.getFileSize(apkPath);
+        sizeSummary.arscFile = fileSizeCalc.getFilesSize(mfParser.getFiles('.arsc'));
+        sizeSummary.dexFiles = fileSizeCalc.getFilesSize(mfParser.getFiles('.dex'));
+        sizeSummary.nativeLibs = fileSizeCalc.getFilesSize(mfParser.getFiles('.so'));
+        sizeSummary.installSize = sizeSummary.apkFile + sizeSummary.dexFiles;
+
+        return sizeSummary;
+    }
+
+}

src/adoTask/adoTaskRunner.ts

@@ -0,0 +1,7 @@
+export default class ApkSizeSummary {
+    apkFile: number = 0;
+    installSize: number = 0;
+    dexFiles: number = 0;
+    arscFile: number = 0;
+    nativeLibs: number = 0;
+}

src/apkAnalyzer/ApkAnalyzer.ts

@@ -0,0 +1,29 @@
+/**
+ * Calculates the cummulative size of given file(s)
+ */
+import * as fs from 'fs';
+import * as util from 'util';
+
+ export class FilesSizeCalculator {
+
+    /**
+     * Returns the cummulative size of all the files
+     */
+    public getFilesSize(filePaths: string[] | undefined) : number {
+        var totalSize = 0;
+
+        if (!util.isNullOrUndefined(filePaths)) {
+            filePaths.forEach(filePath => {
+                totalSize += this.getFileSize(filePath);
+            });
+        }
+        
+        return totalSize;
+    }
+
+    public getFileSize(filePath: string) : number {
+        const stats = fs.statSync(filePath);
+        return stats["size"];
+    }
+
+ }

src/apkAnalyzer/ApkSizeSummary.ts

@@ -0,0 +1,63 @@
+import LineReader from 'line-reader';
+import * as path from 'path';
+import * as util from 'util';
+
+/**
+ * Map from extension to all files with that extension
+ */
+interface ExtensionFiles {
+    [key: string]: Array<string>;
+}
+
+/**
+ * Parses the contents of the Android MetaMf file and sorts the list of files based on extension 
+ */
+ export default class MetaMfParser {
+
+    // Path which is root of the apk contents
+    mBasePath: string;
+
+    // Path to the actual .MF file
+    mfFilePath: string;
+
+    mFilesExtensionMap: Map<string, Array<string>>;
+
+    constructor(apkContentsPath: string) {
+        this.mBasePath = apkContentsPath;
+        this.mfFilePath = path.join(apkContentsPath, 'META-INF', 'MANIFEST.MF');
+        this.mFilesExtensionMap = new Map();
+    }
+
+    /**
+     * Parses the file contents into extension groups
+     */
+    public async parse() {
+        var eachLine: any = util.promisify(LineReader.eachLine);
+        return eachLine(this.mfFilePath, (line: string) => {
+            this.parseLine(line)
+        });
+    }
+
+    /**
+     * Gets array of files with the given extension
+     */
+    public getFiles(extension: string) : Array<string> | undefined {
+        return this.mFilesExtensionMap.get(extension);
+    }
+
+    private parseLine(line: string) {
+        // Ignore lines which doesn't point to a file
+        if (!line.startsWith('Name: ')) {
+            return;
+        }
+        
+        const filePath = path.join(this.mBasePath, line.split('Name: ', 2)[1]);
+        const extension = path.extname(filePath);
+
+        if (!this.mFilesExtensionMap.has(extension)) {
+            this.mFilesExtensionMap.set(extension, []);
+        }
+
+        this.mFilesExtensionMap.get(extension)?.push(filePath);
+    }
+ }

src/apkAnalyzer/FilesSizeCalculator.ts

@@ -29,6 +29,14 @@
             "defaultValue": "",
             "required": true,
             "helpMarkDown": "Path to target apk / aab. This is the app after changes"
+        },
+        {
+            "name": "summaryOutputPath",
+            "type": "string",
+            "label": "Summary output path",
+            "defaultValue": "summary.md",
+            "required": true,
+            "helpMarkDown": "Output file where comparision summary should be written to"
         }
     ],
     "execution": {