| #!/usr/bin/env python3 |
| # |
| # Copyright 2020 - 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. |
| |
| """Configs the jdk.table.xml. |
| |
| In order to enable the feature "Attach debugger to Android process" in Android |
| Studio or IntelliJ, AIDEGen needs the JDK and Android SDK been set-up. The class |
| JDKTableXML parses the jdk.table.xml to find the existing JDK and Android SDK |
| information. If they do not exist, AIDEGen will create them. |
| |
| Usage example: |
| jdk_table_xml = JDKTableXML(jdk_table_xml_file, |
| jdk_template, |
| default_jdk_path, |
| default_android_sdk_path) |
| if jdk_table_xml.config_jdk_table_xml(): |
| android_sdk_version = jdk_table_xml.android_sdk_version |
| """ |
| |
| from __future__ import absolute_import |
| |
| import os |
| |
| from xml.etree import ElementTree |
| |
| from aidegen import constant |
| from aidegen import templates |
| from aidegen.lib import aidegen_metrics |
| from aidegen.lib import common_util |
| from aidegen.lib import xml_util |
| from aidegen.sdk import android_sdk |
| |
| |
| class JDKTableXML(): |
| """Configs jdk.table.xml for IntelliJ and Android Studio. |
| |
| Attributes: |
| _config_file: The absolute file path of the jdk.table.xml, the file |
| might not exist. |
| _jdk_content: A string, the content of the JDK configuration. |
| _jdk_path: The path of JDK in android project. |
| _default_android_sdk_path: The default path to the Android SDK. |
| _platform_version: The version name of the platform, e.g. android-29 |
| _android_sdk_version: The version name of the Android SDK in the |
| jdk.table.xml, e.g. Android API 29 Platform |
| _modify_config: A boolean, True to write new content to jdk.table.xml. |
| _xml: An xml.etree.ElementTree object contains the XML parsing result. |
| _sdk: An AndroidSDK object to get the Android SDK path and platform |
| mapping. |
| """ |
| _JDK = 'jdk' |
| _NAME = 'name' |
| _TYPE = 'type' |
| _VALUE = 'value' |
| _SDK = 'sdk' |
| _HOMEPATH = 'homePath' |
| _ADDITIONAL = 'additional' |
| _ANDROID_SDK = 'Android SDK' |
| _JAVA_SDK = 'JavaSDK' |
| _JDK_VERSION = 'JDK18' |
| _APPLICATION = 'application' |
| _COMPONENT = 'component' |
| _PROJECTJDKTABLE = 'ProjectJdkTable' |
| _LAST_TAG_TAIL = '\n ' |
| _NEW_TAG_TAIL = '\n ' |
| _ANDROID_SDK_VERSION = 'Android API {CODE_NAME} Platform' |
| _DEFAULT_JDK_TABLE_XML = os.path.join(common_util.get_android_root_dir(), |
| constant.AIDEGEN_ROOT_PATH, |
| 'data', |
| 'jdk.table.xml') |
| _ILLEGAL_XML = ('The {XML} is not an useful XML file for IntelliJ. Do you ' |
| 'agree AIDEGen override it?(y/n)') |
| _IGNORE_XML_WARNING = ('The {XML} is not an useful XML file for IntelliJ. ' |
| 'It causes the feature "Attach debugger to Android ' |
| 'process" to be disabled.') |
| |
| def __init__(self, config_file, jdk_content, jdk_path, |
| default_android_sdk_path): |
| """JDKTableXML initialize. |
| |
| Args: |
| config_file: The absolute file path of the jdk.table.xml, the file |
| might not exist. |
| jdk_content: A string, the content of the JDK configuration. |
| jdk_path: The path of JDK in android project. |
| default_android_sdk_path: The default absolute path to the Android |
| SDK. |
| """ |
| self._config_file = config_file |
| self._jdk_content = jdk_content |
| self._jdk_path = jdk_path |
| self._default_android_sdk_path = default_android_sdk_path |
| self._xml = None |
| if os.path.exists(config_file): |
| xml_file = config_file |
| else: |
| xml_file = self._DEFAULT_JDK_TABLE_XML |
| common_util.file_generate(xml_file, templates.JDK_TABLE_XML) |
| self._xml = xml_util.parse_xml(xml_file) |
| self._platform_version = None |
| self._android_sdk_version = None |
| self._modify_config = False |
| self._sdk = android_sdk.AndroidSDK() |
| |
| @property |
| def android_sdk_version(self): |
| """Gets the Android SDK version.""" |
| return self._android_sdk_version |
| |
| def _check_structure(self): |
| """Checks the XML's structure is correct. |
| |
| The content of the XML file should have a root tag as <application> and |
| a child tag <component> of it. |
| E.g. |
| <application> |
| <component name="ProjectJdkTable"> |
| ... |
| </component> |
| </application> |
| |
| Returns: |
| Boolean: True if the structure is correct, otherwise False. |
| """ |
| if (not self._xml or self._xml.getroot().tag != self._APPLICATION |
| or self._xml.find(self._COMPONENT) is None |
| or self._xml.find(self._COMPONENT).tag != self._COMPONENT): |
| return False |
| return self._xml.find(self._COMPONENT).get( |
| self._NAME) == self._PROJECTJDKTABLE |
| |
| def _override_xml(self): |
| """Overrides the XML file when it's invalid. |
| |
| Returns: |
| A boolean, True when developers choose to override the XML file, |
| otherwise False. |
| """ |
| input_data = input(self._ILLEGAL_XML.format(XML=self._config_file)) |
| while input_data not in ('y', 'n'): |
| input_data = input('Please type y(Yes) or n(No): ') |
| if input_data == 'y': |
| # Record the exception about wrong XML format. |
| if self._xml: |
| aidegen_metrics.send_exception_metrics( |
| constant.XML_PARSING_FAILURE, '', |
| ElementTree.tostring(self._xml.getroot()), '') |
| self._xml = xml_util.parse_xml(self._DEFAULT_JDK_TABLE_XML) |
| return True |
| return False |
| |
| def _check_jdk18_in_xml(self): |
| """Checks if the JDK18 is already set in jdk.table.xml. |
| |
| Returns: |
| Boolean: True if the JDK18 exists else False. |
| """ |
| for jdk in self._xml.iter(self._JDK): |
| _name = jdk.find(self._NAME) |
| _type = jdk.find(self._TYPE) |
| if None in (_name, _type): |
| continue |
| if (_type.get(self._VALUE) == self._JAVA_SDK |
| and _name.get(self._VALUE) == self._JDK_VERSION): |
| return True |
| return False |
| |
| def _check_android_sdk_in_xml(self): |
| """Checks if the Android SDK is already set in jdk.table.xml. |
| |
| If the Android SDK exists in xml, validate the value of Android SDK path |
| and platform version. |
| 1. Check if the Android SDK path is valid. |
| 2. Check if the platform version exists in the Android SDK. |
| The Android SDK version can be used to generate enble_debugger module |
| when condition 1 and 2 are true. |
| |
| Returns: |
| Boolean: True if the Android SDK configuration exists, otherwise |
| False. |
| """ |
| for tag in self._xml.iter(self._JDK): |
| _name = tag.find(self._NAME) |
| _type = tag.find(self._TYPE) |
| _homepath = tag.find(self._HOMEPATH) |
| _additional = tag.find(self._ADDITIONAL) |
| if None in (_name, _type, _homepath, _additional): |
| continue |
| |
| tag_type = _type.get(self._VALUE) |
| home_path = _homepath.get(self._VALUE).replace( |
| constant.USER_HOME, os.path.expanduser('~')) |
| platform = _additional.get(self._SDK) |
| if (tag_type != self._ANDROID_SDK |
| or not self._sdk.is_android_sdk_path(home_path) |
| or platform not in self._sdk.platform_mapping): |
| continue |
| self._android_sdk_version = _name.get(self._VALUE) |
| self._platform_version = platform |
| return True |
| return False |
| |
| def _append_config(self, new_config): |
| """Adds a <jdk> configuration at the last of <component>. |
| |
| Args: |
| new_config: A string of new <jdk> configuration. |
| """ |
| node = ElementTree.fromstring(new_config) |
| node.tail = self._NEW_TAG_TAIL |
| component = self._xml.getroot().find(self._COMPONENT) |
| if len(component) > 0: |
| component[-1].tail = self._LAST_TAG_TAIL |
| else: |
| component.text = self._LAST_TAG_TAIL |
| self._xml.getroot().find(self._COMPONENT).append(node) |
| |
| def _generate_jdk_config_string(self): |
| """Generates the default JDK configuration.""" |
| if self._check_jdk18_in_xml(): |
| return |
| self._append_config(self._jdk_content.format(JDKpath=self._jdk_path)) |
| self._modify_config = True |
| |
| def _generate_sdk_config_string(self): |
| """Generates Android SDK configuration.""" |
| if self._check_android_sdk_in_xml(): |
| return |
| if self._sdk.path_analysis(self._default_android_sdk_path): |
| # TODO(b/151582629): Revise the API_LEVEL to CODE_NAME when |
| # abandoning the sdk_config.py. |
| self._append_config(templates.ANDROID_SDK_XML.format( |
| ANDROID_SDK_PATH=self._sdk.android_sdk_path, |
| CODE_NAME=self._sdk.max_code_name)) |
| self._android_sdk_version = self._ANDROID_SDK_VERSION.format( |
| CODE_NAME=self._sdk.max_code_name) |
| self._modify_config = True |
| return |
| # Record the exception about missing Android SDK. |
| aidegen_metrics.send_exception_metrics( |
| constant.LOCATE_SDK_PATH_FAILURE, '', |
| ElementTree.tostring(self._xml.getroot()), '') |
| |
| def config_jdk_table_xml(self): |
| """Configures the jdk.table.xml. |
| |
| 1. Generate the JDK18 configuration if it does not exist. |
| 2. Generate the Android SDK configuration if it does not exist and |
| save the Android SDK path. |
| 3. Update the jdk.table.xml if AIDEGen needs to append JDK18 or |
| Android SDK configuration. |
| |
| Returns: |
| A boolean, True when get the Android SDK version, otherwise False. |
| """ |
| if not self._check_structure() and not self._override_xml(): |
| print(self._IGNORE_XML_WARNING.format(XML=self._config_file)) |
| return False |
| self._generate_jdk_config_string() |
| self._generate_sdk_config_string() |
| if self._modify_config: |
| if not os.path.exists(self._config_file): |
| common_util.file_generate( |
| self._config_file, templates.JDK_TABLE_XML) |
| self._xml.write(self._config_file) |
| return bool(self._android_sdk_version) |
