#!/usr/bin/env python3 # # Copyright 2019 - 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. """native_module_info Module Info class used to hold cached module_bp_cc_deps.json. """ import logging import os import re from aidegen import constant from aidegen.lib import common_util from aidegen.lib import module_info _CLANG = 'clang' _CPPLANG = 'clang++' _MODULES = 'modules' _INCLUDE_TAIL = '_genc++_headers' _SRC_GEN_CHECK = r'^out/soong/.intermediates/.+/gen/.+\.(c|cc|cpp)' _INC_GEN_CHECK = r'^out/soong/.intermediates/.+/gen($|/.+)' class NativeModuleInfo(module_info.AidegenModuleInfo): """Class that offers fast/easy lookup for module related details. Class Attributes: c_lang_path: Make C files compiler path. cpp_lang_path: Make C++ files compiler path. """ c_lang_path = '' cpp_lang_path = '' def __init__(self, force_build=False, module_file=None): """Initialize the NativeModuleInfo object. Load up the module_bp_cc_deps.json file and initialize the helper vars. """ if not module_file: module_file = common_util.get_blueprint_json_path( constant.BLUEPRINT_CC_JSONFILE_NAME) self.force_build = force_build if not os.path.isfile(module_file): self.force_build = True super().__init__(self.force_build, module_file) def _load_module_info_file(self, module_file): """Load the module file. Args: module_file: String of path to file to load up. Used for testing. Returns: Tuple of module_info_target and dict of json. """ if self.force_build: self._discover_mod_file_and_target(True) mod_info = common_util.get_json_dict(module_file) NativeModuleInfo.c_lang_path = mod_info.get(_CLANG, '') NativeModuleInfo.cpp_lang_path = mod_info.get(_CPPLANG, '') name_to_module_info = mod_info.get(_MODULES, {}) root_dir = common_util.get_android_root_dir() module_info_target = os.path.relpath(module_file, root_dir) return module_info_target, name_to_module_info def get_module_names_in_targets_paths(self, targets): """Gets module names exist in native_module_info. Args: targets: A list of build targets to be checked. Returns: A list of native projects' names if native projects exist otherwise return None. """ projects = [] for target in targets: if target == constant.WHOLE_ANDROID_TREE_TARGET: print('Do not deal with whole source tree in native projects.') continue rel_path, _ = common_util.get_related_paths(self, target) for path in self.path_to_module_info: if common_util.is_source_under_relative_path(path, rel_path): projects.extend(self.get_module_names(path)) return projects def get_module_includes(self, mod_name): """Gets module's include paths from module name. The include paths contain in 'header_search_path' and 'system_search_path' of all flags in native module info. Args: mod_name: A string of module name. Returns: A set of module include paths relative to android root. """ includes = set() mod_info = self.name_to_module_info.get(mod_name, {}) if not mod_info: logging.warning('%s module name %s does not exist.', common_util.COLORED_INFO('Warning:'), mod_name) return includes for flag in mod_info: for header in (constant.KEY_HEADER, constant.KEY_SYSTEM): if header in mod_info[flag]: includes.update(set(mod_info[flag][header])) return includes def is_module_need_build(self, mod_name): """Checks if a module need to be built by its module name. If a module's source files or include files contain a path looks like, 'out/soong/.intermediates/../gen/sysprop/charger.sysprop.cpp' or 'out/soong/.intermediates/../android.bufferhub@1.0_genc++_headers/gen' and the paths do not exist, that means the module needs to be built to generate relative source or include files. Args: mod_name: A string of module name. Returns: A boolean, True if it needs to be generated else False. """ mod_info = self.name_to_module_info.get(mod_name, {}) if not mod_info: logging.warning('%s module name %s does not exist.', common_util.COLORED_INFO('Warning:'), mod_name) return False if self._is_source_need_build(mod_info): return True if self._is_include_need_build(mod_info): return True return False def _is_source_need_build(self, mod_info): """Checks if a module's source files need to be built. If a module's source files contain a path looks like, 'out/soong/.intermediates/../gen/sysprop/charger.sysprop.cpp' and the paths do not exist, that means the module needs to be built to generate relative source files. Args: mod_info: A dictionary of module info to check. Returns: A boolean, True if it needs to be generated else False. """ if constant.KEY_SRCS not in mod_info: return False for src in mod_info[constant.KEY_SRCS]: if re.search(_INC_GEN_CHECK, src) and not os.path.isfile(src): return True return False def _is_include_need_build(self, mod_info): """Checks if a module needs to be built by its module name. If a module's include files contain a path looks like, 'out/soong/.intermediates/../android.bufferhub@1.0_genc++_headers/gen' and the paths do not exist, that means the module needs to be built to generate relative include files. Args: mod_info: A dictionary of module info to check. Returns: A boolean, True if it needs to be generated else False. """ for flag in mod_info: for header in (constant.KEY_HEADER, constant.KEY_SYSTEM): if header not in mod_info[flag]: continue for include in mod_info[flag][header]: match = re.search(_INC_GEN_CHECK, include) if match and not os.path.isdir(include): return True return False def is_suite_in_compatibility_suites(self, suite, mod_info): """Check if suite exists in the compatibility_suites of module-info. Args: suite: A string of suite name. mod_info: Dict of module info to check. Returns: True if it exists in mod_info, False otherwise. """ raise NotImplementedError() def get_testable_modules(self, suite=None): """Return the testable modules of the given suite name. Args: suite: A string of suite name. Set to None to return all testable modules. Returns: List of testable modules. Empty list if non-existent. If suite is None, return all the testable modules in module-info. """ raise NotImplementedError() def is_testable_module(self, mod_info): """Check if module is something we can test. A module is testable if: - it's installed, or - it's a robolectric module (or shares path with one). Args: mod_info: Dict of module info to check. Returns: True if we can test this module, False otherwise. """ raise NotImplementedError() def has_test_config(self, mod_info): """Validate if this module has a test config. A module can have a test config in the following manner: - AndroidTest.xml at the module path. - test_config be set in module-info.json. - Auto-generated config via the auto_test_config key in module-info.json. Args: mod_info: Dict of module info to check. Returns: True if this module has a test config, False otherwise. """ raise NotImplementedError() def get_robolectric_test_name(self, module_name): """Returns runnable robolectric module name. There are at least 2 modules in every robolectric module path, return the module that we can run as a build target. Arg: module_name: String of module. Returns: String of module that is the runnable robolectric module, None if none could be found. """ raise NotImplementedError() def is_robolectric_test(self, module_name): """Check if module is a robolectric test. A module can be a robolectric test if the specified module has their class set as ROBOLECTRIC (or shares their path with a module that does). Args: module_name: String of module to check. Returns: True if the module is a robolectric module, else False. """ raise NotImplementedError() def is_auto_gen_test_config(self, module_name): """Check if the test config file will be generated automatically. Args: module_name: A string of the module name. Returns: True if the test config file will be generated automatically. """ raise NotImplementedError() def is_robolectric_module(self, mod_info): """Check if a module is a robolectric module. Args: mod_info: ModuleInfo to check. Returns: True if module is a robolectric module, False otherwise. """ raise NotImplementedError() def is_native_test(self, module_name): """Check if the input module is a native test. Args: module_name: A string of the module name. Returns: True if the test is a native test, False otherwise. """ raise NotImplementedError()