platform_build_soong/android/proto.go

// Copyright 2017 Google Inc. 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 android

import (
	"github.com/google/blueprint"
)

func init() {
	pctx.HostBinToolVariable("protocCmd", "aprotoc")
}

var (
	proto = pctx.AndroidStaticRule("protoc",
		blueprint.RuleParams{
			Command:     "$protocCmd $protoOut=$protoOutFlags:$outDir $protoFlags $in",
			CommandDeps: []string{"$protocCmd"},
		}, "protoFlags", "protoOut", "protoOutFlags", "outDir")
)

// TODO(ccross): protos are often used to communicate between multiple modules.  If the only
// way to convert a proto to source is to reference it as a source file, and external modules cannot
// reference source files in other modules, then every module that owns a proto file will need to
// export a library for every type of external user (lite vs. full, c vs. c++ vs. java).  It would
// be better to support a proto module type that exported a proto file along with some include dirs,
// and then external modules could depend on the proto module but use their own settings to
// generate the source.

func GenProto(ctx ModuleContext, protoFile Path,
	protoFlags string, protoOut, protoOutFlags string, extensions []string) WritablePaths {

	var outFiles WritablePaths
	for _, ext := range extensions {
		outFiles = append(outFiles, GenPathWithExt(ctx, "proto", protoFile, ext))
	}

	ctx.ModuleBuild(pctx, ModuleBuildParams{
		Rule:        proto,
		Description: "protoc " + protoFile.Rel(),
		Outputs:     outFiles,
		Input:       protoFile,
		Args: map[string]string{
			"outDir":        ProtoDir(ctx).String(),
			"protoOut":      protoOut,
			"protoOutFlags": protoOutFlags,
			"protoFlags":    protoFlags,
		},
	})

	return outFiles
}

func ProtoFlags(ctx ModuleContext, p *ProtoProperties) []string {
	var protoFlags []string
	if len(p.Proto.Local_include_dirs) > 0 {
		localProtoIncludeDirs := PathsForModuleSrc(ctx, p.Proto.Local_include_dirs)
		protoFlags = append(protoFlags, JoinWithPrefix(localProtoIncludeDirs.Strings(), "-I"))
	}
	if len(p.Proto.Include_dirs) > 0 {
		rootProtoIncludeDirs := PathsForSource(ctx, p.Proto.Include_dirs)
		protoFlags = append(protoFlags, JoinWithPrefix(rootProtoIncludeDirs.Strings(), "-I"))
	}

	protoFlags = append(protoFlags, "-I .")

	return protoFlags
}

// ProtoDir returns the module's "gen/proto" directory
func ProtoDir(ctx ModuleContext) ModuleGenPath {
	return PathForModuleGen(ctx, "proto")
}

// ProtoSubDir returns the module's "gen/proto/path/to/module" directory
func ProtoSubDir(ctx ModuleContext) ModuleGenPath {
	return PathForModuleGen(ctx, "proto", ctx.ModuleDir())
}

type ProtoProperties struct {
	Proto struct {
		// Proto generator type.  C++: full or lite.  Java: micro, nano, stream, or lite.
		Type *string `android:"arch_variant"`

		// list of directories that will be added to the protoc include paths.
		Include_dirs []string

		// list of directories relative to the bp file that will
		// be added to the protoc include paths.
		Local_include_dirs []string
	} `android:"arch_variant"`
}