src/tools/ak/extractaar/extractaar.go

// Copyright 2021 The Bazel Authors. All rights reserved.
//
// 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 extractaar extracts files from an aar.
package extractaar

import (
	"archive/zip"
	"errors"
	"flag"
	"fmt"
	"io"
	"log"
	"os"
	"path/filepath"
	"strings"
	"sync"

	"src/tools/ak/types"
)

// A tristate may be true, false, or unset
type tristate int

func (t tristate) isSet() bool {
	return t == tsTrue || t == tsFalse
}

func (t tristate) value() bool {
	return t == tsTrue
}

const (
	tsTrue  = 1
	tsFalse = -1

	manifest = iota
	res
	assets
)

var (
	// Cmd defines the command to run the extractor.
	Cmd = types.Command{
		Init: Init,
		Run:  Run,
		Desc: desc,
		Flags: []string{
			"aar", "label",
			"out_manifest", "out_res_dir", "out_assets_dir",
			"has_res", "has_assets",
		},
	}

	aar             string
	label           string
	outputManifest  string
	outputResDir    string
	outputAssetsDir string
	hasRes          int
	hasAssets       int

	initOnce sync.Once
)

// Init initializes the extractor.
func Init() {
	initOnce.Do(func() {
		flag.StringVar(&aar, "aar", "", "Path to the aar")
		flag.StringVar(&label, "label", "", "Target's label")
		flag.StringVar(&outputManifest, "out_manifest", "", "Output manifest")
		flag.StringVar(&outputResDir, "out_res_dir", "", "Output resources directory")
		flag.StringVar(&outputAssetsDir, "out_assets_dir", "", "Output assets directory")
		flag.IntVar(&hasRes, "has_res", 0, "Whether the aar has resources")
		flag.IntVar(&hasAssets, "has_assets", 0, "Whether the aar has assets")
	})
}

func desc() string {
	return "Extracts files from an AAR"
}

type aarFile struct {
	path    string
	relPath string
}

func (file *aarFile) String() string {
	return fmt.Sprintf("%s:%s", file.path, file.relPath)
}

type toCopy struct {
	src  string
	dest string
}

// Run runs the extractor
func Run() {
	if err := doWork(aar, label, outputManifest, outputResDir, outputAssetsDir, hasRes, hasAssets); err != nil {
		log.Fatal(err)
	}
}

func doWork(aar, label, outputManifest, outputResDir, outputAssetsDir string, hasRes, hasAssets int) error {
	tmpDir, err := os.MkdirTemp("", "extractaar_")
	if err != nil {
		return err
	}
	defer os.RemoveAll(tmpDir)

	files, err := extractAAR(aar, tmpDir)
	if err != nil {
		return err
	}

	validators := map[int]validator{
		manifest: manifestValidator{dest: outputManifest},
		res:      resourceValidator{dest: outputResDir, hasRes: tristate(hasRes), ruleAttr: "has_res"},
		assets:   resourceValidator{dest: outputAssetsDir, hasRes: tristate(hasAssets), ruleAttr: "has_assets"},
	}

	var filesToCopy []*toCopy
	var validationErrs []*BuildozerError
	for fileType, files := range groupAARFiles(files) {
		validatedFiles, err := validators[fileType].validate(files)
		if err != nil {
			validationErrs = append(validationErrs, err)
			continue
		}
		filesToCopy = append(filesToCopy, validatedFiles...)
	}

	if len(validationErrs) != 0 {
		return errors.New(mergeBuildozerErrors(label, validationErrs))
	}

	for _, file := range filesToCopy {
		if err := copyFile(file.src, file.dest); err != nil {
			return err
		}
	}

	// TODO(ostonge): Add has_res/has_assets attr to avoid having to do this
	// We need to create at least one file so that Bazel does not complain
	// that the output tree artifact was not created.
	if err := createIfEmpty(outputResDir, "res/values/empty.xml", "<resources/>"); err != nil {
		return err
	}
	// aapt will ignore this file and not print an error message, because it
	// thinks that it is a swap file
	if err := createIfEmpty(outputAssetsDir, "assets/empty_asset_generated_by_bazel~", ""); err != nil {
		return err
	}
	return nil
}

func groupAARFiles(aarFiles []*aarFile) map[int][]*aarFile {
	// Map of file type to channel of aarFile
	filesMap := make(map[int][]*aarFile)
	for _, fileType := range []int{manifest, res, assets} {
		filesMap[fileType] = make([]*aarFile, 0)
	}

	for _, file := range aarFiles {
		if file.relPath == "AndroidManifest.xml" {
			filesMap[manifest] = append(filesMap[manifest], file)
		} else if strings.HasPrefix(file.relPath, "res"+string(os.PathSeparator)) {
			filesMap[res] = append(filesMap[res], file)
		} else if strings.HasPrefix(file.relPath, "assets"+string(os.PathSeparator)) {
			filesMap[assets] = append(filesMap[assets], file)
		}
		// TODO(ostonge): support jar and aidl files
	}
	return filesMap
}

func extractAAR(aar string, dest string) ([]*aarFile, error) {
	reader, err := zip.OpenReader(aar)
	if err != nil {
		return nil, err
	}
	defer reader.Close()

	var files []*aarFile
	for _, f := range reader.File {
		if f.FileInfo().IsDir() {
			continue
		}
		extractedPath := filepath.Join(dest, f.Name)
		if err := extractFile(f, extractedPath); err != nil {
			return nil, err
		}
		files = append(files, &aarFile{path: extractedPath, relPath: f.Name})
	}
	return files, nil
}

func extractFile(file *zip.File, dest string) error {
	if err := os.MkdirAll(filepath.Dir(dest), os.ModePerm); err != nil {
		return err
	}
	outFile, err := os.OpenFile(dest, os.O_WRONLY|os.O_CREATE, file.Mode())
	if err != nil {
		return err
	}
	defer outFile.Close()

	rc, err := file.Open()
	if err != nil {
		return err
	}
	defer rc.Close()

	_, err = io.Copy(outFile, rc)
	if err != nil {
		return err
	}
	return nil
}

func copyFile(name, dest string) error {
	in, err := os.Open(name)
	if err != nil {
		return err
	}
	defer in.Close()

	if err := os.MkdirAll(filepath.Dir(dest), os.ModePerm); err != nil {
		return err
	}
	out, err := os.Create(dest)
	if err != nil {
		return err
	}
	defer out.Close()

	_, err = io.Copy(out, in)
	if err != nil {
		return err
	}
	return nil
}

func dirIsEmpty(dir string) (bool, error) {
	f, err := os.Open(dir)
	if os.IsNotExist(err) {
		return true, nil
	}
	if err != nil {
		return false, err
	}
	defer f.Close()

	_, err = f.Readdirnames(1)
	if err == io.EOF {
		return true, nil
	}
	return false, err
}

// Create the file with the content if the directory is empty or does not exists
func createIfEmpty(dir, filename, content string) error {
	isEmpty, err := dirIsEmpty(dir)
	if err != nil {
		return err
	}
	if isEmpty {
		dest := filepath.Join(dir, filename)
		if err := os.MkdirAll(filepath.Dir(dest), os.ModePerm); err != nil {
			return err
		}
		return os.WriteFile(dest, []byte(content), 0644)
	}
	return nil
}