| /* |
| * Copyright (C) 2016 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.android.tools.lint.checks |
| |
| import com.android.SdkConstants.ANDROID_URI |
| import com.android.SdkConstants.ATTR_ID |
| import com.android.SdkConstants.AUTO_URI |
| import com.android.SdkConstants.MOTION_LAYOUT |
| import com.android.SdkConstants.SUPPORT_ANNOTATIONS_PREFIX |
| import com.android.resources.ResourceFolderType |
| import com.android.resources.ResourceFolderType.LAYOUT |
| import com.android.resources.ResourceFolderType.XML |
| import com.android.support.AndroidxName |
| import com.android.tools.lint.detector.api.Category |
| import com.android.tools.lint.detector.api.ConstantEvaluator |
| import com.android.tools.lint.detector.api.Context |
| import com.android.tools.lint.detector.api.Detector |
| import com.android.tools.lint.detector.api.Implementation |
| import com.android.tools.lint.detector.api.Issue |
| import com.android.tools.lint.detector.api.JavaContext |
| import com.android.tools.lint.detector.api.LintFix |
| import com.android.tools.lint.detector.api.Location |
| import com.android.tools.lint.detector.api.Scope |
| import com.android.tools.lint.detector.api.Severity |
| import com.android.tools.lint.detector.api.SourceCodeScanner |
| import com.android.tools.lint.detector.api.TypeEvaluator |
| import com.android.tools.lint.detector.api.UastLintUtils |
| import com.android.tools.lint.detector.api.XmlContext |
| import com.android.tools.lint.detector.api.XmlScanner |
| import com.android.tools.lint.detector.api.getBaseName |
| import com.android.tools.lint.detector.api.getMethodName |
| import com.android.tools.lint.detector.api.stripIdPrefix |
| import com.android.utils.iterator |
| import com.google.common.collect.Sets |
| import com.intellij.openapi.vfs.VfsUtilCore |
| import com.intellij.psi.PsiClass |
| import com.intellij.psi.PsiClassType |
| import com.intellij.psi.PsiCompiledElement |
| import com.intellij.psi.PsiElement |
| import com.intellij.psi.PsiLocalVariable |
| import com.intellij.psi.PsiMethod |
| import com.intellij.psi.PsiModifierListOwner |
| import com.intellij.psi.PsiVariable |
| import com.intellij.psi.util.PsiTreeUtil |
| import org.jetbrains.uast.UCallExpression |
| import org.jetbrains.uast.UDeclaration |
| import org.jetbrains.uast.UElement |
| import org.jetbrains.uast.UExpression |
| import org.jetbrains.uast.UQualifiedReferenceExpression |
| import org.jetbrains.uast.UReferenceExpression |
| import org.jetbrains.uast.USimpleNameReferenceExpression |
| import org.jetbrains.uast.getContainingUFile |
| import org.jetbrains.uast.getParentOfType |
| import org.w3c.dom.Element |
| |
| /** Looks for issues around ObjectAnimator usages */ |
| class ObjectAnimatorDetector : Detector(), SourceCodeScanner, XmlScanner { |
| /** |
| * Multiple properties might all point back to the same setter; we don't want to highlight these |
| * more than once (duplicate warnings etc) so keep track of them here |
| */ |
| private var mAlreadyWarned: MutableSet<Any?>? = null |
| |
| override fun getApplicableMethodNames(): List<String>? { |
| return listOf( |
| "ofInt", |
| "ofArgb", |
| "ofFloat", |
| "ofMultiInt", |
| "ofMultiFloat", |
| "ofObject", |
| "ofPropertyValuesHolder" |
| ) |
| } |
| |
| override fun visitMethodCall( |
| context: JavaContext, |
| node: UCallExpression, |
| method: PsiMethod |
| ) { |
| val evaluator = context.evaluator |
| if (!evaluator.isMemberInClass(method, "android.animation.ObjectAnimator") && |
| !(method.name == "ofPropertyValuesHolder" && |
| evaluator.isMemberInClass( |
| method, |
| "android.animation.ValueAnimator" |
| )) |
| ) { |
| return |
| } |
| |
| val expressions = node.valueArguments |
| if (expressions.size < 2) { |
| return |
| } |
| |
| val type = TypeEvaluator.evaluate(expressions[0]) as? PsiClassType ?: return |
| val targetClass = type.resolve() ?: return |
| val methodName = method.name |
| if (methodName == "ofPropertyValuesHolder") { |
| if (!evaluator.isMemberInClass(method, "android.animation.ObjectAnimator")) { |
| // *Don't* match ValueAnimator.ofPropertyValuesHolder(); for that method, |
| // arg0 is another PropertyValuesHolder, *not* the target object! |
| return |
| } |
| |
| // Try to find the corresponding property value holder initializations |
| // and validate each one |
| checkPropertyValueHolders(context, targetClass, expressions) |
| } else { |
| // If "ObjectAnimator#ofObject", look for the type evaluator type in |
| // argument at index 2 (third argument) |
| val expectedType = getExpectedType(node, 2) ?: return |
| checkProperty(context, expressions[1], targetClass, expectedType) |
| } |
| } |
| |
| private fun checkPropertyValueHolders( |
| context: JavaContext, |
| targetClass: PsiClass, |
| expressions: List<UExpression> |
| ) { |
| for (i in 1 until expressions.size) { // expressions[0] is the target class |
| val arg = expressions[i] |
| // Find last assignment for each argument; this should be generic |
| // infrastructure. |
| val holder = findHolderConstruction(context, arg) ?: return |
| val args = holder.valueArguments |
| if (args.size >= 2) { |
| // If "PropertyValueHolder#ofObject", look for the type evaluator type in |
| // argument at index 1 (second argument) |
| val expectedType = getExpectedType(holder, 1) ?: return |
| checkProperty(context, args[0], targetClass, expectedType) |
| } |
| } |
| } |
| |
| private fun checkProperty( |
| context: JavaContext, |
| propertyNameExpression: UExpression, |
| targetClass: PsiClass, |
| expectedType: String |
| ) { |
| val property = ConstantEvaluator.evaluate(context, propertyNameExpression) as? String |
| ?: return |
| val qualifiedName = targetClass.qualifiedName ?: return |
| if (qualifiedName.indexOf('.') == -1) { // resolve error? |
| return |
| } |
| val methodName = getMethodName("set", property) |
| val methods = targetClass.findMethodsByName(methodName, true) |
| var bestMethod: PsiMethod? = null |
| var isExactMatch = false |
| for (m in methods) { |
| if (m.parameterList.parametersCount == 1) { |
| if (bestMethod == null) { |
| bestMethod = m |
| } |
| if (context.evaluator.parametersMatch(m, expectedType)) { |
| bestMethod = m |
| isExactMatch = true |
| break |
| } |
| } else if (bestMethod == null) { |
| bestMethod = m |
| } |
| } |
| if (bestMethod == null) { |
| report( |
| context, |
| BROKEN_PROPERTY, |
| propertyNameExpression, |
| null, |
| "Could not find property setter method `$methodName` on `$qualifiedName`", |
| null |
| ) |
| return |
| } |
| if (!isExactMatch) { |
| report( |
| context, |
| BROKEN_PROPERTY, |
| propertyNameExpression, |
| bestMethod, |
| "The setter for this property does not match the " + |
| "expected signature (`public void $methodName($expectedType arg`)", |
| null |
| ) |
| } else if (context.evaluator.isStatic(bestMethod)) { |
| report( |
| context, |
| BROKEN_PROPERTY, |
| propertyNameExpression, |
| bestMethod, |
| "The setter for this property ($qualifiedName.$methodName) should not be static", |
| null |
| ) |
| } else { |
| var owner: PsiModifierListOwner? = bestMethod |
| while (owner != null) { |
| for (annotation in context.evaluator.getAllAnnotations( |
| owner, |
| false |
| )) { |
| if (KEEP_ANNOTATION.isEquals(annotation.qualifiedName)) { |
| return |
| } |
| } |
| owner = PsiTreeUtil.getParentOfType( |
| owner, |
| PsiModifierListOwner::class.java, |
| true |
| ) |
| } |
| |
| // Only flag these warnings if minifyEnabled is true in at least one |
| // variant? |
| if (!isShrinking(context)) { |
| return |
| } |
| report( |
| context, |
| MISSING_KEEP, |
| propertyNameExpression, |
| bestMethod, |
| "This method is accessed from an ObjectAnimator so it should be " + |
| "annotated with `@Keep` to ensure that it is not discarded or renamed " + |
| "in release builds", |
| fix().map().put(PsiMethod::class.java, bestMethod).build() |
| ) |
| } |
| } |
| |
| private fun report( |
| context: JavaContext, |
| issue: Issue, |
| propertyNameExpression: UExpression, |
| method: PsiMethod?, |
| originalMessage: String, |
| fix: LintFix? |
| ) { |
| var message = originalMessage |
| val reportOnMethod = issue === MISSING_KEEP && method != null |
| |
| // No need to report @Keep issues in third party libraries |
| if (reportOnMethod && method is PsiCompiledElement) { |
| return |
| } |
| |
| val locationNode: Any = if (reportOnMethod && method != null) |
| method |
| else |
| propertyNameExpression |
| val alreadyWarned = mAlreadyWarned ?: run { |
| val set: MutableSet<Any?> = Sets.newIdentityHashSet() |
| mAlreadyWarned = set |
| set |
| } |
| if (alreadyWarned.contains(locationNode)) { |
| return |
| } |
| alreadyWarned.add(locationNode) |
| |
| var methodLocation: Location? = null |
| if (method != null && method !is PsiCompiledElement) { |
| val nameIdentifier = method.nameIdentifier |
| methodLocation = if (nameIdentifier != null) |
| context.getRangeLocation( |
| nameIdentifier, |
| fromDelta = 0, |
| to = method.parameterList, |
| toDelta = 0 |
| ) |
| else |
| context.getNameLocation(method) |
| } |
| var location: Location |
| if (reportOnMethod && methodLocation != null && method != null) { |
| location = methodLocation |
| val secondary = context.getLocation(propertyNameExpression) |
| location.secondary = secondary |
| secondary.message = "ObjectAnimator usage here" |
| |
| // In the same compilation unit, don't show the error on the reference, |
| // but in other files (where you may not spot the problem), highlight it. |
| if (isInSameCompilationUnit(propertyNameExpression, method)) { |
| // Same compilation unit: we don't need to show (in the IDE) the secondary |
| // location since we're drawing attention to the keep issue) |
| secondary.visible = false |
| } else { |
| assert(issue === MISSING_KEEP) |
| val secondaryMessage = |
| "The method referenced here (${method.name}) has " + |
| "not been annotated with `@Keep` which means it could be " + |
| "discarded or renamed in release builds" |
| |
| // If on the other hand we're in a separate compilation unit, we should |
| // draw attention to the problem |
| if (location === Location.NONE) { |
| // When running within the IDE in single file scope the IDE just creates |
| // none-locations for items in other files; in this case make this |
| // the primary locations instead |
| location = secondary |
| message = secondaryMessage |
| } else { |
| secondary.message = secondaryMessage |
| } |
| } |
| } else { |
| location = context.getNameLocation(propertyNameExpression) |
| if (methodLocation != null) { |
| location = location.withSecondary(methodLocation, "Property setter here") |
| } |
| } |
| |
| // Allow suppressing at either the property binding site *or* the property site |
| // (we report errors on both) |
| val owner = |
| propertyNameExpression.getParentOfType<UElement>(UDeclaration::class.java, false) |
| if (owner != null && context.driver.isSuppressed(context, issue, owner)) { |
| return |
| } |
| context.report(issue, method, location, message, fix) |
| } |
| |
| private fun getExpectedType( |
| method: UCallExpression, |
| evaluatorIndex: Int |
| ): String? { |
| val methodName = getMethodName(method) ?: return null |
| when (methodName) { |
| "ofArgb", "ofInt" -> return "int" |
| "ofFloat" -> return "float" |
| "ofMultiInt" -> return "int[]" |
| "ofMultiFloat" -> return "float[]" |
| "ofKeyframe" -> return "android.animation.Keyframe" |
| "ofObject" -> { |
| val args = method.valueArguments |
| if (args.size > evaluatorIndex) { |
| val evaluatorType = |
| TypeEvaluator.evaluate( |
| args[evaluatorIndex] |
| ) ?: return null |
| return when (evaluatorType.canonicalText) { |
| "android.animation.FloatEvaluator" -> "float" |
| "android.animation.FloatArrayEvaluator" -> "float[]" |
| "android.animation.IntEvaluator", |
| "android.animation.ArgbEvaluator" -> "int" |
| "android.animation.IntArrayEvaluator" -> "int[]" |
| "android.animation.PointFEvaluator" -> "android.graphics.PointF" |
| else -> null |
| } |
| } |
| } |
| } |
| return null |
| } |
| |
| private fun findHolderConstruction( |
| context: JavaContext, |
| arg: UExpression? |
| ): UCallExpression? { |
| if (arg == null) { |
| return null |
| } |
| if (arg is UCallExpression) { |
| if (isHolderConstructionMethod(context, arg)) { |
| return arg |
| } |
| // else: look inside the method and see if it's a method which trivially returns |
| // an instance? |
| } else if (arg is UReferenceExpression) { |
| if (arg is UQualifiedReferenceExpression) { |
| if (arg.selector is UCallExpression) { |
| val selector = arg.selector as UCallExpression |
| if (isHolderConstructionMethod(context, selector)) { |
| return selector |
| } |
| } |
| } |
| |
| // Variable reference? Field reference? etc. |
| val resolved = arg.resolve() |
| if (resolved is PsiVariable) { |
| var lastAssignment = UastLintUtils.findLastAssignment(resolved, arg) |
| // Resolve variable reassignments |
| while (lastAssignment is USimpleNameReferenceExpression) { |
| val el = lastAssignment.resolve() |
| lastAssignment = if (el is PsiLocalVariable) { |
| UastLintUtils.findLastAssignment(el, lastAssignment) |
| } else { |
| break |
| } |
| } |
| if (lastAssignment is UCallExpression) { |
| val callExpression = lastAssignment |
| if (isHolderConstructionMethod(context, callExpression)) { |
| return callExpression |
| } |
| } else if (lastAssignment is UQualifiedReferenceExpression) { |
| val expression = lastAssignment |
| if (expression.selector is UCallExpression) { |
| val callExpression = expression.selector as UCallExpression |
| if (isHolderConstructionMethod(context, callExpression)) { |
| return callExpression |
| } |
| } |
| } |
| } |
| } |
| return null |
| } |
| |
| private fun isHolderConstructionMethod( |
| context: JavaContext, |
| callExpression: UCallExpression |
| ): Boolean { |
| val referenceName = getMethodName(callExpression) |
| if (referenceName != null && referenceName.startsWith("of") && |
| // This will require more indirection; see unit test |
| referenceName != "ofKeyframe" |
| ) { |
| val resolved = callExpression.resolve() |
| if (resolved != null && |
| context.evaluator.isMemberInClass( |
| resolved, |
| "android.animation.PropertyValuesHolder" |
| ) |
| ) { |
| return true |
| } |
| } |
| return false |
| } |
| |
| private fun isInSameCompilationUnit( |
| element1: UElement, |
| element2: PsiElement |
| ): Boolean { |
| val containingFile = element1.getContainingUFile() |
| var file = containingFile?.psi |
| if (file == null) { |
| val psi = element1.psi |
| if (psi != null) { |
| file = psi.containingFile |
| } |
| } |
| return file == element2.containingFile |
| } |
| |
| // Copy of PropertyValuesHolder#getMethodName - copy to ensure lint & platform agree |
| private fun getMethodName( |
| @Suppress("SameParameterValue") prefix: String, |
| propertyName: String? |
| ): String { |
| if (propertyName == null || propertyName.isEmpty()) { |
| // shouldn't get here |
| return prefix |
| } |
| val firstLetter = Character.toUpperCase(propertyName[0]) |
| val theRest = propertyName.substring(1) |
| return prefix + firstLetter + theRest |
| } |
| |
| private fun isShrinking(context: Context): Boolean { |
| val model = context.mainProject.buildModule |
| return if (model != null) { |
| !model.neverShrinking() |
| } else { |
| // No model? Err on the side of caution; |
| // assume project may be using ProGuard/other shrinking |
| true |
| } |
| } |
| |
| // Implements XmlScanner |
| |
| override fun appliesTo(folderType: ResourceFolderType): Boolean { |
| return folderType == LAYOUT || folderType == XML |
| } |
| |
| override fun getApplicableElements(): Collection<String>? { |
| return listOf(MOTION_LAYOUT.oldName(), MOTION_LAYOUT.newName(), "CustomAttribute") |
| } |
| |
| private data class SceneReference(val viewClass: String, val id: String, val scene: String) |
| |
| private var sceneIds: MutableList<SceneReference>? = null |
| |
| override fun visitElement(context: XmlContext, element: Element) { |
| if (context.resourceFolderType == LAYOUT) { |
| // MotionLayout |
| // app:layoutDescription="@xml/scene_show_details" |
| val sceneReference = element.getAttributeNS(MOTION_LAYOUT_URI, "layoutDescription") |
| if (sceneReference.isEmpty()) { |
| return |
| } |
| |
| val sceneName = sceneReference.substring(sceneReference.indexOf('/') + 1) |
| |
| // Record mapping from id's to class types |
| for (view in element) { |
| if (!view.tagName.contains(".")) { |
| // For now, limit search to custom views |
| continue |
| } |
| val id = stripIdPrefix(view.getAttributeNS(ANDROID_URI, ATTR_ID)) |
| if (id.isNotEmpty()) { |
| val list = sceneIds ?: run { |
| val list = ArrayList<SceneReference>() |
| sceneIds = list |
| list |
| } |
| list += SceneReference(view.tagName, id, sceneName) |
| } |
| } |
| } else { |
| assert(context.resourceFolderType == XML) |
| |
| // Did any layouts reference this scene? |
| val ids = sceneIds ?: return |
| |
| // CustomAttribute |
| val attribute = element.getAttributeNodeNS(MOTION_LAYOUT_URI, "attributeName") |
| attribute ?: return |
| |
| val attributeName = attribute.value |
| val parent = element.parentNode as? Element ?: return |
| val parentId = stripIdPrefix(parent.getAttributeNS(ANDROID_URI, ATTR_ID)) |
| val sceneName = getBaseName(context.file.name) |
| |
| for (s in ids) { |
| if (parentId == s.id && s.scene == sceneName) { |
| val viewClass = s.viewClass |
| val uastParser = context.client.getUastParser(context.project) |
| val evaluator = uastParser.evaluator |
| val targetClass = evaluator.findClass(viewClass) ?: continue |
| val methodName = getMethodName("set", attributeName) |
| val methods = targetClass.findMethodsByName(methodName, true) |
| |
| for (m in methods) { |
| if (m.parameterList.parametersCount == 1) { |
| var owner: PsiModifierListOwner? = m |
| while (owner != null) { |
| val modifierList = owner.modifierList |
| if (modifierList != null) { |
| //noinspection ExternalAnnotations |
| for (annotation in modifierList.annotations) { |
| if (KEEP_ANNOTATION.isEquals(annotation.qualifiedName)) { |
| return |
| } |
| } |
| } |
| owner = PsiTreeUtil.getParentOfType( |
| owner, |
| PsiModifierListOwner::class.java, |
| true |
| ) |
| } |
| |
| // Only flag these warnings if minifyEnabled is true in at least one |
| // variant? |
| if (!isShrinking(context)) { |
| return |
| } |
| |
| val location = context.getValueLocation(attribute) |
| val javaContext = JavaContext( |
| context.driver, context.project, context.mainProject, |
| VfsUtilCore.virtualToIoFile(targetClass.containingFile.virtualFile) |
| ) |
| location.withSecondary( |
| uastParser.getLocation(javaContext, m), |
| "" + |
| "This method is accessed via reflection from a " + |
| "MotionScene ($sceneName) so it should be " + |
| "annotated with `@Keep` to ensure that it is not " + |
| "discarded or renamed in release builds", |
| selfExplanatory = true |
| ) |
| context.report( |
| MISSING_KEEP, element, location, |
| "" + |
| "This attribute references a method or property in " + |
| "custom view $viewClass which is not annotated with " + |
| "`@Keep`; it should be annotated with `@Keep` to " + |
| "ensure that it is not discarded or renamed in " + |
| "release builds" |
| ) |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| companion object { |
| private const val MOTION_LAYOUT_URI = AUTO_URI |
| |
| val KEEP_ANNOTATION = AndroidxName.of( |
| SUPPORT_ANNOTATIONS_PREFIX, |
| "Keep" |
| ) |
| |
| private val IMPLEMENTATION = |
| Implementation( |
| ObjectAnimatorDetector::class.java, Scope.JAVA_AND_RESOURCE_FILES, |
| Scope.JAVA_FILE_SCOPE |
| ) |
| |
| /** Missing @Keep */ |
| @JvmField |
| val MISSING_KEEP = |
| Issue.create( |
| id = "AnimatorKeep", |
| briefDescription = "Missing @Keep for Animated Properties", |
| explanation = """ |
| When you use property animators, properties can be accessed via reflection. \ |
| Those methods should be annotated with @Keep to ensure that during release \ |
| builds, the methods are not potentially treated as unused and removed, or \ |
| treated as internal only and get renamed to something shorter. |
| |
| This check will also flag other potential reflection problems it encounters, \ |
| such as a missing property, wrong argument types, etc. |
| """, |
| category = Category.PERFORMANCE, |
| priority = 4, |
| severity = Severity.WARNING, |
| androidSpecific = true, |
| implementation = IMPLEMENTATION |
| ) |
| |
| /** Incorrect ObjectAnimator binding */ |
| @JvmField |
| val BROKEN_PROPERTY = |
| Issue.create( |
| id = "ObjectAnimatorBinding", |
| briefDescription = "Incorrect ObjectAnimator Property", |
| explanation = """ |
| This check cross references properties referenced by String from \ |
| `ObjectAnimator` and `PropertyValuesHolder` method calls and ensures that \ |
| the corresponding setter methods exist and have the right signatures. |
| """, |
| category = Category.CORRECTNESS, |
| priority = 4, |
| severity = Severity.ERROR, |
| androidSpecific = true, |
| implementation = IMPLEMENTATION |
| ) |
| } |
| } |
