Merge changes I637dea34,I4a9fa35c,I5c952cd2 into rvc-dev (8098b73e) · Commits · e / os / android_build

tools/releasetools/add_img_to_target_files.py

+5 −3

Original line number	Diff line number	Diff line
		@@ -600,17 +600,19 @@ def AddCareMapForAbOta(output_zip, ab_partitions, image_paths):
		care_map_list += care_map

		# adds fingerprint field to the care_map
		build_props = OPTIONS.info_dict.get(partition + ".build.prop", {})
		# TODO(xunchang) revisit the fingerprint calculation for care_map.
		partition_props = OPTIONS.info_dict.get(partition + ".build.prop")
		prop_name_list = ["ro.{}.build.fingerprint".format(partition),
		"ro.{}.build.thumbprint".format(partition)]

		present_props = [x for x in prop_name_list if x in build_props]
		present_props = [x for x in prop_name_list if
		partition_props and partition_props.GetProp(x)]
		if not present_props:
		logger.warning("fingerprint is not present for partition %s", partition)
		property_id, fingerprint = "unknown", "unknown"
		else:
		property_id = present_props[0]
		fingerprint = build_props[property_id]
		fingerprint = partition_props.GetProp(property_id)
		care_map_list += [property_id, fingerprint]

		if not care_map_list:

tools/releasetools/build_image.py

+3 −3

Original line number	Diff line number	Diff line
		@@ -509,9 +509,9 @@ def ImagePropFromGlobalDict(glob_dict, mount_point):
		d = {}

		if "build.prop" in glob_dict:
		bp = glob_dict["build.prop"]
		if "ro.build.date.utc" in bp:
		d["timestamp"] = bp["ro.build.date.utc"]
		timestamp = glob_dict["build.prop"].GetProp("ro.build.date.utc")
		if timestamp:
		d["timestamp"] = timestamp

		def copy_prop(src_p, dest_p):
		"""Copy a property from the global dictionary.

tools/releasetools/check_target_files_vintf.py

+2 −1

Original line number	Diff line number	Diff line
		@@ -80,8 +80,9 @@ def GetArgsForSkus(info_dict):
		'--property', 'ro.boot.product.vendor.sku=' + vendor_sku]
		for odm_sku in odm_skus for vendor_sku in vendor_skus]


		def GetArgsForShippingApiLevel(info_dict):
		shipping_api_level = info_dict['vendor.build.prop'].get(
		shipping_api_level = info_dict['vendor.build.prop'].GetProp(
		'ro.product.first_api_level')
		if not shipping_api_level:
		logger.warning('Cannot determine ro.product.first_api_level')

tools/releasetools/common.py

+154 −46

Original line number	Diff line number	Diff line
		@@ -422,6 +422,14 @@ class BuildInfo(object):
		def items(self):
		return self.info_dict.items()

		def _GetRawBuildProp(self, prop, partition):
		prop_file = '{}.build.prop'.format(
		partition) if partition else 'build.prop'
		partition_props = self.info_dict.get(prop_file)
		if not partition_props:
		return None
		return partition_props.GetProp(prop)

		def GetPartitionBuildProp(self, prop, partition):
		"""Returns the inquired build property for the provided partition."""
		# If provided a partition for this property, only look within that
		@@ -430,9 +438,10 @@ class BuildInfo(object):
		prop = prop.replace("ro.product", "ro.product.{}".format(partition))
		else:
		prop = prop.replace("ro.", "ro.{}.".format(partition))
		try:
		return self.info_dict.get("{}.build.prop".format(partition), {})[prop]
		except KeyError:

		prop_val = self._GetRawBuildProp(prop, partition)
		if prop_val is not None:
		return prop_val
		raise ExternalError("couldn't find %s in %s.build.prop" %
		(prop, partition))

		@@ -441,20 +450,21 @@ class BuildInfo(object):
		if prop in BuildInfo._RO_PRODUCT_RESOLVE_PROPS:
		return self._ResolveRoProductBuildProp(prop)

		try:
		return self.info_dict.get("build.prop", {})[prop]
		except KeyError:
		prop_val = self._GetRawBuildProp(prop, None)
		if prop_val is not None:
		return prop_val

		raise ExternalError("couldn't find %s in build.prop" % (prop,))

		def _ResolveRoProductBuildProp(self, prop):
		"""Resolves the inquired ro.product.* build property"""
		prop_val = self.info_dict.get("build.prop", {}).get(prop)
		prop_val = self._GetRawBuildProp(prop, None)
		if prop_val:
		return prop_val

		default_source_order = self._GetRoProductPropsDefaultSourceOrder()
		source_order_val = self.info_dict.get("build.prop", {}).get(
		"ro.product.property_source_order")
		source_order_val = self._GetRawBuildProp(
		"ro.product.property_source_order", None)
		if source_order_val:
		source_order = source_order_val.split(",")
		else:
		@@ -465,11 +475,10 @@ class BuildInfo(object):
		raise ExternalError(
		"Invalid ro.product.property_source_order '{}'".format(source_order))

		for source in source_order:
		for source_partition in source_order:
		source_prop = prop.replace(
		"ro.product", "ro.product.{}".format(source), 1)
		prop_val = self.info_dict.get(
		"{}.build.prop".format(source), {}).get(source_prop)
		"ro.product", "ro.product.{}".format(source_partition), 1)
		prop_val = self._GetRawBuildProp(source_prop, source_partition)
		if prop_val:
		return prop_val

		@@ -478,11 +487,9 @@ class BuildInfo(object):
		def _GetRoProductPropsDefaultSourceOrder(self):
		# NOTE: refer to CDDs and android.os.Build.VERSION for the definition and
		# values of these properties for each Android release.
		android_codename = self.info_dict.get("build.prop", {}).get(
		"ro.build.version.codename")
		android_codename = self._GetRawBuildProp("ro.build.version.codename", None)
		if android_codename == "REL":
		android_version = self.info_dict.get("build.prop", {}).get(
		"ro.build.version.release")
		android_version = self._GetRawBuildProp("ro.build.version.release", None)
		if android_version == "10":
		return BuildInfo._RO_PRODUCT_PROPS_DEFAULT_SOURCE_ORDER_ANDROID_10
		# NOTE: float() conversion of android_version will have rounding error.
		@@ -565,6 +572,20 @@ class BuildInfo(object):
		script.AssertOemProperty(prop, values, oem_no_mount)


		def ReadFromInputFile(input_file, fn):
		"""Reads the contents of fn from input zipfile or directory."""
		if isinstance(input_file, zipfile.ZipFile):
		return input_file.read(fn).decode()
		else:
		path = os.path.join(input_file, *fn.split("/"))
		try:
		with open(path) as f:
		return f.read()
		except IOError as e:
		if e.errno == errno.ENOENT:
		raise KeyError(fn)


		def LoadInfoDict(input_file, repacking=False):
		"""Loads the key/value pairs from the given input target_files.

		@@ -602,16 +623,7 @@ def LoadInfoDict(input_file, repacking=False):
		"input_file must be a path str when doing repacking"

		def read_helper(fn):
		if isinstance(input_file, zipfile.ZipFile):
		return input_file.read(fn).decode()
		else:
		path = os.path.join(input_file, *fn.split("/"))
		try:
		with open(path) as f:
		return f.read()
		except IOError as e:
		if e.errno == errno.ENOENT:
		raise KeyError(fn)
		return ReadFromInputFile(input_file, fn)

		try:
		d = LoadDictionaryFromLines(read_helper("META/misc_info.txt").split("\n"))
		@@ -679,13 +691,8 @@ def LoadInfoDict(input_file, repacking=False):
		# system and vendor.
		for partition in PARTITIONS_WITH_CARE_MAP:
		partition_prop = "{}.build.prop".format(partition)
		d[partition_prop] = LoadBuildProp(
		read_helper, "{}/build.prop".format(partition.upper()))
		# Some partition might use /<partition>/etc/build.prop as the new path.
		# TODO: try new path first when majority of them switch to the new path.
		if not d[partition_prop]:
		d[partition_prop] = LoadBuildProp(
		read_helper, "{}/etc/build.prop".format(partition.upper()))
		d[partition_prop] = PartitionBuildProps.FromInputFile(
		input_file, partition)
		d["build.prop"] = d["system.build.prop"]

		# Set up the salt (based on fingerprint) that will be used when adding AVB
		@@ -700,15 +707,6 @@ def LoadInfoDict(input_file, repacking=False):
		return d


		def LoadBuildProp(read_helper, prop_file):
		try:
		data = read_helper(prop_file)
		except KeyError:
		logger.warning("Failed to read %s", prop_file)
		data = ""
		return LoadDictionaryFromLines(data.split("\n"))


		def LoadListFromFile(file_path):
		with open(file_path) as f:
		return f.read().splitlines()
		@@ -731,6 +729,116 @@ def LoadDictionaryFromLines(lines):
		return d


		class PartitionBuildProps(object):
		"""The class holds the build prop of a particular partition.

		This class loads the build.prop and holds the build properties for a given
		partition. It also partially recognizes the 'import' statement in the
		build.prop; and calculates alternative values of some specific build
		properties during runtime.

		Attributes:
		input_file: a zipped target-file or an unzipped target-file directory.
		partition: name of the partition.
		props_allow_override: a list of build properties to search for the
		alternative values during runtime.
		build_props: a dict of build properties for the given partition.
		prop_overrides: a set of props that are overridden by import.
		placeholder_values: A dict of runtime variables' values to replace the
		placeholders in the build.prop file. We expect exactly one value for
		each of the variables.
		"""
		def __init__(self, input_file, name, placeholder_values=None):
		self.input_file = input_file
		self.partition = name
		self.props_allow_override = [props.format(name) for props in [
		'ro.product.{}.brand', 'ro.product.{}.name', 'ro.product.{}.device']]
		self.build_props = {}
		self.prop_overrides = set()
		self.placeholder_values = {}
		if placeholder_values:
		self.placeholder_values = copy.deepcopy(placeholder_values)

		@staticmethod
		def FromDictionary(name, build_props):
		"""Constructs an instance from a build prop dictionary."""

		props = PartitionBuildProps("unknown", name)
		props.build_props = build_props.copy()
		return props

		@staticmethod
		def FromInputFile(input_file, name, placeholder_values=None):
		"""Loads the build.prop file and builds the attributes."""
		data = ''
		for prop_file in ['{}/etc/build.prop'.format(name.upper()),
		'{}/build.prop'.format(name.upper())]:
		try:
		data = ReadFromInputFile(input_file, prop_file)
		break
		except KeyError:
		logger.warning('Failed to read %s', prop_file)

		props = PartitionBuildProps(input_file, name, placeholder_values)
		props._LoadBuildProp(data)
		return props

		def _LoadBuildProp(self, data):
		for line in data.split('\n'):
		line = line.strip()
		if not line or line.startswith("#"):
		continue
		if line.startswith("import"):
		overrides = self._ImportParser(line)
		duplicates = self.prop_overrides.intersection(overrides.keys())
		if duplicates:
		raise ValueError('prop {} is overridden multiple times'.format(
		','.join(duplicates)))
		self.prop_overrides = self.prop_overrides.union(overrides.keys())
		self.build_props.update(overrides)
		elif "=" in line:
		name, value = line.split("=", 1)
		if name in self.prop_overrides:
		raise ValueError('prop {} is set again after overridden by import '
		'statement'.format(name))
		self.build_props[name] = value

		def _ImportParser(self, line):
		"""Parses the build prop in a given import statement."""

		tokens = line.split()
		if len(tokens) != 2 or tokens[0] != 'import':
		raise ValueError('Unrecognized import statement {}'.format(line))
		import_path = tokens[1]
		if not re.match(r'^/{}/.*\.prop$'.format(self.partition), import_path):
		raise ValueError('Unrecognized import path {}'.format(line))

		# We only recognize a subset of import statement that the init process
		# supports. And we can loose the restriction based on how the dynamic
		# fingerprint is used in practice. The placeholder format should be
		# ${placeholder}, and its value should be provided by the caller through
		# the placeholder_values.
		for prop, value in self.placeholder_values.items():
		prop_place_holder = '${{{}}}'.format(prop)
		if prop_place_holder in import_path:
		import_path = import_path.replace(prop_place_holder, value)
		if '$' in import_path:
		logger.info('Unresolved place holder in import path %s', import_path)
		return {}

		import_path = import_path.replace('/{}'.format(self.partition),
		self.partition.upper())
		logger.info('Parsing build props override from %s', import_path)

		lines = ReadFromInputFile(self.input_file, import_path).split('\n')
		d = LoadDictionaryFromLines(lines)
		return {key: val for key, val in d.items()
		if key in self.props_allow_override}

		def GetProp(self, prop):
		return self.build_props.get(prop)


		def LoadRecoveryFSTab(read_helper, fstab_version, recovery_fstab_path,
		system_root_image=False):
		class Partition(object):

tools/releasetools/ota_from_target_files.py

+65 −7

Original line number	Diff line number	Diff line
		@@ -189,6 +189,13 @@ A/B OTA specific options
		--payload_signer_key_size <key_size>
		Deprecated. Use the '--payload_signer_maximum_signature_size' instead.

		--boot_variable_file <path>
		A file that contains the possible values of ro.boot.* properties. It's
		used to calculate the possible runtime fingerprints when some
		ro.product.* properties are overridden by the 'import' statement.
		The file expects one property per line, and each line has the following
		format: 'prop_name=value1,value2'. e.g. 'ro.boot.product.sku=std,pro'

		--skip_postinstall
		Skip the postinstall hooks when generating an A/B OTA package (default:
		False). Note that this discards ALL the hooks, including non-optional
		@@ -200,6 +207,8 @@ A/B OTA specific options
		from __future__ import print_function

		import collections
		import copy
		import itertools
		import logging
		import multiprocessing
		import os.path
		@@ -236,6 +245,7 @@ OPTIONS.include_secondary = False
		OPTIONS.no_signing = False
		OPTIONS.block_based = True
		OPTIONS.updater_binary = None
		OPTIONS.oem_dicts = None
		OPTIONS.oem_source = None
		OPTIONS.oem_no_mount = False
		OPTIONS.full_radio = False
		@@ -255,6 +265,7 @@ OPTIONS.skip_compatibility_check = False
		OPTIONS.output_metadata_path = None
		OPTIONS.disable_fec_computation = False
		OPTIONS.force_non_ab = False
		OPTIONS.boot_variable_file = None


		METADATA_NAME = 'META-INF/com/android/metadata'
		@@ -927,8 +938,18 @@ def GetPackageMetadata(target_info, source_info=None):
		assert isinstance(target_info, common.BuildInfo)
		assert source_info is None or isinstance(source_info, common.BuildInfo)

		separator = '\|'

		boot_variable_values = {}
		if OPTIONS.boot_variable_file:
		d = common.LoadDictionaryFromFile(OPTIONS.boot_variable_file)
		for key, values in d.items():
		boot_variable_values[key] = [val.strip() for val in values.split(',')]

		post_build_devices, post_build_fingerprints = \
		CalculateRuntimeDevicesAndFingerprints(target_info, boot_variable_values)
		metadata = {
		'post-build' : target_info.fingerprint,
		'post-build': separator.join(sorted(post_build_fingerprints)),
		'post-build-incremental': target_info.GetBuildProp(
		'ro.build.version.incremental'),
		'post-sdk-level': target_info.GetBuildProp(
		@@ -951,12 +972,15 @@ def GetPackageMetadata(target_info, source_info=None):

		is_incremental = source_info is not None
		if is_incremental:
		metadata['pre-build'] = source_info.fingerprint
		pre_build_devices, pre_build_fingerprints = \
		CalculateRuntimeDevicesAndFingerprints(source_info,
		boot_variable_values)
		metadata['pre-build'] = separator.join(sorted(pre_build_fingerprints))
		metadata['pre-build-incremental'] = source_info.GetBuildProp(
		'ro.build.version.incremental')
		metadata['pre-device'] = source_info.device
		metadata['pre-device'] = separator.join(sorted(pre_build_devices))
		else:
		metadata['pre-device'] = target_info.device
		metadata['pre-device'] = separator.join(sorted(post_build_devices))

		# Use the actual post-timestamp, even for a downgrade case.
		metadata['post-timestamp'] = target_info.GetBuildProp('ro.build.date.utc')
		@@ -1968,6 +1992,37 @@ def GenerateNonAbOtaPackage(target_file, output_file, source_file=None):
		output_file)


		def CalculateRuntimeDevicesAndFingerprints(build_info, boot_variable_values):
		"""Returns a tuple of sets for runtime devices and fingerprints"""

		device_names = {build_info.device}
		fingerprints = {build_info.fingerprint}

		if not boot_variable_values:
		return device_names, fingerprints

		# Calculate all possible combinations of the values for the boot variables.
		keys = boot_variable_values.keys()
		value_list = boot_variable_values.values()
		combinations = [dict(zip(keys, values))
		for values in itertools.product(*value_list)]
		for placeholder_values in combinations:
		# Reload the info_dict as some build properties may change their values
		# based on the value of ro.boot* properties.
		info_dict = copy.deepcopy(build_info.info_dict)
		for partition in common.PARTITIONS_WITH_CARE_MAP:
		partition_prop_key = "{}.build.prop".format(partition)
		old_props = info_dict[partition_prop_key]
		info_dict[partition_prop_key] = common.PartitionBuildProps.FromInputFile(
		old_props.input_file, partition, placeholder_values)
		info_dict["build.prop"] = info_dict["system.build.prop"]

		new_build_info = common.BuildInfo(info_dict, build_info.oem_dicts)
		device_names.add(new_build_info.device)
		fingerprints.add(new_build_info.fingerprint)
		return device_names, fingerprints


		def main(argv):

		def option_handler(o, a):
		@@ -2043,6 +2098,8 @@ def main(argv):
		OPTIONS.disable_fec_computation = True
		elif o == "--force_non_ab":
		OPTIONS.force_non_ab = True
		elif o == "--boot_variable_file":
		OPTIONS.boot_variable_file = a
		else:
		return False
		return True
		@@ -2080,6 +2137,7 @@ def main(argv):
		"output_metadata_path=",
		"disable_fec_computation",
		"force_non_ab",
		"boot_variable_file=",
		], extra_option_handler=option_handler)

		if len(args) != 2: