mirror/naiveproxy
1
0
Fork 0
mirror of https://github.com/klzgrad/naiveproxy.git synced 2024-12-01 01:36:09 +03:00
Code Issues Projects Releases Wiki Activity
95ac1a17b7
naiveproxy/build/config/android/rules.gni
klzgrad 19bc836227 Import chromium-63.0.3239.132
2018-01-29 00:30:36 +08:00

3334 lines
118 KiB
Plaintext
Raw Blame History

# Copyright 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
# Do not add any imports to non-//build directories here.
# Some projects (e.g. V8) do not have non-build directories DEPS'ed in.
import("//build/config/android/config.gni")
import("//build/config/android/internal_rules.gni")
import("//build/config/compiler/compiler.gni")
import("//build/config/dcheck_always_on.gni")
import("//build/toolchain/toolchain.gni")
assert(is_android)
# Creates a dist directory for a native executable.
#
# Running a native executable on a device requires all the shared library
# dependencies of that executable. To make it easier to install and run such an
# executable, this will create a directory containing the native exe and all
# it's library dependencies.
#
# Note: It's usually better to package things as an APK than as a native
# executable.
#
# Variables
# dist_dir: Directory for the exe and libraries. Everything in this directory
# will be deleted before copying in the exe and libraries.
# binary: Path to (stripped) executable.
# extra_files: List of extra files to copy in (optional).
#
# Example
# create_native_executable_dist("foo_dist") {
# dist_dir = "$root_build_dir/foo_dist"
# binary = "$root_build_dir/foo"
# deps = [ ":the_thing_that_makes_foo" ]
# }
template("create_native_executable_dist") {
forward_variables_from(invoker, [ "testonly" ])
_libraries_list = "${target_gen_dir}/${target_name}_library_dependencies.list"
_find_deps_target_name = "${target_name}__find_library_dependencies"
# TODO(agrieve): Extract dependent libs from GN rather than readelf.
action(_find_deps_target_name) {
forward_variables_from(invoker, [ "deps" ])
script = "//build/android/gyp/write_ordered_libraries.py"
depfile = "$target_gen_dir/$target_name.d"
inputs = [
invoker.binary,
android_readelf,
]
outputs = [
_libraries_list,
]
rebased_binaries = rebase_path([ invoker.binary ], root_build_dir)
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--input-libraries=$rebased_binaries",
"--libraries-dir",
rebase_path(root_shlib_dir, root_build_dir),
"--output",
rebase_path(_libraries_list, root_build_dir),
"--readelf",
rebase_path(android_readelf, root_build_dir),
]
}
copy_ex(target_name) {
inputs = [
_libraries_list,
invoker.binary,
]
dest = invoker.dist_dir
data = [
"${invoker.dist_dir}/",
]
_rebased_libraries_list = rebase_path(_libraries_list, root_build_dir)
_rebased_binaries_list = rebase_path([ invoker.binary ], root_build_dir)
args = [
"--clear",
"--files=@FileArg($_rebased_libraries_list:lib_paths)",
"--files=$_rebased_binaries_list",
]
if (defined(invoker.extra_files)) {
_rebased_extra_files = rebase_path(invoker.extra_files, root_build_dir)
args += [ "--files=$_rebased_extra_files" ]
}
_depfile = "$target_gen_dir/$target_name.d"
_stamp_file = "$target_gen_dir/$target_name.stamp"
outputs = [
_stamp_file,
]
args += [
"--depfile",
rebase_path(_depfile, root_build_dir),
"--stamp",
rebase_path(_stamp_file, root_build_dir),
]
deps = [
":$_find_deps_target_name",
]
if (defined(invoker.deps)) {
deps += invoker.deps
}
}
}
# Writes a script to root_out_dir/bin that passes --output-directory to the
# wrapped script, in addition to forwarding arguments. Most / all of these
# wrappers should be made deps of //tools/android:android_tools.
#
# Variables
# target: Script to wrap.
# flag_name: Default is "--output-directory"
#
# Example
# wrapper_script("foo_wrapper") {
# target = "//pkg/foo.py"
# }
template("wrapper_script") {
action(target_name) {
_name = get_path_info(invoker.target, "name")
_output = "$root_out_dir/bin/$_name"
script = "//build/android/gyp/create_tool_wrapper.py"
outputs = [
_output,
]
# The target isn't actually used by the script, but it's nice to have GN
# check that it exists.
inputs = [
invoker.target,
]
args = [
"--output",
rebase_path(_output, root_build_dir),
"--target",
rebase_path(invoker.target, root_build_dir),
"--output-directory",
rebase_path(root_out_dir, root_build_dir),
]
if (defined(invoker.flag_name)) {
args += [ "--flag-name=${invoker.flag_name}" ]
}
}
}
if (enable_java_templates) {
import("//build/config/sanitizers/sanitizers.gni")
import("//tools/grit/grit_rule.gni")
# Declare a jni target
#
# This target generates the native jni bindings for a set of .java files.
#
# See base/android/jni_generator/jni_generator.py for more info about the
# format of generating JNI bindings.
#
# Variables
# sources: list of .java files to generate jni for
# jni_package: subdirectory path for generated bindings
#
# Example
# generate_jni("foo_jni") {
# sources = [
# "android/java/src/org/chromium/foo/Foo.java",
# "android/java/src/org/chromium/foo/FooUtil.java",
# ]
# jni_package = "foo"
# }
template("generate_jni") {
set_sources_assignment_filter([])
forward_variables_from(invoker, [ "testonly" ])
assert(defined(invoker.sources))
assert(defined(invoker.jni_package))
jni_package = invoker.jni_package
base_output_dir = "${target_gen_dir}/${target_name}"
package_output_dir = "${base_output_dir}/${jni_package}"
jni_output_dir = "${package_output_dir}/jni"
if (defined(invoker.jni_generator_include)) {
jni_generator_include = invoker.jni_generator_include
} else {
jni_generator_include =
"//base/android/jni_generator/jni_generator_helper.h"
}
foreach_target_name = "${target_name}__jni_gen"
action_foreach(foreach_target_name) {
script = "//base/android/jni_generator/jni_generator.py"
depfile = "$target_gen_dir/$target_name.{{source_name_part}}.d"
sources = invoker.sources
outputs = [
"${jni_output_dir}/{{source_name_part}}_jni.h",
]
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--input_file={{source}}",
"--ptr_type=long",
"--output_dir",
rebase_path(jni_output_dir, root_build_dir),
"--includes",
rebase_path(jni_generator_include, jni_output_dir),
]
if (enable_profiling) {
args += [ "--enable_profiling" ]
}
}
config("jni_includes_${target_name}") {
# TODO(cjhopman): #includes should probably all be relative to
# base_output_dir. Remove that from this config once the includes are
# updated.
include_dirs = [
base_output_dir,
package_output_dir,
]
}
group(target_name) {
forward_variables_from(invoker,
[
"deps",
"public_deps",
"visibility",
])
if (!defined(public_deps)) {
public_deps = []
}
public_deps += [ ":$foreach_target_name" ]
public_configs = [ ":jni_includes_${target_name}" ]
}
}
# Declare a jni target for a prebuilt jar
#
# This target generates the native jni bindings for a set of classes in a .jar.
#
# See base/android/jni_generator/jni_generator.py for more info about the
# format of generating JNI bindings.
#
# Variables
# classes: list of .class files in the jar to generate jni for. These should
# include the full path to the .class file.
# jni_package: subdirectory path for generated bindings
# jar_file: the path to the .jar. If not provided, will default to the sdk's
# android.jar
#
# deps, public_deps: As normal
#
# Example
# generate_jar_jni("foo_jni") {
# classes = [
# "android/view/Foo.class",
# ]
# jni_package = "foo"
# }
template("generate_jar_jni") {
set_sources_assignment_filter([])
forward_variables_from(invoker, [ "testonly" ])
assert(defined(invoker.classes))
assert(defined(invoker.jni_package))
if (defined(invoker.jar_file)) {
jar_file = invoker.jar_file
} else {
jar_file = android_sdk_jar
}
jni_package = invoker.jni_package
base_output_dir = "${root_gen_dir}/${target_name}/${jni_package}"
jni_output_dir = "${base_output_dir}/jni"
jni_generator_include =
"//base/android/jni_generator/jni_generator_helper.h"
# TODO(cjhopman): make jni_generator.py support generating jni for multiple
# .class files from a .jar.
jni_actions = []
foreach(class, invoker.classes) {
_classname_list = []
_classname_list = process_file_template([ class ], "{{source_name_part}}")
classname = _classname_list[0]
jni_target_name = "${target_name}__jni_${classname}"
jni_actions += [ ":$jni_target_name" ]
action(jni_target_name) {
# The sources aren't compiled so don't check their dependencies.
check_includes = false
depfile = "$target_gen_dir/$target_name.d"
script = "//base/android/jni_generator/jni_generator.py"
sources = [
jar_file,
]
outputs = [
"${jni_output_dir}/${classname}_jni.h",
]
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--jar_file",
rebase_path(jar_file, root_build_dir),
"--input_file",
class,
"--ptr_type=long",
"--output_dir",
rebase_path(jni_output_dir, root_build_dir),
"--includes",
rebase_path(jni_generator_include, jni_output_dir),
]
if (enable_profiling) {
args += [ "--enable_profiling" ]
}
}
}
config("jni_includes_${target_name}") {
include_dirs = [ base_output_dir ]
}
group(target_name) {
public_deps = []
forward_variables_from(invoker,
[
"deps",
"public_deps",
"visibility",
])
public_deps += jni_actions
public_configs = [ ":jni_includes_${target_name}" ]
}
}
# Declare a jni registration target.
#
# This target generates a header file calling JNI registration functions
# created by generate_jni and generate_jar_jni.
#
# See base/android/jni_generator/jni_registration_generator.py for more info
# about the format of the header file.
#
# Variables
# target: The Apk target to generate registrations for.
# output: Path to the generated .h file.
# exception_files: List of .java files that should be ignored when searching
# for native methods. (optional)
#
# Example
# generate_jni_registration("chrome_jni_registration") {
# target = ":chrome_public_apk"
# output = "$root_gen_dir/chrome/browser/android/${target_name}.h"
# exception_files = [
# "//base/android/java/src/org/chromium/base/library_loader/LegacyLinker.java",
# "//base/android/java/src/org/chromium/base/library_loader/Linker.java",
# "//base/android/java/src/org/chromium/base/library_loader/ModernLinker.java",
# ]
# }
template("generate_jni_registration") {
action(target_name) {
forward_variables_from(invoker, [ "testonly" ])
_build_config = get_label_info(invoker.target, "target_gen_dir") + "/" +
get_label_info(invoker.target, "name") + ".build_config"
_rebased_build_config = rebase_path(_build_config, root_build_dir)
_rebase_exception_java_files =
rebase_path(invoker.exception_files, root_build_dir)
script = "//base/android/jni_generator/jni_registration_generator.py"
deps = [
"${invoker.target}__build_config",
]
inputs = [
_build_config,
]
outputs = [
invoker.output,
]
depfile = "$target_gen_dir/$target_name.d"
args = [
# This is a list of .sources files.
"--sources_files=@FileArg($_rebased_build_config:jni:all_source)",
"--output",
rebase_path(invoker.output, root_build_dir),
"--no_register_java=$_rebase_exception_java_files",
"--depfile",
rebase_path(depfile, root_build_dir),
]
}
}
# Declare a target for c-preprocessor-generated java files
#
# NOTE: For generating Java conterparts to enums prefer using the java_cpp_enum
# rule instead.
#
# This target generates java files using the host C pre-processor. Each file in
# sources will be compiled using the C pre-processor. If include_path is
# specified, it will be passed (with --I) to the pre-processor.
#
# This target will create a single .srcjar. Adding this target to an
# android_library target's srcjar_deps will make the generated java files be
# included in that library's final outputs.
#
# Variables
# sources: list of files to be processed by the C pre-processor. For each
# file in sources, there will be one .java file in the final .srcjar. For a
# file named FooBar.template, a java file will be created with name
# FooBar.java.
# inputs: additional compile-time dependencies. Any files
# `#include`-ed in the templates should be listed here.
# package_path: this will be the subdirectory for each .java file in the
# .srcjar.
#
# Example
# java_cpp_template("foo_generated_enum") {
# sources = [
# "android/java/templates/Foo.template",
# ]
# inputs = [
# "android/java/templates/native_foo_header.h",
# ]
#
# package_path = "org/chromium/base/library_loader"
# include_path = "android/java/templates"
# }
template("java_cpp_template") {
set_sources_assignment_filter([])
forward_variables_from(invoker, [ "testonly" ])
_include_path = "//"
if (defined(invoker.include_path)) {
_include_path = invoker.include_path
}
_apply_gcc_target_name = "${target_name}__apply_gcc"
_base_gen_dir = "${target_gen_dir}/${target_name}/java_cpp_template"
if (defined(invoker.package_path)) {
package_path = invoker.package_path
} else {
# TODO(jbudorick): Back this out once all clients have been switched to
# package_path.
assert(defined(invoker.package_name))
package_path = invoker.package_name
}
action_foreach(_apply_gcc_target_name) {
forward_variables_from(invoker,
[
"deps",
"public_deps",
"data_deps",
])
script = "//build/android/gyp/gcc_preprocess.py"
if (defined(invoker.inputs)) {
inputs = invoker.inputs + []
}
depfile =
"${target_gen_dir}/${invoker.target_name}_{{source_name_part}}.d"
sources = invoker.sources
outputs = [
"$_base_gen_dir/${package_path}/{{source_name_part}}.java",
]
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--include-path",
rebase_path(_include_path, root_build_dir),
"--output",
rebase_path(outputs[0], root_build_dir),
"--template={{source}}",
]
if (defined(invoker.defines)) {
foreach(def, invoker.defines) {
args += [
"--defines",
def,
]
}
}
}
# Filter out .d files.
set_sources_assignment_filter([ "*.d" ])
sources = get_target_outputs(":$_apply_gcc_target_name")
zip(target_name) {
forward_variables_from(invoker, [ "visibility" ])
inputs = sources
output = "${target_gen_dir}/${target_name}.srcjar"
base_dir = _base_gen_dir
deps = [
":$_apply_gcc_target_name",
]
}
}
# Declare a target for generating Java classes from C++ enums.
#
# This target generates Java files from C++ enums using a script.
#
# This target will create a single .srcjar. Adding this target to an
# android_library target's srcjar_deps will make the generated java files be
# included in that library's final outputs.
#
# Variables
# sources: list of files to be processed by the script. For each annotated
# enum contained in the sources files the script will generate a .java
# file with the same name as the name of the enum.
#
# Example
# java_cpp_enum("foo_generated_enum") {
# sources = [
# "src/native_foo_header.h",
# ]
# }
template("java_cpp_enum") {
action(target_name) {
# The sources aren't compiled so don't check their dependencies.
check_includes = false
set_sources_assignment_filter([])
assert(defined(invoker.sources))
forward_variables_from(invoker,
[
"sources",
"testonly",
"visibility",
])
script = "//build/android/gyp/java_cpp_enum.py"
depfile = "$target_gen_dir/$target_name.d"
_srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
_rebased_srcjar_path = rebase_path(_srcjar_path, root_build_dir)
_rebased_sources = rebase_path(invoker.sources, root_build_dir)
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--srcjar=$_rebased_srcjar_path",
] + _rebased_sources
outputs = [
_srcjar_path,
]
}
}
# Declare a target for processing a Jinja template.
#
# Variables
# input: The template file to be processed.
# output: Where to save the result.
# variables: (Optional) A list of variables to make available to the template
# processing environment, e.g. ["name=foo", "color=red"].
#
# Example
# jinja_template("chrome_public_manifest") {
# input = "java/AndroidManifest.xml"
# output = "$target_gen_dir/AndroidManifest.xml"
# }
template("jinja_template") {
set_sources_assignment_filter([])
forward_variables_from(invoker, [ "testonly" ])
assert(defined(invoker.input))
assert(defined(invoker.output))
action(target_name) {
forward_variables_from(invoker,
[
"visibility",
"deps",
])
sources = [
invoker.input,
]
script = "//build/android/gyp/jinja_template.py"
depfile = "$target_gen_dir/$target_name.d"
outputs = [
invoker.output,
]
args = [
"--loader-base-dir",
rebase_path("//", root_build_dir),
"--inputs",
rebase_path(invoker.input, root_build_dir),
"--output",
rebase_path(invoker.output, root_build_dir),
"--depfile",
rebase_path(depfile, root_build_dir),
]
if (defined(invoker.variables)) {
variables = invoker.variables
args += [ "--variables=${variables}" ]
}
}
}
# Declare a target for processing Android resources as Jinja templates.
#
# This takes an Android resource directory where each resource is a Jinja
# template, processes each template, then packages the results in a zip file
# which can be consumed by an android resources, library, or apk target.
#
# If this target is included in the deps of an android resources/library/apk,
# the resources will be included with that target.
#
# Variables
# resources: The list of resources files to process.
# res_dir: The resource directory containing the resources.
# variables: (Optional) A list of variables to make available to the template
# processing environment, e.g. ["name=foo", "color=red"].
#
# Example
# jinja_template_resources("chrome_public_template_resources") {
# res_dir = "res_template"
# resources = ["res_template/xml/syncable.xml"]
# variables = ["color=red"]
# }
template("jinja_template_resources") {
set_sources_assignment_filter([])
forward_variables_from(invoker, [ "testonly" ])
assert(defined(invoker.resources))
assert(defined(invoker.res_dir))
_base_path = "$target_gen_dir/$target_name"
# JUnit tests use resource zip files. These must not be put in gen/
# directory or they will not be available to tester bots.
_resources_zip_rebased_path = rebase_path(target_gen_dir, root_gen_dir)
_resources_zip = "${root_out_dir}/resource_zips/${_resources_zip_rebased_path}/${target_name}.resources.zip"
_build_config = _base_path + ".build_config"
write_build_config("${target_name}__build_config") {
build_config = _build_config
resources_zip = _resources_zip
type = "android_resources"
if (defined(invoker.deps)) {
possible_config_deps = invoker.deps
}
}
action("${target_name}__template") {
forward_variables_from(invoker, [ "deps" ])
sources = invoker.resources
script = "//build/android/gyp/jinja_template.py"
depfile = "$target_gen_dir/$target_name.d"
outputs = [
_resources_zip,
]
rebased_resources = rebase_path(invoker.resources, root_build_dir)
args = [
"--inputs=${rebased_resources}",
"--inputs-base-dir",
rebase_path(invoker.res_dir, root_build_dir),
"--outputs-zip",
rebase_path(_resources_zip, root_build_dir),
"--depfile",
rebase_path(depfile, root_build_dir),
]
if (defined(invoker.variables)) {
variables = invoker.variables
args += [ "--variables=${variables}" ]
}
}
group(target_name) {
public_deps = [
":${target_name}__build_config",
":${target_name}__template",
]
}
}
# Declare an Android resources target
#
# This creates a resources zip file that will be used when building an Android
# library or apk and included into a final apk.
#
# To include these resources in a library/apk, this target should be listed in
# the library's deps. A library/apk will also include any resources used by its
# own dependencies.
#
# Variables
# deps: Specifies the dependencies of this target. Any Android resources
# listed in deps will be included by libraries/apks that depend on this
# target.
# resource_dirs: List of directories containing resources for this target.
# generated_resource_dirs: List of directories containing resources for this
# target which are *generated* by a dependency. |generated_resource_files|
# must be specified if |generated_resource_dirs| is specified.
# generated_resource_files: List of all files in |generated_resource_dirs|.
# |generated_resource_dirs| must be specified in |generated_resource_files|
# is specified.
# android_manifest: AndroidManifest.xml for this target. Defaults to
# //build/android/AndroidManifest.xml.
# android_manifest_dep: Target that generates AndroidManifest (if applicable)
# custom_package: java package for generated .java files.
# v14_skip: If true, don't run v14 resource generator on this. Defaults to
# false. (see build/android/gyp/generate_v14_compatible_resources.py)
# shared_resources: If true make a resource package that can be loaded by a
# different application at runtime to access the package's resources.
# app_as_shared_lib: If true make a resource package that can be loaded as
# both shared_resources and normal application.
# r_text_file: (optional) path to pre-generated R.txt to be used when
# generating R.java instead of resource-based aapt-generated one.
# create_srcjar: If false, does not create an R.java file. Needed only for
# prebuilts that have R.txt files that do not match their res/
# (Play Services).
#
# Example:
# android_resources("foo_resources") {
# deps = [":foo_strings_grd"]
# resource_dirs = ["res"]
# custom_package = "org.chromium.foo"
# }
#
# android_resources("foo_resources_overrides") {
# deps = [":foo_resources"]
# resource_dirs = ["res_overrides"]
# }
template("android_resources") {
forward_variables_from(invoker, [ "testonly" ])
_base_path = "$target_gen_dir/$target_name"
# JUnit tests use resource zip files. These must not be put in gen/
# directory or they will not be available to tester bots.
_resources_zip_rebased_path = rebase_path(target_gen_dir, root_gen_dir)
_zip_path = "${root_out_dir}/resource_zips/${_resources_zip_rebased_path}/${target_name}.resources.zip"
_r_text_out_path = _base_path + "_R.txt"
_build_config = _base_path + ".build_config"
_build_config_target_name = "${target_name}__build_config"
if (!defined(invoker.create_srcjar) || invoker.create_srcjar) {
_srcjar_path = _base_path + ".srcjar"
}
write_build_config(_build_config_target_name) {
type = "android_resources"
build_config = _build_config
resources_zip = _zip_path
resource_dirs = invoker.resource_dirs
if (defined(invoker.generated_resource_dirs)) {
resource_dirs += invoker.generated_resource_dirs
}
if (defined(_srcjar_path)) {
forward_variables_from(invoker,
[
"android_manifest",
"custom_package",
])
# No package means resources override their deps.
if (defined(custom_package) || defined(android_manifest)) {
r_text = _r_text_out_path
} else {
assert(defined(invoker.deps),
"Must specify deps when custom_package is omitted.")
}
srcjar = _srcjar_path
}
if (defined(invoker.deps)) {
possible_config_deps = invoker.deps
}
if (defined(invoker.android_manifest_dep)) {
deps = [
invoker.android_manifest_dep,
]
}
}
process_resources(target_name) {
forward_variables_from(invoker,
[
"app_as_shared_lib",
"android_manifest",
"custom_package",
"deps",
"generated_resource_dirs",
"generated_resource_files",
"resource_dirs",
"shared_resources",
"v14_skip",
])
if (!defined(deps)) {
deps = []
}
deps += [ ":$_build_config_target_name" ]
if (defined(invoker.android_manifest_dep)) {
deps += [ invoker.android_manifest_dep ]
}
build_config = _build_config
zip_path = _zip_path
r_text_out_path = _r_text_out_path
if (defined(invoker.r_text_file)) {
r_text_in_path = invoker.r_text_file
}
if (defined(_srcjar_path)) {
srcjar_path = _srcjar_path
}
# Always generate R.onResourcesLoaded() method, it is required for
# compiling ResourceRewriter, there is no side effect because the
# generated R.class isn't used in final apk.
shared_resources = true
if (!defined(android_manifest)) {
android_manifest = "//build/android/AndroidManifest.xml"
}
}
}
# Declare an Android assets target.
#
# Defines a set of files to include as assets in a dependent apk.
#
# To include these assets in an apk, this target should be listed in
# the apk's deps, or in the deps of a library target used by an apk.
#
# Variables
# deps: Specifies the dependencies of this target. Any Android assets
# listed in deps will be included by libraries/apks that depend on this
# target.
# sources: List of files to include as assets.
# renaming_sources: List of files to include as assets and be renamed.
# renaming_destinations: List of asset paths for files in renaming_sources.
# disable_compression: Whether to disable compression for files that are
# known to be compressable (default: false).
#
# Example:
# android_assets("content_shell_assets") {
# deps = [
# ":generates_foo",
# ":other_assets",
# ]
# sources = [
# "//path/asset1.png",
# "//path/asset2.png",
# "$target_gen_dir/foo.dat",
# ]
# }
#
# android_assets("overriding_content_shell_assets") {
# deps = [ ":content_shell_assets" ]
# # Override foo.dat from content_shell_assets.
# sources = [ "//custom/foo.dat" ]
# renaming_sources = [ "//path/asset2.png" ]
# renaming_destinations = [ "renamed/asset2.png" ]
# }
template("android_assets") {
set_sources_assignment_filter([])
forward_variables_from(invoker, [ "testonly" ])
_build_config = "$target_gen_dir/$target_name.build_config"
_build_config_target_name = "${target_name}__build_config"
write_build_config(_build_config_target_name) {
type = "android_assets"
build_config = _build_config
forward_variables_from(invoker, [ "disable_compression" ])
if (defined(invoker.deps)) {
possible_config_deps = invoker.deps
}
if (defined(invoker.sources)) {
asset_sources = invoker.sources
}
if (defined(invoker.renaming_sources)) {
assert(defined(invoker.renaming_destinations))
_source_count = 0
foreach(_, invoker.renaming_sources) {
_source_count += 1
}
_dest_count = 0
foreach(_, invoker.renaming_destinations) {
_dest_count += 1
}
assert(
_source_count == _dest_count,
"android_assets() renaming_sources.length != renaming_destinations.length")
asset_renaming_sources = invoker.renaming_sources
asset_renaming_destinations = invoker.renaming_destinations
}
}
group(target_name) {
forward_variables_from(invoker,
[
"deps",
"visibility",
])
public_deps = [
":$_build_config_target_name",
]
}
}
# Declare a group() that supports forwarding java dependency information.
#
# Example
# java_group("conditional_deps") {
# if (enable_foo) {
# deps = [":foo_java"]
# }
# }
template("java_group") {
forward_variables_from(invoker, [ "testonly" ])
write_build_config("${target_name}__build_config") {
type = "group"
build_config = "$target_gen_dir/${invoker.target_name}.build_config"
if (defined(invoker.deps)) {
possible_config_deps = invoker.deps
}
}
group(target_name) {
forward_variables_from(invoker, "*")
if (!defined(deps)) {
deps = []
}
deps += [ ":${target_name}__build_config" ]
}
}
# Declare a target that generates localized strings.xml from a .grd file.
#
# If this target is included in the deps of an android resources/library/apk,
# the strings.xml will be included with that target.
#
# Variables
# deps: Specifies the dependencies of this target.
# grd_file: Path to the .grd file to generate strings.xml from.
# outputs: Expected grit outputs (see grit rule).
#
# Example
# java_strings_grd("foo_strings_grd") {
# grd_file = "foo_strings.grd"
# }
template("java_strings_grd") {
set_sources_assignment_filter([])
forward_variables_from(invoker, [ "testonly" ])
base_path = "$target_gen_dir/$target_name"
# JUnit tests use resource zip files. These must not be put in gen/
# directory or they will not be available to tester bots.
_resources_zip_rebased_path = rebase_path(target_gen_dir, root_gen_dir)
resources_zip = "${root_out_dir}/resource_zips/${_resources_zip_rebased_path}/${target_name}.resources.zip"
build_config = base_path + ".build_config"
write_build_config("${target_name}__build_config") {
type = "android_resources"
}
# Put grit files into this subdirectory of target_gen_dir.
extra_output_path = target_name + "_grit_output"
grit_target_name = "${target_name}__grit"
grit_output_dir = "$target_gen_dir/$extra_output_path"
grit(grit_target_name) {
forward_variables_from(invoker, [ "deps" ])
grit_flags = [
"-E",
"ANDROID_JAVA_TAGGED_ONLY=false",
]
output_dir = grit_output_dir
resource_ids = ""
source = invoker.grd_file
outputs = invoker.outputs
}
# This needs to get outputs from grit's internal target, not the final
# source_set.
generate_strings_outputs = get_target_outputs(":${grit_target_name}_grit")
zip("${target_name}__zip") {
base_dir = grit_output_dir
inputs = generate_strings_outputs
output = resources_zip
deps = [
":$grit_target_name",
]
}
group(target_name) {
public_deps = [
":${target_name}__build_config",
":${target_name}__zip",
]
}
}
# Declare a target that packages strings.xml generated from a grd file.
#
# If this target is included in the deps of an android resources/library/apk,
# the strings.xml will be included with that target.
#
# Variables
# grit_output_dir: directory containing grit-generated files.
# generated_files: list of android resource files to package.
#
# Example
# java_strings_grd_prebuilt("foo_strings_grd") {
# grit_output_dir = "$root_gen_dir/foo/grit"
# generated_files = [
# "values/strings.xml"
# ]
# }
template("java_strings_grd_prebuilt") {
set_sources_assignment_filter([])
forward_variables_from(invoker, [ "testonly" ])
base_path = "$target_gen_dir/$target_name"
# JUnit tests use resource zip files. These must not be put in gen/
# directory or they will not be available to tester bots.
_resources_zip_rebased_path = rebase_path(target_gen_dir, root_gen_dir)
resources_zip = "${root_out_dir}/resource_zips/${_resources_zip_rebased_path}/${target_name}.resources.zip"
build_config = base_path + ".build_config"
build_config_target_name = "${target_name}__build_config"
zip_target_name = "${target_name}__zip"
final_target_name = target_name
write_build_config(build_config_target_name) {
type = "android_resources"
}
zip(zip_target_name) {
visibility = [ ":$final_target_name" ]
base_dir = invoker.grit_output_dir
inputs = rebase_path(invoker.generated_files, ".", base_dir)
output = resources_zip
deps = [
":$build_config_target_name",
]
if (defined(invoker.deps)) {
deps += invoker.deps
}
}
group(final_target_name) {
forward_variables_from(invoker, [ "visibility" ])
public_deps = [
":$zip_target_name",
]
}
}
# Declare a Java executable target
#
# This target creates an executable from java code and libraries. The executable
# will be in the output folder's /bin/ directory.
#
# Variables
# deps: Specifies the dependencies of this target. Java targets in this list
# will be included in the executable (and the javac classpath).
# java_files: List of .java files included in this library.
# srcjar_deps: List of srcjar dependencies. The .java files in the srcjars
# will be added to java_files and be included in this library.
# srcjars: List of srcjars to be included in this library, together with the
# ones obtained from srcjar_deps.
# bypass_platform_checks: Disables checks about cross-platform (Java/Android)
# dependencies for this target. This will allow depending on an
# android_library target, for example.
# chromium_code: If true, extra analysis warning/errors will be enabled.
# enable_errorprone: If true, enables the errorprone compiler.
# enable_incremental_javac_override: Overrides the
# global enable_incremental_javac.
# main_class: When specified, a wrapper script is created within
# $root_build_dir/bin to launch the binary with the given class as the
# entrypoint.
# wrapper_script_args: List of additional arguments for the wrapper script.
#
# data_deps, testonly
#
# Example
# java_binary("foo") {
# java_files = [ "org/chromium/foo/FooMain.java" ]
# deps = [ ":bar_java" ]
# main_class = "org.chromium.foo.FooMain"
# }
template("java_binary") {
set_sources_assignment_filter([])
java_library_impl(target_name) {
forward_variables_from(invoker, "*")
supports_android = false
main_class = invoker.main_class
is_java_binary = true
}
}
# Declare a Junit executable target
#
# This target creates an executable from java code for running as a junit test
# suite. The executable will be in the output folder's /bin/ directory.
#
# Variables
# deps: Specifies the dependencies of this target. Java targets in this list
# will be included in the executable (and the javac classpath).
#
# java_files: List of .java files included in this library.
# srcjar_deps: List of srcjar dependencies. The .java files in the srcjars
# will be added to java_files and be included in this library.
# srcjars: List of srcjars to be included in this library, together with the
# ones obtained from srcjar_deps.
#
# chromium_code: If true, extra analysis warning/errors will be enabled.
#
# Example
# junit_binary("foo") {
# java_files = [ "org/chromium/foo/FooTest.java" ]
# deps = [ ":bar_java" ]
# }
template("junit_binary") {
set_sources_assignment_filter([])
testonly = true
_java_binary_target_name = "${target_name}__java_binary"
_test_runner_target_name = "${target_name}__test_runner_script"
_build_config = "$target_gen_dir/$target_name.build_config"
_build_config_target_name = "${target_name}__build_config"
if (defined(invoker.deps)) {
# This dep is required if any deps require android (but it doesn't hurt
# to add it regardless) and is used by bytecode rewritten classes.
invoker.deps +=
[ "//build/android/buildhooks:build_hooks_android_impl_java" ]
}
write_build_config(_build_config_target_name) {
type = "junit_binary"
build_config = _build_config
if (defined(invoker.deps)) {
possible_config_deps = invoker.deps
}
}
test_runner_script(_test_runner_target_name) {
test_name = invoker.target_name
test_suite = invoker.target_name
test_type = "junit"
ignore_all_data_deps = true
forward_variables_from(invoker,
[
"android_manifest_path",
"package_name",
])
}
java_binary(_java_binary_target_name) {
deps = []
output_name = invoker.target_name
forward_variables_from(invoker, "*")
testonly = true
bypass_platform_checks = true
main_class = "org.chromium.testing.local.JunitTestMain"
wrapper_script_name = "helper/$target_name"
deps += [
"//testing/android/junit:junit_test_support",
"//third_party/junit",
"//third_party/mockito:mockito_java",
"//third_party/robolectric:robolectric_all_java",
]
}
group(target_name) {
public_deps = [
":$_build_config_target_name",
":$_java_binary_target_name",
":$_test_runner_target_name",
]
}
}
# Declare a java library target
#
# Variables
# deps: Specifies the dependencies of this target. Java targets in this list
# will be added to the javac classpath.
#
# java_files: List of .java files included in this library.
# srcjar_deps: List of srcjar dependencies. The .java files in the srcjars
# will be added to java_files and be included in this library.
# srcjars: List of srcjars to be included in this library, together with the
# ones obtained from srcjar_deps.
#
# input_jars_paths: A list of paths to the jars that should be included
# in the classpath. These are in addition to library .jars that
# appear in deps.
#
# chromium_code: If true, extra analysis warning/errors will be enabled.
# enable_errorprone: If true, enables the errorprone compiler.
# enable_incremental_javac_override: Overrides the global
# enable_incremental_javac.
#
# jar_excluded_patterns: List of patterns of .class files to exclude from the
# final jar.
#
# output_name: File name for the output .jar (not including extension).
# Defaults to the input .jar file name.
#
# proguard_configs: List of proguard configs to use in final apk step for
# any apk that depends on this library.
#
# supports_android: If true, Android targets (android_library, android_apk)
# may depend on this target. Note: if true, this target must only use the
# subset of Java available on Android.
# bypass_platform_checks: Disables checks about cross-platform (Java/Android)
# dependencies for this target. This will allow depending on an
# android_library target, for example.
#
# additional_jar_files: Use to package additional files into the output jar.
# Pass a list of length-2 lists with format
# [ [ path_to_file, path_to_put_in_jar ] ]
#
#
# data_deps, testonly
#
# Example
# java_library("foo_java") {
# java_files = [
# "org/chromium/foo/Foo.java",
# "org/chromium/foo/FooInterface.java",
# "org/chromium/foo/FooService.java",
# ]
# deps = [
# ":bar_java"
# ]
# srcjar_deps = [
# ":foo_generated_enum"
# ]
# jar_excluded_patterns = [
# "*/FooService.class", "*/FooService\$*.class"
# ]
# }
template("java_library") {
set_sources_assignment_filter([])
java_library_impl(target_name) {
forward_variables_from(invoker, "*")
}
}
# Declare a java library target for a prebuilt jar
#
# Variables
# deps: Specifies the dependencies of this target. Java targets in this list
# will be added to the javac classpath.
# jar_path: Path to the prebuilt jar.
# jar_dep: Target that builds jar_path (optional).
# main_class: When specified, a wrapper script is created within
# $root_build_dir/bin to launch the binary with the given class as the
# entrypoint.
# output_name: File name for the output .jar (not including extension).
# Defaults to the input .jar file name.
# proguard_configs: List of proguard configs to use in final apk step for
# any apk that depends on this library.
# supports_android: If true, Android targets (android_library, android_apk)
# may depend on this target. Note: if true, this target must only use the
# subset of Java available on Android.
#
# Example
# java_prebuilt("foo_java") {
# jar_path = "foo.jar"
# deps = [
# ":foo_resources",
# ":bar_java"
# ]
# }
template("java_prebuilt") {
set_sources_assignment_filter([])
java_prebuilt_impl(target_name) {
forward_variables_from(invoker, "*")
}
}
# Combines all dependent .jar files into a single .jar file.
#
# Variables:
# output: Path to the output jar.
# dex_path: Path to dex()'ed output (optional).
# override_build_config: Use a pre-existing .build_config. Must be of type
# "apk".
# use_interface_jars: Use all dependent interface .jars rather than
# implementation .jars.
# direct_deps_only: Do not recurse on deps.
# data, deps, testonly, visibility: Usual meaning.
# proguard_enabled: Whether to run ProGuard on resulting jar.
# proguard_configs: List of proguard configs.
# proguard_jar_path: The path to proguard.jar you wish to use. If undefined,
# the proguard used will be the checked in one in //third_party/proguard.
# alternative_android_sdk_jar: System jar to use when proguard is enabled.
#
# Example
# dist_jar("lib_fatjar") {
# deps = [ ":my_java_lib" ]
# output = "$root_build_dir/MyLibrary.jar"
# }
template("dist_jar") {
forward_variables_from(invoker, [ "testonly" ])
_supports_android =
!defined(invoker.supports_android) || invoker.supports_android
_requires_android =
defined(invoker.requires_android) && invoker.requires_android
_proguard_enabled =
defined(invoker.proguard_enabled) && invoker.proguard_enabled
_use_interface_jars =
defined(invoker.use_interface_jars) && invoker.use_interface_jars
_direct_deps_only =
defined(invoker.direct_deps_only) && invoker.direct_deps_only
assert(
!(_proguard_enabled && _use_interface_jars),
"Cannot set both proguard_enabled and use_interface_jars (target=$target_name)")
assert(
!(_proguard_enabled && _direct_deps_only),
"Cannot set both proguard_enabled and direct_deps_only (target=$target_name)")
_jar_target_name = target_name
if (defined(invoker.dex_path)) {
if (_proguard_enabled) {
_jar_target_name = "${target_name}__proguard"
} else {
_jar_target_name = "${target_name}__dist_jar"
}
}
_deps = []
if (defined(invoker.deps)) {
_deps = invoker.deps
}
_enable_build_hooks =
_supports_android &&
(!defined(invoker.no_build_hooks) || !invoker.no_build_hooks)
if (_enable_build_hooks && _requires_android) {
_deps += [ "//build/android/buildhooks:build_hooks_android_impl_java" ]
}
if (defined(invoker.override_build_config)) {
_build_config = invoker.override_build_config
} else {
_build_config = "$target_gen_dir/$target_name.build_config"
_build_config_target_name = "${target_name}__build_config"
write_build_config(_build_config_target_name) {
type = "dist_jar"
forward_variables_from(invoker,
[
"dex_path",
"proguard_enabled",
])
supports_android = _supports_android
requires_android = _requires_android
possible_config_deps = _deps
build_config = _build_config
if (_proguard_enabled) {
proguard_info = "${invoker.output}.info"
}
}
_deps += [ ":$_build_config_target_name" ]
}
_rebased_build_config = rebase_path(_build_config, root_build_dir)
if (_proguard_enabled) {
proguard(_jar_target_name) {
forward_variables_from(invoker,
[
"alternative_android_sdk_jar",
"data",
"proguard_jar_path",
])
deps = _deps
inputs = [
_build_config,
]
output_jar_path = invoker.output
args = [
"--proguard-configs=@FileArg($_rebased_build_config:proguard:lib_configs)",
"--input-paths=@FileArg($_rebased_build_config:proguard:input_paths)",
"--classpath=@FileArg($_rebased_build_config:proguard:lib_paths)",
]
if (defined(invoker.proguard_configs)) {
_rebased_proguard_configs =
rebase_path(invoker.proguard_configs, root_build_dir)
args += [ "--proguard-configs=$_rebased_proguard_configs" ]
}
if (defined(invoker.proguard_config_exclusions)) {
_rebased_proguard_config_exclusions =
rebase_path(invoker.proguard_config_exclusions, root_build_dir)
args += [ "--proguard-config-exclusions=$_rebased_proguard_config_exclusions" ]
}
}
} else {
action(_jar_target_name) {
forward_variables_from(invoker, [ "data" ])
script = "//build/android/gyp/create_dist_jar.py"
depfile = "$target_gen_dir/$target_name.d"
deps = _deps
inputs = [
_build_config,
]
outputs = [
invoker.output,
]
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--output",
rebase_path(invoker.output, root_build_dir),
]
if (_direct_deps_only) {
if (_use_interface_jars) {
args += [ "--inputs=@FileArg($_rebased_build_config:javac:interface_classpath)" ]
} else {
args +=
[ "--inputs=@FileArg($_rebased_build_config:javac:classpath)" ]
}
} else {
if (_use_interface_jars) {
args += [ "--inputs=@FileArg($_rebased_build_config:dist_jar:all_interface_jars)" ]
} else {
args += [ "--inputs=@FileArg($_rebased_build_config:dist_jar:dependency_jars)" ]
}
}
}
}
if (defined(invoker.dex_path)) {
dex(target_name) {
deps = [
":$_jar_target_name",
]
sources = [
invoker.output,
]
output = invoker.dex_path
}
}
}
# Declare an Android library target
#
# This target creates an Android library containing java code and Android
# resources.
#
# Variables
# deps: Specifies the dependencies of this target. Java targets in this list
# will be added to the javac classpath. Android resources in dependencies
# will be used when building this library.
#
# java_files: List of .java files included in this library.
# srcjar_deps: List of srcjar dependencies. The .java files in the srcjars
# will be added to java_files and be included in this library.
# srcjars: List of srcjars to be included in this library, together with the
# ones obtained from srcjar_deps.
#
# input_jars_paths: A list of paths to the jars that should be included
# in the classpath. These are in addition to library .jars that
# appear in deps.
#
# chromium_code: If true, extra analysis warning/errors will be enabled.
# enable_errorprone: If true, enables the errorprone compiler.
# enable_incremental_javac_override: Overrides the global
# enable_incremental_javac.
#
# jar_excluded_patterns: List of patterns of .class files to exclude from the
# final jar.
#
# proguard_configs: List of proguard configs to use in final apk step for
# any apk that depends on this library.
#
# output_name: File name for the output .jar (not including extension).
# Defaults to the input .jar file name.
# dex_path: If set, the resulting .dex.jar file will be placed under this
# path.
#
# alternative_android_sdk_ijar: if set, the given android_sdk_ijar file
# replaces the default android_sdk_ijar.
#
# alternative_android_sdk_ijar_dep: the target that generates
# alternative_android_sdk_ijar, must be set if alternative_android_sdk_ijar
# is used.
#
# alternative_android_sdk_jar: actual jar corresponding to
# alternative_android_sdk_ijar, must be set if alternative_android_sdk_ijar
# is used.
#
# emma_never_instrument: Disables EMMA Java code coverage for this target.
#
# Example
# android_library("foo_java") {
# java_files = [
# "android/org/chromium/foo/Foo.java",
# "android/org/chromium/foo/FooInterface.java",
# "android/org/chromium/foo/FooService.java",
# ]
# deps = [
# ":bar_java"
# ]
# srcjar_deps = [
# ":foo_generated_enum"
# ]
# jar_excluded_patterns = [
# "*/FooService.class", "*/FooService\$*.class"
# ]
# }
template("android_library") {
set_sources_assignment_filter([])
assert(!defined(invoker.jar_path),
"android_library does not support a custom jar path")
if (defined(invoker.alternative_android_sdk_ijar)) {
assert(defined(invoker.alternative_android_sdk_ijar_dep))
assert(defined(invoker.alternative_android_sdk_jar))
}
java_library_impl(target_name) {
forward_variables_from(invoker, "*")
supports_android = true
requires_android = true
if (!defined(jar_excluded_patterns)) {
jar_excluded_patterns = []
}
jar_excluded_patterns += [
"*/R.class",
"*/R\$*.class",
"*/Manifest.class",
"*/Manifest\$*.class",
]
}
}
# Declare a target that packages a set of Java dependencies into a standalone
# .dex.jar.
#
# Variables
# deps: specifies the dependencies of this target. Android libraries in deps
# will be packaged into the resulting .dex.jar file.
# dex_path: location at which the output file will be put
template("android_standalone_library") {
set_sources_assignment_filter([])
deps_dex(target_name) {
forward_variables_from(invoker,
[
"deps",
"dex_path",
"excluded_jars",
])
}
}
# Declare an Android library target for a prebuilt jar
#
# This target creates an Android library containing java code and Android
# resources.
#
# Variables
# deps: Specifies the dependencies of this target. Java targets in this list
# will be added to the javac classpath. Android resources in dependencies
# will be used when building this library.
# jar_path: Path to the prebuilt jar.
# output_name: File name for the output .jar (not including extension).
# Defaults to the input .jar file name.
# proguard_configs: List of proguard configs to use in final apk step for
# any apk that depends on this library.
#
# Example
# android_java_prebuilt("foo_java") {
# jar_path = "foo.jar"
# deps = [
# ":foo_resources",
# ":bar_java"
# ]
# }
template("android_java_prebuilt") {
set_sources_assignment_filter([])
java_prebuilt_impl(target_name) {
forward_variables_from(invoker, "*")
supports_android = true
requires_android = true
strip_resource_classes = true
}
}
# Declare an Android apk target
#
# This target creates an Android APK containing java code, resources, assets,
# and (possibly) native libraries.
#
# Variables
# alternative_android_sdk_jar: The alternative android sdk jar used in
# proguard.
# android_aapt_path: Android aapt tool to replace default one to build
# resource.
# android_manifest: Path to AndroidManifest.xml.
# android_manifest_dep: Target that generates AndroidManifest (if applicable)
# chromium_code: If true, extra analysis warning/errors will be enabled.
# png_to_webp: If true, pngs (with the exception of 9-patch) are
# converted to webp during resource packaging.
# dist_ijar_path: Path to create "${target_name}_dist_ijar" target
# (used by instrumentation_test_apk).
# data_deps: List of dependencies needed at runtime. These will be built but
# won't change the generated .apk in any way (in fact they may be built
# after the .apk is).
# deps: List of dependencies. All Android java resources and libraries in the
# "transitive closure" of these dependencies will be included in the apk.
# Note: this "transitive closure" actually only includes such targets if
# they are depended on through android_library or android_resources targets
# (and so not through builtin targets like 'action', 'group', etc).
# install_script_name: Name of wrapper script (default=target_name).
# java_files: List of .java files to include in the apk.
# srcjar_deps: List of srcjar dependencies. The .java files in the srcjars
# will be added to java_files and be included in this apk.
# apk_name: Name for final apk.
# final_apk_path: Path to final built apk. Default is
# $root_out_dir/apks/$apk_name.apk. Setting this will override apk_name.
# loadable_modules: List of paths to native libraries to include. Different
# from |shared_libraries| in that:
# * dependencies of this .so are not automatically included
# * ".cr.so" is never added
# * they are not side-loaded for _incremental targets.
# * load_library_from_apk, use_chromium_linker,
# and enable_relocation_packing do not apply
# Use this instead of shared_libraries when you are going to load the library
# conditionally, and only when shared_libraries doesn't work for you.
# shared_libraries: List shared_library targets to bundle. If these
# libraries depend on other shared_library targets, those dependencies will
# also be included in the apk (e.g. for is_component_build).
# secondary_abi_shared_libraries: secondary abi shared_library targets to
# bundle. If these libraries depend on other shared_library targets, those
# dependencies will also be included in the apk (e.g. for is_component_build).
# native_lib_placeholders: List of placeholder filenames to add to the apk
# (optional).
# apk_under_test: For an instrumentation test apk, this is the target of the
# tested apk.
# include_all_resources - If true include all resource IDs in all generated
# R.java files.
# testonly: Marks this target as "test-only".
# write_asset_list: Adds an extra file to the assets, which contains a list of
# all other asset files.
# generate_buildconfig_java: If defined and false, skip generating the
# BuildConfig java class describing the build configuration. The default
# is true for non-test APKs.
# requires_sdk_api_level_23: If defined and true, the apk is intended for
# installation only on Android M or later. In these releases the system
# linker does relocation unpacking, so we can enable it unconditionally.
# secondary_native_libs (deprecated): The path of native libraries for secondary
# app abi.
# run_findbugs_override: Forces run_findbugs on or off. If undefined, the
# default will use the build arg run_findbugs.
# proguard_jar_path: The path to proguard.jar you wish to use. If undefined,
# the proguard used will be the checked in one in //third_party/proguard.
# never_incremental: If true, |incremental_apk_by_default| will be ignored.
# aapt_locale_whitelist: If set, all locales not in this list will be
# stripped from resources.arsc.
# exclude_xxxhdpi: Causes all drawable-xxxhdpi images to be excluded
# (mipmaps are still included).
# xxxhdpi_whitelist: A list of globs used when exclude_xxxhdpi=true. Files
# that match this whitelist will still be included.
#
# Example
# android_apk("foo_apk") {
# android_manifest = "AndroidManifest.xml"
# java_files = [
# "android/org/chromium/foo/FooApplication.java",
# "android/org/chromium/foo/FooActivity.java",
# ]
# deps = [
# ":foo_support_java"
# ":foo_resources"
# ]
# srcjar_deps = [
# ":foo_generated_enum"
# ]
# shared_libraries = [
# ":my_shared_lib",
# ]
# }
template("android_apk") {
set_sources_assignment_filter([])
forward_variables_from(invoker, [ "testonly" ])
assert(defined(invoker.final_apk_path) || defined(invoker.apk_name))
assert(defined(invoker.android_manifest))
gen_dir = "$target_gen_dir/$target_name"
base_path = "$gen_dir/$target_name"
_build_config = "$target_gen_dir/$target_name.build_config"
# JUnit tests use resource zip files. These must not be put in gen/
# directory or they will not be available to tester bots.
_resources_zip_rebased_path = rebase_path(target_gen_dir, root_gen_dir)
resources_zip_path = "${root_out_dir}/resource_zips/${_resources_zip_rebased_path}/${target_name}.resources.zip"
_all_resources_zip_path = "$base_path.resources.all.zip"
_jar_path = "$base_path.jar"
_lib_dex_path = "$base_path.dex.jar"
_rebased_lib_dex_path = rebase_path(_lib_dex_path, root_build_dir)
_template_name = target_name
if (defined(invoker.java_files)) {
_java_sources_file = "$base_path.sources"
}
enable_multidex =
defined(invoker.enable_multidex) && invoker.enable_multidex
if (enable_multidex) {
final_dex_path = "$gen_dir/classes.dex.zip"
} else {
final_dex_path = "$gen_dir/classes.dex"
}
final_dex_target_name = "${_template_name}__final_dex"
if (defined(invoker.final_apk_path)) {
_final_apk_path = invoker.final_apk_path
} else {
_final_apk_path = "$root_build_dir/apks/${invoker.apk_name}.apk"
}
_final_apk_path_no_ext_list =
process_file_template([ _final_apk_path ],
"{{source_dir}}/{{source_name_part}}")
_final_apk_path_no_ext = _final_apk_path_no_ext_list[0]
assert(_final_apk_path_no_ext != "") # Mark as used.
_incremental_install_json_path =
"$target_gen_dir/$target_name.incremental.json"
_version_code = android_default_version_code
if (defined(invoker.version_code)) {
_version_code = invoker.version_code
}
_version_name = android_default_version_name
if (defined(invoker.version_name)) {
_version_name = invoker.version_name
}
_keystore_path = android_keystore_path
_keystore_name = android_keystore_name
_keystore_password = android_keystore_password
if (defined(invoker.keystore_path)) {
_keystore_path = invoker.keystore_path
_keystore_name = invoker.keystore_name
_keystore_password = invoker.keystore_password
}
_srcjar_deps = []
if (defined(invoker.srcjar_deps)) {
_srcjar_deps += invoker.srcjar_deps
}
_use_build_hooks =
!defined(invoker.no_build_hooks) || !invoker.no_build_hooks
if (defined(invoker.build_hooks_android_impl_deps)) {
assert(_use_build_hooks,
"Cannot set no_build_hooks and build_hooks_android_impl_deps at " +
"the same time")
_build_hooks_android_impl_deps = invoker.build_hooks_android_impl_deps
} else if (_use_build_hooks) {
_build_hooks_android_impl_deps =
[ "//build/android/buildhooks:build_hooks_android_impl_java" ]
} else {
_build_hooks_android_impl_deps = []
}
_use_chromium_linker =
defined(invoker.use_chromium_linker) && invoker.use_chromium_linker
_enable_relocation_packing = defined(invoker.enable_relocation_packing) &&
invoker.enable_relocation_packing
if (use_lld) {
# TODO(pcc): lld's output is currently incompatible with the relocation
# packer tool. We will probably want to implement relocation packing in
# lld itself eventually. http://crbug.com/760838.
_enable_relocation_packing = false
}
_load_library_from_apk =
defined(invoker.load_library_from_apk) && invoker.load_library_from_apk
_requires_sdk_api_level_23 = defined(invoker.requires_sdk_api_level_23) &&
invoker.requires_sdk_api_level_23
assert(_use_chromium_linker || true) # Mark as used.
assert(_requires_sdk_api_level_23 || true)
if (_enable_relocation_packing) {
assert(_use_chromium_linker || _requires_sdk_api_level_23,
"enable_relocation_packing requires either use_chromium_linker " +
"or requires_sdk_api_level_23")
}
if (_load_library_from_apk) {
assert(_use_chromium_linker || _requires_sdk_api_level_23,
"load_library_from_apk requires use_chromium_linker " +
"or requires_sdk_api_level_23")
}
# The dependency that makes the chromium linker, if any is needed.
_native_libs_deps = []
_shared_libraries_is_valid =
defined(invoker.shared_libraries) && invoker.shared_libraries != []
_secondary_abi_native_libs_deps = []
assert(_secondary_abi_native_libs_deps == []) # mark as used.
_secondary_abi_shared_libraries_is_valid =
defined(invoker.secondary_abi_shared_libraries) &&
invoker.secondary_abi_shared_libraries != []
if (is_component_build || is_asan) {
if (_shared_libraries_is_valid) {
_native_libs_deps += [ "//build/android:cpplib_stripped" ]
}
if (_secondary_abi_shared_libraries_is_valid) {
_secondary_abi_native_libs_deps += [ "//build/android:cpplib_stripped($android_secondary_abi_toolchain)" ]
}
}
if (_shared_libraries_is_valid) {
_native_libs_deps += invoker.shared_libraries
# To determine the filenames of all dependent shared libraries, write the
# runtime deps of |shared_libraries| to a file during "gn gen".
# write_build_config.py will then grep this file for *.so to obtain the
# complete list.
_runtime_deps_file =
"$target_gen_dir/${_template_name}.native.runtimedeps"
group("${_template_name}__runtime_deps") {
deps = _native_libs_deps
write_runtime_deps = _runtime_deps_file
}
_native_lib_version_rule = ""
if (defined(invoker.native_lib_version_rule)) {
_native_lib_version_rule = invoker.native_lib_version_rule
}
_native_lib_version_arg = "\"\""
if (defined(invoker.native_lib_version_arg)) {
_native_lib_version_arg = invoker.native_lib_version_arg
}
} else {
# Must exist for instrumentation_test_apk() to depend on.
group("${_template_name}__runtime_deps") {
}
}
if (_secondary_abi_shared_libraries_is_valid) {
_secondary_abi_native_libs_deps += invoker.secondary_abi_shared_libraries
# To determine the filenames of all dependent shared libraries, write the
# runtime deps of |shared_libraries| to a file during "gn gen".
# write_build_config.py will then grep this file for *.so to obtain the
# complete list.
_secondary_abi_runtime_deps_file =
"$target_gen_dir/${_template_name}.secondary.abi.native.runtimedeps"
group("${_template_name}__secondary_abi__runtime_deps") {
deps = _secondary_abi_native_libs_deps
write_runtime_deps = _secondary_abi_runtime_deps_file
}
} else {
# Must exist for instrumentation_test_apk() to depend on.
group("${_template_name}__secondary_abi_runtime_deps") {
}
}
if (defined(invoker.deps)) {
set_sources_assignment_filter([ "*manifest*" ])
sources = invoker.deps
set_sources_assignment_filter([])
if (sources != invoker.deps) {
_bad_deps = invoker.deps - sources
assert(
false,
"Possible manifest-generating dep found in deps. Use android_manifest_dep for this instead. Found: $_bad_deps")
}
sources = []
}
_android_root_manifest_deps = []
if (defined(invoker.android_manifest_dep)) {
_android_root_manifest_deps = [ invoker.android_manifest_dep ]
}
_android_root_manifest = invoker.android_manifest
_rebased_build_config = rebase_path(_build_config, root_build_dir)
_create_abi_split =
defined(invoker.create_abi_split) && invoker.create_abi_split
_create_density_splits =
defined(invoker.create_density_splits) && invoker.create_density_splits
_create_language_splits =
defined(invoker.language_splits) && invoker.language_splits != []
_generate_buildconfig_java = !defined(invoker.apk_under_test)
if (defined(invoker.generate_buildconfig_java)) {
_generate_buildconfig_java = invoker.generate_buildconfig_java
}
# Help GN understand that _create_abi_split is not unused (bug in GN).
assert(_create_abi_split || true)
_proguard_enabled =
defined(invoker.proguard_enabled) && invoker.proguard_enabled
if (_proguard_enabled) {
_proguard_output_jar_path = "$base_path.proguard.jar"
}
_emma_never_instrument = defined(invoker.testonly) && invoker.testonly
_incremental_allowed =
!(defined(invoker.never_incremental) && invoker.never_incremental)
build_config_target = "${_template_name}__build_config"
write_build_config(build_config_target) {
forward_variables_from(invoker, [ "apk_under_test" ])
type = "android_apk"
jar_path = _jar_path
dex_path = final_dex_path
apk_path = _final_apk_path
incremental_allowed = _incremental_allowed
incremental_apk_path = "${_final_apk_path_no_ext}_incremental.apk"
incremental_install_json_path = _incremental_install_json_path
resources_zip = resources_zip_path
build_config = _build_config
android_manifest = _android_root_manifest
if (defined(_java_sources_file)) {
java_sources_file = _java_sources_file
}
deps = _android_root_manifest_deps
possible_config_deps = _build_hooks_android_impl_deps
if (defined(invoker.deps)) {
possible_config_deps += invoker.deps
}
# Added emma to the target's classpath via its .build_config.
if (emma_coverage && !_emma_never_instrument) {
possible_config_deps +=
[ "//third_party/android_tools:emma_device_java" ]
}
proguard_enabled = _proguard_enabled
if (_proguard_enabled) {
proguard_info = "$_proguard_output_jar_path.info"
}
if (_enable_relocation_packing) {
enable_relocation_packing = "1"
} else {
enable_relocation_packing = "0"
}
# Don't depend on the runtime_deps target in order to avoid having to
# build the native libraries just to create the .build_config file.
# The dep is unnecessary since the runtime_deps file is created by gn gen
# and the runtime_deps file is added to write_build_config.py's depfile.
if (_native_libs_deps != []) {
shared_libraries_runtime_deps_file = _runtime_deps_file
}
if (_secondary_abi_native_libs_deps != []) {
secondary_abi_shared_libraries_runtime_deps_file =
_secondary_abi_runtime_deps_file
}
}
_android_manifest =
"$target_gen_dir/${_template_name}_manifest/AndroidManifest.xml"
android_manifest_target = "${_template_name}__merge_manifests"
action(android_manifest_target) {
script = "//build/android/gyp/merge_manifest.py"
depfile = "$target_gen_dir/$target_name.d"
sources = [
_android_root_manifest,
]
outputs = [
_android_manifest,
]
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--build-vars",
rebase_path(android_build_vars, root_build_dir),
"--root-manifest",
rebase_path(_android_root_manifest, root_build_dir),
"--output",
rebase_path(_android_manifest, root_build_dir),
"--extras",
"@FileArg($_rebased_build_config:extra_android_manifests)",
]
deps = _android_root_manifest_deps + [ ":$build_config_target" ]
}
_final_deps = []
if (enable_multidex) {
_generated_proguard_main_dex_config =
"$base_path.resources.main-dex-proguard.txt"
}
_generated_proguard_config = "$base_path.resources.proguard.txt"
process_resources_target = "${_template_name}__process_resources"
process_resources(process_resources_target) {
forward_variables_from(invoker,
[
"alternative_android_sdk_jar",
"android_aapt_path",
"app_as_shared_lib",
"include_all_resources",
"shared_resources",
])
srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
r_text_out_path = "${target_gen_dir}/${target_name}_R.txt"
android_manifest = _android_manifest
resource_dirs = [ "//build/android/ant/empty/res" ]
zip_path = resources_zip_path
all_resources_zip_path = _all_resources_zip_path
generate_constant_ids = true
proguard_file = _generated_proguard_config
if (enable_multidex) {
proguard_file_main_dex = _generated_proguard_main_dex_config
}
build_config = _build_config
deps = [
":$android_manifest_target",
":$build_config_target",
]
if (defined(invoker.deps)) {
deps += invoker.deps
}
}
_srcjar_deps += [ ":$process_resources_target" ]
if (_native_libs_deps != []) {
_enable_chromium_linker_tests = false
if (defined(invoker.enable_chromium_linker_tests)) {
_enable_chromium_linker_tests = invoker.enable_chromium_linker_tests
}
_ordered_libraries_json =
"$target_gen_dir/$target_name.ordered_libararies.json"
_rebased_ordered_libraries_json =
rebase_path(_ordered_libraries_json, root_build_dir)
_ordered_libraries_target = "${_template_name}__write_ordered_libraries"
# TODO(agrieve): Make GN write runtime deps in dependency order so as to
# not need this manual sorting step.
action(_ordered_libraries_target) {
script = "//build/android/gyp/write_ordered_libraries.py"
deps = _native_libs_deps + [ ":$build_config_target" ]
outputs = [
_ordered_libraries_json,
]
_rebased_android_readelf = rebase_path(android_readelf, root_build_dir)
args = [
"--readelf=$_rebased_android_readelf",
"--output=$_rebased_ordered_libraries_json",
"--libraries-dir=.",
"--input-libraries=@FileArg($_rebased_build_config:native:libraries)",
]
}
java_cpp_template("${_template_name}__native_libraries_java") {
package_path = "org/chromium/base/library_loader"
sources = [
"//base/android/java/templates/NativeLibraries.template",
]
inputs = [
_ordered_libraries_json,
]
deps = [
":${_ordered_libraries_target}",
]
if (_native_lib_version_rule != "") {
deps += [ _native_lib_version_rule ]
}
defines = [
"NATIVE_LIBRARIES_LIST=" +
"@FileArg($_rebased_ordered_libraries_json:java_libraries_list)",
"NATIVE_LIBRARIES_VERSION_NUMBER=$_native_lib_version_arg",
]
if (_use_chromium_linker) {
defines += [ "ENABLE_CHROMIUM_LINKER" ]
}
if (_load_library_from_apk) {
defines += [ "ENABLE_CHROMIUM_LINKER_LIBRARY_IN_ZIP_FILE" ]
}
if (_enable_chromium_linker_tests) {
defines += [ "ENABLE_CHROMIUM_LINKER_TESTS" ]
}
}
_srcjar_deps += [ ":${_template_name}__native_libraries_java" ]
}
if (_generate_buildconfig_java) {
java_cpp_template("${_template_name}__build_config_java") {
package_path = "org/chromium/base"
sources = [
"//base/android/java/templates/BuildConfig.template",
]
deps = [
":$build_config_target",
]
defines = []
if (enable_multidex) {
defines += [ "ENABLE_MULTIDEX" ]
}
if (is_java_debug || dcheck_always_on) {
defines += [ "_DCHECK_IS_ON" ]
}
defines += [
"COMPRESSED_LOCALE_LIST=" +
"@FileArg($_rebased_build_config:compressed_locales_java_list)",
"UNCOMPRESSED_LOCALE_LIST=" +
"@FileArg($_rebased_build_config:uncompressed_locales_java_list)",
]
}
_srcjar_deps += [ ":${_template_name}__build_config_java" ]
}
java_target = "${_template_name}__java"
java_library_impl(java_target) {
forward_variables_from(invoker,
[
"chromium_code",
"java_files",
"run_findbugs_override",
"no_build_hooks",
])
supports_android = true
requires_android = true
override_build_config = _build_config
deps = [
":$android_manifest_target",
":$build_config_target",
] + _build_hooks_android_impl_deps
android_manifest = _android_manifest
srcjar_deps = _srcjar_deps
jar_path = _jar_path
dex_path = _lib_dex_path
emma_never_instrument = _emma_never_instrument
if (defined(_java_sources_file)) {
java_sources_file = _java_sources_file
}
if (defined(invoker.deps)) {
deps += invoker.deps
}
if (defined(invoker.apk_under_test)) {
deps += [ "${invoker.apk_under_test}__java" ]
}
if (emma_coverage && !_emma_never_instrument) {
deps += [ "//third_party/android_tools:emma_device_java" ]
}
}
# TODO(cjhopman): This is only ever needed to calculate the list of tests to
# run. See build/android/pylib/instrumentation/test_jar.py. We should be
# able to just do that calculation at build time instead.
if (defined(invoker.dist_ijar_path)) {
_dist_ijar_path = invoker.dist_ijar_path
dist_jar("${_template_name}_dist_ijar") {
override_build_config = _build_config
output = _dist_ijar_path
data = [
_dist_ijar_path,
]
use_interface_jars = true
deps = [
":$build_config_target",
":$java_target",
]
}
}
if (_proguard_enabled) {
_proguard_configs = [ _generated_proguard_config ]
if (defined(invoker.proguard_configs)) {
_proguard_configs += invoker.proguard_configs
}
if (enable_multidex) {
_proguard_configs += [ "//build/android/multidex.flags" ]
}
assert(_proguard_configs != []) # Mark as used.
_proguard_target = "${_template_name}__proguard"
proguard(_proguard_target) {
forward_variables_from(invoker,
[
"alternative_android_sdk_jar",
"deps",
"proguard_jar_path",
])
if (!defined(deps)) {
deps = []
}
deps += [
":$build_config_target",
":$java_target",
":$process_resources_target",
]
inputs = [
_build_config,
_jar_path,
] + _proguard_configs
output_jar_path = _proguard_output_jar_path
_rebased_proguard_configs =
rebase_path(_proguard_configs, root_build_dir)
args = [
"--proguard-configs=$_rebased_proguard_configs",
"--proguard-configs=@FileArg($_rebased_build_config:proguard:lib_configs)",
"--input-paths=@FileArg($_rebased_build_config:proguard:input_paths)",
"--classpath=@FileArg($_rebased_build_config:proguard:lib_paths)",
]
if (defined(invoker.proguard_config_exclusions)) {
_rebased_proguard_config_exclusions =
rebase_path(invoker.proguard_config_exclusions, root_build_dir)
args += [ "--proguard-config-exclusions=$_rebased_proguard_config_exclusions" ]
}
if (defined(invoker.apk_under_test)) {
deps += [
"${invoker.apk_under_test}__build_config",
"${invoker.apk_under_test}__proguard",
]
_apk_under_test_build_config =
get_label_info(invoker.apk_under_test, "target_gen_dir") + "/" +
get_label_info(invoker.apk_under_test, "name") + ".build_config"
_rebased_apk_under_test_build_config =
rebase_path(_apk_under_test_build_config, root_build_dir)
args += [ "--tested-apk-info=@FileArg($_rebased_apk_under_test_build_config:deps_info:proguard_info)" ]
}
}
_dex_sources = [ _proguard_output_jar_path ]
_dex_deps = [ ":$_proguard_target" ]
_copy_proguard_mapping_target = "${_template_name}__copy_proguard_mapping"
copy(_copy_proguard_mapping_target) {
sources = [
"$_proguard_output_jar_path.mapping",
]
outputs = [
"$_final_apk_path.mapping",
]
deps = [
":$_proguard_target",
]
}
} else {
if (enable_multidex) {
_dex_sources = [ _jar_path ]
} else {
_dex_sources = [ _lib_dex_path ]
}
_dex_deps = [ ":$java_target" ]
}
dex("$final_dex_target_name") {
deps = _dex_deps + [ ":$build_config_target" ]
inputs = [
_build_config,
]
sources = _dex_sources
output = final_dex_path
# All deps are already included in _dex_sources when proguard is used.
if (!_proguard_enabled) {
if (enable_multidex) {
_dex_arg_key = "${_rebased_build_config}:dist_jar:dependency_jars"
extra_main_dex_proguard_config = _generated_proguard_main_dex_config
deps += [ ":$process_resources_target" ]
} else {
_dex_arg_key =
"${_rebased_build_config}:final_dex:dependency_dex_files"
}
args = [ "--inputs=@FileArg($_dex_arg_key)" ]
}
# http://crbug.com/725224. Fix for bots running out of memory.
use_pool = true
}
_native_libs_file_arg_dep = ":$build_config_target"
_native_libs_file_arg = "@FileArg($_rebased_build_config:native:libraries)"
_secondary_abi_native_libs_file_arg_dep = ":$build_config_target"
_secondary_abi_native_libs_file_arg =
"@FileArg($_rebased_build_config:native:secondary_abi_libraries)"
assert(_secondary_abi_native_libs_file_arg != "" &&
_secondary_abi_native_libs_file_arg_dep != "") # Mark as used.
if (_native_libs_deps != [] && _enable_relocation_packing) {
_prepare_native_target_name = "${_template_name}__prepare_native"
_native_libs_json = "$gen_dir/packed-libs/filelist.json"
_rebased_native_libs_json = rebase_path(_native_libs_json, root_build_dir)
_native_libs_file_arg_dep = ":$_prepare_native_target_name"
_native_libs_file_arg = "@FileArg($_rebased_native_libs_json:files)"
pack_relocation_section(_prepare_native_target_name) {
forward_variables_from(invoker,
[
"deps",
"public_deps",
])
file_list_json = _native_libs_json
libraries_filearg =
"@FileArg(${_rebased_build_config}:native:libraries)"
inputs = [
_build_config,
]
deps += _native_libs_deps
deps += [ ":$build_config_target" ]
}
if (_secondary_abi_native_libs_deps != []) {
_prepare_native_target_name =
"${_template_name}_secondary_abi__prepare_native"
_native_libs_json =
"$gen_dir/packed-libs/$android_secondary_abi_cpu/filelist.json"
_rebased_native_libs_json =
rebase_path(_native_libs_json, root_build_dir)
_secondary_abi_native_libs_file_arg_dep =
":$_prepare_native_target_name"
_secondary_abi_native_libs_file_arg =
"@FileArg($_rebased_native_libs_json:files)"
pack_relocation_section(_prepare_native_target_name) {
forward_variables_from(invoker,
[
"deps",
"public_deps",
])
file_list_json = _native_libs_json
libraries_filearg = "@FileArg(${_rebased_build_config}:native:secondary_abi_libraries)"
inputs = [
_build_config,
]
deps += _secondary_abi_native_libs_deps
deps += [ ":$build_config_target" ]
}
}
}
_extra_native_libs = []
_extra_native_libs_deps = []
assert(_extra_native_libs_deps == []) # Mark as used.
_extra_native_libs_even_when_incremental = []
if (_native_libs_deps != []) {
if (_use_chromium_linker) {
_extra_native_libs =
[ "$root_shlib_dir/libchromium_android_linker$shlib_extension" ]
_extra_native_libs_deps +=
[ "//base/android/linker:chromium_android_linker" ]
}
_create_stack_script_rule_name = "${_template_name}__stack_script"
_final_deps += [ ":${_create_stack_script_rule_name}" ]
stack_script(_create_stack_script_rule_name) {
stack_target_name = invoker.target_name
deps = _native_libs_deps
if (_native_libs_deps != [] && _enable_relocation_packing) {
packed_libraries = _native_libs_file_arg
deps += [ _native_libs_file_arg_dep ]
}
}
}
if (defined(invoker.loadable_modules) && invoker.loadable_modules != []) {
_extra_native_libs_even_when_incremental += invoker.loadable_modules
}
_final_deps += [ ":${_template_name}__create" ]
create_apk("${_template_name}__create") {
forward_variables_from(invoker,
[
"aapt_locale_whitelist",
"alternative_android_sdk_jar",
"android_aapt_path",
"app_as_shared_lib",
"deps",
"exclude_xxxhdpi",
"extensions_to_not_compress",
"language_splits",
"png_to_webp",
"post_process_package_resources_script",
"public_deps",
"secondary_native_libs",
"shared_resources",
"uncompress_shared_libraries",
"write_asset_list",
"xxxhdpi_whitelist",
])
if (!defined(deps)) {
deps = []
}
apk_path = _final_apk_path
android_manifest = _android_manifest
assets_build_config = _build_config
resources_zip = _all_resources_zip_path
dex_path = final_dex_path
load_library_from_apk = _load_library_from_apk
create_density_splits = _create_density_splits
if (!defined(extensions_to_not_compress)) {
# Allow icu data, v8 snapshots, and pak files to be loaded directly from
# the .apk.
# Note: These are actually suffix matches, not necessarily extensions.
extensions_to_not_compress = ".dat,.bin,.pak"
}
version_code = _version_code
version_name = _version_name
keystore_name = _keystore_name
keystore_path = _keystore_path
keystore_password = _keystore_password
# Incremental apk does not use native libs nor final dex.
incremental_deps = deps + [
":$android_manifest_target",
":$build_config_target",
":$process_resources_target",
]
# This target generates the input file _all_resources_zip_path.
deps += [
":$android_manifest_target",
":$build_config_target",
":$final_dex_target_name",
":$process_resources_target",
]
if ((_native_libs_deps != [] ||
_extra_native_libs_even_when_incremental != []) &&
!_create_abi_split) {
deps += _native_libs_deps + _extra_native_libs_deps +
[ _native_libs_file_arg_dep ]
native_libs_filearg = _native_libs_file_arg
native_libs = _extra_native_libs
native_libs_even_when_incremental =
_extra_native_libs_even_when_incremental
}
if (_secondary_abi_native_libs_deps != [] && !_create_abi_split) {
deps += _secondary_abi_native_libs_deps +
[ _secondary_abi_native_libs_file_arg_dep ]
secondary_abi_native_libs_filearg = _secondary_abi_native_libs_file_arg
}
# Placeholders necessary for some older devices.
# http://crbug.com/395038
forward_variables_from(invoker, [ "native_lib_placeholders" ])
}
if ((_native_libs_deps != [] ||
_extra_native_libs_even_when_incremental != []) && _create_abi_split) {
_manifest_rule =
"${_template_name}__split_manifest_abi_${android_app_abi}"
generate_split_manifest(_manifest_rule) {
main_manifest = _android_manifest
out_manifest =
"$gen_dir/split-manifests/${android_app_abi}/AndroidManifest.xml"
split_name = "abi_${android_app_abi}"
deps = [
":$android_manifest_target",
]
}
_apk_rule = "${_template_name}__split_apk_abi_${android_app_abi}"
_final_deps += [ ":$_apk_rule" ]
create_apk(_apk_rule) {
apk_path = "${_final_apk_path_no_ext}-abi-${android_app_abi}.apk"
base_path = "$gen_dir/$_apk_rule"
manifest_outputs = get_target_outputs(":${_manifest_rule}")
android_manifest = manifest_outputs[1]
load_library_from_apk = _load_library_from_apk
version_code = _version_code
version_name = _version_name
keystore_name = _keystore_name
keystore_path = _keystore_path
keystore_password = _keystore_password
# Placeholders necessary for some older devices.
# http://crbug.com/395038
deps = []
forward_variables_from(invoker,
[
"alternative_android_sdk_jar",
"android_aapt_path",
"deps",
"native_lib_placeholders",
"public_deps",
])
incremental_deps = deps + [ ":$_manifest_rule" ]
deps = []
deps = incremental_deps + _native_libs_deps + _extra_native_libs_deps +
[ _native_libs_file_arg_dep ]
native_libs_filearg = _native_libs_file_arg
native_libs = _extra_native_libs
native_libs_even_when_incremental =
_extra_native_libs_even_when_incremental
}
}
_write_installer_json_rule_name = "${_template_name}__incremental_json"
action(_write_installer_json_rule_name) {
script = "//build/android/incremental_install/write_installer_json.py"
depfile = "$target_gen_dir/$target_name.d"
deps = [
_native_libs_file_arg_dep,
]
outputs = [
_incremental_install_json_path,
]
_rebased_apk_path_no_ext =
rebase_path(_final_apk_path_no_ext, root_build_dir)
_rebased_incremental_install_json_path =
rebase_path(_incremental_install_json_path, root_build_dir)
_rebased_depfile = rebase_path(depfile, root_build_dir)
_dex_arg_key = "${_rebased_build_config}:final_dex:dependency_dex_files"
args = [
"--apk-path=${_rebased_apk_path_no_ext}_incremental.apk",
"--output-path=$_rebased_incremental_install_json_path",
"--dex-file=$_rebased_lib_dex_path",
"--dex-file-list=@FileArg($_dex_arg_key)",
"--depfile=$_rebased_depfile",
]
if (_proguard_enabled) {
args += [ "--show-proguard-warning" ]
}
if (defined(_native_libs_file_arg)) {
args += [ "--native-libs=$_native_libs_file_arg" ]
}
if (_extra_native_libs != []) {
# Don't pass in _extra_native_libs_even_when_incremental, since these are
# end up in the apk and are not side-loaded.
_rebased_extra_native_libs =
rebase_path(_extra_native_libs, root_build_dir)
args += [ "--native-libs=$_rebased_extra_native_libs" ]
}
if (_create_density_splits) {
args += [ "--split=${_rebased_apk_path_no_ext}-density-*.apk" ]
}
if (_create_language_splits) {
args += [ "--split=${_rebased_apk_path_no_ext}-language-*.apk" ]
}
if (_load_library_from_apk) {
args += [ "--dont-even-try=Incremental builds do not work with load_library_from_apk. Try setting is_component_build=true in your GN args." ]
}
}
_apk_operations = []
_incremental_apk_operations = []
# Generate apk opeartion related script.
if (!defined(invoker.create_apk_script) || invoker.create_apk_script) {
_apk_operations_target_name = "${target_name}__apk_operations"
action(_apk_operations_target_name) {
_generated_script = "$root_build_dir/bin/${invoker.target_name}"
script = "//build/android/gyp/create_apk_operations_script.py"
outputs = [
_generated_script,
]
if (_proguard_enabled) {
# Required by logcat command.
data_deps = [
"//build/android/stacktrace:java_deobfuscate",
]
}
args = [
"--script-output-path",
rebase_path(_generated_script, root_build_dir),
"--apk-path",
rebase_path(_final_apk_path, root_build_dir),
"--target-cpu=$target_cpu",
]
if (defined(invoker.command_line_flags_file)) {
args += [
"--command-line-flags-file",
invoker.command_line_flags_file,
]
}
if (_incremental_allowed) {
args += [
"--incremental-install-json-path",
rebase_path(_incremental_install_json_path, root_build_dir),
]
}
if (_proguard_enabled) {
args += [
"--proguard-mapping-path",
rebase_path("$_final_apk_path.mapping", root_build_dir),
]
}
}
_apk_operations += [ ":$_apk_operations_target_name" ]
_incremental_apk_operations += [ ":$_apk_operations_target_name" ]
}
group(target_name) {
if (_incremental_allowed && incremental_apk_by_default) {
deps = [
":${target_name}_incremental",
]
assert(_apk_operations != [] || true) # Prevent "unused variable".
} else {
forward_variables_from(invoker,
[
"data",
"data_deps",
])
public_deps = _final_deps
# Generate apk related operations at runtime.
public_deps += _apk_operations
# Make the proguard .mapping file easy to find by putting it beside the .apk.
if (_proguard_enabled) {
deps = [
":$_copy_proguard_mapping_target",
]
}
}
}
if (_incremental_allowed) {
group("${target_name}_incremental") {
forward_variables_from(invoker,
[
"data",
"data_deps",
])
if (!defined(data_deps)) {
data_deps = []
}
# device/commands is used by the installer script to push files via .zip.
data_deps += [ "//build/android/pylib/device/commands" ] +
_native_libs_deps + _extra_native_libs_deps
# Since the _incremental.apk does not include use .so nor .dex from the
# actual target, but instead loads them at runtime, we need to explicitly
# depend on them here.
public_deps = [
":${_template_name}__create_incremental",
":${_write_installer_json_rule_name}",
":${java_target}",
]
# Generate incremental apk related operations at runtime.
public_deps += _incremental_apk_operations
}
}
}
# Declare an Android instrumentation test apk
#
# This target creates an Android instrumentation test apk.
#
# Variables
# android_manifest: Path to AndroidManifest.xml.
# data_deps: List of dependencies needed at runtime. These will be built but
# won't change the generated .apk in any way (in fact they may be built
# after the .apk is).
# deps: List of dependencies. All Android java resources and libraries in the
# "transitive closure" of these dependencies will be included in the apk.
# Note: this "transitive closure" actually only includes such targets if
# they are depended on through android_library or android_resources targets
# (and so not through builtin targets like 'action', 'group', etc).
# java_files: List of .java files to include in the apk.
# srcjar_deps: List of srcjar dependencies. The .java files in the srcjars
# will be added to java_files and be included in this apk.
# apk_name: Name for final apk.
# final_apk_path: Path to final built apk. Default is
# $root_out_dir/apks/$apk_name.apk. Setting this will override apk_name.
# shared_libraries: List shared_library targets to bundle. If these
# libraries depend on other shared_library targets, those dependencies will
# also be included in the apk (e.g. for is_component_build).
# apk_under_test: The apk being tested.
#
# Example
# instrumentation_test_apk("foo_test_apk") {
# android_manifest = "AndroidManifest.xml"
# apk_name = "FooTest"
# apk_under_test = "Foo"
# java_files = [
# "android/org/chromium/foo/FooTestCase.java",
# "android/org/chromium/foo/FooExampleTest.java",
# ]
# deps = [
# ":foo_test_support_java"
# ]
# }
template("instrumentation_test_apk") {
assert(defined(invoker.apk_name))
testonly = true
_apk_target_name = "${target_name}__apk"
_test_runner_target_name = "${target_name}__test_runner_script"
_dist_ijar_path =
"$root_build_dir/test.lib.java/" + invoker.apk_name + ".jar"
_incremental_test_runner_target_name =
"${_test_runner_target_name}_incremental"
_incremental_test_name = "${invoker.target_name}_incremental"
if (incremental_apk_by_default) {
_incremental_test_runner_target_name = _test_runner_target_name
_incremental_test_name = invoker.target_name
}
if (!incremental_apk_by_default) {
test_runner_script(_test_runner_target_name) {
forward_variables_from(invoker,
[
"additional_apks",
"apk_under_test",
"data",
"data_deps",
"deps",
"ignore_all_data_deps",
"proguard_enabled",
"public_deps",
])
test_name = invoker.target_name
test_type = "instrumentation"
apk_target = ":$_apk_target_name"
test_jar = _dist_ijar_path
}
}
test_runner_script(_incremental_test_runner_target_name) {
forward_variables_from(invoker,
[
"additional_apks",
"apk_under_test",
"data",
"data_deps",
"deps",
"ignore_all_data_deps",
"public_deps",
])
test_name = _incremental_test_name
test_type = "instrumentation"
apk_target = ":$_apk_target_name"
test_jar = _dist_ijar_path
incremental_install = true
}
android_apk(_apk_target_name) {
deps = []
data_deps = []
forward_variables_from(invoker, "*")
deps += [ "//testing/android/broker:broker_java" ]
data_deps += [
"//build/android/pylib/device/commands",
"//tools/android/forwarder2",
"//tools/android/md5sum",
]
if (defined(invoker.additional_apks)) {
data_deps += invoker.additional_apks
}
if (defined(invoker.apk_under_test)) {
# Prevent a build_hooks_android_impl exising in both the test apks as
# well as the apk_under_test.
no_build_hooks = true
}
if (defined(invoker.proguard_enabled) && invoker.proguard_enabled) {
# When ProGuard is on, we use ProGuard to combine the under test java
# code and the test java code. This is to allow us to apply all ProGuard
# optimizations that we ship with, but not have them break tests. The
# apk under test will still have the same resources, assets, and
# manifest, all of which are the ones used in the tests.
if (!defined(invoker.proguard_configs)) {
proguard_configs = []
}
proguard_configs += [ "//testing/android/proguard_for_test.flags" ]
if (defined(final_apk_path)) {
_final_apk_path = final_apk_path
} else {
_final_apk_path = "$root_build_dir/apks/${apk_name}.apk"
}
data = [
"$_final_apk_path.mapping",
]
}
dist_ijar_path = _dist_ijar_path
if (defined(invoker.run_findbugs_override)) {
# Only allow findbugs when there are java files.
run_findbugs_override =
invoker.run_findbugs_override && defined(invoker.java_files)
}
create_apk_script = false
}
group(target_name) {
if (incremental_apk_by_default) {
public_deps = [
":${target_name}_incremental",
]
} else {
public_deps = [
":$_apk_target_name",
":$_test_runner_target_name",
# Required by test runner to enumerate test list.
":${_apk_target_name}_dist_ijar",
]
if (defined(invoker.apk_under_test)) {
public_deps += [ invoker.apk_under_test ]
}
}
# Ensure unstripped libraries are included in runtime deps so that
# symbolization can be done.
deps = [
":${_apk_target_name}__runtime_deps",
":${_apk_target_name}__secondary_abi_runtime_deps",
]
if (defined(invoker.apk_under_test)) {
_under_test_label =
get_label_info(invoker.apk_under_test, "label_no_toolchain")
deps += [
"${_under_test_label}__runtime_deps",
"${_under_test_label}__secondary_abi_runtime_deps",
]
}
}
# TODO: Delete once recipes no longer use this target.
group("${target_name}_run") {
public_deps = [
":${invoker.target_name}",
]
}
group("${target_name}_incremental") {
public_deps = [
":$_incremental_test_runner_target_name",
":${_apk_target_name}_dist_ijar",
":${_apk_target_name}_incremental",
]
if (defined(invoker.apk_under_test)) {
public_deps += [ "${invoker.apk_under_test}_incremental" ]
}
}
}
# Declare an Android gtest apk
#
# This target creates an Android apk for running gtest-based unittests.
#
# Variables
# deps: Specifies the dependencies of this target. These will be passed to
# the underlying android_apk invocation and should include the java and
# resource dependencies of the apk.
# shared_library: shared_library target that contains the unit tests.
# apk_name: The name of the produced apk. If unspecified, it uses the name
# of the shared_library target suffixed with "_apk"
# use_default_launcher: Whether the default activity (NativeUnitTestActivity)
# should be used for launching tests.
# use_native_activity: Test implements ANativeActivity_onCreate().
#
# Example
# unittest_apk("foo_unittests_apk") {
# deps = [ ":foo_java", ":foo_resources" ]
# shared_library = ":foo_unittests"
# }
template("unittest_apk") {
_use_native_activity =
defined(invoker.use_native_activity) && invoker.use_native_activity
_android_manifest = "$target_gen_dir/$target_name/AndroidManifest.xml"
assert(invoker.shared_library != "")
# This trivial assert is needed in case android_manifest is defined,
# as otherwise _use_native_activity and _android_manifest would not be used.
assert(_use_native_activity != "" && _android_manifest != "")
if (!defined(invoker.android_manifest)) {
jinja_template("${target_name}_manifest") {
_native_library_name = get_label_info(invoker.shared_library, "name")
input = "//testing/android/native_test/java/AndroidManifest.xml.jinja2"
output = _android_manifest
variables = [
"is_component_build=${is_component_build}",
"native_library_name=${_native_library_name}",
"use_native_activity=${_use_native_activity}",
]
}
}
android_apk(target_name) {
set_sources_assignment_filter([])
data_deps = []
deps = []
forward_variables_from(invoker, "*")
testonly = true
create_apk_script = false
assert(!defined(invoker.proguard_enabled) || !invoker.proguard_enabled ||
invoker.proguard_configs != [])
if (!defined(apk_name)) {
apk_name = get_label_info(invoker.shared_library, "name")
}
if (!defined(android_manifest)) {
android_manifest_dep = ":${target_name}_manifest"
android_manifest = _android_manifest
}
final_apk_path = "$root_build_dir/${apk_name}_apk/${apk_name}-debug.apk"
if (!defined(use_default_launcher) || use_default_launcher) {
deps += [ "//testing/android/native_test:native_test_java" ]
}
shared_libraries = [ invoker.shared_library ]
deps += [
":${target_name}__runtime_deps",
":${target_name}__secondary_abi_runtime_deps",
"//base:base_java",
"//testing/android/appurify_support:appurify_support_java",
"//testing/android/reporter:reporter_java",
]
data_deps += [
"//build/android/pylib/device/commands",
"//tools/android/md5sum",
]
if (host_os == "linux") {
data_deps += [ "//tools/android/forwarder2" ]
}
}
}
# Generate .java files from .aidl files.
#
# This target will store the .java files in a srcjar and should be included in
# an android_library or android_apk's srcjar_deps.
#
# Variables
# sources: Paths to .aidl files to compile.
# import_include: Path to directory containing .java files imported by the
# .aidl files.
# interface_file: Preprocessed aidl file to import.
#
# Example
# android_aidl("foo_aidl") {
# import_include = "java/src"
# sources = [
# "java/src/com/foo/bar/FooBarService.aidl",
# "java/src/com/foo/bar/FooBarServiceCallback.aidl",
# ]
# }
template("android_aidl") {
set_sources_assignment_filter([])
forward_variables_from(invoker, [ "testonly" ])
srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
aidl_path = "${android_sdk_build_tools}/aidl"
framework_aidl = "$android_sdk/framework.aidl"
action(target_name) {
script = "//build/android/gyp/aidl.py"
sources = invoker.sources
imports = [ framework_aidl ]
if (defined(invoker.interface_file)) {
assert(invoker.interface_file != "")
imports += [ invoker.interface_file ]
}
inputs = [ aidl_path ] + imports
depfile = "${target_gen_dir}/${target_name}.d"
outputs = [
srcjar_path,
]
rebased_imports = rebase_path(imports, root_build_dir)
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--aidl-path",
rebase_path(aidl_path, root_build_dir),
"--imports=$rebased_imports",
"--srcjar",
rebase_path(srcjar_path, root_build_dir),
]
if (defined(invoker.import_include) && invoker.import_include != []) {
# TODO(cjhopman): aidl supports creating a depfile. We should be able to
# switch to constructing a depfile for the overall action from that
# instead of having all the .java files in the include paths as inputs.
rebased_import_paths = []
foreach(import_path, invoker.import_include) {
_rebased_import_path = []
_rebased_import_path += rebase_path([ import_path ], root_build_dir)
rebased_import_paths += _rebased_import_path
_java_files_build_rel = []
_java_files_build_rel = exec_script("//build/android/gyp/find.py",
_rebased_import_path,
"list lines")
inputs += rebase_path(_java_files_build_rel, ".", root_build_dir)
}
args += [ "--includes=$rebased_import_paths" ]
}
args += rebase_path(sources, root_build_dir)
}
}
# Compile a protocol buffer to java.
#
# This generates java files from protocol buffers and creates an Android library
# containing the classes.
#
# Variables
# sources: Paths to .proto files to compile.
# proto_path: Root directory of .proto files.
#
# Example:
# proto_java_library("foo_proto_java") {
# proto_path = "src/foo"
# sources = [ "$proto_path/foo.proto" ]
# }
template("proto_java_library") {
set_sources_assignment_filter([])
forward_variables_from(invoker, [ "testonly" ])
_protoc_dep =
"//third_party/android_protobuf:android_protoc($host_toolchain)"
_protoc_out_dir = get_label_info(_protoc_dep, "root_out_dir")
_protoc_bin = "$_protoc_out_dir/android_protoc"
_proto_path = invoker.proto_path
_template_name = target_name
action("${_template_name}__protoc_java") {
srcjar_path = "$target_gen_dir/$target_name.srcjar"
script = "//build/protoc_java.py"
deps = [
_protoc_dep,
]
if (defined(invoker.deps)) {
deps += invoker.deps
}
sources = invoker.sources
depfile = "$target_gen_dir/$target_name.d"
outputs = [
srcjar_path,
]
args = [
"--depfile",
rebase_path(depfile, root_build_dir),
"--protoc",
rebase_path(_protoc_bin, root_build_dir),
"--proto-path",
rebase_path(_proto_path, root_build_dir),
"--srcjar",
rebase_path(srcjar_path, root_build_dir),
] + rebase_path(sources, root_build_dir)
}
android_library(target_name) {
chromium_code = false
java_files = []
srcjar_deps = [ ":${_template_name}__protoc_java" ]
deps = [
"//third_party/android_protobuf:protobuf_nano_javalib",
]
}
}
# Declare an Android library target for a prebuilt AAR.
#
# This target creates an Android library containing java code and Android
# resources. For libraries without resources, it will not generate
# corresponding android_resources targets.
#
# To avoid slowing down "gn gen", an associated .info file must be committed
# along with the .aar file. In order to create this file, define the target
# and then run once with the gn arg "update_android_aar_prebuilts = true".
#
# Variables
# aar_path: Path to the AAR.
# info_path: Path to the .aar.info file (generated via
# update_android_aar_prebuilts GN arg).
# proguard_configs: List of proguard configs to use in final apk step for
# any apk that depends on this library.
# ignore_aidl: Whether to ignore .aidl files found with the .aar.
# ignore_assets: Whether to ignore assets found in the .aar.
# ignore_native_libraries: Whether to ignore .so files found in the .aar.
# create_srcjar: If false, does not create an R.java file.
# TODO(jbudorick@): remove this arguments after crbug.com/522043 is fixed.
# requires_android: Whether this target can only be used for compiling
# Android related targets.
#
# Example
# android_aar_prebuilt("foo_java") {
# aar_path = "foo.aar"
# }
template("android_aar_prebuilt") {
_info_path = "$target_name.info"
if (defined(invoker.info_path)) {
_info_path = invoker.info_path
}
_output_path = "${target_gen_dir}/${target_name}"
_unpack_target_name = "${target_name}__unpack_aar"
_ignore_aidl = defined(invoker.ignore_aidl) && invoker.ignore_aidl
_ignore_assets = defined(invoker.ignore_assets) && invoker.ignore_assets
_ignore_native_libraries = defined(invoker.ignore_native_libraries) &&
invoker.ignore_native_libraries
# Scan the AAR file and determine the resources and jar files.
# Some libraries might not have resources; others might have two jars.
if (update_android_aar_prebuilts) {
print("Writing " + rebase_path(_info_path, "//"))
exec_script("//build/android/gyp/aar.py",
[
"list",
rebase_path(invoker.aar_path, root_build_dir),
"--output",
rebase_path(_info_path, root_build_dir),
])
}
# If "gn gen" is failing on the following line, you need to generate an
# .info file for your new target by running:
# gn gen --args='target_os="android" update_android_aar_prebuilts=true' out/tmp
# rm -r out/tmp
_scanned_files = read_file(_info_path, "scope")
assert(_ignore_aidl || _scanned_files.aidl == [],
"android_aar_prebuilt() aidl not yet supported." +
" Implement or use ignore_aidl = true." +
" http://crbug.com/644439")
assert(_ignore_assets || _scanned_files.assets == [],
"android_aar_prebuilt() assets not yet supported." +
" Implement or use ignore_assets = true." +
" http://crbug.com/643966")
assert(_ignore_native_libraries || !_scanned_files.has_native_libraries,
"android_aar_prebuilt() with .so files is not supported." +
" Use ignore_native_libraries = true to silence this error.")
assert(_scanned_files.has_classes_jar || _scanned_files.subjars == [])
action(_unpack_target_name) {
script = "//build/android/gyp/aar.py" # Unzips the AAR
args = [
"extract",
rebase_path(invoker.aar_path, root_build_dir),
"--output-dir",
rebase_path(_output_path, root_build_dir),
"--assert-info-file",
rebase_path(_info_path, root_build_dir),
]
inputs = [
invoker.aar_path,
]
outputs = [
"${_output_path}/AndroidManifest.xml",
]
if (_scanned_files.has_r_text_file) {
# Certain packages, in particular Play Services have no R.txt even
# though its presence is mandated by AAR spec. Such packages cause
# spurious rebuilds if this output is specified unconditionally.
outputs += [ "${_output_path}/R.txt" ]
}
if (_scanned_files.resources != []) {
outputs += get_path_info(
rebase_path(_scanned_files.resources, "", _output_path),
"abspath")
}
if (_scanned_files.has_classes_jar) {
outputs += [ "${_output_path}/classes.jar" ]
}
outputs +=
get_path_info(rebase_path(_scanned_files.subjars, "", _output_path),
"abspath")
if (_scanned_files.has_proguard_flags) {
outputs += [ "${_output_path}/proguard.txt" ]
}
}
# Create the android_resources target for resources.
if (_scanned_files.resources != [] || _scanned_files.has_r_text_file ||
!_scanned_files.is_manifest_empty) {
_res_target_name = "${target_name}__res"
android_resources(_res_target_name) {
forward_variables_from(invoker,
[
"create_srcjar",
"deps",
"testonly",
])
if (!defined(deps)) {
deps = []
}
deps += [ ":$_unpack_target_name" ]
resource_dirs = []
generated_resource_dirs = []
if (_scanned_files.resources != []) {
generated_resource_dirs += [ "${_output_path}/res" ]
}
generated_resource_files =
rebase_path(_scanned_files.resources, "", _output_path)
android_manifest_dep = ":$_unpack_target_name"
android_manifest = "${_output_path}/AndroidManifest.xml"
if (_scanned_files.has_r_text_file) {
r_text_file = "${_output_path}/R.txt"
}
v14_skip = true
}
}
# Create android_java_prebuilt target for extra jars within jars/.
_subjar_targets = []
foreach(_tuple, _scanned_files.subjar_tuples) {
_current_target = "${target_name}__subjar_${_tuple[0]}"
_subjar_targets += [ ":$_current_target" ]
java_prebuilt(_current_target) {
forward_variables_from(invoker,
[
"jar_excluded_patterns",
"requires_android",
])
deps = [
":$_unpack_target_name",
]
if (!defined(requires_android)) {
requires_android = true
}
supports_android = true
jar_path = "$_output_path/${_tuple[1]}"
_base_output_name = get_path_info(jar_path, "name")
output_name = "${invoker.target_name}-$_base_output_name"
}
}
# Create android_java_prebuilt target for classes.jar.
if (_scanned_files.has_classes_jar) {
_jar_target_name = "${target_name}__classes"
java_prebuilt(_jar_target_name) {
forward_variables_from(invoker,
[
"deps",
"input_jars_paths",
"jar_excluded_patterns",
"proguard_configs",
"requires_android",
"testonly",
])
if (!defined(deps)) {
deps = []
}
deps += _subjar_targets + [ ":$_unpack_target_name" ]
if (defined(_res_target_name)) {
deps += [ ":$_res_target_name" ]
}
if (!defined(requires_android)) {
requires_android = true
}
supports_android = true
jar_path = "$_output_path/classes.jar"
output_name = invoker.target_name
if (_scanned_files.has_proguard_flags) {
if (!defined(proguard_configs)) {
proguard_configs = []
}
proguard_configs += [ "$_output_path/proguard.txt" ]
}
}
}
java_group(target_name) {
forward_variables_from(invoker,
[
"testonly",
"visibility",
])
deps = []
if (defined(_jar_target_name)) {
deps += [ ":$_jar_target_name" ]
# Although subjars are meant to be private, we add them as deps here
# because in practice they seem to contain classes required to be in the
# classpath.
deps += _subjar_targets
}
if (defined(_res_target_name)) {
deps += [ ":$_res_target_name" ]
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink