LineageOS/android_development
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
062f9cb27e697f679cfcefc436aed70f11df8f8f
android_development/vndk/snapshot/gen_buildfiles.py
Jae Shin a2504712de Prevent manifest file from being added to prebuilts 
Change logic that handles the manifest file so that the manifest
is not added to the prebuilts/ directory but remains in a
temporary dir for GPL checking. At the end of the update.py script,
the manifest file is deleted when the temporary dir is deleted.

Also modify how check_gpl_license.py is run independently since
the manifest file has to be fetched first.

Test: python update.py -b oc-mr1-treble-dev --build 4728343 -vv 27
Bug: 77546642
Change-Id: I7749e2998cd12325b9c6275da5e697e328137b73
2018-04-19 14:56:28 +09:00

365 lines
14 KiB
Python
Raw Blame History

#!/usr/bin/env python
#
# Copyright (C) 2017 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import glob
import os
import sys
import utils
class GenBuildFile(object):
"""Generates Android.mk and Android.bp for VNDK snapshot.
VNDK snapshot directory structure under prebuilts/vndk/v{version}:
{SNAPSHOT_VARIANT}/
Android.bp
arch-{TARGET_ARCH}-{TARGET_ARCH_VARIANT}/
shared/
vndk-core/
(VNDK-core libraries, e.g. libbinder.so)
vndk-sp/
(VNDK-SP libraries, e.g. libc++.so)
arch-{TARGET_2ND_ARCH}-{TARGET_2ND_ARCH_VARIANT}/
shared/
vndk-core/
(VNDK-core libraries, e.g. libbinder.so)
vndk-sp/
(VNDK-SP libraries, e.g. libc++.so)
configs/
(various *.txt configuration files, e.g. ld.config.*.txt)
... (other {SNAPSHOT_VARIANT}/ directories)
common/
Android.mk
NOTICE_FILES/
(license files, e.g. libfoo.so.txt)
"""
INDENT = ' '
ETC_MODULES = [
'ld.config.txt', 'llndk.libraries.txt', 'vndksp.libraries.txt'
]
# TODO(b/70312118): Parse from soong build system
RELATIVE_INSTALL_PATHS = {'android.hidl.memory@1.0-impl.so': 'hw'}
def __init__(self, install_dir, vndk_version):
"""GenBuildFile constructor.
Args:
install_dir: string, absolute path to the prebuilts/vndk/v{version}
directory where the build files will be generated.
vndk_version: int, VNDK snapshot version (e.g., 27, 28)
"""
self._install_dir = install_dir
self._vndk_version = vndk_version
self._etc_paths = self._get_etc_paths()
self._snapshot_variants = utils.get_snapshot_variants(install_dir)
self._mkfile = os.path.join(install_dir, utils.ANDROID_MK_PATH)
self._vndk_core = self._parse_lib_list('vndkcore.libraries.txt')
self._vndk_sp = self._parse_lib_list(
os.path.basename(self._etc_paths['vndksp.libraries.txt']))
self._vndk_private = self._parse_lib_list('vndkprivate.libraries.txt')
def _get_etc_paths(self):
"""Returns a map of relative file paths for each ETC module."""
etc_paths = dict()
for etc_module in self.ETC_MODULES:
etc_pattern = '{}*'.format(os.path.splitext(etc_module)[0])
etc_path = glob.glob(
os.path.join(self._install_dir, utils.CONFIG_DIR_PATH_PATTERN,
etc_pattern))[0]
rel_etc_path = etc_path.replace(self._install_dir, '')[1:]
etc_paths[etc_module] = rel_etc_path
return etc_paths
def _parse_lib_list(self, txt_filename):
"""Returns a map of VNDK library lists per VNDK snapshot variant.
Args:
txt_filename: string, name of snapshot config file
Returns:
dict, e.g. {'arm64': ['libfoo.so', 'libbar.so', ...], ...}
"""
lib_map = dict()
for txt_path in utils.find(self._install_dir, [txt_filename]):
variant = utils.variant_from_path(txt_path)
abs_path_of_txt = os.path.join(self._install_dir, txt_path)
with open(abs_path_of_txt, 'r') as f:
lib_map[variant] = f.read().strip().split('\n')
return lib_map
def generate_android_mk(self):
"""Autogenerates Android.mk."""
etc_buildrules = []
for prebuilt in self.ETC_MODULES:
etc_buildrules.append(self._gen_etc_prebuilt(prebuilt))
with open(self._mkfile, 'w') as mkfile:
mkfile.write(self._gen_autogen_msg('#'))
mkfile.write('\n')
mkfile.write('LOCAL_PATH := $(call my-dir)\n')
mkfile.write('\n')
mkfile.write('\n\n'.join(etc_buildrules))
mkfile.write('\n')
def generate_android_bp(self):
"""Autogenerates Android.bp file for each VNDK snapshot variant."""
for variant in self._snapshot_variants:
bpfile = os.path.join(self._install_dir, variant, 'Android.bp')
vndk_core_buildrules = self._gen_vndk_shared_prebuilts(
self._vndk_core[variant], variant, False)
vndk_sp_buildrules = self._gen_vndk_shared_prebuilts(
self._vndk_sp[variant], variant, True)
with open(bpfile, 'w') as bpfile:
bpfile.write(self._gen_autogen_msg('/'))
bpfile.write('\n')
bpfile.write(self._gen_bp_phony(variant))
bpfile.write('\n')
bpfile.write('\n'.join(vndk_core_buildrules))
bpfile.write('\n')
bpfile.write('\n'.join(vndk_sp_buildrules))
def _gen_autogen_msg(self, comment_char):
return ('{0}{0} THIS FILE IS AUTOGENERATED BY '
'development/vndk/snapshot/gen_buildfiles.py\n'
'{0}{0} DO NOT EDIT\n'.format(comment_char))
def _get_versioned_name(self, prebuilt, variant, is_etc):
"""Returns the VNDK version-specific module name for a given prebuilt.
The VNDK version-specific module name is defined as follows:
For a VNDK shared lib: 'libfoo.so'
-> 'libfoo.vndk.{version}.{variant}.vendor'
For an ETC module: 'foo.txt' -> 'foo.{version}.txt'
Args:
prebuilt: string, name of the prebuilt object
variant: string, VNDK snapshot variant (e.g. 'arm64')
is_etc: bool, True if the LOCAL_MODULE_CLASS of prebuilt is 'ETC'
"""
name, ext = os.path.splitext(prebuilt)
if is_etc:
versioned_name = '{}.{}{}'.format(name, self._vndk_version, ext)
else:
versioned_name = '{}.vndk.{}.{}.vendor'.format(
name, self._vndk_version, variant)
return versioned_name
def _gen_etc_prebuilt(self, prebuilt):
"""Generates build rule for an ETC prebuilt.
Args:
prebuilt: string, name of ETC prebuilt object
"""
etc_path = self._etc_paths[prebuilt]
etc_sub_path = etc_path[etc_path.index('/') + 1:]
return ('#######################################\n'
'# {prebuilt}\n'
'include $(CLEAR_VARS)\n'
'LOCAL_MODULE := {versioned_name}\n'
'LOCAL_SRC_FILES := ../$(TARGET_ARCH)/{etc_sub_path}\n'
'LOCAL_MODULE_CLASS := ETC\n'
'LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)\n'
'LOCAL_MODULE_STEM := $(LOCAL_MODULE)\n'
'include $(BUILD_PREBUILT)\n'.format(
prebuilt=prebuilt,
versioned_name=self._get_versioned_name(
prebuilt, None, True),
etc_sub_path=etc_sub_path))
def _gen_bp_phony(self, variant):
"""Generates build rule for phony package 'vndk_v{ver}_{variant}'.
Args:
variant: string, VNDK snapshot variant (e.g. 'arm64')
"""
required = []
for prebuilts in (self._vndk_core[variant], self._vndk_sp[variant]):
for prebuilt in prebuilts:
required.append(
self._get_versioned_name(prebuilt, variant, False))
for prebuilt in self.ETC_MODULES:
required.append(self._get_versioned_name(prebuilt, None, True))
required_str = ['"{}",'.format(prebuilt) for prebuilt in required]
required_formatted = '\n{ind}{ind}'.format(
ind=self.INDENT).join(required_str)
required_buildrule = ('{ind}required: [\n'
'{ind}{ind}{required_formatted}\n'
'{ind}],\n'.format(
ind=self.INDENT,
required_formatted=required_formatted))
return ('phony {{\n'
'{ind}name: "vndk_v{ver}_{variant}",\n'
'{required_buildrule}'
'}}\n'.format(
ind=self.INDENT,
ver=self._vndk_version,
variant=variant,
required_buildrule=required_buildrule))
def _gen_vndk_shared_prebuilts(self, prebuilts, variant, is_vndk_sp):
"""Returns list of build rules for given prebuilts.
Args:
prebuilts: list of VNDK shared prebuilts
variant: string, VNDK snapshot variant (e.g. 'arm64')
is_vndk_sp: bool, True if prebuilts are VNDK_SP libs
"""
build_rules = []
for prebuilt in prebuilts:
build_rules.append(
self._gen_vndk_shared_prebuilt(prebuilt, variant, is_vndk_sp))
return build_rules
def _gen_vndk_shared_prebuilt(self, prebuilt, variant, is_vndk_sp):
"""Returns build rule for given prebuilt.
Args:
prebuilt: string, name of prebuilt object
variant: string, VNDK snapshot variant (e.g. 'arm64')
is_vndk_sp: bool, True if prebuilt is a VNDK_SP lib
"""
def get_notice_file(prebuilt):
"""Returns build rule for notice file (attribute 'notice').
Args:
prebuilt: string, name of prebuilt object
"""
notice = ''
notice_file_name = '{}.txt'.format(prebuilt)
notices_dir = os.path.join(self._install_dir,
utils.NOTICE_FILES_DIR_PATH)
notice_files = utils.find(notices_dir, [notice_file_name])
if len(notice_files) > 0:
notice = '{ind}notice: "{notice_file_path}",\n'.format(
ind=self.INDENT,
notice_file_path=os.path.join(
'..', utils.NOTICE_FILES_DIR_PATH, notice_files[0]))
return notice
def get_rel_install_path(prebuilt):
"""Returns build rule for 'relative_install_path'.
Args:
prebuilt: string, name of prebuilt object
"""
rel_install_path = ''
if prebuilt in self.RELATIVE_INSTALL_PATHS:
path = self.RELATIVE_INSTALL_PATHS[prebuilt]
rel_install_path += ('{ind}relative_install_path: "{path}",\n'
.format(ind=self.INDENT, path=path))
return rel_install_path
def get_arch_srcs(prebuilt, variant):
"""Returns build rule for arch specific srcs.
e.g.,
arch: {
arm: {
srcs: ["..."]
},
arm64: {
srcs: ["..."]
},
}
Args:
prebuilt: string, name of prebuilt object
variant: string, VNDK snapshot variant (e.g. 'arm64')
"""
arch_srcs = '{ind}arch: {{\n'.format(ind=self.INDENT)
variant_path = os.path.join(self._install_dir, variant)
src_paths = utils.find(variant_path, [prebuilt])
for src in sorted(src_paths):
arch_srcs += ('{ind}{ind}{arch}: {{\n'
'{ind}{ind}{ind}srcs: ["{src}"],\n'
'{ind}{ind}}},\n'.format(
ind=self.INDENT,
arch=utils.arch_from_path(
os.path.join(variant, src)),
src=src))
arch_srcs += '{ind}}},\n'.format(ind=self.INDENT)
return arch_srcs
name = os.path.splitext(prebuilt)[0]
vendor_available = str(
prebuilt not in self._vndk_private[variant]).lower()
if is_vndk_sp:
vndk_sp = '{ind}{ind}support_system_process: true,\n'.format(
ind=self.INDENT)
else:
vndk_sp = ''
notice = get_notice_file(prebuilt)
rel_install_path = get_rel_install_path(prebuilt)
arch_srcs = get_arch_srcs(prebuilt, variant)
return ('vndk_prebuilt_shared {{\n'
'{ind}name: "{name}",\n'
'{ind}version: "{ver}",\n'
'{ind}target_arch: "{target_arch}",\n'
'{ind}vendor_available: {vendor_available},\n'
'{ind}vndk: {{\n'
'{ind}{ind}enabled: true,\n'
'{vndk_sp}'
'{ind}}},\n'
'{notice}'
'{rel_install_path}'
'{arch_srcs}'
'}}\n'.format(
ind=self.INDENT,
name=name,
ver=self._vndk_version,
vendor_available=vendor_available,
target_arch=variant,
vndk_sp=vndk_sp,
notice=notice,
rel_install_path=rel_install_path,
arch_srcs=arch_srcs))
def main():
"""For local testing purposes.
Note: VNDK snapshot must be already installed under
prebuilts/vndk/v{version}.
"""
ANDROID_BUILD_TOP = utils.get_android_build_top()
PREBUILTS_VNDK_DIR = utils.join_realpath(ANDROID_BUILD_TOP,
'prebuilts/vndk')
vndk_version = 27 # set appropriately
install_dir = os.path.join(PREBUILTS_VNDK_DIR, 'v{}'.format(vndk_version))
buildfile_generator = GenBuildFile(install_dir, vndk_version)
buildfile_generator.generate_android_mk()
buildfile_generator.generate_android_bp()
if __name__ == '__main__':
main()
Reference in New Issue View Git Blame Copy Permalink