def backup_to_metadata(pab):
# copy to metadata
for dirpath, dirnames, filenames in os.walk(pab.final_images):
for f in filenames:
nicecopy.ncopy(pjoin(pab.final_images, f),
pjoin(pab.android_top, "metadata"))
pab.print_success("===> medatada/" + f)
def pab_otadiff(self):
pack_ota_path = pjoin(self.android_top, "out/host/linux-x86")
pack_ota_key = pjoin(self.android_top, self.ota_key)
ota_diff_package = "ota_diff.zip"
# ota_from_target_files [flags] input_target_files output_ota_package
pack_ota_script = pjoin(self.android_top, self.ota_script)
build_otadiff_cmd = "%s -v -i %s -p %s -k %s %s %s" % (
pack_ota_script, self.source_package, pack_ota_path, pack_ota_key,
self.target_package, ota_diff_package)
self.run_command(build_otadiff_cmd)
def __init__(self, product_device):
self.__android_top = os.path.abspath(os.getcwd())
self.__otp = "out/target/product"
self.__android_out = pjoin(self.__android_top, self.__otp,
product_device)
self.__armgcc = "prebuilts/gcc/linux-x86/arm/arm-eabi-4.6/bin/arm-eabi-"
self.__cross_compile = pjoin(self.__android_top, self.__armgcc)
self.__host_bin = "out/host/linux-x86/bin"
self.__host_utils_dir = pjoin(self.__android_top, self.__host_bin)
self.__build_target = get_config_file("bt")
build_target = parse_kv_file(self.__build_target)
self.envd = {
"android_top": self.__android_top,
"otp": self.__otp,
"armgcc": self.__armgcc,
"host_bin": self.__host_bin,
"android_out": self.__android_out,
"uboot_out": pjoin(self.__android_out, "obj", "UBOOT"),
"kernel_out": pjoin(self.__android_out, "obj", "KERNEL"),
"cross_compile": self.__cross_compile,
"host_utils_dir": self.__host_utils_dir,
"uboot_src": pjoin(self.__android_top, "u-boot"),
"kernel_src": pjoin(self.__android_top, "kernel"),
"env_setup": pjoin(self.__android_top, "build/envsetup.sh"),
"gendroid": get_config_file("gendroid"),
"kernel_config_file": build_target.get("KERNEL_CONFIG_FILE"),
"kernel_target_image": build_target.get("KERNEL_TARGET_IMAGE"),
"uboot_config": build_target.get("UBOOT_CONFIG_FILE"),
"ota_script": "build/tools/releasetools/ota_from_target_files",
"ota_key": "build/target/product/security/testkey"
}
def pab_packres(self, res_dir, res_in, res_out):
"""
pack res into resource.img
res_dir : directory contain resource ready to pack
res_in : old resource.img
res_out : new resource.img with res packed
"""
target_res_tool = pjoin(self.android_out, "resource_tool")
# copy resource tool to out dir
if not os.path.exists(target_res_tool):
nicecopy.ncopy(self.uboot_src + "/tools/resource_tool",
self.android_out)
# make tool
make_tool = "make -C %s" % target_res_tool
self.run_command(make_tool)
pack_cmd = "%s/pack_resource.sh %s %s %s %s/resource_tool" \
% (target_res_tool, res_dir, res_in, res_out,
target_res_tool)
self.run_command(pack_cmd)
nicecopy.ncopy(res_out, self.kernel_src, "resource.img")
nicecopy.ncopy(res_out, self.kernel_out, "resource.img")
nicecopy.ncopy(res_out, self.final_images, "resource.img")
os.remove(res_out)
def pab_uclean(self):
target_res_tool = pjoin(self.android_out, "resource_tool")
if os.path.exists(target_res_tool):
shutil.rmtree(target_res_tool)
if os.path.exists(self.uboot_out):
shutil.rmtree(self.uboot_out)
self.print_success("Uboot clean done.")
def pab_genu(self):
""" build uboot """
# clean all
if os.path.exists(self.uboot_out):
shutil.rmtree(self.uboot_out)
# make uboot config
make_uboot_config = self.pab_make_target(self.uboot_src,
self.uboot_out,
self.uboot_config)
if not os.path.exists(pjoin(self.uboot_out, ".config")):
self.run_command(make_uboot_config)
nicecopy.ncopy(self.rktools, self.uboot_out)
# make uboot, which just make without named target
make_uboot = self.pab_make_target(self.uboot_src, self.uboot_out, "")
self.run_command(make_uboot)
nicecopy.ncopy(self.loader, self.final_images)
# pack logo
self.pab_packres(self.logo_resource, self.res_in, self.res_out_logo)
# print some info
loadername = self.loader.split('/')[-1]
self.print_success("===> %s" %
(os.path.join(self.final_images_r, loadername)))
def pab_kconfig(self):
# no config file, generate it first
make_config = self.pab_make_target(self.kernel_src, self.kernel_out,
self.kernel_config_file)
if not os.path.exists(pjoin(self.kernel_out, ".config")):
self.run_command(make_config)
# make menuconfig
make_menuconfig = self.pab_make_target(self.kernel_src,
self.kernel_out, "menuconfig")
self.run_command(make_menuconfig)
def pab_genr(self):
""" pack recovery image """
if os.path.exists(self.android_out + '/recovery/root'):
cmds = []
cmd = "%s/mkbootfs %s/recovery/root | %s/minigzip > %s/ramdisk-recovery.img" % \
(self.host_bin, self.android_out, self.host_bin,
self.android_out)
cmds.append(cmd)
cmd = "/usr/bin/truncate -s %%4 %s/ramdisk-recovery.img" % self.android_out
cmds.append(cmd)
cmd = "%s/mkbootimg --kernel %s/arch/arm/boot/zImage \
--ramdisk %s/ramdisk-recovery.img --second %s/resource.img --output %s/recovery.img" % (
self.host_bin, self.kernel_out, self.android_out,
self.kernel_out, self.android_out)
cmds.append(cmd)
self.run_cmdlist(cmds)
nicecopy.ncopy(pjoin(self.android_out, 'recovery.img'),
self.final_images)
# print message
self.print_success("===> " + self.final_images_r + "/recovery.img")
def pab_genb(self):
""" build boot image """
if os.path.exists(self.android_out + '/root'):
cmds = []
cmd = "%s/mkbootfs %s/root | %s/minigzip > %s/ramdisk.img" % \
(self.host_bin, self.android_out, self.host_bin,
self.android_out)
cmds.append(cmd)
cmd = "/usr/bin/truncate -s %%4 %s/ramdisk.img" % self.android_out
cmds.append(cmd)
cmd = "%s/mkbootimg --kernel %s/arch/arm/boot/zImage \
--ramdisk %s/ramdisk.img --second %s/resource.img --output %s/boot.img" \
% (self.host_bin, self.kernel_out,
self.android_out, self.kernel_out, self.android_out)
cmds.append(cmd)
self.run_cmdlist(cmds)
nicecopy.ncopy(pjoin(self.android_out, 'boot.img'),
self.final_images)
self.print_success("===> %s" %
(os.path.join(self.final_images_r, "boot.img")))
else:
self.goto_exit("No root dir exist.")
def __init__(self):
# init log function with color enable
color_print = ColorPrint(True)
self.print_success = color_print.color_print_success
self.print_warn = color_print.color_print_warn
# timestamp
self.time_stamp = time.strftime('%Y%m%d', time.localtime(time.time()))
# build argument
pa = BuildArgument()
for k, v in pa.argsd.iteritems():
setattr(self, k, v)
self.lunchcombo = self.target_product + "-" + self.build_varient
# build enviroment
be = BuildEnv(self.product_device)
for k, v in be.envd.iteritems():
setattr(self, k, v)
# vendor
self.rktools = pjoin(self.uboot_src, "tools")
self.loader = pjoin(self.uboot_out, "RK3288UbootLoader_V2.30.10.bin")
# final images absolutely path
self.final_images = pjoin(self.android_top,
"rockdev/Image-" + self.target_product)
# final images relatively path
self.final_images_r = self.final_images[len(self.android_top) + 1:]
self.logo_resource = pjoin(self.uboot_src,
"tools/resource_tool/resources")
self.res_in = pjoin(self.kernel_src, "resource.img")
self.res_out_logo = "resource_logo.img"
self.res_out_fdt = "resource_dtb.img"
self.misc_img = pjoin(self.android_top, "rkst/Image")
self.vendor_package_tag = get_vendor_xxx_info()[2]
def pab_genk(self):
""" build kernel """
# copy necessary file or dir
prev_copy_filename = get_config_file("prevcp")
with open(prev_copy_filename) as f:
cp_list = f.read().splitlines()
nicecopy.copy_stuffs(self.kernel_src, self.kernel_out, cp_list)
# all the target cmd
make_cmds = []
# config cmd
make_config = self.pab_make_target(self.kernel_src, self.kernel_out,
self.kernel_config_file)
# not config file? make one
if not os.path.exists(pjoin(self.kernel_out, ".config")):
make_cmds.append(make_config)
# kernel cmd
make_kernel = self.pab_make_target(self.kernel_src, self.kernel_out,
self.kernel_target_image)
make_cmds.append(make_kernel)
# dtb cmd
dtb_file = get_config_file("dtbs")
with open(dtb_file) as f:
dtb_list = f.read().splitlines()
# dtb file not empty
if not dtb_list == []:
for dtb in dtb_list:
make_dtb = self.pab_make_target(self.kernel_src,
self.kernel_out, dtb)
make_cmds.append(make_dtb)
# modules cmd
self.append_modules_target(make_cmds)
# start make things we need
self.run_cmdlist(make_cmds)
# dtb file not empty
if not dtb_list == []:
# pack resource image
# multi dtb supported
fdt_res_dir = pjoin(self.android_top, "fdt_res")
if not os.path.exists(fdt_res_dir):
os.mkdir(fdt_res_dir)
# copy dtbs to fdt_res_dir
dtbs_dir = pjoin(self.kernel_out, "arch/arm/boot/dts/")
for i in range(len(dtb_list)):
nicecopy.ncopy(dtbs_dir + dtb_list[i], fdt_res_dir)
fdt_res = pjoin(self.android_top, "fdt_res")
res_in = pjoin(self.kernel_out, "resource.img")
res_out = pjoin(fdt_res, "resource_fdt.img")
self.pab_packres(fdt_res, res_in, res_out)
shutil.rmtree(fdt_res_dir)
# Misc stuff
post_copy_filename = get_config_file("postcp")
with open(post_copy_filename) as f:
misc_stuff = f.read().splitlines()
nicecopy.copy_stuffs(self.kernel_out, self.kernel_src, misc_stuff)
# final copy
final_copy = ["kernel.img", "resource.img"]
nicecopy.copy_stuffs(self.kernel_out, self.final_images, final_copy)
def pab_genus(self):
# copy userdata
nicecopy.ncopy(pjoin(self.android_out, "userdata.img"),
pjoin(self.android_top, "metadata"))