Java tutorial
/* * 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; } }