| /* |
| * Copyright (C) 2015 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.google.appindexing.api; |
| |
| import com.android.SdkConstants; |
| import com.android.annotations.VisibleForTesting; |
| import com.android.builder.model.AndroidArtifact; |
| import com.android.builder.model.AndroidLibrary; |
| import com.android.builder.model.Dependencies; |
| import com.android.builder.model.MavenCoordinates; |
| import com.android.ide.common.repository.GradleCoordinate; |
| import com.android.tools.idea.gradle.project.model.AndroidModuleModel; |
| import com.android.tools.idea.gradle.dsl.model.GradleBuildModel; |
| import com.android.tools.idea.gradle.dsl.model.dependencies.ArtifactDependencyModel; |
| import com.android.tools.idea.gradle.dsl.model.dependencies.ArtifactDependencySpec; |
| import com.android.tools.idea.gradle.dsl.model.dependencies.DependenciesModel; |
| import com.android.tools.idea.gradle.project.sync.GradleSyncInvoker; |
| import com.google.appindexing.util.DeepLinkUtils; |
| import com.google.appindexing.util.ManifestUtils; |
| import com.google.common.base.CharMatcher; |
| import com.google.common.collect.Lists; |
| import com.google.common.collect.Maps; |
| import com.google.common.collect.Sets; |
| import com.intellij.ide.highlighter.JavaFileType; |
| import com.intellij.lang.java.JavaLanguage; |
| import com.intellij.lang.xml.XMLLanguage; |
| import com.intellij.openapi.diagnostic.Logger; |
| import com.intellij.openapi.editor.Document; |
| import com.intellij.openapi.editor.Editor; |
| import com.intellij.openapi.module.Module; |
| import com.intellij.openapi.module.ModuleUtilCore; |
| import com.intellij.openapi.project.Project; |
| import com.intellij.psi.*; |
| import com.intellij.psi.codeStyle.CodeStyleManager; |
| import com.intellij.psi.codeStyle.JavaCodeStyleManager; |
| import com.intellij.psi.codeStyle.VariableKind; |
| import com.intellij.psi.util.InheritanceUtil; |
| import com.intellij.psi.util.PsiTreeUtil; |
| import com.intellij.psi.xml.XmlComment; |
| import com.intellij.psi.xml.XmlFile; |
| import com.intellij.psi.xml.XmlTag; |
| import com.siyeh.ig.psiutils.ImportUtils; |
| import org.jetbrains.annotations.NotNull; |
| import org.jetbrains.annotations.Nullable; |
| |
| import java.util.Collection; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import static com.android.tools.idea.gradle.dsl.model.dependencies.CommonConfigurationNames.COMPILE; |
| import static com.android.tools.idea.gradle.util.GradleUtil.getDependencies; |
| |
| /** |
| * A class for detecting the situation where developers need App Indexing API code and inserting |
| * the API code in their projects. |
| */ |
| public final class ApiCreator { |
| static private final String COMPILE_GMS_GROUP = "com.google.android.gms"; |
| static private final String COMPILE_APPINDEXING = "play-services-appindexing"; |
| static private final String MINIMUM_VERSION = "8.4.0"; |
| |
| static private final String TAG_METADATA = "meta-data"; |
| static private final String ATTR_NAME_METADATA_GMS = "com.google.android.gms.version"; |
| static private final String ATTR_VALUE_METADATA_GMS = "@integer/google_play_services_version"; |
| |
| static private final String METHOD_GET_ACTION = "getIndexApiAction"; |
| |
| static private final String CLASS_ACTION = "Action"; |
| static private final String CLASS_APP_INDEX = "AppIndex"; |
| static private final String CLASS_GOOGLE_API_CLIENT = "GoogleApiClient"; |
| static private final String CLASS_THING = "Thing"; |
| static private final String CLASS_ACTION_FULL = "com.google.android.gms.appindexing.Action"; |
| static private final String CLASS_APP_INDEX_FULL = "com.google.android.gms.appindexing.AppIndex"; |
| static private final String CLASS_THING_FULL = "com.google.android.gms.appindexing.Thing"; |
| static private final String CLASS_GOOGLE_API_CLIENT_FULL = "com.google.android.gms.common.api.GoogleApiClient"; |
| |
| static private final List<String> SIGNATURE_ON_CREATE = Lists.newArrayList("android.os.Bundle"); |
| static private final List<String> SIGNATURE_ON_START = Lists.newArrayList(); |
| static private final List<String> SIGNATURE_ON_STOP = Lists.newArrayList(); |
| static private final String ON_CREATE_FORMAT = "@Override\n" + |
| "protected void onCreate(android.os.Bundle savedInstanceState) {\n" + |
| " super.onCreate(savedInstanceState);\n" + |
| " \n" + |
| " // ATTENTION: This was auto-generated to implement the App Indexing API.\n" + |
| " // See https://g.co/AppIndexing/AndroidStudio for more information.\n" + |
| " %1$s = new %2$s.Builder(this).addApi(%3$s.API).build();\n" + |
| "}"; |
| static private final String ON_START_FORMAT = "@Override\n" + |
| "public void onStart(){\n" + |
| " super.onStart();\n" + |
| " \n" + |
| " // ATTENTION: This was auto-generated to implement the App Indexing API.\n" + |
| " // See https://g.co/AppIndexing/AndroidStudio for more information.\n" + |
| " %1$s.connect();\n" + |
| " %3$s.AppIndexApi.start(%1$s, %2$s);\n" + |
| "}"; |
| static private final String ON_STOP_FORMAT = "@Override\n" + |
| "public void onStop() {\n" + |
| " super.onStop();\n" + |
| " \n" + |
| " // ATTENTION: This was auto-generated to implement the App Indexing API.\n" + |
| " // See https://g.co/AppIndexing/AndroidStudio for more information.\n" + |
| " %3$s.AppIndexApi.end(%1$s, %2$s);\n" + |
| " %1$s.disconnect();\n" + |
| "}"; |
| |
| static private final String GET_ACTION_FORMAT = "/**\n" + |
| " * ATTENTION: This was auto-generated to implement the App Indexing API.\n" + |
| " * See https://g.co/AppIndexing/AndroidStudio for more information.\n" + |
| " */\n" + |
| "public %4$s %1$s() {\n" + |
| " %5$s object = new %5$s.Builder()\n" + |
| " .setName(\"%2$s Page\") // TODO: Define a title for the content shown.\n" + |
| " // TODO: Make sure this auto-generated URL is correct.\n" + |
| " .setUrl(android.net.Uri.parse(\"%3$s\"))\n" + |
| " .build();\n" + |
| " return new %4$s.Builder(%4$s.TYPE_VIEW)\n" + |
| " .setObject(object)\n" + |
| " .setActionStatus(%4$s.STATUS_TYPE_COMPLETED)\n" + |
| " .build();\n" + |
| "}"; |
| |
| static private final String CLIENT_FORMAT = "%1$s = new %2$s.Builder(this).addApi(%3$s.API).build();"; |
| static private final String BUILDER_APPINDEXAPI = ".addApi(%s.API)"; |
| static private final String APP_INDEXING_START = "%3$s.AppIndexApi.start(%1$s,%2$s);"; |
| static private final String APP_INDEXING_END = "%3$s.AppIndexApi.end(%1$s,%2$s);"; |
| static private final String APP_INDEXING_START_HALF = "AppIndexApi.start(%1$s,"; |
| static private final String APP_INDEXING_END_HALF = "AppIndexApi.end(%1$s,"; |
| static private final String APP_INDEXING_VIEW = "AppIndexApi.view(%1$s,"; |
| static private final String APP_INDEXING_VIEWEND = "AppIndexApi.viewEnd(%1$s,"; |
| |
| static private final List<String> COMMENT_BUILDER_APPINDEXAPI = Lists |
| .newArrayList("// ATTENTION: This \"addApi(AppIndex.API)\"was auto-generated to implement the App Indexing API.", |
| "// See https://g.co/AppIndexing/AndroidStudio for more information."); |
| static private final List<String> COMMENT_IN_JAVA = Lists |
| .newArrayList("// ATTENTION: This was auto-generated to implement the App Indexing API.", |
| "// See https://g.co/AppIndexing/AndroidStudio for more information."); |
| static private final String COMMENT_FOR_FIELD = "/**\n" + |
| " * ATTENTION: This %1$swas auto-generated to implement the App Indexing API.\n" + |
| " * See https://g.co/AppIndexing/AndroidStudio for more information.\n" + |
| " */"; |
| static private final String COMMENT_IN_MANIFEST = |
| "<!-- ATTENTION: This was auto-generated to add Google Play services to your project for\n" + |
| " App Indexing. See https://g.co/AppIndexing/AndroidStudio for more information. -->"; |
| |
| /* To prompt developers to update deep link url, sets default url to a noticeable wrong url */ |
| static private final String DEFAULT_DEEP_LINK_URL = "http://[ENTER-YOUR-URL-HERE]"; |
| |
| |
| private Project myProject = null; |
| private Module myModule = null; |
| private PsiFile myFile = null; |
| |
| private PsiClass myActivity = null; |
| |
| private PsiElementFactory myFactory = null; |
| private CodeStyleManager myCodeStyleManager = null; |
| |
| private PsiCodeBlock myOnCreate = null; |
| private PsiCodeBlock myOnStart = null; |
| private PsiCodeBlock myOnStop = null; |
| |
| /* The App Indexing API statements in onStart / onStop method */ |
| private List<PsiStatement> myStartStatements = Lists.newArrayList(); |
| private List<PsiStatement> myEndStatements = Lists.newArrayList(); |
| private List<PsiStatement> myViewStatements = Lists.newArrayList(); |
| private List<PsiStatement> myViewEndStatements = Lists.newArrayList(); |
| |
| private String myHighestGmsLibVersion = null; |
| private String myAppIndexingLibVersion = null; |
| |
| private Map<String, String> myImportClasses = Maps.newHashMap(); |
| |
| public ApiCreator(@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) { |
| myProject = project; |
| myFile = file; |
| myModule = ModuleUtilCore.findModuleForFile(myFile.getVirtualFile(), myProject); |
| |
| if (myFile instanceof PsiJavaFile) { |
| PsiElement element = myFile.findElementAt(editor.getCaretModel().getOffset()); |
| if (element != null) { |
| myActivity = getSurroundingInheritingClass(element, SdkConstants.CLASS_ACTIVITY); |
| if (myActivity != null) { |
| myOnCreate = getMethodBodyByName("onCreate", SIGNATURE_ON_CREATE, myActivity); |
| myOnStart = getMethodBodyByName("onStart", SIGNATURE_ON_START, myActivity); |
| myOnStop = getMethodBodyByName("onStop", SIGNATURE_ON_STOP, myActivity); |
| if (myOnStart != null) { |
| myStartStatements = StatementFilter.filterCodeBlock("AppIndex.AppIndexApi.start", myOnStart); |
| myViewStatements = StatementFilter.filterCodeBlock("AppIndex.AppIndexApi.view", myOnStart); |
| } |
| if (myOnStop != null) { |
| myEndStatements = StatementFilter.filterCodeBlock("AppIndex.AppIndexApi.end", myOnStop); |
| myViewEndStatements = StatementFilter.filterCodeBlock("AppIndex.AppIndexApi.viewEnd", myOnStop); |
| } |
| } |
| } |
| } |
| myFactory = (PsiElementFactory)JVMElementFactories.getFactory(JavaLanguage.INSTANCE, myProject); |
| myCodeStyleManager = CodeStyleManager.getInstance(myProject); |
| myImportClasses.put(CLASS_ACTION, CLASS_ACTION_FULL); |
| myImportClasses.put(CLASS_APP_INDEX, CLASS_APP_INDEX_FULL); |
| myImportClasses.put(CLASS_GOOGLE_API_CLIENT, CLASS_GOOGLE_API_CLIENT_FULL); |
| myImportClasses.put(CLASS_THING, CLASS_THING_FULL); |
| } |
| |
| @VisibleForTesting |
| void setGmsLibVersion(@Nullable String version) { |
| myHighestGmsLibVersion = version; |
| myAppIndexingLibVersion = version; |
| } |
| |
| /** |
| * If the current caret's position is eligible for creating App Indexing API code, |
| * i.e. the caret is inside an 'Activity' class |
| * and the class does not call app indexing api. |
| * |
| * @return true if the current caret's position needs app indexing generating intention. |
| */ |
| public static boolean eligibleForInsertingAppIndexingApiCode(@NotNull Editor editor, @NotNull PsiFile file) { |
| if (!(file instanceof PsiJavaFile)) return false; |
| PsiElement element = file.findElementAt(editor.getCaretModel().getOffset()); |
| if (element == null) return false; |
| PsiClass activity = getSurroundingInheritingClass(element, SdkConstants.CLASS_ACTIVITY); |
| if (activity == null) return false; |
| PsiCodeBlock onStart = getMethodBodyByName("onStart", SIGNATURE_ON_START, activity); |
| if (onStart == null) return true; |
| PsiCodeBlock onStop = getMethodBodyByName("onStop", SIGNATURE_ON_STOP, activity); |
| if (onStop == null) return true; |
| List<PsiStatement> startStatements = StatementFilter.filterCodeBlock("AppIndexApi.start", onStart); |
| List<PsiStatement> viewStatements = StatementFilter.filterCodeBlock("AppIndexApi.view", onStart); |
| if (startStatements.isEmpty() && viewStatements.isEmpty()) return true; |
| List<PsiStatement> endStatements = StatementFilter.filterCodeBlock("AppIndexApi.end", onStop); |
| List<PsiStatement> viewEndStatements = StatementFilter.filterCodeBlock("AppIndexApi.viewEnd", onStop); |
| if (endStatements.isEmpty() && viewEndStatements.isEmpty()) return true; |
| return false; |
| } |
| |
| /** |
| * Inserts the AppIndexing API code for the activity where the caret is in. |
| * Steps: |
| * 1. Generates Google Play Service Support in build.gradle and AndroidManifest.xml of current |
| * module. |
| * 2. Generates App Indexing API code in Java source file. |
| * 3. Sync the project if build.gradle of module is changed. |
| */ |
| public void insertAppIndexingApiCodeForActivity() { |
| boolean needGradleSync = false; |
| try { |
| if (myModule == null || myActivity == null || myFactory == null || myCodeStyleManager == null) { |
| Logger.getInstance(ApiCreator.class).info("Unable to generate App Indexing API code."); |
| return; |
| } |
| |
| getGmsDependencyVersion(); |
| needGradleSync = insertGmsCompileDependencyInGradleIfNeeded(); |
| |
| XmlFile manifestPsiFile = ManifestUtils.getAndroidManifestPsi(myModule); |
| if (manifestPsiFile == null) { |
| Logger.getInstance(ApiCreator.class).info("AndroidManifest.xml not found."); |
| return; |
| } |
| insertGmsVersionTagInManifestIfNeeded(manifestPsiFile); |
| |
| insertAppIndexingApiCodeInJavaFile(getDeepLinkOfActivity(), !needGradleSync); |
| } |
| catch (ApiCreatorException e) { |
| e.printStackTrace(); |
| } |
| finally { |
| if (needGradleSync) { |
| GradleSyncInvoker.getInstance().requestProjectSyncAndSourceGeneration(myProject, null); |
| } |
| } |
| } |
| |
| private void getGmsDependencyVersion() throws ApiCreatorException { |
| AndroidModuleModel model = AndroidModuleModel.get(myModule); |
| if (model == null) { |
| throw new ApiCreatorException("AndroidGradleModel not found."); |
| } |
| AndroidArtifact artifact = model.getMainArtifact(); |
| Dependencies dependencies = getDependencies(artifact, model.getModelVersion()); |
| Collection<AndroidLibrary> libraries = dependencies.getLibraries(); |
| for (AndroidLibrary library : libraries) { |
| getDependencyVersionFromAndroidLibrary(library); |
| } |
| } |
| |
| private void getDependencyVersionFromAndroidLibrary(AndroidLibrary library) { |
| MavenCoordinates coordinates = library.getResolvedCoordinates(); |
| if (coordinates != null && coordinates.getGroupId().equals(COMPILE_GMS_GROUP)) { |
| String version = coordinates.getVersion(); |
| if (coordinates.getArtifactId().equals(COMPILE_APPINDEXING)) { |
| myAppIndexingLibVersion = version; |
| } |
| if (myHighestGmsLibVersion == null || compareVersion(version, myHighestGmsLibVersion) > 0) { |
| myHighestGmsLibVersion = version; |
| } |
| } |
| |
| for (AndroidLibrary dependency : library.getLibraryDependencies()) { |
| getDependencyVersionFromAndroidLibrary(dependency); |
| } |
| } |
| |
| /** |
| * Generates App Indexing Support in build.gradle of app module, if no such support exists. |
| * |
| * @return true if gradle myFile is changed and needs sync. |
| */ |
| @VisibleForTesting |
| boolean insertGmsCompileDependencyInGradleIfNeeded() throws ApiCreatorException { |
| GradleBuildModel buildModel = GradleBuildModel.get(myModule); |
| if (buildModel == null) { |
| throw new ApiCreatorException("Build model not found."); |
| } |
| DependenciesModel dependencies = buildModel.dependencies(); |
| String versionToUse = MINIMUM_VERSION; |
| if (myHighestGmsLibVersion != null && compareVersion(myHighestGmsLibVersion, MINIMUM_VERSION) > 0) { |
| versionToUse = myHighestGmsLibVersion; |
| } |
| |
| boolean gradleChange = false; |
| if (myAppIndexingLibVersion == null) { |
| ArtifactDependencySpec newDependency = new ArtifactDependencySpec(COMPILE_APPINDEXING, COMPILE_GMS_GROUP, versionToUse); |
| dependencies = buildModel.dependencies(); |
| dependencies.addArtifact(COMPILE, newDependency); |
| buildModel.applyChanges(); |
| gradleChange = true; |
| } |
| |
| if (myHighestGmsLibVersion != null && compareVersion(myHighestGmsLibVersion, versionToUse) < 0) { |
| List<ArtifactDependencyModel> dependencyList = dependencies.artifacts(); |
| for (ArtifactDependencyModel dependency : dependencyList) { |
| String group = dependency.group().value(); |
| if (group != null && group.equals(COMPILE_GMS_GROUP)) { |
| dependency.setVersion(versionToUse); |
| buildModel.applyChanges(); |
| gradleChange = true; |
| } |
| } |
| } |
| return gradleChange; |
| } |
| |
| /** |
| * Generates App Indexing Support in AndroidManifest.xml. |
| * |
| * @param manifestPsiFile The psi file of AndroidManifest.xml. |
| */ |
| @VisibleForTesting |
| void insertGmsVersionTagInManifestIfNeeded(@NotNull XmlFile manifestPsiFile) { |
| XmlTag root = manifestPsiFile.getRootTag(); |
| if (root != null) { |
| List<XmlTag> applications = ManifestUtils.searchXmlTagsByName(root, SdkConstants.TAG_APPLICATION); |
| for (XmlTag application : applications) { |
| if (getGmsTag(application) == null) { |
| XmlTag gms = application.createChildTag(TAG_METADATA, null, null, false); |
| gms = application.addSubTag(gms, false); |
| gms.setAttribute(SdkConstants.ATTR_NAME, SdkConstants.ANDROID_URI, ATTR_NAME_METADATA_GMS); |
| gms.setAttribute(SdkConstants.ATTR_VALUE, SdkConstants.ANDROID_URI, ATTR_VALUE_METADATA_GMS); |
| |
| XmlTag GmsTag = getGmsTag(application); |
| XmlComment comment = createXmlComment(COMMENT_IN_MANIFEST); |
| if (comment != null && GmsTag != null) { |
| application.addBefore(comment, GmsTag); |
| } |
| } |
| } |
| unlockFromPsiOperation(manifestPsiFile); |
| } |
| } |
| |
| /** |
| * Generates App Indexing API code in Java source file. |
| * Steps: |
| * 1. Generates import statements in activity class. |
| * 2. Generates GoogleApiClient variable. |
| * The method will firstly scan the code to find existing App Indexing API call to get |
| * GoogleApiClient candidate. Then verify if the candidate could be reused in the generated |
| * code - it's a class member and the initialization can be adjusted to add App Indexing API. |
| * If not, a new GoogleApiClient class member will be created. |
| * 3. Generates App Indexing API call in activity. |
| * |
| * @param deepLink The deep link for the activity. It may be nullable, because |
| * we should deal with situation where no deep link is specified |
| * in AndroidManifest.xml. |
| * @param withAppIndexingDependency If gradle will be sync later. |
| */ |
| @VisibleForTesting |
| void insertAppIndexingApiCodeInJavaFile(@Nullable String deepLink, boolean withAppIndexingDependency) { |
| insertImportStatements(withAppIndexingDependency); |
| |
| String clientName = null, clientNameCandidate = null; |
| List<PsiStatement> statementsAppIndexApi = getAppIndexApiStatement(); |
| for (PsiStatement statementAppIndexApi : statementsAppIndexApi) { |
| clientNameCandidate = getClientInAppIndexingApi(statementAppIndexApi); |
| if (clientNameCandidate != null) { |
| break; |
| } |
| } |
| if (clientNameCandidate == null) { |
| List<String> clientNames = getFieldNameByType(CLASS_GOOGLE_API_CLIENT); |
| if (!clientNames.isEmpty()) { |
| clientNameCandidate = clientNames.get(0); |
| } |
| } |
| if (clientNameCandidate != null) { |
| PsiField clientField = getFieldByName(clientNameCandidate); |
| PsiStatement clientInitStatement = null; |
| if (clientField != null && !clientField.hasInitializer()) { |
| clientInitStatement = getClientInitStatements(clientNameCandidate); |
| } |
| // Adjusts client's initialization to add AppIndexing API. |
| if (clientField != null) { |
| boolean adjustmentSucceed = false; |
| if (clientField.hasInitializer()) { |
| adjustmentSucceed = adjustClientFieldInitializerIfNeeded(clientField); |
| } |
| else if (clientInitStatement != null) { |
| adjustmentSucceed = adjustClientInitStatementIfNeeded(clientInitStatement); |
| } |
| if (adjustmentSucceed) { |
| clientName = clientNameCandidate; |
| } |
| } |
| } |
| if (clientName == null) { |
| // Creates a class member with GoogleApiClient type, and initializes it at onCreate method. |
| clientName = createGoogleApiClientField(); |
| } |
| |
| String getActionMethodCallText = insertGetActionMethod(deepLink) + "()"; |
| addOrMergeOnStart(clientName, getActionMethodCallText); |
| addOrMergeOnStop(clientName, getActionMethodCallText); |
| |
| JavaCodeStyleManager.getInstance(myProject).shortenClassReferences(myActivity); |
| |
| unlockFromPsiOperation(myFile); |
| } |
| |
| /** |
| * Insert a method which construct Action instance and return it. Return the name of the method inserted. |
| * @param deepLink The deeplink used to construct the Action instance. |
| * @return The name of the method inserted. |
| */ |
| @NotNull |
| private String insertGetActionMethod(@Nullable String deepLink) { |
| String methodName = getUnusedMethodName(METHOD_GET_ACTION); |
| String pageName = myActivity.getName(); |
| if (pageName.endsWith("Activity")) { |
| pageName = pageName.substring(0, pageName.length() - 8); |
| } |
| String url = deepLink == null ? DEFAULT_DEEP_LINK_URL : deepLink; |
| String getActionMethod = String.format( |
| GET_ACTION_FORMAT, methodName, pageName, url, myImportClasses.get(CLASS_ACTION), myImportClasses.get(CLASS_THING)); |
| PsiMethod newGetAction = myFactory.createMethodFromText(getActionMethod, null); |
| myActivity.add(newGetAction); |
| return methodName; |
| } |
| |
| @NotNull |
| private String getUnusedMethodName(@NotNull String methodName) { |
| PsiMethod[] psiMethods = myActivity.getMethods(); |
| Set<String> usedMethodNames = Sets.newHashSet(); |
| for (PsiMethod p : psiMethods) { |
| usedMethodNames.add(p.getName()); |
| } |
| String unusedMethodName = methodName; |
| for (int suffix = 0; usedMethodNames.contains(unusedMethodName); suffix++) { |
| unusedMethodName = methodName + suffix; |
| } |
| return unusedMethodName; |
| }; |
| |
| /** |
| * Generates import statements of app indexing Java Code. |
| * |
| * @param withAppIndexingDependency If gradle will be sync later. |
| */ |
| private void insertImportStatements(boolean withAppIndexingDependency) { |
| if (!withAppIndexingDependency) { |
| // Without App Indexing dependency, App-Indexing-related classes cannot be found, |
| // so "shortenClassReferences" cannot be used. |
| for (Map.Entry<String, String> className : myImportClasses.entrySet()) { |
| if (!ImportUtils.hasOnDemandImportConflict(className.getValue(), myActivity) && |
| !hasExactImportConflict(className.getValue(), (PsiJavaFile)myFile)) { |
| insertSingleImportIfNeeded(className.getValue()); |
| className.setValue(className.getKey()); |
| } |
| } |
| } |
| } |
| |
| // Copied from ImportUtils - where it was made private in 1.5 so we can't call it directly. |
| private static boolean hasExactImportConflict(String fqName, PsiJavaFile file) { |
| final PsiImportList imports = file.getImportList(); |
| if (imports == null) { |
| return false; |
| } |
| final PsiImportStatement[] importStatements = imports.getImportStatements(); |
| final int lastDotIndex = fqName.lastIndexOf((int)'.'); |
| final String shortName = fqName.substring(lastDotIndex + 1); |
| final String dottedShortName = '.' + shortName; |
| for (final PsiImportStatement importStatement : importStatements) { |
| if (importStatement.isOnDemand()) { |
| continue; |
| } |
| final String importName = importStatement.getQualifiedName(); |
| if (importName == null) { |
| return false; |
| } |
| if (!importName.equals(fqName) && importName.endsWith(dottedShortName)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| |
| /** |
| * Searches App Indexing API call in onStart & onStop. |
| * |
| * @return All the App Indexing API call found. |
| */ |
| @NotNull |
| private List<PsiStatement> getAppIndexApiStatement() { |
| List<PsiStatement> result = Lists.newArrayList(myStartStatements); |
| result.addAll(myViewStatements); |
| if (!result.isEmpty()) { |
| return result; |
| } |
| result.addAll(myEndStatements); |
| result.addAll(myViewEndStatements); |
| return result; |
| } |
| |
| /** |
| * Gets all assignment statements of the client in onCreate. |
| * |
| * @param clientName The GoogleApiClient name. |
| * @return All the init statements. |
| */ |
| @Nullable |
| private PsiStatement getClientInitStatements(@NotNull String clientName) { |
| if (myOnCreate != null) { |
| List<PsiStatement> statements = StatementFilter.filterCodeBlock(".build()", myOnCreate); |
| for (PsiStatement statement : statements) { |
| if (statement instanceof PsiExpressionStatement) { |
| PsiType statementType = ((PsiExpressionStatement)statement).getExpression().getType(); |
| if (statementType != null && |
| statementType.getPresentableText().equals(CLASS_GOOGLE_API_CLIENT) && |
| CharMatcher.WHITESPACE.removeFrom(statement.getText()).startsWith(clientName + "=")) { |
| return statement; |
| } |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Adjusts the initializer of the client field to add App Indexing API, |
| * if there is the initializer ends with ".build()" and have not added App Indexing API. |
| * |
| * @param clientField The client field. |
| * @return true if the adjustment succeeds, i.e. the initializer has added App Indexing API. |
| */ |
| private boolean adjustClientFieldInitializerIfNeeded(@NotNull PsiField clientField) { |
| PsiExpression clientInitializer = clientField.getInitializer(); |
| if (clientInitializer != null) { |
| String oldInitializerText = clientInitializer.getText(); |
| String newInitializerText = generateApiClientInitializeString(oldInitializerText); |
| if (newInitializerText != null) { |
| if (!newInitializerText.equals(oldInitializerText)) { |
| clientField.setInitializer(myFactory.createExpressionFromText(newInitializerText, null)); |
| String commentText = String.format(COMMENT_FOR_FIELD, "\"addApi(AppIndex.API)\" "); |
| myActivity.addBefore(myFactory.createCommentFromText(commentText, null), clientField); |
| } |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Adjusts the the client initializing statement to add AppIndexing API, |
| * if there is the initializer ends with ".build()" and have not added App Indexing API. |
| * |
| * @param statement The init statement of client. |
| * @return true if the adjustment succeeds, i.e. the statement has added App Indexing API. |
| */ |
| private boolean adjustClientInitStatementIfNeeded(@NotNull PsiStatement statement) { |
| String oldText = statement.getText(); |
| String newText = generateApiClientInitializeString(oldText); |
| if (newText != null) { |
| PsiElement newStatement = statement.replace(myFactory.createStatementFromText(newText, null)); |
| if (!newText.equals(oldText)) { |
| addCommentsBefore(COMMENT_BUILDER_APPINDEXAPI, myOnCreate, newStatement); |
| } |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Creates a class member with GoogleApiClient type, and initializes it at onCreate method. |
| * |
| * @return The GoogleApiClient name. |
| */ |
| @NotNull |
| private String createGoogleApiClientField() { |
| String clientName = getUnusedName("client", VariableKind.FIELD); |
| PsiClassType type = myFactory.createTypeByFQClassName(myImportClasses.get(CLASS_GOOGLE_API_CLIENT)); |
| PsiField clientField = (PsiField)myActivity.add(myFactory.createField(clientName, type)); |
| myCodeStyleManager.reformat(myActivity); |
| String comment = String.format(COMMENT_FOR_FIELD, ""); |
| myActivity.addBefore(myFactory.createCommentFromText(comment, null), clientField); |
| generateGoogleApiClientInitializationInOnCreate(clientName); |
| return clientName; |
| } |
| |
| /** |
| * Generates GoogleApiClient initialization in onCreate method. |
| * Used when there is no initializing statement before. |
| * |
| * @param clientName The GoogleApiClient name. |
| */ |
| private void generateGoogleApiClientInitializationInOnCreate(@NotNull String clientName) { |
| if (myOnCreate == null) { |
| String onCreateMethod = |
| String.format(ON_CREATE_FORMAT, clientName, myImportClasses.get(CLASS_GOOGLE_API_CLIENT), myImportClasses.get(CLASS_APP_INDEX)); |
| PsiMethod newOnCreate = myFactory.createMethodFromText(onCreateMethod, null); |
| myActivity.add(newOnCreate); |
| } |
| else { |
| String initText = |
| String.format(CLIENT_FORMAT, clientName, myImportClasses.get(CLASS_GOOGLE_API_CLIENT), myImportClasses.get(CLASS_APP_INDEX)); |
| PsiElement initStatement = myOnCreate.add(myFactory.createStatementFromText(initText, null)); |
| addCommentsBefore(COMMENT_IN_JAVA, myOnCreate, initStatement); |
| } |
| } |
| |
| /** |
| * Generates app indexing api calls (GoogleApiClient's connect & start) in onStart method. |
| * |
| * @param clientName The GoogleApiClient name. |
| * @param getActionMethodCallText The text of method call for get action. |
| */ |
| private void addOrMergeOnStart(@NotNull String clientName, @NotNull String getActionMethodCallText) { |
| if (myOnStart == null) { |
| String onStartMethod = String.format(ON_START_FORMAT, clientName, getActionMethodCallText, myImportClasses.get(CLASS_APP_INDEX)); |
| myActivity.add(myFactory.createMethodFromText(onStartMethod, null)); |
| } |
| else { |
| String connectCall = clientName + ".connect();"; |
| List<PsiStatement> connectStatements = StatementFilter.filterCodeBlock(connectCall, myOnStart); |
| // Creates connect() if needed. It should be on the top. |
| if (connectStatements.isEmpty()) { |
| PsiStatement connectStatement = myFactory.createStatementFromText(connectCall, null); |
| List<PsiStatement> superOnStartStatements = StatementFilter.filterCodeBlock("super.onStart();", myOnStart); |
| if (!superOnStartStatements.isEmpty()) { |
| // Adds connect() statement after "super.onStart();". |
| connectStatement = (PsiStatement)myOnStart.addAfter(connectStatement, superOnStartStatements.get(0)); |
| addCommentsBefore(COMMENT_IN_JAVA, myOnStart, connectStatement); |
| } |
| else { |
| // Adds connect() statement after "{" in the code block. |
| connectStatement = (PsiStatement)myOnStart.addAfter(connectStatement, myOnStart.getFirstBodyElement()); |
| addCommentsBefore(COMMENT_IN_JAVA, myOnStart, connectStatement); |
| } |
| } |
| String startTextHalf = String.format(APP_INDEXING_START_HALF, clientName); |
| myStartStatements = StatementFilter.filterStatements(startTextHalf, myStartStatements); |
| String viewText = String.format(APP_INDEXING_VIEW, clientName); |
| myViewStatements = StatementFilter.filterStatements(viewText, myViewStatements); |
| // Creates Action variable and AppIndex.AppIndexApi.start() at the bottom. |
| if (myStartStatements.isEmpty() && myViewStatements.isEmpty()) { |
| String startText = String.format(APP_INDEXING_START, clientName, getActionMethodCallText, myImportClasses.get(CLASS_APP_INDEX)); |
| PsiElement startStatement = myFactory.createStatementFromText(startText, null); |
| startStatement = myOnStart.add(startStatement); |
| addCommentsBefore(COMMENT_IN_JAVA, myOnStart, startStatement); |
| } |
| } |
| } |
| |
| /** |
| * Generates app indexing api calls (GoogleApiClient's disconnect & end) in onStop method. |
| * |
| * @param clientName The GoogleApiClient name. |
| * @param getActionMethodCallText The text of method call for get action. |
| */ |
| private void addOrMergeOnStop(@NotNull String clientName, @NotNull String getActionMethodCallText) { |
| if (myOnStop == null) { |
| String onStopMethod = String.format(ON_STOP_FORMAT, clientName, getActionMethodCallText, myImportClasses.get(CLASS_APP_INDEX)); |
| myActivity.add(myFactory.createMethodFromText(onStopMethod, null)); |
| } |
| else { |
| String disconnectCall = clientName + ".disconnect();"; |
| List<PsiStatement> disconnectStatements = StatementFilter.filterCodeBlock(disconnectCall, myOnStop); |
| // Creates disconnect() if needed. It should be at the bottom. |
| if (disconnectStatements.isEmpty()) { |
| PsiElement disconnectStatement = myOnStop.add(myFactory.createStatementFromText(disconnectCall, null)); |
| addCommentsBefore(COMMENT_IN_JAVA, myOnStop, disconnectStatement); |
| } |
| String endTextHalf = String.format(APP_INDEXING_END_HALF, clientName); |
| myEndStatements = StatementFilter.filterStatements(endTextHalf, myEndStatements); |
| String viewEndText = String.format(APP_INDEXING_VIEWEND, clientName); |
| myViewEndStatements = StatementFilter.filterStatements(viewEndText, myViewEndStatements); |
| // Creates Action variable and AppIndex.AppIndexApi.end() on the top. |
| if (myEndStatements.isEmpty() && myViewEndStatements.isEmpty()) { |
| String endText = String.format(APP_INDEXING_END, clientName, getActionMethodCallText, myImportClasses.get(CLASS_APP_INDEX)); |
| PsiStatement endStatement = myFactory.createStatementFromText(endText, null); |
| List<PsiStatement> superOnStopStatements = StatementFilter.filterCodeBlock("super.onStop();", myOnStop); |
| if (!superOnStopStatements.isEmpty()) { |
| // after "super.onStop();" |
| endStatement = (PsiStatement)myOnStop.addAfter(endStatement, superOnStopStatements.get(0)); |
| addCommentsBefore(COMMENT_IN_JAVA, myOnStop, endStatement); |
| } |
| else { |
| // after "{" in the code block. |
| endStatement = (PsiStatement)myOnStop.addAfter(endStatement, myOnStop.getFirstBodyElement()); |
| addCommentsBefore(COMMENT_IN_JAVA, myOnStop, endStatement); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Compares two versions in the form of "12.3.456" etc. |
| * |
| * @return < 0 if version1 < version2; = 0 if version1 = version2; > 0 if version1 > version2 |
| */ |
| private static int compareVersion(@NotNull String version1, @NotNull String version2) { |
| GradleCoordinate coordinate1 = GradleCoordinate.parseVersionOnly(version1); |
| GradleCoordinate coordinate2 = GradleCoordinate.parseVersionOnly(version2); |
| return GradleCoordinate.COMPARE_PLUS_HIGHER.compare(coordinate1, coordinate2); |
| } |
| |
| /** |
| * Gets the GMS meta-data tag in the application tag. |
| */ |
| @Nullable |
| private static XmlTag getGmsTag(@NotNull XmlTag application) { |
| XmlTag[] children = application.getSubTags(); |
| for (XmlTag child : children) { |
| if (child.getName().equalsIgnoreCase(TAG_METADATA)) { |
| String tagName = child.getAttributeValue(SdkConstants.ATTR_NAME, SdkConstants.ANDROID_URI); |
| if (tagName != null && tagName.equals(ATTR_NAME_METADATA_GMS)) { |
| return child; |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Gets the client name in an app indexing API call statement. |
| */ |
| @Nullable |
| private static String getClientInAppIndexingApi(@NotNull PsiStatement statement) { |
| if (statement instanceof PsiExpressionStatement) { |
| // In the form of "AppIndex.AppIndexApi.start(mClient, viewAction);". |
| PsiElement[] children = statement.getChildren(); |
| for (PsiElement child : children) { |
| if (child instanceof PsiMethodCallExpression) { |
| String callExpression = ((PsiMethodCallExpression)child).getMethodExpression().getText(); |
| callExpression = CharMatcher.WHITESPACE.removeFrom(callExpression); |
| PsiType[] argsType = ((PsiMethodCallExpression)child).getArgumentList().getExpressionTypes(); |
| // API start / end has 2 arguments, viewEnd has 3 arguments, and view has 2. |
| // The first arg is GoogleApiClient. If not declared before used, it has a null type. |
| if ((callExpression.startsWith("AppIndex.AppIndexApi.") || |
| callExpression.startsWith("AppIndexApi") || |
| callExpression.startsWith(CLASS_APP_INDEX_FULL)) && |
| (argsType.length == 2 || argsType.length == 3 || argsType.length == 6) && |
| argsType[0] != null) { |
| PsiExpression[] args = ((PsiMethodCallExpression)child).getArgumentList().getExpressions(); |
| String clientName = args[0].getText(); |
| if (clientName != null) { |
| return clientName; |
| } |
| } |
| } |
| } |
| } |
| else if (statement instanceof PsiDeclarationStatement) { |
| // In form of "PendingResult<Status> a = AppIndex.AppIndexApi.start(mClient, viewAction);". |
| PsiElement[] children = ((PsiDeclarationStatement)statement).getDeclaredElements(); |
| for (PsiElement child : children) { |
| if (child instanceof PsiVariable) { |
| PsiExpression initializer = ((PsiVariable)child).getInitializer(); |
| if (initializer != null) { |
| // Initializer is in the form of "AppIndex.AppIndexApi.start(mClient, viewAction)". |
| PsiElement[] initChildren = initializer.getChildren(); |
| if (initChildren.length == 2 && |
| initChildren[0] instanceof PsiReferenceExpression && |
| initChildren[1] instanceof PsiExpressionList) { |
| // initChildren[0] should be in the form of "AppIndex.AppIndexApi.start". |
| // initChildren[1] should be in the form of "(mClient, ...)". |
| // args should be in the form of {"mClient", ...}. Check its length and type. |
| String referenceExpression = CharMatcher.WHITESPACE.removeFrom(initChildren[0].getText()); |
| PsiExpression[] args = ((PsiExpressionList)initChildren[1]).getExpressions(); |
| // API start / end has 2 arguments, viewEnd has 3 arguments, and view has 2. |
| // The first arg is GoogleApiClient. If not declared before used, it has a null type. |
| if ((referenceExpression.startsWith("AppIndex.AppIndexApi.") || |
| referenceExpression.startsWith("AppIndexApi.") || |
| referenceExpression.startsWith(CLASS_APP_INDEX_FULL)) && |
| (args.length == 2 || args.length == 3 || args.length == 6) && args[0].getType() != null) { |
| String clientName = args[0].getText(); |
| if (clientName != null) { |
| return clientName; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Generates a name which has not been used. |
| * Example: if "name" is used, "name2" will be returned; |
| * if "name2" is also used, "name3" will be returned; ... |
| * |
| * @param name The initial default name. |
| * @return A name based on the initial name which has not been used. |
| */ |
| @NotNull |
| private String getUnusedName(String name, VariableKind kind) { |
| JavaCodeStyleManager javaCodeStyleManager = JavaCodeStyleManager.getInstance(myProject); |
| name = javaCodeStyleManager.suggestVariableName(kind, name, null, null).names[0]; |
| |
| Set<String> usedName = getUsedVariableName(); |
| String unusedName = name; |
| int suffix = 2; |
| while (usedName.contains(unusedName)) { |
| unusedName = name + suffix; |
| suffix++; |
| } |
| return unusedName; |
| } |
| |
| /** |
| * Generates GoogleApiClient initializing string. |
| * |
| * @param statementText The original initialize string. |
| * @return The new string. |
| */ |
| @Nullable |
| private String generateApiClientInitializeString(@NotNull String statementText) { |
| int splitPoint = statementText.lastIndexOf(".build()"); |
| if (!statementText.contains(String.format(BUILDER_APPINDEXAPI, CLASS_APP_INDEX_FULL)) && |
| !statementText.contains(String.format(BUILDER_APPINDEXAPI, CLASS_APP_INDEX)) && splitPoint != -1) { |
| return statementText.substring(0, splitPoint) + |
| String.format(BUILDER_APPINDEXAPI, myImportClasses.get(CLASS_APP_INDEX)) + |
| statementText.substring(splitPoint); |
| } |
| else if (splitPoint != -1) { |
| return statementText; |
| } |
| return null; |
| } |
| |
| /** |
| * Returns deep links of current activity in AndroidManifest.xml. |
| */ |
| @Nullable |
| @VisibleForTesting |
| String getDeepLinkOfActivity() { |
| XmlFile manifest = ManifestUtils.getAndroidManifestPsi(myModule); |
| if (manifest != null && manifest.getRootTag() != null) { |
| List<XmlTag> activityTags = ManifestUtils.searchXmlTagsByName(manifest.getRootTag(), SdkConstants.TAG_ACTIVITY); |
| for (XmlTag activityTag : activityTags) { |
| String activityName = activityTag.getAttributeValue(SdkConstants.ATTR_NAME, SdkConstants.ANDROID_URI); |
| if (activityName != null && activityName.equals("." + myActivity.getName())) { |
| List<String> deepLinks = DeepLinkUtils.getAllDeepLinks(activityTag); |
| if (!deepLinks.isEmpty()) { |
| return deepLinks.get(0); |
| } |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Creates xml comment element. |
| * |
| * @param text The text form of comment. |
| * @return The created comment. |
| */ |
| @Nullable |
| private XmlComment createXmlComment(@NotNull String text) { |
| // XmlElementFactory does not provide API for creating comment. |
| // So we create a tag wrapping the comment, and extract comment from the created tag. |
| XmlElementFactory xmlElementFactory = XmlElementFactory.getInstance(myProject); |
| XmlTag commentElement = xmlElementFactory.createTagFromText("<foo>" + text + "</foo>", XMLLanguage.INSTANCE); |
| return PsiTreeUtil.getChildOfType(commentElement, XmlComment.class); |
| } |
| |
| /** |
| * Adds comments before a specific psi element. |
| * |
| * @param texts The text of the comments. |
| * "// Comment1. |
| * // Comment2." are 2 comments. |
| * Factory cannot create 2 comments together, so we split them into list of comment texts. |
| * @param element The psi element for adding comment in. |
| * @param anchor The psi element the added comment is anchored before. |
| */ |
| private void addCommentsBefore(@NotNull List<String> texts, @NotNull PsiElement element, @NotNull PsiElement anchor) { |
| myCodeStyleManager.reformat(element); |
| for (String text : texts) { |
| element.addBefore(myFactory.createCommentFromText(text, null), anchor); |
| myCodeStyleManager.reformat(element); |
| } |
| } |
| |
| /** |
| * Unlocks the file locked by PSI operation, so that the project can sync. |
| * |
| * @param file The file locked by PSI operation. |
| */ |
| private void unlockFromPsiOperation(@NotNull PsiFile file) { |
| Document doc = PsiDocumentManager.getInstance(myProject).getDocument(file); |
| if (doc != null) { |
| PsiDocumentManager.getInstance(myProject).doPostponedOperationsAndUnblockDocument(doc); |
| } |
| } |
| |
| /** |
| * Gets the surrounding class, if it inherits from a particular super class. |
| * |
| * @param element The PsiElement for query. |
| * @param inheritedClass the name of the class to inherit from |
| * @return The surrounding class that meet the inheriting requirement. |
| */ |
| @Nullable |
| private static PsiClass getSurroundingInheritingClass(@NotNull PsiElement element, @NotNull String inheritedClass) { |
| while (element != null) { |
| if (element instanceof PsiClass) { |
| PsiClass psiClass = (PsiClass)element; |
| if (InheritanceUtil.isInheritor(psiClass, inheritedClass)) { |
| return psiClass; |
| } |
| } |
| if (element instanceof PsiFile) { |
| return null; |
| } |
| element = element.getParent(); |
| } |
| return null; |
| } |
| |
| /** |
| * Gets the body of the method in a specific class, given the method name. |
| * |
| * @param name The method name. |
| * @param parametersTypeName The type name of the parameters in the specific method. |
| * @param psiClass The class to find method in. |
| * @return The code block body of the method, which will be null if no method is found with designated name or parameters. |
| */ |
| @Nullable |
| public static PsiCodeBlock getMethodBodyByName(@NotNull String name, |
| @NotNull List<String> parametersTypeName, |
| @NotNull PsiClass psiClass) { |
| PsiMethod[] psiMethods = psiClass.findMethodsByName(name, false); |
| for (PsiMethod psiMethod : psiMethods) { |
| PsiType[] types = psiMethod.getSignature(PsiSubstitutor.EMPTY).getParameterTypes(); |
| if (types.length != parametersTypeName.size()) { |
| continue; |
| } |
| boolean correctSignature = true; |
| for (int i = 0; i < types.length; i++) { |
| if (!types[i].getCanonicalText().equals(parametersTypeName.get(i))) { |
| correctSignature = false; |
| break; |
| } |
| } |
| if (correctSignature) { |
| return psiMethod.getBody(); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Gets names of class members, given the type name. |
| * |
| * @param typeName The type presentable name. |
| * @return The members' names |
| */ |
| @NotNull |
| private List<String> getFieldNameByType(@NotNull String typeName) { |
| List<String> result = Lists.newArrayList(); |
| PsiField[] psiFields = myActivity.getFields(); |
| for (PsiField psiField : psiFields) { |
| if (psiField.getType().getPresentableText().equals(typeName)) { |
| result.add(psiField.getName()); |
| } |
| } |
| return result; |
| } |
| |
| @Nullable |
| private PsiField getFieldByName(@NotNull String name) { |
| PsiField[] psiFields = myActivity.getFields(); |
| for (PsiField psiField : psiFields) { |
| if (psiField.getName().equals(name)) { |
| return psiField; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Inserts a single import statement. |
| * |
| * @param className The name of the import class. |
| */ |
| private void insertSingleImportIfNeeded(@NotNull String className) { |
| PsiImportList importList = ((PsiJavaFile)myFile).getImportList(); |
| if (importList != null && !hasImportStatement(importList, className)) { |
| String dummyFileName = "_Dummy_" + className + "_." + JavaFileType.INSTANCE.getDefaultExtension(); |
| PsiJavaFile aFile = (PsiJavaFile)PsiFileFactory.getInstance(myProject) |
| .createFileFromText(dummyFileName, JavaFileType.INSTANCE, "import " + className + ";"); |
| PsiImportList dummyImportList = aFile.getImportList(); |
| if (dummyImportList != null) { |
| PsiImportStatement[] statements = dummyImportList.getImportStatements(); |
| PsiImportStatement statement = (PsiImportStatement)myCodeStyleManager.reformat(statements[0]); |
| importList.add(statement); |
| } |
| } |
| } |
| |
| /** |
| * If an class has been imported in the importList. |
| * |
| * @param importList The import list. |
| * @param className The name of the class to be imported. |
| * @return True if an class has been imported. |
| */ |
| public static boolean hasImportStatement(@NotNull PsiImportList importList, @NotNull String className) { |
| String packageName = className.substring(0, className.lastIndexOf('.')); |
| PsiImportStatement singleImport = importList.findSingleClassImportStatement(className); |
| PsiImportStatement onDemandImport = importList.findOnDemandImportStatement(packageName); |
| return singleImport != null || onDemandImport != null; |
| } |
| |
| /** |
| * Returns all the fields' and local variables' names which have already been used. |
| */ |
| @NotNull |
| private Set<String> getUsedVariableName() { |
| Set<String> usedNames = Sets.newHashSet(); |
| // name of PsiFields in PsiClass |
| PsiField[] psiFields = myActivity.getFields(); |
| for (PsiField psiField : psiFields) { |
| usedNames.add(psiField.getName()); |
| } |
| // name of PsiLocalVariables in PsiMethods in PsiClass |
| PsiMethod[] psiMethods = myActivity.getMethods(); |
| for (PsiMethod psiMethod : psiMethods) { |
| PsiCodeBlock methodBody = psiMethod.getBody(); |
| if (methodBody != null) { |
| List<PsiStatement> psiStatements = StatementFilter.filterCodeBlock("", methodBody); |
| for (PsiStatement psiStatement : psiStatements) { |
| if (psiStatement instanceof PsiDeclarationStatement) { |
| PsiElement[] declaredElements = ((PsiDeclarationStatement)psiStatement).getDeclaredElements(); |
| for (PsiElement declaredElement : declaredElements) { |
| usedNames.add(((PsiLocalVariable)declaredElement).getName()); |
| } |
| } |
| } |
| } |
| } |
| return usedNames; |
| } |
| |
| static class ApiCreatorException extends Exception { |
| public ApiCreatorException(String message) { |
| super(message); |
| } |
| } |
| } |
