| /* | |
| * Copyright (C) 2012 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. | |
| */ | |
| package com.motorola.studio.android.generatecode; | |
| import java.io.File; | |
| import java.util.ArrayList; | |
| import java.util.List; | |
| import org.eclipse.core.resources.IFile; | |
| import org.eclipse.core.resources.IProject; | |
| import org.eclipse.core.runtime.IProgressMonitor; | |
| import org.eclipse.core.runtime.NullProgressMonitor; | |
| import org.eclipse.core.runtime.SubMonitor; | |
| import org.eclipse.jdt.core.ICompilationUnit; | |
| import org.eclipse.jdt.core.IJavaElement; | |
| import org.eclipse.jdt.core.IJavaProject; | |
| import org.eclipse.jdt.core.IPackageFragment; | |
| import org.eclipse.jdt.core.IPackageFragmentRoot; | |
| import org.eclipse.jdt.core.IType; | |
| import org.eclipse.jdt.core.ITypeHierarchy; | |
| import org.eclipse.jdt.core.JavaCore; | |
| import org.eclipse.jdt.core.JavaModelException; | |
| import org.eclipse.jdt.core.compiler.IProblem; | |
| import org.eclipse.jdt.core.dom.AST; | |
| import org.eclipse.jdt.core.dom.ASTParser; | |
| import org.eclipse.jdt.core.dom.CompilationUnit; | |
| import org.eclipse.osgi.util.NLS; | |
| import com.motorola.studio.android.codeutils.i18n.CodeUtilsNLS; | |
| import com.motorola.studio.android.common.IAndroidConstants; | |
| import com.motorola.studio.android.common.exception.AndroidException; | |
| import com.motorola.studio.android.common.log.StudioLogger; | |
| import com.motorola.studio.android.generatemenucode.model.codegenerators.CodeGeneratorBasedOnMenuVisitor; | |
| import com.motorola.studio.android.generatemenucode.model.codegenerators.CodeGeneratorDataBasedOnMenu; | |
| import com.motorola.studio.android.generateviewbylayout.GenerateCodeBasedOnLayoutVisitor; | |
| import com.motorola.studio.android.generateviewbylayout.model.CodeGeneratorDataBasedOnLayout; | |
| import com.motorola.studio.android.generateviewbylayout.model.JavaLayoutData; | |
| /** | |
| * Class that implements convenient methods to abstract and handle JDT related operations. | |
| * This class is not meant to be instantiated. | |
| * */ | |
| public class JDTUtils | |
| { | |
| private JDTUtils() | |
| { | |
| //does nothing. | |
| //prevents other objects to instantiate this class. | |
| } | |
| /** | |
| * Retrieves the name of the inflated menu inside Activity or Fragment {@code type}. | |
| * @param project The android project that contains the activity or fragment. | |
| * @param compUnit The compilation unit of the activity or fragment. | |
| * @return The name of the inflated menu inside {@code compUnit}. | |
| * */ | |
| public static String getInflatedMenuFileName(IProject project, ICompilationUnit compUnit) | |
| { | |
| //check if type is either activity or fragment | |
| //check if type inflates a menu on OnCreateOptionsMenu | |
| //return the name of the inflated menu with ".xml" appended | |
| CodeGeneratorBasedOnMenuVisitor visitor = new CodeGeneratorBasedOnMenuVisitor(); | |
| CompilationUnit cpAstNode = parse(compUnit); | |
| StudioLogger.info("Trying to visit code for class: " + compUnit.getResource().getName()); //$NON-NLS-1$ | |
| try | |
| { | |
| cpAstNode.accept(visitor); | |
| } | |
| catch (IllegalArgumentException illegalArgumentException) | |
| { | |
| StudioLogger.error("Error while trying to visit code to get an inflated menu:" | |
| + compUnit.getResource().getName()); | |
| } | |
| return visitor.getInflatedMenuName(); | |
| } | |
| /** | |
| * Retrieves a list with the available android activities inside {@code project}. | |
| * @param project The android project to retrieve the activities. | |
| * @param monitor A progress monitor to be used to show operation status. | |
| * */ | |
| public static List<IType> getAvailableActivities(IProject project, IProgressMonitor monitor) | |
| throws JavaModelException | |
| { | |
| return getAvailableSubclasses(project, "android.app.Activity", monitor); //$NON-NLS-1$ | |
| } | |
| /** | |
| * Retrieves the list of subclasses of a given {@code superclass} inside an {@code androidProject}. | |
| * @throws JavaModelException If there are problems parsing java files. | |
| * */ | |
| public static List<IType> getAvailableSubclasses(IProject androidProject, String superclass, | |
| IProgressMonitor monitor) throws JavaModelException | |
| { | |
| List<IType> availableActivities = new ArrayList<IType>(); | |
| SubMonitor subMonitor = SubMonitor.convert(monitor); | |
| subMonitor.beginTask("Resolving available types", 1000); //$NON-NLS-1$ | |
| IJavaProject javaProject = JavaCore.create(androidProject); | |
| IPackageFragmentRoot root = | |
| javaProject.getPackageFragmentRoot(androidProject.findMember("src")); //$NON-NLS-1$ | |
| ArrayList<IPackageFragment> fragments = new ArrayList<IPackageFragment>(); | |
| for (IJavaElement element : root.getChildren()) | |
| { | |
| fragments.add((IPackageFragment) element); | |
| } | |
| subMonitor.worked(100); | |
| if (fragments.size() == 0) | |
| { | |
| subMonitor.worked(900); | |
| } | |
| for (IPackageFragment fragment : fragments) | |
| { | |
| ICompilationUnit[] units = fragment.getCompilationUnits(); | |
| if (units.length == 0) | |
| { | |
| subMonitor.worked(900 / fragments.size()); | |
| } | |
| for (int j = 0; j < units.length; j++) | |
| { | |
| ICompilationUnit unit = units[j]; | |
| IType[] availableTypes = unit.getTypes(); | |
| if (availableTypes.length == 0) | |
| { | |
| subMonitor.worked(900 / fragments.size() / units.length); | |
| } | |
| for (int k = 0; k < availableTypes.length; k++) | |
| { | |
| ITypeHierarchy hierarchy = | |
| availableTypes[k].newSupertypeHierarchy(subMonitor.newChild(900 | |
| / fragments.size() / units.length / availableTypes.length)); | |
| if (isSubclass(hierarchy, availableTypes[k], superclass)) | |
| { | |
| availableActivities.add(availableTypes[k]); | |
| } | |
| } | |
| } | |
| } | |
| return availableActivities; | |
| } | |
| /** | |
| * Retrieves the list of fragments of a given {@code androidProject}. | |
| * @throws JavaModelException If there are problems parsing java files. | |
| * */ | |
| public static List<IType> getAvailableFragmentsSubclasses(IProject androidProject, | |
| IProgressMonitor monitor) throws JavaModelException | |
| { | |
| List<IType> availableFragments = new ArrayList<IType>(); | |
| SubMonitor subMonitor = SubMonitor.convert(monitor); | |
| subMonitor.beginTask("Resolving available types", 1000); //$NON-NLS-1$ | |
| IJavaProject javaProject = JavaCore.create(androidProject); | |
| IPackageFragmentRoot root = | |
| javaProject.getPackageFragmentRoot(androidProject.findMember("src")); //$NON-NLS-1$ | |
| ArrayList<IPackageFragment> fragments = new ArrayList<IPackageFragment>(); | |
| for (IJavaElement element : root.getChildren()) | |
| { | |
| fragments.add((IPackageFragment) element); | |
| } | |
| subMonitor.worked(100); | |
| if (fragments.size() == 0) | |
| { | |
| subMonitor.worked(900); | |
| } | |
| for (IPackageFragment fragment : fragments) | |
| { | |
| ICompilationUnit[] units = fragment.getCompilationUnits(); | |
| if (units.length == 0) | |
| { | |
| subMonitor.worked(900 / fragments.size()); | |
| } | |
| for (int j = 0; j < units.length; j++) | |
| { | |
| ICompilationUnit unit = units[j]; | |
| IType[] availableTypes = unit.getTypes(); | |
| if (availableTypes.length == 0) | |
| { | |
| subMonitor.worked(900 / fragments.size() / units.length); | |
| } | |
| for (int k = 0; k < availableTypes.length; k++) | |
| { | |
| ITypeHierarchy hierarchy = | |
| availableTypes[k].newSupertypeHierarchy(subMonitor.newChild(900 | |
| / fragments.size() / units.length / availableTypes.length)); | |
| if (isFragmentSubclass(hierarchy, availableTypes[k])) | |
| { | |
| availableFragments.add(availableTypes[k]); | |
| } | |
| } | |
| } | |
| } | |
| return availableFragments; | |
| } | |
| /* | |
| * Returns true if the {@code type} belongs to {@code superclass} hierarchy. Otherwise, returns false. | |
| * */ | |
| private static boolean isSubclass(ITypeHierarchy hierarchy, IType type, String superclass) | |
| { | |
| boolean contains = false; | |
| IType superclasstype = hierarchy.getSuperclass(type); | |
| if (superclasstype != null) | |
| { | |
| if (hierarchy.getType().getFullyQualifiedName().equals(superclass) | |
| || superclasstype.getFullyQualifiedName().equals(superclass)) | |
| { | |
| contains = true; | |
| } | |
| else | |
| { | |
| contains = isSubclass(hierarchy, superclasstype, superclass); | |
| } | |
| } | |
| return contains; | |
| } | |
| /** | |
| * @return | |
| * True if the {@code type} belongs to {@code superclass} hierarchy. Otherwise, returns false. | |
| * */ | |
| public static boolean isSubclass(IType type, String superclass) throws JavaModelException | |
| { | |
| ITypeHierarchy typeHierarchy = type.newSupertypeHierarchy(new NullProgressMonitor()); | |
| return isSubclass(typeHierarchy, type, superclass); | |
| } | |
| /* | |
| * Verifies if a given class extends a Fragment class (from sdk after 3.0 or from compatibility pack) | |
| * | |
| * @param hierarchy the hierarchy abstraction to the {@code type} | |
| * @param type the type to be checked | |
| * @return | |
| * True if {@code type} has a Android Fragment in its type hierarchy. | |
| */ | |
| private static boolean isFragmentSubclass(ITypeHierarchy hierarchy, IType type) | |
| { | |
| boolean contains = false; | |
| IType superclasstype = hierarchy.getSuperclass(type); | |
| if (superclasstype != null) | |
| { | |
| if (isAndroidFragment(superclasstype.getFullyQualifiedName())) | |
| { | |
| contains = true; | |
| } | |
| else | |
| { | |
| contains = isFragmentSubclass(hierarchy, superclasstype); | |
| } | |
| } | |
| return contains; | |
| } | |
| /* | |
| * Verifies if a given class extends a Fragment class (Fragment from compatibility pack) | |
| * | |
| * @param hierarchy | |
| * @param type | |
| * @return | |
| */ | |
| private static boolean isCompatibilityPackFragmentsSubclass(ITypeHierarchy hierarchy, IType type) | |
| { | |
| boolean contains = false; | |
| IType superclasstype = hierarchy.getSuperclass(type); | |
| if (superclasstype != null) | |
| { | |
| if (isAndroidCompatibilityPackFragment(superclasstype.getFullyQualifiedName())) | |
| { | |
| contains = true; | |
| } | |
| else | |
| { | |
| contains = isCompatibilityPackFragmentsSubclass(hierarchy, superclasstype); | |
| } | |
| } | |
| return contains; | |
| } | |
| /* | |
| * Verifies if a given class extends a Fragment class (FragmentActivity from compatibility pack) | |
| * | |
| * @param hierarchy | |
| * @param type | |
| * @return | |
| */ | |
| private static boolean isCompatibilityPackFragmentActivitySubclass(ITypeHierarchy hierarchy, | |
| IType type) | |
| { | |
| boolean contains = false; | |
| IType superclasstype = hierarchy.getSuperclass(type); | |
| if (superclasstype != null) | |
| { | |
| if (isAndroidCompatibilityPackFragmentActivity(superclasstype.getFullyQualifiedName())) | |
| { | |
| contains = true; | |
| } | |
| else | |
| { | |
| contains = isCompatibilityPackFragmentActivitySubclass(hierarchy, superclasstype); | |
| } | |
| } | |
| return contains; | |
| } | |
| private static boolean isAndroidFragment(String className) | |
| { | |
| boolean result = false; | |
| if ((className != null) && (className.startsWith("android.")) | |
| && (className.endsWith(".Fragment"))) | |
| { | |
| result = true; | |
| } | |
| return result; | |
| } | |
| private static boolean isAndroidCompatibilityPackFragment(String className) | |
| { | |
| boolean result = false; | |
| if ((className != null) && (className.startsWith("android.support.")) | |
| && (className.endsWith(".Fragment"))) | |
| { | |
| result = true; | |
| } | |
| return result; | |
| } | |
| private static boolean isAndroidCompatibilityPackFragmentActivity(String className) | |
| { | |
| boolean result = false; | |
| if ((className != null) && (className.startsWith("android.support.")) | |
| && (className.endsWith(".FragmentActivity"))) | |
| { | |
| result = true; | |
| } | |
| return result; | |
| } | |
| /** | |
| * Parses source code. | |
| * | |
| * @param lwUnit | |
| * the Java Model handle for the compilation unit | |
| * @return the root AST node of the parsed source | |
| */ | |
| public static CompilationUnit parse(ICompilationUnit lwUnit) | |
| { | |
| ASTParser parser = ASTParser.newParser(AST.JLS3); | |
| parser.setKind(ASTParser.K_COMPILATION_UNIT); | |
| parser.setSource(lwUnit); // set source | |
| parser.setResolveBindings(true); // we need bindings later on | |
| return (CompilationUnit) parser.createAST(null /* IProgressMonitor */); // parse | |
| } | |
| /** | |
| * Creates the representation of a layout file based on the compilation unit | |
| * @param visitor | |
| * @param layout | |
| * @return layout file | |
| * @throws AndroidException if layout xml is malformed | |
| */ | |
| public static CodeGeneratorDataBasedOnLayout createLayoutFile(IProject project, | |
| ICompilationUnit compUnit) throws AndroidException | |
| { | |
| GenerateCodeBasedOnLayoutVisitor visitor = new GenerateCodeBasedOnLayoutVisitor(); | |
| CompilationUnit cpAstNode = parse(compUnit); | |
| StudioLogger.info("Trying to visit code for class: " + compUnit.getResource().getName()); //$NON-NLS-1$ | |
| try | |
| { | |
| cpAstNode.accept(visitor); | |
| } | |
| catch (IllegalArgumentException illegalArgumentException) | |
| { | |
| String msg = CodeUtilsNLS.JDTUtils_FragmentOnCreateViewWithProblemsOrWithWrongFormat; | |
| throw new AndroidException(msg, illegalArgumentException); | |
| } | |
| IFile layout = | |
| project.getFile(File.separator + IAndroidConstants.FD_RES + File.separator | |
| + IAndroidConstants.FD_LAYOUT + File.separator + visitor.getLayoutName() | |
| + ".xml"); //$NON-NLS-1$ | |
| CodeGeneratorDataBasedOnLayout codeGeneratorData = null; | |
| if (visitor.getLayoutName() == null) | |
| { | |
| //layout set or inflate not declared | |
| throw new AndroidException( | |
| CodeUtilsNLS.UI_ChooseLayoutItemsDialog_Error_onCreate_Not_Declared); | |
| } | |
| else | |
| { | |
| StudioLogger.info("Trying to read layout: " + layout); //$NON-NLS-1$ | |
| try | |
| { | |
| codeGeneratorData = new CodeGeneratorDataBasedOnLayout(); | |
| codeGeneratorData.init(visitor.getLayoutName(), layout.getLocation().toFile()); | |
| codeGeneratorData.setAssociatedType(visitor.getTypeAssociatedToLayout()); | |
| JavaLayoutData javaLayoutData = new JavaLayoutData(); | |
| javaLayoutData.setInflatedViewName(visitor.getInflatedViewName()); | |
| javaLayoutData.setDeclaredViewIdsOnCode(visitor.getDeclaredViewIds()); | |
| javaLayoutData.setSavedViewIds(visitor.getSavedViewIds()); | |
| javaLayoutData.setRestoredViewIds(visitor.getRestoredViewIds()); | |
| javaLayoutData.setVisitor(visitor); | |
| javaLayoutData.setCompUnit(compUnit); | |
| javaLayoutData.setCompUnitAstNode(cpAstNode); | |
| codeGeneratorData.setJavaLayoutData(javaLayoutData); | |
| } | |
| catch (AndroidException ae) | |
| { | |
| String errorsMsg = | |
| visitor.getLayoutName() != null ? NLS.bind( | |
| CodeUtilsNLS.JDTUtils_MalformedXMLWhenFilenameAvailable_Error, | |
| layout.getFullPath().toFile()) | |
| : CodeUtilsNLS.JDTUtils_MalformedXMLWhenFilenameNotAvailable_Error; | |
| throw new AndroidException(errorsMsg, ae); | |
| } | |
| } | |
| return codeGeneratorData; | |
| } | |
| /** | |
| * Creates the representation of a menu file based on the compilation unit | |
| * @param project | |
| * @param compUnit | |
| * @param menuFileName | |
| * @param typeAssociated | |
| * @return | |
| * @throws AndroidException if menu xml is malformed | |
| */ | |
| public static CodeGeneratorDataBasedOnMenu createMenuFile(IProject project, | |
| ICompilationUnit compUnit, String menuFileName, | |
| CodeGeneratorDataBasedOnMenu.TYPE typeAssociated) throws AndroidException | |
| { | |
| CodeGeneratorBasedOnMenuVisitor visitor = new CodeGeneratorBasedOnMenuVisitor(); | |
| CompilationUnit cpAstNode = parse(compUnit); | |
| StudioLogger.info("Trying to visit code for class: " + compUnit.getResource().getName()); //$NON-NLS-1$ | |
| try | |
| { | |
| cpAstNode.accept(visitor); | |
| } | |
| catch (IllegalArgumentException illegalArgumentException) | |
| { | |
| String msg = CodeUtilsNLS.JDTUtils_GenerateCodeForMenuVisitingCode_Error; | |
| throw new AndroidException(msg, illegalArgumentException); | |
| } | |
| IFile menu = | |
| project.getFile(File.separator + IAndroidConstants.FD_RES + File.separator | |
| + IAndroidConstants.FD_MENU + File.separator + menuFileName); //$NON-NLS-1$ | |
| CodeGeneratorDataBasedOnMenu codeGeneratorData = null; | |
| StudioLogger.info("Trying to read menu: " + menu); //$NON-NLS-1$ | |
| try | |
| { | |
| codeGeneratorData = new CodeGeneratorDataBasedOnMenu(); | |
| codeGeneratorData.init(menuFileName, menu.getLocation().toFile()); | |
| codeGeneratorData.setAssociatedType(typeAssociated); | |
| codeGeneratorData.setAbstractCodeVisitor(visitor); | |
| codeGeneratorData.setICompilationUnit(compUnit); | |
| codeGeneratorData.setCompilationUnit(cpAstNode); | |
| } | |
| catch (AndroidException ae) | |
| { | |
| String errorsMsg = | |
| NLS.bind(CodeUtilsNLS.JDTUtils_MalformedMenuXMLWhenFilenameAvailable_Error, | |
| menu.getLocation().toFile().toString()); | |
| throw new AndroidException(errorsMsg, ae); | |
| } | |
| return codeGeneratorData; | |
| } | |
| /** | |
| * Given a Java {@link IFile}, this method returns <code>true</code> in case | |
| * the qualified name entered as parameter represents its superclass. | |
| * | |
| * @param javaFile Java {@link IFile}. | |
| * @param superClassFullyQualifiedName Super class fully qualified naem. | |
| * | |
| * @return Returns <code>true</code> in case the Java {@link IFile} class | |
| * inherits from the super class represented by its full qualified name. | |
| * | |
| * @throws JavaModelException Exception thrown in case there are problems retrieving | |
| * classes hierarchy. | |
| */ | |
| public static boolean isSubclass(IFile javaFile, String superClassFullyQualifiedName) | |
| throws JavaModelException | |
| { | |
| ICompilationUnit compUnit = JavaCore.createCompilationUnitFrom(javaFile); | |
| IType type = | |
| compUnit.getType(javaFile.getName().split("." + javaFile.getFileExtension())[0]); //$NON-NLS-1$ | |
| ITypeHierarchy typeHierarchy = type.newSupertypeHierarchy(new NullProgressMonitor()); | |
| return isSubclass(typeHierarchy, type, superClassFullyQualifiedName); | |
| } | |
| /** | |
| * Verifies if a java class extends a Fragment class from a compatibility pack | |
| * | |
| * @param javaFile | |
| * @return | |
| * @throws JavaModelException | |
| */ | |
| public static boolean isFragmentSubclass(IFile javaFile) throws JavaModelException | |
| { | |
| ICompilationUnit compUnit = JavaCore.createCompilationUnitFrom(javaFile); | |
| IType type = | |
| compUnit.getType(javaFile.getName().split("." + javaFile.getFileExtension())[0]); //$NON-NLS-1$ | |
| ITypeHierarchy typeHierarchy = type.newSupertypeHierarchy(new NullProgressMonitor()); | |
| return isFragmentSubclass(typeHierarchy, type); | |
| } | |
| /** | |
| * Verifies if a java class extends a Fragment class from a compatibility pack | |
| * | |
| * @param javaFile | |
| * @return | |
| * @throws JavaModelException | |
| */ | |
| public static boolean isCompatibilityFragmentSubclass(IFile javaFile) throws JavaModelException | |
| { | |
| ICompilationUnit compUnit = JavaCore.createCompilationUnitFrom(javaFile); | |
| IType type = | |
| compUnit.getType(javaFile.getName().split("." + javaFile.getFileExtension())[0]); //$NON-NLS-1$ | |
| ITypeHierarchy typeHierarchy = type.newSupertypeHierarchy(new NullProgressMonitor()); | |
| return isCompatibilityPackFragmentsSubclass(typeHierarchy, type); | |
| } | |
| /** | |
| * Verifies if a java class extends a FragmentActivity class from a compatibility pack | |
| * | |
| * @param javaFile | |
| * @return | |
| * @throws JavaModelException | |
| */ | |
| public static boolean isCompatibilityFragmentActivitySubclass(IFile javaFile) | |
| throws JavaModelException | |
| { | |
| ICompilationUnit compUnit = JavaCore.createCompilationUnitFrom(javaFile); | |
| IType type = | |
| compUnit.getType(javaFile.getName().split("." + javaFile.getFileExtension())[0]); //$NON-NLS-1$ | |
| ITypeHierarchy typeHierarchy = type.newSupertypeHierarchy(new NullProgressMonitor()); | |
| return isCompatibilityPackFragmentActivitySubclass(typeHierarchy, type); | |
| } | |
| /** | |
| * @return true if AST have at least one error (warnings are not considered), false otherwise. | |
| */ | |
| public static boolean hasErrorInCompilationUnitAstUtils(CompilationUnit cpUnit) | |
| { | |
| boolean hasError = false; | |
| if (cpUnit != null) | |
| { | |
| IProblem[] problems = cpUnit.getProblems(); | |
| for (IProblem probl : problems) | |
| { | |
| if (probl.isError()) | |
| { | |
| hasError = true; | |
| break; | |
| } | |
| } | |
| } | |
| return hasError; | |
| } | |
| } |