| #!/usr/bin/env python3 |
| # |
| # Copyright 2018 - 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. |
| |
| """Project information.""" |
| |
| from __future__ import absolute_import |
| |
| import logging |
| import os |
| |
| from aidegen import constant |
| from aidegen.lib import common_util |
| from aidegen.lib.common_util import COLORED_INFO |
| from aidegen.lib.common_util import get_related_paths |
| |
| _KEY_ROBOTESTS = ['robotests', 'robolectric'] |
| _ANDROID_MK = 'Android.mk' |
| _ANDROID_BP = 'Android.bp' |
| _CONVERT_MK_URL = ('https://android.googlesource.com/platform/build/soong/' |
| '#convert-android_mk-files') |
| _ANDROID_MK_WARN = ( |
| '{} contains Android.mk file(s) in its dependencies:\n{}\nPlease help ' |
| 'convert these files into blueprint format in the future, otherwise ' |
| 'AIDEGen may not be able to include all module dependencies.\nPlease visit ' |
| '%s for reference on how to convert makefile.' % _CONVERT_MK_URL) |
| _ROBOLECTRIC_MODULE = 'Robolectric_all' |
| _NOT_TARGET = ('Module %s\'s class setting is %s, none of which is included in ' |
| '%s, skipping this module in the project.') |
| # The module fake-framework have the same package name with framework but empty |
| # content. It will impact the dependency for framework when referencing the |
| # package from fake-framework in IntelliJ. |
| _EXCLUDE_MODULES = ['fake-framework'] |
| |
| |
| class ProjectInfo(): |
| """Project information. |
| |
| Class attributes: |
| modules_info: A dict of all modules info by combining module-info.json |
| with module_bp_java_deps.json. |
| |
| Attributes: |
| project_absolute_path: The absolute path of the project. |
| project_relative_path: The relative path of the project to |
| constant.ANDROID_ROOT_PATH. |
| project_module_names: A list of module names under project_absolute_path |
| directory or it's subdirectories. |
| dep_modules: A dict has recursively dependent modules of |
| project_module_names. |
| git_path: The project's git path. |
| iml_path: The project's iml file path. |
| source_path: A dictionary to keep following data: |
| source_folder_path: A set contains the source folder |
| relative paths. |
| test_folder_path: A set contains the test folder relative |
| paths. |
| jar_path: A set contains the jar file paths. |
| jar_module_path: A dictionary contains the jar file and |
| the module's path mapping. |
| """ |
| |
| modules_info = {} |
| |
| def __init__(self, module_info, target=None): |
| """ProjectInfo initialize. |
| |
| Args: |
| module_info: A ModuleInfo instance contains data of |
| module-info.json. |
| target: Includes target module or project path from user input, when |
| locating the target, project with matching module name of |
| the given target has a higher priority than project path. |
| """ |
| rel_path, abs_path = get_related_paths(module_info, target) |
| target = self._get_target_name(target, abs_path) |
| self.project_module_names = set(module_info.get_module_names(rel_path)) |
| self.project_relative_path = rel_path |
| self.project_absolute_path = abs_path |
| self.iml_path = '' |
| self._set_default_modues() |
| self._init_source_path() |
| self.dep_modules = self.get_dep_modules() |
| self._filter_out_modules() |
| self._display_convert_make_files_message(module_info, target) |
| |
| def _set_default_modues(self): |
| """Append default hard-code modules, source paths and jar files. |
| |
| 1. framework: Framework module is always needed for dependencies but it |
| might not always be located by module dependency. |
| 2. org.apache.http.legacy.stubs.system: The module can't be located |
| through module dependency. Without it, a lot of java files will have |
| error of "cannot resolve symbol" in IntelliJ since they import |
| packages android.Manifest and com.android.internal.R. |
| """ |
| # TODO(b/112058649): Do more research to clarify how to remove these |
| # hard-code sources. |
| self.project_module_names.update( |
| ['framework', 'org.apache.http.legacy.stubs.system']) |
| |
| def _init_source_path(self): |
| """Initialize source_path dictionary.""" |
| self.source_path = { |
| 'source_folder_path': set(), |
| 'test_folder_path': set(), |
| 'jar_path': set(), |
| 'jar_module_path': dict() |
| } |
| |
| def _display_convert_make_files_message(self, module_info, target): |
| """Show message info users convert their Android.mk to Android.bp. |
| |
| Args: |
| module_info: A ModuleInfo instance contains data of |
| module-info.json. |
| target: When locating the target module or project path from users' |
| input, project with matching module name of the given target |
| has a higher priority than project path. |
| """ |
| mk_set = set(self._search_android_make_files(module_info)) |
| if mk_set: |
| print('\n{} {}\n'.format( |
| COLORED_INFO('Warning:'), |
| _ANDROID_MK_WARN.format(target, '\n'.join(mk_set)))) |
| |
| def _search_android_make_files(self, module_info): |
| """Search project and dependency modules contain Android.mk files. |
| |
| If there is only Android.mk but no Android.bp, we'll show the warning |
| message, otherwise we won't. |
| |
| Args: |
| module_info: A ModuleInfo instance contains data of |
| module-info.json. |
| |
| Yields: |
| A string: the relative path of Android.mk. |
| """ |
| android_mk = os.path.join(self.project_absolute_path, _ANDROID_MK) |
| android_bp = os.path.join(self.project_absolute_path, _ANDROID_BP) |
| if os.path.isfile(android_mk) and not os.path.isfile(android_bp): |
| yield '\t' + os.path.join(self.project_relative_path, _ANDROID_MK) |
| for module_name in self.dep_modules: |
| rel_path, abs_path = get_related_paths(module_info, module_name) |
| mod_mk = os.path.join(abs_path, _ANDROID_MK) |
| mod_bp = os.path.join(abs_path, _ANDROID_BP) |
| if os.path.isfile(mod_mk) and not os.path.isfile(mod_bp): |
| yield '\t' + os.path.join(rel_path, _ANDROID_MK) |
| |
| def set_modules_under_project_path(self): |
| """Find modules whose class is qualified to be included under the |
| project path. |
| """ |
| logging.info('Find modules whose class is in %s under %s.', |
| common_util.TARGET_CLASSES, self.project_relative_path) |
| for name, data in self.modules_info.items(): |
| if common_util.is_project_path_relative_module( |
| data, self.project_relative_path): |
| if self._is_a_target_module(data): |
| self.project_module_names.add(name) |
| if self._is_a_robolectric_module(data): |
| self.project_module_names.add(_ROBOLECTRIC_MODULE) |
| else: |
| logging.debug(_NOT_TARGET, name, data['class'], |
| common_util.TARGET_CLASSES) |
| |
| def _filter_out_modules(self): |
| """Filter out unnecessary modules.""" |
| for module in _EXCLUDE_MODULES: |
| self.dep_modules.pop(module, None) |
| |
| @staticmethod |
| def _is_a_target_module(data): |
| """Determine if the module is a target module. |
| |
| A module's class is in {'APPS', 'JAVA_LIBRARIES', 'ROBOLECTRIC'} |
| |
| Args: |
| data: the module-info dictionary of the checked module. |
| |
| Returns: |
| A boolean, true if is a target module, otherwise false. |
| """ |
| if not 'class' in data: |
| return False |
| return any(x in data['class'] for x in common_util.TARGET_CLASSES) |
| |
| @staticmethod |
| def _is_a_robolectric_module(data): |
| """Determine if the module is a robolectric module. |
| |
| Hardcode for robotest dependency. If a folder named robotests or |
| robolectric is in the module's path hierarchy then add the module |
| Robolectric_all as a dependency. |
| |
| Args: |
| data: the module-info dictionary of the checked module. |
| |
| Returns: |
| A boolean, true if robolectric, otherwise false. |
| """ |
| if not 'path' in data: |
| return False |
| path = data['path'][0] |
| return any(key_dir in path.split(os.sep) for key_dir in _KEY_ROBOTESTS) |
| |
| def get_dep_modules(self, module_names=None, depth=0): |
| """Recursively find dependent modules of the project. |
| |
| Find dependent modules by dependencies parameter of each module. |
| For example: |
| The module_names is ['m1']. |
| The modules_info is |
| { |
| 'm1': {'dependencies': ['m2'], 'path': ['path_to_m1']}, |
| 'm2': {'path': ['path_to_m4']}, |
| 'm3': {'path': ['path_to_m1']} |
| 'm4': {'path': []} |
| } |
| The result dependent modules are: |
| { |
| 'm1': {'dependencies': ['m2'], 'path': ['path_to_m1'] |
| 'depth': 0}, |
| 'm2': {'path': ['path_to_m4'], 'depth': 1}, |
| 'm3': {'path': ['path_to_m1'], 'depth': 0} |
| } |
| Note that: |
| 1. m4 is not in the result as it's not among dependent modules. |
| 2. m3 is in the result as it has the same path to m1. |
| |
| Args: |
| module_names: A list of module names. |
| depth: An integer shows the depth of module dependency referenced by |
| source. Zero means the max module depth. |
| |
| Returns: |
| deps: A dict contains all dependent modules data of given modules. |
| """ |
| dep = {} |
| children = set() |
| if not module_names: |
| self.set_modules_under_project_path() |
| module_names = self.project_module_names |
| self.project_module_names = set() |
| for name in module_names: |
| if (name in self.modules_info |
| and name not in self.project_module_names): |
| dep[name] = self.modules_info[name] |
| dep[name][constant.KEY_DEPTH] = depth |
| self.project_module_names.add(name) |
| if (constant.KEY_DEP in dep[name] |
| and dep[name][constant.KEY_DEP]): |
| children.update(dep[name][constant.KEY_DEP]) |
| if children: |
| dep.update(self.get_dep_modules(children, depth + 1)) |
| return dep |
| |
| @staticmethod |
| def generate_projects(module_info, targets): |
| """Generate a list of projects in one time by a list of module names. |
| |
| Args: |
| module_info: An Atest module-info instance. |
| targets: A list of target modules or project paths from user input, |
| when locating the target, project with matched module name |
| of the target has a higher priority than project path. |
| |
| Returns: |
| List: A list of ProjectInfo instances. |
| """ |
| return [ProjectInfo(module_info, target) for target in targets] |
| |
| @staticmethod |
| def _get_target_name(target, abs_path): |
| """Get target name from target's absolute path. |
| |
| If the project is for entire Android source tree, change the target to |
| source tree's root folder name. In this way, we give IDE project file |
| a more specific name. e.g, master.iml. |
| |
| Args: |
| target: Includes target module or project path from user input, when |
| locating the target, project with matching module name of |
| the given target has a higher priority than project path. |
| abs_path: A string, target's absolute path. |
| |
| Returns: |
| A string, the target name. |
| """ |
| if abs_path == constant.ANDROID_ROOT_PATH: |
| return os.path.basename(abs_path) |
| return target |
