Merge "Add BOARD_SUPER_IMAGE_IN_UPDATE_PACKAGE flag." into qt-dev (d8900299) · Commits · e / os / android_build

core/Makefile

+49 −20

Original line number	Diff line number	Diff line
		@@ -3806,6 +3806,8 @@ define dump-dynamic-partitions-info
		echo "super_$(group)_partition_list=$(BOARD_$(call to-upper,$(group))_PARTITION_LIST)" >> $(1);))
		$(if $(filter true,$(TARGET_USERIMAGES_SPARSE_EXT_DISABLED)), \
		echo "build_non_sparse_super_partition=true" >> $(1))
		$(if $(filter true,$(BOARD_SUPER_IMAGE_IN_UPDATE_PACKAGE)), \
		echo "super_image_in_update_package=true" >> $(1))
		endef

		# Depending on the various images guarantees that the underlying
		@@ -4308,25 +4310,6 @@ endif # BOARD_BUILD_RETROFIT_DYNAMIC_PARTITIONS_OTA_PACKAGE

		endif # build_ota_package

		# -----------------------------------------------------------------
		# The update package

		name := $(TARGET_PRODUCT)
		ifeq ($(TARGET_BUILD_TYPE),debug)
		name := $(name)_debug
		endif
		name := $(name)-img-$(FILE_NAME_TAG)

		INTERNAL_UPDATE_PACKAGE_TARGET := $(PRODUCT_OUT)/$(name).zip

		$(INTERNAL_UPDATE_PACKAGE_TARGET): $(BUILT_TARGET_FILES_PACKAGE) $(ZIP2ZIP)
		@echo "Package: $@"
		$(hide) $(ZIP2ZIP) -i $(BUILT_TARGET_FILES_PACKAGE) -o $@ \
		OTA/android-info.txt:android-info.txt "IMAGES/*.img:."

		.PHONY: updatepackage
		updatepackage: $(INTERNAL_UPDATE_PACKAGE_TARGET)

		# -----------------------------------------------------------------
		# A zip of the appcompat directory containing logs
		APPCOMPAT_ZIP := $(PRODUCT_OUT)/appcompat.zip
		@@ -4348,7 +4331,6 @@ $(APPCOMPAT_ZIP): $(SOONG_ZIP)
		$(hide) find $(PRODUCT_OUT)/appcompat \| sort >$(PRIVATE_LIST_FILE)
		$(hide) $(SOONG_ZIP) -d -o $@ -C $(PRODUCT_OUT)/appcompat -l $(PRIVATE_LIST_FILE)


		# -----------------------------------------------------------------
		# A zip of the symbols directory. Keep the full paths to make it
		# more obvious where these files came from.
		@@ -4497,7 +4479,10 @@ $(INTERNAL_SUPERIMAGE_DIST_TARGET): $(LPMAKE) $(BUILT_TARGET_FILES_PACKAGE) $(BU
		PATH=$(dir $(LPMAKE)):$$PATH \
		$(BUILD_SUPER_IMAGE) -v $(extracted_input_target_files) $@

		# Skip packing it in dist package because it is in update package.
		ifneq (true,$(BOARD_SUPER_IMAGE_IN_UPDATE_PACKAGE))
		$(call dist-for-goals,dist_files,$(INTERNAL_SUPERIMAGE_DIST_TARGET))
		endif

		.PHONY: superimage_dist
		superimage_dist: $(INTERNAL_SUPERIMAGE_DIST_TARGET)
		@@ -4581,6 +4566,50 @@ $(call dist-for-goals,dist_files,$(INSTALLED_SUPERIMAGE_EMPTY_TARGET))
		endif # BOARD_SUPER_PARTITION_SIZE != ""
		endif # PRODUCT_BUILD_SUPER_PARTITION == "true"


		# -----------------------------------------------------------------
		# The update package

		name := $(TARGET_PRODUCT)
		ifeq ($(TARGET_BUILD_TYPE),debug)
		name := $(name)_debug
		endif
		name := $(name)-img-$(FILE_NAME_TAG)

		INTERNAL_UPDATE_PACKAGE_TARGET := $(PRODUCT_OUT)/$(name).zip

		$(INTERNAL_UPDATE_PACKAGE_TARGET): $(BUILT_TARGET_FILES_PACKAGE) $(ZIP2ZIP)

		ifeq (true,$(BOARD_SUPER_IMAGE_IN_UPDATE_PACKAGE))
		$(INTERNAL_UPDATE_PACKAGE_TARGET): $(INTERNAL_SUPERIMAGE_DIST_TARGET)
		@echo "Package: $@"
		# Filter out super_empty and images in BOARD_SUPER_PARTITION_PARTITION_LIST.
		# Filter out system_other for launch DAP devices because it is in super image.
		# Include OTA/super_*.img for retrofit devices and super.img for non-retrofit
		# devices.
		$(hide) $(ZIP2ZIP) -i $(BUILT_TARGET_FILES_PACKAGE) -o $@ \
		-x IMAGES/super_empty.img \
		$(foreach partition,$(BOARD_SUPER_PARTITION_PARTITION_LIST), \
		-x IMAGES/$(partition).img) \
		$(if $(filter system, $(BOARD_SUPER_PARTITION_PARTITION_LIST)), \
		$(if $(filter true, $(PRODUCT_RETROFIT_DYNAMIC_PARTITIONS)),, \
		-x IMAGES/system_other.img)) \
		$(if $(filter true,$(PRODUCT_RETROFIT_DYNAMIC_PARTITIONS)), \
		$(foreach device,$(BOARD_SUPER_PARTITION_BLOCK_DEVICES), \
		OTA/super_$(device).img:super_$(device).img)) \
		OTA/android-info.txt:android-info.txt "IMAGES/*.img:."
		$(if $(INTERNAL_SUPERIMAGE_DIST_TARGET), zip -q -j -u $@ $(INTERNAL_SUPERIMAGE_DIST_TARGET))
		else
		$(INTERNAL_UPDATE_PACKAGE_TARGET):
		@echo "Package: $@"
		$(hide) $(ZIP2ZIP) -i $(BUILT_TARGET_FILES_PACKAGE) -o $@ \
		OTA/android-info.txt:android-info.txt "IMAGES/*.img:."
		endif # BOARD_SUPER_IMAGE_IN_UPDATE_PACKAGE

		.PHONY: updatepackage
		updatepackage: $(INTERNAL_UPDATE_PACKAGE_TARGET)


		# -----------------------------------------------------------------
		# dalvik something
		.PHONY: dalvikfiles

tools/releasetools/img_from_target_files.py

+101 −18

Original line number	Diff line number	Diff line
		@@ -35,6 +35,7 @@ import sys
		import zipfile

		import common
		from build_super_image import BuildSuperImage

		if sys.hexversion < 0x02070000:
		print("Python 2.7 or newer is required.", file=sys.stderr)
		@@ -45,13 +46,102 @@ logger = logging.getLogger(__name__)
		OPTIONS = common.OPTIONS


		def CopyInfo(output_zip):
		def LoadOptions(input_file):
		"""
		Load information from input_file to OPTIONS.

		Args:
		input_file: A Zipfile instance of input zip file, or path to the directory
		of extracted zip.
		"""
		info = OPTIONS.info_dict = common.LoadInfoDict(input_file)

		OPTIONS.put_super = info.get("super_image_in_update_package") == "true"
		OPTIONS.dynamic_partition_list = info.get("dynamic_partition_list",
		"").strip().split()
		OPTIONS.super_device_list = info.get("super_block_devices",
		"").strip().split()
		OPTIONS.retrofit_dap = info.get("dynamic_partition_retrofit") == "true"
		OPTIONS.build_super = info.get("build_super_partition") == "true"
		OPTIONS.sparse_userimages = bool(info.get("extfs_sparse_flag"))


		def CopyInfo(input_tmp, output_zip):
		"""Copy the android-info.txt file from the input to the output."""
		common.ZipWrite(
		output_zip, os.path.join(OPTIONS.input_tmp, "OTA", "android-info.txt"),
		output_zip, os.path.join(input_tmp, "OTA", "android-info.txt"),
		"android-info.txt")


		def CopyUserImages(input_tmp, output_zip):
		"""
		Copy user images from the unzipped input and write to output_zip.

		Args:
		input_tmp: path to the unzipped input.
		output_zip: a ZipFile instance to write images to.
		"""
		dynamic_images = [p + ".img" for p in OPTIONS.dynamic_partition_list]

		# Filter out system_other for launch DAP devices because it is in super image.
		if not OPTIONS.retrofit_dap and "system" in OPTIONS.dynamic_partition_list:
		dynamic_images.append("system_other.img")

		images_path = os.path.join(input_tmp, "IMAGES")
		# A target-files zip must contain the images since Lollipop.
		assert os.path.exists(images_path)
		for image in sorted(os.listdir(images_path)):
		if OPTIONS.bootable_only and image not in ("boot.img", "recovery.img"):
		continue
		if not image.endswith(".img"):
		continue
		if image == "recovery-two-step.img":
		continue
		if OPTIONS.put_super:
		if image == "super_empty.img":
		continue
		if image in dynamic_images:
		continue
		logger.info("writing %s to archive...", os.path.join("IMAGES", image))
		common.ZipWrite(output_zip, os.path.join(images_path, image), image)


		def WriteSuperImages(input_tmp, output_zip):
		"""
		Write super images from the unzipped input and write to output_zip. This is
		only done if super_image_in_update_package is set to "true".

		- For retrofit dynamic partition devices, copy split super images from target
		files package.
		- For devices launched with dynamic partitions, build super image from target
		files package.

		Args:
		input_tmp: path to the unzipped input.
		output_zip: a ZipFile instance to write images to.
		"""
		if not OPTIONS.build_super or not OPTIONS.put_super:
		return

		if OPTIONS.retrofit_dap:
		# retrofit devices already have split super images under OTA/
		images_path = os.path.join(input_tmp, "OTA")
		for device in OPTIONS.super_device_list:
		image = "super_%s.img" % device
		image_path = os.path.join(images_path, image)
		assert os.path.exists(image_path)
		logger.info("writing %s to archive...", os.path.join("OTA", image))
		common.ZipWrite(output_zip, image_path, image)
		else:
		# super image for non-retrofit devices aren't in target files package,
		# so build it.
		super_file = common.MakeTempFile("super_", ".img")
		logger.info("building super image %s...", super_file)
		BuildSuperImage(input_tmp, super_file)
		logger.info("writing super.img to archive...")
		common.ZipWrite(output_zip, super_file, "super.img")


		def main(argv):
		# This allows modifying the value from inner function.
		bootable_only_array = [False]
		@@ -68,7 +158,7 @@ def main(argv):
		extra_long_opts=["bootable_zip"],
		extra_option_handler=option_handler)

		bootable_only = bootable_only_array[0]
		OPTIONS.bootable_only = bootable_only_array[0]

		if len(args) != 2:
		common.Usage(__doc__)
		@@ -76,23 +166,16 @@ def main(argv):

		common.InitLogging()

		OPTIONS.input_tmp = common.UnzipTemp(args[0], ["IMAGES/", "OTA/"])
		output_zip = zipfile.ZipFile(args[1], "w", compression=zipfile.ZIP_DEFLATED)
		CopyInfo(output_zip)
		OPTIONS.input_tmp = common.UnzipTemp(args[0],
		["IMAGES/", "OTA/", "META/*"])
		LoadOptions(OPTIONS.input_tmp)
		output_zip = zipfile.ZipFile(args[1], "w", compression=zipfile.ZIP_DEFLATED,
		allowZip64=not OPTIONS.sparse_userimages)

		try:
		images_path = os.path.join(OPTIONS.input_tmp, "IMAGES")
		# A target-files zip must contain the images since Lollipop.
		assert os.path.exists(images_path)
		for image in sorted(os.listdir(images_path)):
		if bootable_only and image not in ("boot.img", "recovery.img"):
		continue
		if not image.endswith(".img"):
		continue
		if image == "recovery-two-step.img":
		continue
		common.ZipWrite(output_zip, os.path.join(images_path, image), image)

		CopyInfo(OPTIONS.input_tmp, output_zip)
		CopyUserImages(OPTIONS.input_tmp, output_zip)
		WriteSuperImages(OPTIONS.input_tmp, output_zip)
		finally:
		logger.info("cleaning up...")
		common.ZipClose(output_zip)