You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
695 lines
28 KiB
695 lines
28 KiB
#!/usr/bin/env python3
|
|
#
|
|
# 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 argparse
|
|
import glob
|
|
import json
|
|
import logging
|
|
import os
|
|
import sys
|
|
|
|
import utils
|
|
|
|
|
|
class GenBuildFile(object):
|
|
"""Generates Android.bp for VNDK snapshot.
|
|
|
|
VNDK snapshot directory structure under prebuilts/vndk/v{version}:
|
|
Android.bp
|
|
{SNAPSHOT_ARCH}/
|
|
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)
|
|
binder32/
|
|
(This directory is newly introduced in v28 (Android P) to hold
|
|
prebuilts built for 32-bit binder interface.)
|
|
Android.bp
|
|
arch-{TARGET_ARCH}-{TARGE_ARCH_VARIANT}/
|
|
...
|
|
configs/
|
|
(various *.txt configuration files, e.g. ld.config.*.txt)
|
|
... (other {SNAPSHOT_ARCH}/ directories)
|
|
common/
|
|
Android.bp
|
|
NOTICE_FILES/
|
|
(license files, e.g. libfoo.so.txt)
|
|
"""
|
|
INDENT = ' '
|
|
ETC_MODULES = [
|
|
'llndk.libraries.txt',
|
|
'vndksp.libraries.txt',
|
|
'vndkcore.libraries.txt',
|
|
'vndkprivate.libraries.txt',
|
|
'vndkproduct.libraries.txt',
|
|
]
|
|
|
|
"""Some vendor prebuilts reference libprotobuf-cpp-lite.so and
|
|
libprotobuf-cpp-full.so and expect the 3.0.0-beta3 version.
|
|
The new version of protobuf will be installed as
|
|
/vendor/lib64/libprotobuf-cpp-lite-3.9.1.so. The VNDK doesn't
|
|
help here because we compile old devices against the current
|
|
branch and not an old VNDK snapshot. We need to continue to
|
|
provide a vendor libprotobuf-cpp-lite.so until all products in
|
|
the current branch get updated prebuilts or are obsoleted.
|
|
|
|
VENDOR_COMPAT is a dictionary that has VNDK versions as keys and
|
|
the list of (library name string, shared libs list) as values.
|
|
"""
|
|
VENDOR_COMPAT = {
|
|
28: [
|
|
('libprotobuf-cpp-lite',
|
|
['libc++', 'libc', 'libdl', 'liblog', 'libm', 'libz']),
|
|
('libprotobuf-cpp-full',
|
|
['libc++', 'libc', 'libdl', 'liblog', 'libm', 'libz']),
|
|
]
|
|
}
|
|
|
|
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. 30)
|
|
"""
|
|
self._install_dir = install_dir
|
|
self._vndk_version = vndk_version
|
|
self._etc_paths = self._get_etc_paths()
|
|
self._snapshot_archs = utils.get_snapshot_archs(install_dir)
|
|
self._root_bpfile = os.path.join(install_dir, utils.ROOT_BP_PATH)
|
|
self._common_bpfile = os.path.join(install_dir, utils.COMMON_BP_PATH)
|
|
self._llndk = self._parse_lib_list(
|
|
os.path.basename(self._etc_paths['llndk.libraries.txt']))
|
|
self._vndk_core = self._parse_lib_list(
|
|
os.path.basename(self._etc_paths['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(
|
|
os.path.basename(self._etc_paths['vndkprivate.libraries.txt']))
|
|
self._vndk_product = self._parse_lib_list(
|
|
os.path.basename(self._etc_paths['vndkproduct.libraries.txt']))
|
|
self._modules_with_notice = self._get_modules_with_notice()
|
|
|
|
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])
|
|
globbed = glob.glob(
|
|
os.path.join(self._install_dir, utils.CONFIG_DIR_PATH_PATTERN,
|
|
etc_pattern))
|
|
if len(globbed) > 0:
|
|
rel_etc_path = globbed[0].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 arch.
|
|
|
|
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]):
|
|
arch = utils.snapshot_arch_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[arch] = f.read().strip().split('\n')
|
|
if lib_map[arch] == ['']:
|
|
lib_map[arch].clear()
|
|
return lib_map
|
|
|
|
def _get_modules_with_notice(self):
|
|
"""Returns a list of modules that have associated notice files. """
|
|
notice_paths = glob.glob(
|
|
os.path.join(self._install_dir, utils.NOTICE_FILES_DIR_PATH,
|
|
'*.txt'))
|
|
return sorted(os.path.splitext(os.path.basename(p))[0] for p in notice_paths)
|
|
|
|
def generate_root_android_bp(self):
|
|
"""Autogenerates Android.bp."""
|
|
|
|
logging.info('Generating Android.bp for snapshot v{}'.format(
|
|
self._vndk_version))
|
|
prebuilt_buildrules = []
|
|
for prebuilt in self.ETC_MODULES:
|
|
prebuilt_buildrules.append(self._gen_etc_prebuilt(prebuilt))
|
|
|
|
if self._vndk_version in self.VENDOR_COMPAT:
|
|
prebuilt_buildrules.append('// Defining prebuilt libraries '
|
|
'for the compatibility of old vendor modules')
|
|
for vendor_compat_lib_info in self.VENDOR_COMPAT[self._vndk_version]:
|
|
prebuilt_buildrules.append(
|
|
self._gen_prebuilt_library_shared(vendor_compat_lib_info))
|
|
|
|
with open(self._root_bpfile, 'w') as bpfile:
|
|
bpfile.write(self._gen_autogen_msg('/'))
|
|
bpfile.write('\n')
|
|
bpfile.write('\n'.join(prebuilt_buildrules))
|
|
bpfile.write('\n')
|
|
|
|
logging.info('Successfully generated {}'.format(self._root_bpfile))
|
|
|
|
def generate_common_android_bp(self):
|
|
"""Autogenerates common/Android.bp."""
|
|
|
|
logging.info('Generating common/Android.bp for snapshot v{}'.format(
|
|
self._vndk_version))
|
|
with open(self._common_bpfile, 'w') as bpfile:
|
|
bpfile.write(self._gen_autogen_msg('/'))
|
|
for module in self._modules_with_notice:
|
|
bpfile.write('\n')
|
|
bpfile.write(self._gen_notice_filegroup(module))
|
|
|
|
def generate_android_bp(self):
|
|
"""Autogenerates Android.bp."""
|
|
|
|
def gen_for_variant(arch, is_binder32=False):
|
|
"""Generates Android.bp file for specified VNDK snapshot variant.
|
|
|
|
A VNDK snapshot variant is defined by the TARGET_ARCH and binder
|
|
bitness. Example snapshot variants:
|
|
vndk_v{ver}_arm: {arch: arm, binder: 64-bit}
|
|
vndk_v{ver}_arm_binder32: {arch: arm, binder: 32-bit}
|
|
|
|
Args:
|
|
arch: string, VNDK snapshot arch (e.g. 'arm64')
|
|
is_binder32: bool, True if binder interface is 32-bit
|
|
"""
|
|
binder32_suffix = '_{}'.format(
|
|
utils.BINDER32) if is_binder32 else ''
|
|
logging.info('Generating Android.bp for vndk_v{}_{}{}'.format(
|
|
self._vndk_version, arch, binder32_suffix))
|
|
|
|
src_root = os.path.join(self._install_dir, arch)
|
|
module_names_txt = os.path.join(
|
|
src_root, "configs", "module_names.txt")
|
|
module_names = dict()
|
|
try:
|
|
with open(module_names_txt, 'r') as f:
|
|
# Remove empty lines from module_names_txt
|
|
module_list = filter(None, f.read().split('\n'))
|
|
for module in module_list:
|
|
lib, name = module.split(' ')
|
|
module_names[lib] = name
|
|
except IOError:
|
|
# If module_names.txt doesn't exist, ignore it and parse
|
|
# module names out from .so filenames. (old snapshot)
|
|
pass
|
|
|
|
variant_subpath = arch
|
|
if is_binder32:
|
|
variant_subpath = os.path.join(arch, utils.BINDER32)
|
|
variant_path = os.path.join(self._install_dir, variant_subpath)
|
|
bpfile_path = os.path.join(variant_path, 'Android.bp')
|
|
|
|
vndk_core_buildrules = self._gen_vndk_shared_prebuilts(
|
|
self._vndk_core[arch],
|
|
arch,
|
|
is_llndk=False,
|
|
is_vndk_sp=False,
|
|
is_binder32=is_binder32,
|
|
module_names=module_names)
|
|
vndk_sp_buildrules = self._gen_vndk_shared_prebuilts(
|
|
self._vndk_sp[arch],
|
|
arch,
|
|
is_llndk=False,
|
|
is_vndk_sp=True,
|
|
is_binder32=is_binder32,
|
|
module_names=module_names)
|
|
include_llndk = self._vndk_version > 30
|
|
if include_llndk:
|
|
llndk_buildrules = self._gen_vndk_shared_prebuilts(
|
|
self._llndk[arch],
|
|
arch,
|
|
is_llndk=True,
|
|
is_vndk_sp=False,
|
|
is_binder32=is_binder32,
|
|
module_names=module_names)
|
|
|
|
with open(bpfile_path, 'w') as bpfile:
|
|
bpfile.write(self._gen_autogen_msg('/'))
|
|
bpfile.write('\n')
|
|
bpfile.write('\n'.join(vndk_core_buildrules))
|
|
bpfile.write('\n')
|
|
bpfile.write('\n'.join(vndk_sp_buildrules))
|
|
if include_llndk:
|
|
bpfile.write('\n')
|
|
bpfile.write('\n'.join(llndk_buildrules))
|
|
|
|
variant_include_path = os.path.join(variant_path, 'include')
|
|
include_path = os.path.join(self._install_dir, arch, 'include')
|
|
if os.path.isdir(include_path) and variant_include_path != include_path:
|
|
os.symlink(os.path.relpath(include_path, variant_path),
|
|
variant_include_path)
|
|
|
|
logging.info('Successfully generated {}'.format(bpfile_path))
|
|
|
|
for arch in self._snapshot_archs:
|
|
if os.path.isdir(
|
|
os.path.join(self._install_dir, arch, utils.BINDER32)):
|
|
gen_for_variant(arch, is_binder32=True)
|
|
gen_for_variant(arch)
|
|
|
|
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,
|
|
arch,
|
|
is_etc=False,
|
|
is_binder32=False,
|
|
module_names=None):
|
|
"""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'
|
|
if binder is 32-bit:
|
|
'libfoo.vndk.{version}.{arch}.binder32.vendor'
|
|
else:
|
|
'libfoo.vndk.{version}.{arch}.vendor'
|
|
For an ETC module: 'foo.txt' -> 'foo.{version}.txt'
|
|
|
|
Args:
|
|
prebuilt: string, name of the prebuilt object
|
|
arch: string, VNDK snapshot arch (e.g. 'arm64')
|
|
is_etc: bool, True if the LOCAL_MODULE_CLASS of prebuilt is 'ETC'
|
|
is_binder32: bool, True if binder interface is 32-bit
|
|
module_names: dict, module names for given prebuilts
|
|
"""
|
|
if is_etc:
|
|
name, ext = os.path.splitext(prebuilt)
|
|
versioned_name = '{}.{}{}'.format(name, self._vndk_version, ext)
|
|
else:
|
|
module_names = module_names or dict()
|
|
if prebuilt in module_names:
|
|
name = module_names[prebuilt]
|
|
else:
|
|
name = os.path.splitext(prebuilt)[0]
|
|
binder_suffix = '.{}'.format(utils.BINDER32) if is_binder32 else ''
|
|
versioned_name = '{}.vndk.{}.{}{}.vendor'.format(
|
|
name, self._vndk_version, arch, binder_suffix)
|
|
|
|
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:]
|
|
|
|
prebuilt_etc = ('prebuilt_etc {{\n'
|
|
'{ind}name: "{versioned_name}",\n'
|
|
'{ind}target: {{\n'.format(
|
|
ind=self.INDENT,
|
|
versioned_name=self._get_versioned_name(
|
|
prebuilt, None, is_etc=True)))
|
|
for arch in self._snapshot_archs:
|
|
prebuilt_etc += ('{ind}{ind}android_{arch}: {{\n'
|
|
'{ind}{ind}{ind}src: "{arch}/{etc_sub_path}",\n'
|
|
'{ind}{ind}}},\n'.format(
|
|
ind=self.INDENT,
|
|
arch=arch,
|
|
etc_sub_path=etc_sub_path))
|
|
prebuilt_etc += ('{ind}}},\n'
|
|
'}}\n'.format(ind=self.INDENT))
|
|
return prebuilt_etc
|
|
|
|
def _gen_prebuilt_library_shared(self, prebuilt_lib_info):
|
|
"""Generates cc_prebuilt_library_shared modules for the old vendor
|
|
compatibility.
|
|
|
|
Some vendor modules still require old version of libraries that is not
|
|
available from the current source tree. To provide the old copy of the
|
|
libraries, use the vndk snapshot.
|
|
|
|
Args:
|
|
prebuilt_lib_info: pair of (string, list of strings), name of the
|
|
prebuilt library and the list of shared libs for it.
|
|
"""
|
|
lib_name = prebuilt_lib_info[0]
|
|
shared_libs = prebuilt_lib_info[1]
|
|
|
|
shared_libs_prop = ''
|
|
if shared_libs:
|
|
shared_libs_prop = ('{ind}shared_libs: [\n'.format(ind=self.INDENT))
|
|
for lib in shared_libs:
|
|
shared_libs_prop += ('{ind}{ind}"{lib}",\n'.format(
|
|
ind=self.INDENT, lib=lib))
|
|
shared_libs_prop += ('{ind}],\n'.format(ind=self.INDENT))
|
|
|
|
cc_prebuilt_libraries = ('cc_prebuilt_library_shared {{\n'
|
|
'{ind}name: "{name}-vendorcompat",\n'
|
|
'{ind}stem: "{name}",\n'
|
|
'{ind}vendor: true,\n'
|
|
'{ind}// These are already stripped, and '
|
|
'restripping them just issues diagnostics.\n'
|
|
'{ind}strip: {{\n'
|
|
'{ind}{ind}none: true,\n'
|
|
'{ind}}},\n'
|
|
'{shared_libs}'
|
|
'{ind}target: {{\n'.format(
|
|
ind=self.INDENT,
|
|
name=lib_name,
|
|
shared_libs=shared_libs_prop))
|
|
src_paths = utils.find(self._install_dir, [lib_name+'.so'])
|
|
for src in src_paths:
|
|
dirs = src.split(os.path.sep)
|
|
if len(dirs) < 3 or not dirs[1].startswith('arch-{}-'.format(dirs[0])):
|
|
continue
|
|
cc_prebuilt_libraries += ('{ind}{ind}android_{arch}: {{\n'
|
|
'{ind}{ind}{ind}srcs: ["{src}"],\n'
|
|
'{ind}{ind}}},\n'.format(
|
|
ind=self.INDENT, arch=dirs[0], src=src))
|
|
cc_prebuilt_libraries += ('{ind}}},\n'
|
|
'}}\n'.format(ind=self.INDENT))
|
|
return cc_prebuilt_libraries
|
|
|
|
def _gen_notice_filegroup(self, module):
|
|
"""Generates a notice filegroup build rule for a given module.
|
|
|
|
Args:
|
|
notice: string, module name
|
|
"""
|
|
return ('filegroup {{\n'
|
|
'{ind}name: "{filegroup_name}",\n'
|
|
'{ind}srcs: ["{notice_dir}/{module}.txt"],\n'
|
|
'}}\n'.format(
|
|
ind=self.INDENT,
|
|
filegroup_name=self._get_notice_filegroup_name(module),
|
|
module=module,
|
|
notice_dir=utils.NOTICE_FILES_DIR_NAME))
|
|
|
|
def _get_notice_filegroup_name(self, module):
|
|
""" Gets a notice filegroup module name for a given module.
|
|
|
|
Args:
|
|
notice: string, module name.
|
|
"""
|
|
return 'vndk-v{ver}-{module}-notice'.format(
|
|
ver=self._vndk_version, module=module)
|
|
|
|
def _gen_vndk_shared_prebuilts(self,
|
|
prebuilts,
|
|
arch,
|
|
is_llndk,
|
|
is_vndk_sp,
|
|
is_binder32,
|
|
module_names):
|
|
"""Returns list of build rules for given prebuilts.
|
|
|
|
Args:
|
|
prebuilts: list of VNDK shared prebuilts
|
|
arch: string, VNDK snapshot arch (e.g. 'arm64')
|
|
is_llndk: bool, True if the prebuilts are LLNDK stubs
|
|
is_vndk_sp: bool, True if prebuilts are VNDK_SP libs
|
|
is_binder32: bool, True if binder interface is 32-bit
|
|
module_names: dict, module names for given prebuilts
|
|
"""
|
|
|
|
build_rules = []
|
|
for prebuilt in prebuilts:
|
|
bp_module = self._gen_vndk_shared_prebuilt(
|
|
prebuilt,
|
|
arch,
|
|
is_llndk=is_llndk,
|
|
is_vndk_sp=is_vndk_sp,
|
|
is_binder32=is_binder32,
|
|
module_names=module_names)
|
|
if bp_module:
|
|
build_rules.append(bp_module)
|
|
return build_rules
|
|
|
|
def _gen_vndk_shared_prebuilt(self,
|
|
prebuilt,
|
|
arch,
|
|
is_llndk,
|
|
is_vndk_sp,
|
|
is_binder32,
|
|
module_names):
|
|
"""Returns build rule for given prebuilt, or an empty string if the
|
|
prebuilt is invalid (e.g. srcs doesn't exist).
|
|
|
|
Args:
|
|
prebuilt: string, name of prebuilt object
|
|
arch: string, VNDK snapshot arch (e.g. 'arm64')
|
|
is_llndk: bool, True if prebuilt is a LLNDK stub
|
|
is_vndk_sp: bool, True if prebuilt is a VNDK_SP lib
|
|
is_binder32: bool, True if binder interface is 32-bit
|
|
module_names: dict, module names for given prebuilts
|
|
"""
|
|
|
|
def get_notice_file(prebuilt):
|
|
"""Returns build rule for notice file (attribute 'notice').
|
|
|
|
Args:
|
|
prebuilt: string, name of prebuilt object
|
|
"""
|
|
notice = ''
|
|
if prebuilt in self._modules_with_notice:
|
|
notice = '{ind}notice: ":{notice_filegroup}",\n'.format(
|
|
ind=self.INDENT,
|
|
notice_filegroup=self._get_notice_filegroup_name(prebuilt))
|
|
return notice
|
|
|
|
def get_arch_props(prebuilt, arch, src_paths):
|
|
"""Returns build rule for arch specific srcs.
|
|
|
|
e.g.,
|
|
arch: {
|
|
arm: {
|
|
export_include_dirs: ["..."],
|
|
export_system_include_dirs: ["..."],
|
|
export_flags: ["..."],
|
|
relative_install_path: "...",
|
|
srcs: ["..."]
|
|
},
|
|
arm64: {
|
|
export_include_dirs: ["..."],
|
|
export_system_include_dirs: ["..."],
|
|
export_flags: ["..."],
|
|
relative_install_path: "...",
|
|
srcs: ["..."]
|
|
},
|
|
}
|
|
|
|
Args:
|
|
prebuilt: string, name of prebuilt object
|
|
arch: string, VNDK snapshot arch (e.g. 'arm64')
|
|
src_paths: list of string paths, prebuilt source paths
|
|
"""
|
|
arch_props = '{ind}arch: {{\n'.format(ind=self.INDENT)
|
|
|
|
def list_to_prop_value(l, name):
|
|
if len(l) == 0:
|
|
return ''
|
|
dirs=',\n{ind}{ind}{ind}{ind}'.format(
|
|
ind=self.INDENT).join(['"%s"' % d for d in l])
|
|
return ('{ind}{ind}{ind}{name}: [\n'
|
|
'{ind}{ind}{ind}{ind}{dirs},\n'
|
|
'{ind}{ind}{ind}],\n'.format(
|
|
ind=self.INDENT,
|
|
dirs=dirs,
|
|
name=name))
|
|
|
|
for src in sorted(src_paths):
|
|
include_dirs = ''
|
|
system_include_dirs = ''
|
|
flags = ''
|
|
relative_install_path = ''
|
|
prop_path = os.path.join(src_root, src+'.json')
|
|
props = dict()
|
|
try:
|
|
with open(prop_path, 'r') as f:
|
|
props = json.loads(f.read())
|
|
os.unlink(prop_path)
|
|
except:
|
|
# TODO(b/70312118): Parse from soong build system
|
|
if prebuilt == 'android.hidl.memory@1.0-impl.so':
|
|
props['RelativeInstallPath'] = 'hw'
|
|
if 'ExportedDirs' in props:
|
|
l = ['include/%s' % d for d in props['ExportedDirs']]
|
|
include_dirs = list_to_prop_value(l, 'export_include_dirs')
|
|
if 'ExportedSystemDirs' in props:
|
|
l = ['include/%s' % d for d in props['ExportedSystemDirs']]
|
|
system_include_dirs = list_to_prop_value(l, 'export_system_include_dirs')
|
|
if 'ExportedFlags' in props:
|
|
flags = list_to_prop_value(props['ExportedFlags'], 'export_flags')
|
|
if 'RelativeInstallPath' in props:
|
|
relative_install_path = ('{ind}{ind}{ind}'
|
|
'relative_install_path: "{path}",\n').format(
|
|
ind=self.INDENT,
|
|
path=props['RelativeInstallPath'])
|
|
|
|
arch_props += ('{ind}{ind}{arch}: {{\n'
|
|
'{include_dirs}'
|
|
'{system_include_dirs}'
|
|
'{flags}'
|
|
'{relative_install_path}'
|
|
'{ind}{ind}{ind}srcs: ["{src}"],\n'
|
|
'{ind}{ind}}},\n').format(
|
|
ind=self.INDENT,
|
|
arch=utils.prebuilt_arch_from_path(
|
|
os.path.join(arch, src)),
|
|
include_dirs=include_dirs,
|
|
system_include_dirs=system_include_dirs,
|
|
flags=flags,
|
|
relative_install_path=relative_install_path,
|
|
src=src)
|
|
arch_props += '{ind}}},\n'.format(ind=self.INDENT)
|
|
return arch_props
|
|
|
|
src_root = os.path.join(self._install_dir, arch)
|
|
if is_binder32:
|
|
src_root = os.path.join(src_root, utils.BINDER32)
|
|
|
|
src_paths = utils.find(src_root, [prebuilt])
|
|
# filter out paths under 'binder32' subdirectory
|
|
src_paths = list(filter(lambda src: not src.startswith(utils.BINDER32),
|
|
src_paths))
|
|
# This prebuilt is invalid if no srcs are found.
|
|
if not src_paths:
|
|
logging.info('No srcs found for {}; skipping'.format(prebuilt))
|
|
return ""
|
|
|
|
if prebuilt in module_names:
|
|
name = module_names[prebuilt]
|
|
else:
|
|
name = os.path.splitext(prebuilt)[0]
|
|
|
|
product_available = ''
|
|
# if vndkproduct.libraries.txt is empty, make the VNDKs available to product by default.
|
|
if not self._vndk_product[arch] or prebuilt in self._vndk_product[arch] or is_llndk:
|
|
product_available = '{ind}product_available: true,\n'.format(
|
|
ind=self.INDENT)
|
|
|
|
vndk_props = ''
|
|
if not is_llndk:
|
|
vndk_sp = ''
|
|
if is_vndk_sp:
|
|
vndk_sp = '{ind}{ind}support_system_process: true,\n'.format(
|
|
ind=self.INDENT)
|
|
|
|
vndk_private = ''
|
|
if prebuilt in self._vndk_private[arch]:
|
|
vndk_private = '{ind}{ind}private: true,\n'.format(
|
|
ind=self.INDENT)
|
|
|
|
vndk_props = ('{ind}vndk: {{\n'
|
|
'{ind}{ind}enabled: true,\n'
|
|
'{vndk_sp}'
|
|
'{vndk_private}'
|
|
'{ind}}},\n'.format(
|
|
ind=self.INDENT,
|
|
product_available=product_available,
|
|
vndk_sp=vndk_sp,
|
|
vndk_private=vndk_private))
|
|
|
|
notice = get_notice_file(prebuilt)
|
|
arch_props = get_arch_props(prebuilt, arch, src_paths)
|
|
|
|
binder32bit = ''
|
|
if is_binder32:
|
|
binder32bit = '{ind}binder32bit: true,\n'.format(ind=self.INDENT)
|
|
|
|
return ('vndk_prebuilt_shared {{\n'
|
|
'{ind}name: "{name}",\n'
|
|
'{ind}version: "{ver}",\n'
|
|
'{ind}target_arch: "{target_arch}",\n'
|
|
'{binder32bit}'
|
|
'{ind}vendor_available: true,\n'
|
|
'{product_available}'
|
|
'{vndk_props}'
|
|
'{notice}'
|
|
'{arch_props}'
|
|
'}}\n'.format(
|
|
ind=self.INDENT,
|
|
name=name,
|
|
ver=self._vndk_version,
|
|
target_arch=arch,
|
|
binder32bit=binder32bit,
|
|
product_available=product_available,
|
|
vndk_props=vndk_props,
|
|
notice=notice,
|
|
arch_props=arch_props))
|
|
|
|
|
|
def get_args():
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument(
|
|
'vndk_version',
|
|
type=utils.vndk_version_int,
|
|
help='VNDK snapshot version to install, e.g. "{}".'.format(
|
|
utils.MINIMUM_VNDK_VERSION))
|
|
parser.add_argument(
|
|
'-v',
|
|
'--verbose',
|
|
action='count',
|
|
default=0,
|
|
help='Increase output verbosity, e.g. "-v", "-vv".')
|
|
return parser.parse_args()
|
|
|
|
|
|
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')
|
|
|
|
args = get_args()
|
|
vndk_version = args.vndk_version
|
|
install_dir = os.path.join(PREBUILTS_VNDK_DIR, 'v{}'.format(vndk_version))
|
|
if not os.path.isdir(install_dir):
|
|
raise ValueError(
|
|
'Please provide valid VNDK version. {} does not exist.'
|
|
.format(install_dir))
|
|
utils.set_logging_config(args.verbose)
|
|
|
|
buildfile_generator = GenBuildFile(install_dir, vndk_version)
|
|
buildfile_generator.generate_root_android_bp()
|
|
buildfile_generator.generate_common_android_bp()
|
|
buildfile_generator.generate_android_bp()
|
|
|
|
logging.info('Done.')
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|