| /* | |
| * 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.generateviewbylayout.codegenerators; | |
| import java.util.ArrayList; | |
| import java.util.List; | |
| import org.eclipse.core.runtime.CoreException; | |
| import org.eclipse.core.runtime.IStatus; | |
| import org.eclipse.jdt.core.JavaConventions; | |
| import org.eclipse.jdt.core.JavaModelException; | |
| import org.eclipse.jdt.core.dom.AnonymousClassDeclaration; | |
| import org.eclipse.jdt.core.dom.Assignment; | |
| import org.eclipse.jdt.core.dom.CastExpression; | |
| import org.eclipse.jdt.core.dom.ClassInstanceCreation; | |
| import org.eclipse.jdt.core.dom.Expression; | |
| import org.eclipse.jdt.core.dom.ExpressionStatement; | |
| import org.eclipse.jdt.core.dom.FieldAccess; | |
| import org.eclipse.jdt.core.dom.MethodDeclaration; | |
| import org.eclipse.jdt.core.dom.MethodInvocation; | |
| import org.eclipse.jdt.core.dom.QualifiedName; | |
| import org.eclipse.jdt.core.dom.SimpleName; | |
| import org.eclipse.jdt.core.dom.SimpleType; | |
| import org.eclipse.jdt.core.dom.Statement; | |
| import org.eclipse.jdt.core.dom.TypeDeclaration; | |
| import org.eclipse.jdt.core.dom.VariableDeclarationFragment; | |
| import org.eclipse.jdt.core.dom.VariableDeclarationStatement; | |
| import com.motorola.studio.android.codeutils.i18n.CodeUtilsNLS; | |
| import com.motorola.studio.android.generatecode.AbstractCodeGenerator; | |
| import com.motorola.studio.android.generateviewbylayout.JavaViewBasedOnLayoutModifierConstants; | |
| import com.motorola.studio.android.generateviewbylayout.model.CodeGeneratorDataBasedOnLayout; | |
| import com.motorola.studio.android.generateviewbylayout.model.LayoutNode; | |
| /** | |
| * Class that have common methods to generate code based on layout (for GUI handlers, findViewById, attributes) | |
| */ | |
| public abstract class AbstractLayoutCodeGenerator extends AbstractCodeGenerator | |
| { | |
| protected CodeGeneratorDataBasedOnLayout codeGeneratorData; | |
| protected MethodDeclaration onCreateDeclaration; | |
| /** | |
| * @param codeGeneratorData input where to get the information (generally a xml, for example, it could be menu or layout) | |
| * @param onCreateDeclaration method onCreate (for Activity) or onCreateView (for Fragment) | |
| * @param typeDeclaration AST type representing Activity or Fragment Android class | |
| */ | |
| public AbstractLayoutCodeGenerator(CodeGeneratorDataBasedOnLayout codeGeneratorData, | |
| MethodDeclaration onCreateDeclaration, TypeDeclaration typeDeclaration) | |
| { | |
| super(typeDeclaration); | |
| this.codeGeneratorData = codeGeneratorData; | |
| this.onCreateDeclaration = onCreateDeclaration; | |
| } | |
| /** | |
| * @return the codeGeneratorData | |
| */ | |
| protected CodeGeneratorDataBasedOnLayout getCodeGeneratorData() | |
| { | |
| return codeGeneratorData; | |
| } | |
| /** | |
| * Adds method invocation that instantiates an anonymous class to deal with the event | |
| */ | |
| protected void addMethodInvocationToListenerHandler(String callerId, String invocationMethod, | |
| String classType, String listenerClazzName, MethodDeclaration methodDeclaration) | |
| throws JavaModelException | |
| { | |
| List<MethodDeclaration> declarations = new ArrayList<MethodDeclaration>(); | |
| declarations.add(methodDeclaration); | |
| addMethodInvocationToListenerHandler(callerId, invocationMethod, classType, | |
| listenerClazzName, declarations); | |
| } | |
| /** | |
| * Adds method invocation that instantiates an anonymous class to deal with the event | |
| */ | |
| @SuppressWarnings("unchecked") | |
| protected void addMethodInvocationToListenerHandler(String callerId, String invocationMethod, | |
| String classType, String listenerClazzName, List<MethodDeclaration> methodDeclarations) | |
| throws JavaModelException | |
| { | |
| MethodInvocation methodInvocation = onCreateDeclaration.getAST().newMethodInvocation(); | |
| SimpleName listenerInvocationName = | |
| onCreateDeclaration.getAST().newSimpleName(invocationMethod); | |
| SimpleName listenerOptionalName = onCreateDeclaration.getAST().newSimpleName(callerId); | |
| FieldAccess fieldAccess = onCreateDeclaration.getAST().newFieldAccess(); | |
| fieldAccess.setExpression(onCreateDeclaration.getAST().newThisExpression()); | |
| fieldAccess.setName(listenerOptionalName); | |
| methodInvocation.setName(listenerInvocationName); | |
| methodInvocation.setExpression(fieldAccess); | |
| ClassInstanceCreation classInstanceCreation = | |
| onCreateDeclaration.getAST().newClassInstanceCreation(); | |
| SimpleType listenerType = getListenerSimpleType(classType, listenerClazzName); | |
| classInstanceCreation.setType(listenerType); | |
| AnonymousClassDeclaration classDeclaration = | |
| onCreateDeclaration.getAST().newAnonymousClassDeclaration(); | |
| for (MethodDeclaration methodDeclaration : methodDeclarations) | |
| { | |
| classDeclaration.bodyDeclarations().add(methodDeclaration); | |
| } | |
| classInstanceCreation.setAnonymousClassDeclaration(classDeclaration); | |
| methodInvocation.arguments().add(classInstanceCreation); | |
| ExpressionStatement expressionStatement = | |
| onCreateDeclaration.getAST().newExpressionStatement(methodInvocation); | |
| insertStatementsAtOnCreateDeclaration(expressionStatement, false); | |
| } | |
| /** | |
| * Insert statements on create declaration depending if it is activity / fragment | |
| * @param expr | |
| * @param insertInTheBeginningOfMethod true, if must insert after setContentView (activity) or after inflate (fragment); | |
| * false if must insert in the of the method (activity), last statement before return (fragment) | |
| * @throws JavaModelException if fragment can not be modified because it is not in the format appropriate | |
| */ | |
| @SuppressWarnings("unchecked") | |
| protected void insertStatementsAtOnCreateDeclaration(Statement expr, | |
| boolean insertInTheBeginningOfMethod) throws JavaModelException | |
| { | |
| int size = onCreateDeclaration.getBody().statements().size(); | |
| if (getCodeGeneratorData().getAssociatedType().equals( | |
| CodeGeneratorDataBasedOnLayout.TYPE.ACTIVITY)) | |
| { | |
| if (insertInTheBeginningOfMethod) | |
| { | |
| int foundIndex = findSetContentViewIndexInsideStatement(); | |
| //if activity => add after second statement (after setContentView) | |
| if (foundIndex >= 0) | |
| { | |
| //it should have super.onCreate and setContentView => add after them | |
| onCreateDeclaration.getBody().statements().add(foundIndex + 1, expr); | |
| } | |
| } | |
| else | |
| { | |
| //last statement | |
| onCreateDeclaration.getBody().statements().add(size, expr); | |
| } | |
| } | |
| else if (getCodeGeneratorData().getAssociatedType().equals( | |
| CodeGeneratorDataBasedOnLayout.TYPE.FRAGMENT)) | |
| { | |
| if (size <= 1) | |
| { | |
| throw new JavaModelException(new IllegalArgumentException( | |
| CodeUtilsNLS.MethodVisitor_InvalidFormatForFragmentOnCreateView), | |
| IStatus.ERROR); | |
| } | |
| if (insertInTheBeginningOfMethod) | |
| { | |
| if (size >= 2) | |
| { | |
| int foundIndex = findInflateIndexAtStatement(); | |
| if (foundIndex >= 0) | |
| { | |
| //if fragment => add after first statement (after inflater.inflate) | |
| //it should have inflater.inflate and return statement => add between them | |
| onCreateDeclaration.getBody().statements().add(foundIndex + 1, expr); | |
| } | |
| } | |
| } | |
| else | |
| { | |
| //last statement before return | |
| onCreateDeclaration.getBody().statements().add(size - 1, expr); | |
| } | |
| } | |
| } | |
| /** | |
| * Returns the last statement of inflate inside onCreate from Fragment | |
| * @return -1 if inflate not found, value >=0 if statement found | |
| */ | |
| private int findInflateIndexAtStatement() | |
| { | |
| int foundIndex = -1; | |
| int index = 0; | |
| while (index < onCreateDeclaration.getBody().statements().size()) | |
| { | |
| Object st = onCreateDeclaration.getBody().statements().get(index); | |
| Expression expression = null; | |
| if (st instanceof VariableDeclarationStatement) | |
| { | |
| VariableDeclarationStatement variableDeclarationStatement = | |
| (VariableDeclarationStatement) st; | |
| for (Object f : variableDeclarationStatement.fragments()) | |
| { | |
| VariableDeclarationFragment frag = (VariableDeclarationFragment) f; | |
| expression = frag.getInitializer(); | |
| } | |
| } | |
| else if (st instanceof ExpressionStatement) | |
| { | |
| ExpressionStatement expressionStatement = (ExpressionStatement) st; | |
| if (expressionStatement.getExpression() instanceof Assignment) | |
| { | |
| Assignment assignment = (Assignment) expressionStatement.getExpression(); | |
| expression = assignment.getRightHandSide(); | |
| } | |
| } | |
| if (expression != null) | |
| { | |
| int aux = findInflateIndexAtStatement(index, expression); | |
| if (aux >= 0) | |
| { | |
| foundIndex = aux; | |
| } | |
| } | |
| index++; | |
| } | |
| return foundIndex; | |
| } | |
| /** | |
| * Returns the last statement of setContentView inside onCreate from Activity | |
| * @return -1 if setContentView not found, value >=0 if statement found | |
| */ | |
| private int findSetContentViewIndexInsideStatement() | |
| { | |
| int foundIndex = -1; | |
| int index = 0; | |
| while (index < onCreateDeclaration.getBody().statements().size()) | |
| { | |
| Object st = onCreateDeclaration.getBody().statements().get(index); | |
| if (st instanceof ExpressionStatement) | |
| { | |
| ExpressionStatement expressionStatement = (ExpressionStatement) st; | |
| if (expressionStatement.getExpression() instanceof MethodInvocation) | |
| { | |
| MethodInvocation setContentInvocation = | |
| (MethodInvocation) expressionStatement.getExpression(); | |
| if ((setContentInvocation.getName() != null) | |
| && setContentInvocation.getName().getIdentifier() | |
| .equals("setContentView")) | |
| { | |
| foundIndex = index; | |
| } | |
| } | |
| } | |
| index++; | |
| } | |
| return foundIndex; | |
| } | |
| /** | |
| * Checks if the method is already invoked in the body of onCreate method | |
| * @param node | |
| * @return | |
| */ | |
| public boolean checkIfInvokeMethodIsDeclared(LayoutNode node, String method) | |
| { | |
| boolean containMethodDeclared = false; | |
| if (onCreateDeclaration.getBody() != null) | |
| { | |
| //check if method invocation already declared | |
| for (Object bodystat : onCreateDeclaration.getBody().statements()) | |
| { | |
| if (bodystat instanceof ExpressionStatement) | |
| { | |
| ExpressionStatement exprStatement = (ExpressionStatement) bodystat; | |
| if (exprStatement.getExpression() instanceof MethodInvocation) | |
| { | |
| MethodInvocation invoke = (MethodInvocation) exprStatement.getExpression(); | |
| if ((invoke.getName() != null) | |
| && invoke.getName().toString().equals(method)) | |
| { | |
| if ((invoke.getExpression() != null) | |
| && invoke.getExpression().toString() | |
| .equals(THIZ + node.getNodeId())) | |
| { | |
| containMethodDeclared = true; | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| return containMethodDeclared; | |
| } | |
| /** | |
| * @param node | |
| * @return true if there is one findViewById with the give node.getNodeId(), | |
| * false otherwise | |
| */ | |
| public boolean checkIfFindViewByIdAlreadyDeclared(LayoutNode node) | |
| { | |
| return codeGeneratorData.getJavaLayoutData().getDeclaredViewIdsOnCode() | |
| .contains(node.getNodeId()); | |
| } | |
| /** | |
| * Creates an assigment statement. The format follows the example: | |
| * | |
| * <br><br> | |
| * <code>Button b = (Button) v.findViewById($nodeId);</code> | |
| * | |
| * | |
| * @param node | |
| * @param optionalExpression if invocation was nested (e.g.: getFragmentManager()) | |
| * @param methodToBeCalled | |
| * @throws JavaModelException | |
| */ | |
| @SuppressWarnings("unchecked") | |
| public void addAssignmentStatement(LayoutNode node, Expression optionalExpression, | |
| String methodToBeCalled) throws JavaModelException | |
| { | |
| SimpleName guiName; | |
| try | |
| { | |
| guiName = getNodeVariableTypeBasedOnLayoutNode(node); | |
| } | |
| catch (CoreException e) | |
| { | |
| throw new JavaModelException(e); | |
| } | |
| SimpleType guiType = onCreateDeclaration.getAST().newSimpleType(guiName); | |
| SimpleName method = onCreateDeclaration.getAST().newSimpleName(methodToBeCalled); | |
| SimpleName rId1 = | |
| onCreateDeclaration.getAST() | |
| .newSimpleName(JavaViewBasedOnLayoutModifierConstants.R); | |
| SimpleName rId2 = | |
| onCreateDeclaration.getAST().newSimpleName( | |
| JavaViewBasedOnLayoutModifierConstants.ID); | |
| QualifiedName rQualified1 = onCreateDeclaration.getAST().newQualifiedName(rId1, rId2); | |
| SimpleName guiId = onCreateDeclaration.getAST().newSimpleName(node.getNodeId()); | |
| QualifiedName rQualified2 = | |
| onCreateDeclaration.getAST().newQualifiedName(rQualified1, guiId); | |
| MethodInvocation invocation = onCreateDeclaration.getAST().newMethodInvocation(); | |
| invocation.setName(method); | |
| if (optionalExpression != null) | |
| { | |
| invocation.setExpression(optionalExpression); | |
| } | |
| if (getCodeGeneratorData().getAssociatedType().equals( | |
| CodeGeneratorDataBasedOnLayout.TYPE.FRAGMENT)) | |
| { | |
| if (!node.isFragmentPlaceholder()) | |
| { | |
| invocation.setExpression(onCreateDeclaration.getAST().newSimpleName( | |
| getCodeGeneratorData().getJavaLayoutData().getInflatedViewName())); | |
| } | |
| } | |
| invocation.arguments().add(rQualified2); | |
| CastExpression castExpr = onCreateDeclaration.getAST().newCastExpression(); | |
| castExpr.setExpression(invocation); | |
| castExpr.setType(guiType); | |
| Assignment assign = onCreateDeclaration.getAST().newAssignment(); | |
| SimpleName variableId = onCreateDeclaration.getAST().newSimpleName(node.getNodeId()); | |
| FieldAccess fieldAccess = onCreateDeclaration.getAST().newFieldAccess(); | |
| fieldAccess.setExpression(onCreateDeclaration.getAST().newThisExpression()); | |
| fieldAccess.setName(variableId); | |
| assign.setLeftHandSide(fieldAccess); | |
| assign.setOperator(Assignment.Operator.ASSIGN); | |
| assign.setRightHandSide(castExpr); | |
| ExpressionStatement expr = onCreateDeclaration.getAST().newExpressionStatement(assign); | |
| insertStatementsAtOnCreateDeclaration(expr, true); | |
| } | |
| /** | |
| * Gets the name of the variable based on the type declared in the layout xml | |
| * @param node | |
| * @return | |
| * @throws CoreException | |
| */ | |
| public SimpleName getNodeVariableTypeBasedOnLayoutNode(LayoutNode node) throws CoreException | |
| { | |
| SimpleName guiName = null; | |
| String clazzName = node.getClazzName(); | |
| if (node.isFragmentPlaceholder() && (clazzName != null)) | |
| { | |
| //use type defined in the xml | |
| IStatus nameStatus = JavaConventions.validateIdentifier(clazzName, "5", "5"); | |
| if (nameStatus.isOK()) | |
| { | |
| guiName = onCreateDeclaration.getAST().newSimpleName(clazzName); | |
| } | |
| else | |
| { | |
| throw new CoreException(nameStatus); | |
| } | |
| } | |
| else | |
| { | |
| guiName = onCreateDeclaration.getAST().newSimpleName(node.getNodeType()); | |
| } | |
| return guiName; | |
| } | |
| } |