#!/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
|
