#!/usr/bin/env python3 # # Copyright 2014 The Chromium Authors # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """Writes a .build_config.json file. This script collects information about a target and all of its transitive dependencies and writes it to a .build_config.json file for use by other build steps. It also performs a few validations. See //build/android/docs/build_config.md for more information. """ import argparse import itertools import os import sys import xml.dom.minidom from util import build_utils from util import params_json_util import action_helpers class OrderedSet(dict): """A simple implementation of an ordered set.""" def __init__(self, iterable=()): super().__init__() self.update(iterable) def __add__(self, other): ret = OrderedSet(self) ret.update(other) return ret def add(self, key): self[key] = True def remove(self, key): self.pop(key, None) def update(self, iterable): for k in iterable: self[k] = True def difference_update(self, iterable): for k in iterable: self.pop(k, None) class AndroidManifest: """Helper class to inspect properties of an AndroidManifest.xml file.""" def __init__(self, path): self.path = path dom = xml.dom.minidom.parse(path) manifests = dom.getElementsByTagName('manifest') assert len(manifests) == 1 self.manifest = manifests[0] def GetInstrumentationElements(self): instrumentation_els = self.manifest.getElementsByTagName('instrumentation') if len(instrumentation_els) == 0: return None return instrumentation_els def CheckInstrumentationElements(self, expected_package): instrs = self.GetInstrumentationElements() if not instrs: raise Exception('No elements found in %s' % self.path) for instr in instrs: instrumented_package = instr.getAttributeNS( 'http://schemas.android.com/apk/res/android', 'targetPackage') if instrumented_package != expected_package: raise Exception( 'Wrong instrumented package. Expected %s, got %s' % (expected_package, instrumented_package)) def GetPackageName(self): return self.manifest.getAttribute('package') class _TransitiveValues: """A container for the transitive dependencies of a target. This class holds sets of paths for various types of dependencies, such as jars, resources, assets, etc. """ # Some values should not be removed when subtracting subtrees. _NEVER_REMOVE = frozenset([ 'all_interface_jars', 'all_input_jars_paths', 'direct_input_jars_paths', 'direct_interface_jars', 'direct_unprocessed_jars', 'proguard_configs', ]) def __init__(self): # Direct classpath: self.direct_unprocessed_jars = OrderedSet() self.direct_interface_jars = OrderedSet() self.direct_input_jars_paths = OrderedSet() # Jar files self.all_unprocessed_jars = OrderedSet() self.all_interface_jars = OrderedSet() self.all_input_jars_paths = OrderedSet() self.all_dex_files = OrderedSet() self.all_processed_jars = OrderedSet() # Assets self.assets = OrderedSet() self.uncompressed_assets = OrderedSet() self.locale_paks = OrderedSet() # Resources self.dependency_zip_overlays = OrderedSet() self.dependency_zips = OrderedSet() self.extra_package_names = OrderedSet() # Other self.android_manifests = OrderedSet() self.java_resources_jars = OrderedSet() self.proguard_configs = OrderedSet() def RemoveSubtree(self, other, retain_processed_jars=False, retain_unprocessed_jars=False, retain_resource_zips=False, retain_extra_package_names=False, retain_android_manifests=False): """Removes all values from |other| from this instance.""" for key, value in self.__dict__.items(): if not (key in _TransitiveValues._NEVER_REMOVE or (retain_processed_jars and key == 'all_processed_jars') or (retain_unprocessed_jars and key in ('all_unprocessed_jars', 'all_interface_jars')) or (retain_resource_zips and key in ('dependency_zips', 'dependency_zip_overlays')) or (retain_extra_package_names and key == 'extra_package_names') or (retain_android_manifests and key == 'android_manifests')): value.difference_update(getattr(other, key)) def _SortClasspath(dep_list): """Sorts a list of dependencies for the classpath. Move low priority libraries to the end of the classpath. """ dep_list.sort(key=lambda p: 1 if p.get('low_classpath_priority') else 0) return dep_list class _TransitiveValuesBuilder: def __init__(self, params, remove_parent_module_overlap=True): self._params = params self._remove_parent_module_overlap = remove_parent_module_overlap self._ret = _TransitiveValues() def Build(self): """Computes the transitive dependencies for a given target. This is the core logic of the script, collecting all necessary paths and metadata from the dependency graph. """ params = self._params # System .jar files go into sdk_jars / sdk_interface_jars. direct_deps = _SortClasspath( params.deps().not_of_type('system_java_library')) all_deps = _SortClasspath( direct_deps.recursive().not_of_type('system_java_library')) all_deps_without_under_test = all_deps if apk_under_test_params := params.apk_under_test(): # Cannot use .append() since this is the cached instance. direct_deps = direct_deps + [apk_under_test_params] all_deps = _SortClasspath( direct_deps.recursive().not_of_type('system_java_library')) self._CollectClasspath(direct_deps, all_deps) if params.merges_manifests(): self._CollectManifests(all_deps_without_under_test) if params.collects_resources(): self._CollectResources(all_deps_without_under_test) self._CollectExtraPackageNames(direct_deps, all_deps) self._ret.proguard_configs.update(params.get('proguard_configs', [])) self._ret.proguard_configs.update( all_deps.collect('proguard_configs', flatten=True)) if params.is_bundle_module() and self._remove_parent_module_overlap: self._RemoveParentModuleOverlap() # If there are deps common between dist_jar() and non-dist_jar(), then # subtract them off the full classpath to avoid double-deps. for dist_jar_params in all_deps.of_type('dist_jar'): self._RemoveJarsOwnedByDistJars(dist_jar_params) if apk_under_test_params := params.apk_under_test(): self._RemoveApkUnderTestOverlap(apk_under_test_params) if params.is_bundle_module() and not params.is_base_module(): self._AddBaseModuleToClasspath() return self._ret def _CollectClasspath(self, direct_deps, all_deps): params = self._params ret = self._ret # Bundle modules do not depend on each other because their names do not # match the java naming scheme that identifies them as libraries. # TODO(agrieve): Recognize bundle module names as java_library targets so # that they contribute to classpath. ret.direct_unprocessed_jars.update( direct_deps.collect('unprocessed_jar_path')) ret.direct_interface_jars.update(direct_deps.collect('interface_jar_path')) ret.all_unprocessed_jars.update(all_deps.collect('unprocessed_jar_path')) ret.all_interface_jars.update(all_deps.collect('interface_jar_path')) # Deps to add to the compile-time classpath (but not the runtime # classpath). ret.direct_input_jars_paths.update(params.get('input_jars_paths', [])) ret.direct_input_jars_paths.update( direct_deps.collect('input_jars_paths', flatten=True)) ret.all_input_jars_paths.update(params.get('input_jars_paths', [])) ret.all_input_jars_paths.update( all_deps.collect('input_jars_paths', flatten=True)) # Add the target's .jar (except for dist_jar, where it's the output .jar). if params.collects_processed_classpath(): if not params.is_dist_jar(): if path := params.get('processed_jar_path'): ret.all_processed_jars.add(path) ret.all_processed_jars.update(all_deps.collect('processed_jar_path')) if params.collects_dex_paths(): if not params.is_dist_jar(): if path := params.get('dex_path'): ret.all_dex_files.add(path) ret.all_dex_files.update(all_deps.collect('dex_path')) def _AddBaseModuleToClasspath(self): base_module = self._params.base_module() # Adding base module to classpath to compile against its R.java file self._ret.direct_unprocessed_jars.add(base_module['unprocessed_jar_path']) self._ret.all_unprocessed_jars.add(base_module['unprocessed_jar_path']) self._ret.direct_interface_jars.add(base_module['interface_jar_path']) self._ret.all_interface_jars.add(base_module['interface_jar_path']) def _CollectManifests(self, all_deps_without_under_test): # Manifests are listed from highest priority to lowest priority. # Ensure direct manifests come first, then sort the rest by name. # https://developer.android.com/build/manage-manifests#merge_priorities params = self._params ret = self._ret ret.android_manifests.update(params.get('mergeable_android_manifests', [])) indirect_manifests = all_deps_without_under_test.collect( 'mergeable_android_manifests', flatten=True) indirect_manifests.sort(key=lambda p: (os.path.basename(p), p)) ret.android_manifests.update(indirect_manifests) # Prevent the main manifest from showing up in mergeable_android_manifests. if path := params.get('android_manifest'): if path in ret.android_manifests: ret.android_manifests.remove(path) def _CollectResources(self, all_deps_without_under_test): params = self._params ret = self._ret resource_deps = params.resource_deps() ret.dependency_zips.update(resource_deps.collect('resources_zip')) ret.dependency_zip_overlays.update( resource_deps.collect('resources_overlay_zip')) assets, uncompressed_assets, locale_paks = _MergeAssets( all_deps_without_under_test.of_type('android_assets')) ret.assets.update(assets) ret.uncompressed_assets.update(uncompressed_assets) ret.locale_paks = locale_paks if params.get('java_resources_jar_path'): ret.java_resources_jars.add(params) ret.java_resources_jars.update( all_deps_without_under_test.collect('java_resources_jar_path')) def _CollectExtraPackageNames(self, direct_deps, all_deps): # Needed by java_library targets. if self._params.is_library(): # TODO(agrieve): We would ideally move away from being able to use R.java # from package_names other than the library's own. resource_deps = direct_deps.of_type('android_resources') else: resource_deps = all_deps.recursive_resource_deps() self._ret.extra_package_names.update(resource_deps.collect('package_name')) if name := self._params.get('package_name'): self._ret.extra_package_names.add(name) def _RemoveJarsOwnedByDistJars(self, dist_jar_params): """Removes jars from a _TransitiveValues object that are owned by a dist_jar. """ if dist_jar_params.get('use_interface_jars'): return if dist_jar_params.get('direct_deps_only'): deps = dist_jar_params.deps() dist_jar_tvs = _TransitiveValues() dist_jar_tvs.all_unprocessed_jars = deps.collect('unprocessed_jar_path') dist_jar_tvs.all_interface_jars = deps.collect('interface_jar_path') dist_jar_tvs.all_dex_files = deps.collect('dex_path') dist_jar_tvs.all_processed_jars = deps.collect('processed_jar_path') else: dist_jar_tvs = _TransitiveValuesBuilder(dist_jar_params).Build() self._ret.RemoveSubtree(dist_jar_tvs, retain_resource_zips=True, retain_extra_package_names=True) self._ret.direct_unprocessed_jars.difference_update( dist_jar_tvs.direct_unprocessed_jars) self._ret.direct_interface_jars.difference_update( dist_jar_tvs.direct_interface_jars) def _RemoveParentModuleOverlap(self): # There are two approaches to dealing with modules dependencies: # 1) Perform steps in android_apk_or_module(), with only the knowledge of # ancesstor splits. # 2) Perform steps in android_app_bundle(), with knowledge of full set of # modules. This is required for dex because it can handle the case of # two leaf nodes having the same dep, and promoting that dep to their # common parent. # _PromoteToCommonAncestor() implements this approach. # # We do 1) unconditionally, and 2) for dex / proguard, but we really # should do 2) for all applicable fields. if parent_module := self._params.parent_module(): x = _TransitiveValuesBuilder(parent_module, remove_parent_module_overlap=False).Build() self._ret.RemoveSubtree(x) def _RemoveApkUnderTestOverlap(self, apk_under_test_params): # The java code for an instrumentation test apk is assembled differently # for R8 vs. non-R8. # # Without R8: Each library's jar is dexed separately and then combined # into a single classes.dex. A test apk will include all dex files not # present in the apk-under-test. At runtime all test code lives in the # test apk, and the program code lives in the apk-under-test. # # With R8: Each library's .jar file is fed into R8, which outputs # a single .jar, which is then dexed into a classes.dex. A test apk # includes all jar files from the program and the tests because having # them separate doesn't work with R8's whole-program optimizations. # Although the apk-under-test still has all of its code in its # classes.dex, none of it is used at runtime because the copy within the # test apk takes precedence. self._ret.RemoveSubtree( _TransitiveValuesBuilder(apk_under_test_params).Build(), retain_processed_jars=self._params.get('proguard_enabled'), retain_unprocessed_jars=True, retain_resource_zips=True, retain_android_manifests=True) def _MergeAssets(all_assets): """Merges all assets from the given deps. Returns: A tuple of: (compressed, uncompressed, locale_paks) |compressed| and |uncompressed| are lists of "srcPath:zipPath". srcPath is the path of the asset to add, and zipPath is the location within the zip (excluding assets/ prefix). |locale_paks| is a set of all zipPaths that have been marked as treat_as_locale_paks=true. """ compressed = {} uncompressed = {} locale_paks = set() for asset_dep in all_assets: entry = asset_dep['assets'] disable_compression = entry.get('disable_compression') treat_as_locale_paks = entry.get('treat_as_locale_paks') dest_map = uncompressed if disable_compression else compressed other_map = compressed if disable_compression else uncompressed outputs = entry.get('outputs', []) for src, dest in itertools.zip_longest(entry['sources'], outputs): if not dest: dest = os.path.basename(src) # Merge so that each path shows up in only one of the lists, and that # deps of the same target override previous ones. other_map.pop(dest, 0) dest_map[dest] = src if treat_as_locale_paks: locale_paks.add(dest) def create_list(asset_map): # Sort to ensure deterministic ordering. items = sorted(asset_map.items()) return [f'{src}:{dest}' for dest, src in items] return create_list(compressed), create_list(uncompressed), locale_paks def _CreateJavaLocaleListFromAssets(assets, locale_paks): """Returns a java literal array from a list of locale assets. Args: assets: A list of all APK asset paths in the form 'src:dst' locale_paks: A list of asset paths that correponds to the locale pak files of interest. Each |assets| entry will have its 'dst' part matched against it to determine if they are part of the result. Returns: A string that is a Java source literal array listing the locale names of the corresponding asset files, without directory or .pak suffix. E.g. '{"en-GB", "en-US", "es-ES", "fr", ... }' """ assets_paths = [a.split(':')[1] for a in assets] locales = [os.path.basename(a)[:-4] for a in assets_paths if a in locale_paks] return '{%s}' % ','.join('"%s"' % l for l in sorted(locales)) def _AddJarMapping(jar_to_target, config): """Adds mappings from jar path to GN target for a given config.""" if jar := config.get('unprocessed_jar_path'): jar_to_target[jar] = config['gn_target'] for jar in config.get('input_jars_paths', []): jar_to_target[jar] = config['gn_target'] def _PromoteToCommonAncestor(modules, child_to_ancestors, field_name): """Finds duplicates of a field across modules and moves them to the nearest common ancestor module. This is used for app bundles to avoid duplicating dependencies in multiple modules. """ module_to_fields_set = {} for module_name, module in modules.items(): if field_name in module: module_to_fields_set[module_name] = set(module[field_name]) # Find all items that are duplicated across at least two modules. seen = set() dupes = set() for fields in module_to_fields_set.values(): new_dupes = seen & fields if new_dupes: dupes |= new_dupes seen |= fields for d in dupes: owning_modules = [] for module_name, fields in module_to_fields_set.items(): if d in fields: owning_modules.append(module_name) assert len(owning_modules) >= 2 # Rely on the fact that ancestors are inserted from closest to # farthest, where "base" should always be the last element. # Arbitrarily using the first owning module - any would work. for ancestor in child_to_ancestors[owning_modules[0]]: for o in owning_modules[1:]: if ancestor not in child_to_ancestors[o] and ancestor is not o: break else: common_ancestor = ancestor break else: raise Exception('Should have already removed ancestor dupes. ' + ','.join(owning_modules) + ' field=' + field_name + ' dupes: ' + ','.join(dupes)) # Move the duplicated item to the common ancestor. for o in owning_modules: module_to_fields_set[o].remove(d) module_to_fields_set[common_ancestor].add(d) # Update the original modules dictionary with the de-duplicated lists. for module_name, module in modules.items(): if field_name in module: module[field_name] = sorted(list(module_to_fields_set[module_name])) def _DoPlatformChecks(params): """Check for platform mismatches between a target and its dependencies.""" # Robolectric is special in that it's an android target that runs on host. # You are allowed to depend on both android |deps_require_android| and # non-android |deps_not_support_android| targets. if params.get('bypass_platform_checks') or params.get('requires_robolectric'): return deps_require_android = [d for d in params.deps() if d.requires_android()] deps_not_support_android = [ d for d in params.deps() if not d.supports_android() ] if deps_require_android and not params.requires_android(): raise Exception('Some deps require building for the Android platform:\n' + '\n'.join('* ' + d['gn_target'] for d in deps_require_android)) if deps_not_support_android and params.supports_android(): raise Exception('Not all deps support the Android platform:\n' + '\n'.join('* ' + d['gn_target'] for d in deps_not_support_android)) def _SuffixAssets(config, target_config): """Adds a suffix to asset paths to avoid collisions.""" def helper(suffix_names, suffix, assets): new_assets = [] for x in assets: src_path, apk_subpath = x.split(':', 1) if apk_subpath in suffix_names: apk_subpath += suffix new_assets.append(f'{src_path}:{apk_subpath}') return new_assets all_assets = target_config['assets'] + target_config['uncompressed_assets'] suffix = '+' + target_config['package_name'] + '+' suffix_names = {x.split(':', 1)[1].replace(suffix, '') for x in all_assets} config['assets'] = helper(suffix_names, suffix, config['assets']) config['uncompressed_assets'] = helper(suffix_names, suffix, config['uncompressed_assets']) config['apk_assets_suffixed_list'] = ','.join(f'"assets/{x}"' for x in sorted(suffix_names)) config['apk_assets_suffix'] = suffix def _ToTraceEventRewrittenPath(jar_dir, path): """Returns the path to the trace-event-rewritten version of a jar.""" path = path.replace('../', '') path = path.replace('obj/', '') path = path.replace('gen/', '') path = path.replace('.jar', '.tracing_rewritten.jar') return os.path.join(jar_dir, path) def _WriteLintJson(params, lint_json, main_config): # Collect all sources and resources at the apk/bundle_module level. aars = set() srcjars = set() sources = set() resource_sources = set() resource_zips = set() if path := params.get('target_sources_file'): sources.add(path) if paths := params.get('bundled_srcjars'): srcjars.update(paths) for c in params.deps().recursive(): if c.get('chromium_code', True) and c.requires_android(): if path := c.get('target_sources_file'): sources.add(path) if paths := c.get('bundled_srcjars'): srcjars.update(paths) if path := c.get('aar_path'): aars.add(path) for c in params.resource_deps(): if c.get('chromium_code', True): # Prefer res_sources_path to resources_zips so that lint errors have # real paths and to avoid needing to extract during lint. if path := c.get('res_sources_path'): resource_sources.add(path) else: resource_zips.add( c.get('resources_zip') or c.get('resources_overlay_zip')) if params.is_bundle(): classpath = OrderedSet() manifests = OrderedSet(p['android_manifest'] for p in params.module_deps()) for m in params.module_deps(): module_config = m.build_config_json() classpath.update(module_config['javac_full_interface_classpath']) manifests.update(module_config['extra_android_manifests']) classpath = list(classpath) manifests = list(manifests) else: classpath = main_config['javac_full_interface_classpath'] manifests = [params['android_manifest']] manifests += main_config['extra_android_manifests'] config = {} config['aars'] = sorted(aars) config['android_manifests'] = manifests config['classpath'] = classpath config['sources'] = sorted(sources) config['srcjars'] = sorted(srcjars) config['resource_sources'] = sorted(resource_sources) config['resource_zips'] = sorted(resource_zips) build_utils.WriteJson(config, lint_json, only_if_changed=True) def main(): parser = argparse.ArgumentParser( description='Writes a .build_config.json file.') action_helpers.add_depfile_arg(parser) parser.add_argument('--output', help='.build_config.json to write.') options = parser.parse_args() build_config_path = options.output params = params_json_util.get_params( build_config_path.replace('.build_config.json', '.params.json')) if lines := params.get('fail'): parser.error('\n'.join(lines)) target_type = params.type is_bundle_module = params.is_bundle_module() is_apk = params.is_apk() is_apk_or_module = is_apk or is_bundle_module is_bundle = params.is_bundle() has_classpath = params.has_classpath() proguard_enabled = params.get('proguard_enabled', False) if has_classpath: _DoPlatformChecks(params) if is_bundle_module: if parent_module_params := params.parent_module(): # Validate uses_split matches the parent split's name. parent_split_name = params.get('uses_split', 'base') actual = parent_module_params['module_name'] assert actual == parent_split_name, ( f'uses_split={parent_split_name} but parent was {actual}') if is_bundle: deps_proguard_enabled = [] deps_proguard_disabled = [] for module in params.module_deps(): if module.get('proguard_enabled'): deps_proguard_enabled.append(module['module_name']) else: deps_proguard_disabled.append(module['module_name']) if deps_proguard_enabled and deps_proguard_disabled: raise Exception('Deps %s have proguard enabled while deps %s have ' 'proguard disabled' % (deps_proguard_enabled, deps_proguard_disabled)) apk_under_test_params = params.apk_under_test() if is_apk and apk_under_test_params: if apk_under_test_params['proguard_enabled']: assert proguard_enabled, ( 'proguard must be enabled for ' 'instrumentation apks if it\'s enabled for the tested apk.') if is_apk_or_module: manifest = AndroidManifest(params['android_manifest']) if not apk_under_test_params and manifest.GetInstrumentationElements(): # This must then have instrumentation only for itself. manifest.CheckInstrumentationElements(manifest.GetPackageName()) config = {} if is_apk: config['apk_path'] = params['apk_path'] if path := params.get('incremental_install_json_path'): config['incremental_install_json_path'] = path config['incremental_apk_path'] = params['incremental_apk_path'] if is_bundle_module: config['unprocessed_jar_path'] = params['unprocessed_jar_path'] config['res_size_info_path'] = params['res_size_info_path'] if has_classpath: tv = _TransitiveValuesBuilder(params).Build() if apk_under_test_params: assert is_apk config['arsc_package_name'] = ( apk_under_test_params.build_config_json()['package_name']) config['classpath'] = list(tv.direct_unprocessed_jars) + list( tv.direct_input_jars_paths) config['interface_classpath'] = list(tv.direct_interface_jars) + list( tv.direct_input_jars_paths) # processor_configs will be of type 'java_annotation_processor', and so not # included in deps().recursive().of_type('java_library'). Annotation # processors run as part of the build, so need processed_jar_path. processor_deps = params.processor_deps() config['processor_classpath'] = _SortClasspath( processor_deps.recursive()).collect('processed_jar_path') config['processor_classes'] = sorted(processor_deps.collect('main_class')) config['javac_full_classpath'] = (list(tv.all_unprocessed_jars) + list(tv.all_input_jars_paths)) config['javac_full_interface_classpath'] = (list(tv.all_interface_jars) + list(tv.all_input_jars_paths)) if params.collects_processed_classpath(): config['processed_classpath'] = list(tv.all_processed_jars) if trace_events_jar_dir := params.get('trace_events_jar_dir'): config['trace_event_rewritten_classpath'] = [ _ToTraceEventRewrittenPath(trace_events_jar_dir, p) for p in tv.all_processed_jars ] if params.collects_dex_paths(): config['all_dex_files'] = list(tv.all_dex_files) if target_type in ('dist_aar', 'java_library'): config['dependency_rtxt_files'] = ( params.resource_deps().collect('rtxt_path')) sdk_deps = params.deps().of_type('system_java_library') config['sdk_jars'] = sdk_deps.collect('unprocessed_jar_path') config['sdk_interface_jars'] = sdk_deps.collect('interface_jar_path') if proguard_enabled or target_type == 'dist_aar': config['proguard_all_configs'] = sorted(tv.proguard_configs) if proguard_enabled: config['proguard_classpath_jars'] = sorted(tv.all_input_jars_paths) if is_apk_or_module: config['java_resources_jars'] = sorted(tv.java_resources_jars) if params.is_dist_jar(): if params.get('direct_deps_only'): if params.get('use_interface_jars'): dist_jars = tv.direct_interface_jars else: dist_jars = params.deps().collect('processed_jar_path') elif params.get('use_interface_jars'): dist_jars = tv.all_interface_jars else: dist_jars = tv.all_processed_jars config['dist_jar'] = {} config['dist_jar']['jars'] = list(dist_jars) if params.collects_resources(): # Safe to sort: Build checks that non-overlay resource have no overlap. config['dependency_zips'] = sorted(tv.dependency_zips) config['dependency_zip_overlays'] = list(tv.dependency_zip_overlays) config['assets'] = sorted(tv.assets) config['uncompressed_assets'] = sorted(tv.uncompressed_assets) if params.get('create_locales_java_list'): config['locales_java_list'] = _CreateJavaLocaleListFromAssets( tv.uncompressed_assets, tv.locale_paks) if params.compiles_resources(): config['extra_package_names'] = sorted(tv.extra_package_names) if params.merges_manifests(): config['extra_android_manifests'] = list(tv.android_manifests) if is_bundle: module_deps = params.module_deps() module_params_by_name = {m['module_name']: m for m in module_deps} module_configs_by_name = { m['module_name']: m.build_config_json() for m in module_deps } modules = {m: {} for m in module_params_by_name} child_to_ancestors = {n: [] for n in module_params_by_name} for name, module in module_params_by_name.items(): while module := module.parent_module(): child_to_ancestors[name].append(module['module_name']) per_module_fields = [ 'processed_classpath', 'trace_event_rewritten_classpath', 'all_dex_files', 'assets', 'uncompressed_assets', ] union_fields = {} if params.get('trace_events_jar_dir'): union_fields['processed_classpath'] = 'processed_classpath' union_fields['trace_event_rewritten_classpath'] = ( 'trace_event_rewritten_classpath') if proguard_enabled: union_fields['proguard_classpath_jars'] = 'proguard_classpath_jars' union_fields['proguard_all_configs'] = 'proguard_all_configs' union_fields['sdk_jars'] = 'sdk_jars' unioned_values = {k: OrderedSet() for k in union_fields} for n, c in module_configs_by_name.items(): module_params = module_params_by_name[n] if n == 'base': assert 'base_module_config' not in config, ( 'Must have exactly 1 base module!') config['package_name'] = c['package_name'] config['version_code'] = module_params['version_code'] config['version_name'] = module_params['version_name'] config['base_module_config'] = module_params.path config['android_manifest'] = module_params['android_manifest'] for dst_key, src_key in union_fields.items(): unioned_values[dst_key].update(c[src_key]) module = modules[n] module['final_dex_path'] = module_params['final_dex_path'] for f in per_module_fields: if f in c: module[f] = c[f] for dst_key in union_fields: config[dst_key] = list(unioned_values[dst_key]) # Promote duplicates from siblings/cousins. for f in per_module_fields: _PromoteToCommonAncestor(modules, child_to_ancestors, f) config['modules'] = modules if is_apk_or_module: config['package_name'] = manifest.GetPackageName() config['android_manifest'] = params['android_manifest'] config['merged_android_manifest'] = params['merged_android_manifest'] if is_apk: config['version_code'] = params['version_code'] config['version_name'] = params['version_name'] # TrichromeLibrary has no dex. if final_dex_path := params.get('final_dex_path'): config['final_dex_path'] = final_dex_path library_paths = params.native_libraries() secondary_abi_libraries = params.secondary_abi_native_libraries() paths_without_parent_dirs = [ p for p in secondary_abi_libraries if os.path.sep not in p ] if paths_without_parent_dirs: sys.stderr.write('Found secondary native libraries from primary ' 'toolchain directory. This is a bug!\n') sys.stderr.write('\n'.join(paths_without_parent_dirs)) sys.stderr.write('\n\nIt may be helpful to run: \n') sys.stderr.write(' gn path out/Default //chrome/android:' 'monochrome_secondary_abi_lib //base:base\n') sys.exit(1) config['native'] = {} config['native']['libraries'] = library_paths config['native']['secondary_abi_libraries'] = secondary_abi_libraries if is_bundle_module: loadable_modules = params.get('loadable_modules', []) loadable_modules.sort() secondary_abi_loadable_modules = params.get( 'secondary_abi_loadable_modules', []) secondary_abi_loadable_modules.sort() placeholder_paths = params.get('native_lib_placeholders', []) placeholder_paths.sort() secondary_abi_placeholder_paths = params.get( 'secondary_native_lib_placeholders', []) secondary_abi_placeholder_paths.sort() config['native']['loadable_modules'] = loadable_modules config['native']['placeholders'] = placeholder_paths config['native'][ 'secondary_abi_loadable_modules'] = secondary_abi_loadable_modules config['native'][ 'secondary_abi_placeholders'] = secondary_abi_placeholder_paths config['native']['library_always_compress'] = params.get( 'library_always_compress') config['proto_resources_path'] = params['proto_resources_path'] config['base_allowlist_rtxt_path'] = params['base_allowlist_rtxt_path'] config['rtxt_path'] = params['rtxt_path'] config['module_pathmap_path'] = params['module_pathmap_path'] if is_apk_or_module or target_type == 'robolectric_binary': if path := params.get('suffix_apk_assets_used_by_config'): if path == build_config_path: target_config = config else: target_config = params_json_util.get_build_config(path) _SuffixAssets(config, target_config) if has_classpath: jar_to_target = {} all_params = params.deps() + [params] if apk_under_test_params: all_params.append(apk_under_test_params) for d in all_params.recursive(): _AddJarMapping(jar_to_target, d) # Used by check_for_missing_direct_deps.py to give better error message # when missing deps are found. Both javac_full_classpath_targets and # javac_full_classpath must be in identical orders, as they get passed as # separate arrays and then paired up based on index. config['javac_full_classpath_targets'] = [ jar_to_target[x] for x in config['javac_full_classpath'] ] if path := params.get('lint_json'): _WriteLintJson(params, path, config) build_utils.WriteJson(config, build_config_path, only_if_changed=True) if options.depfile: all_inputs = params_json_util.all_read_file_paths() if path := params.get('shared_libraries_runtime_deps_file'): # Path must be added to depfile because the GN template does not add this # input to avoid having to depend on the generated_file() target. all_inputs.append(path) if path := params.get('secondary_abi_shared_libraries_runtime_deps_file'): all_inputs.append(path) action_helpers.write_depfile(options.depfile, build_config_path, all_inputs) if __name__ == '__main__': main()